Individualisieren Sie Maps-Ansichten: Mitarbeiter und Auftragsstatus dynamisch visualisieren mit einfachen Symbolen
Die Darstellung von Informationen auf Karten ist ein essenzielles Werkzeug für Unternehmen mit Außendienstmitarbeitern. Warum sollten Sie sich jedoch mit Standard-Icons zufrieden geben, wenn Sie die Kartenansicht individuell anpassen können? In diesem Blog zeigen wir, wie Sie mit individuell gestalteten Symbolen auf Google Maps nicht nur Mitarbeiter und Teams visuell hervorheben, sondern auch den aktuellen Status ihrer Aufträge darstellen können. Vor einigen Jahren stand ich vor dieser Herausforderung. Also habe ich mich ans Werk gemacht. Es gab 11 Mitarbeiter die entweder allein oder mit einem weiteren Mitarbeiter unterwegs waren bzw. immer noch sind. Diese Lösung ist noch exakt so im Einsatz, muss aber im Zuge der Anforderungsänderung auf jeweils drei Mitarbeiter aufgerüstet werden. Da aber die jetzigen Anforderungen schon eine Anzahl von über 440 Symbolen notwendig macht, werde ich das über dynamische Symbolgenerierung versuchen umzusetzen.
1. Die Ausgangssituation
Stellen Sie sich vor, Ihr Unternehmen verwaltet Außendienstmitarbeiter mit einer FileMaker-Lösung. Mitarbeiter arbeiten allein oder zu zweit, und ihre Aufgaben sind klar kategorisiert: • Wartung (W) • Service (S) • Reparatur (R) • Inbetriebnahme (I)
Die Herausforderung besteht darin, auf einer Karte die folgenden Informationen klar darzustellen: 1. Wer arbeitet wo? 2. Arbeitet der Mitarbeiter alleine oder im Team? 3. Welcher Auftrag wird aktuell bearbeitet?
2. Visuelle Darstellung
Lösen konnte ich die Herausforderung, indem wir individuelle Symbole verwenden, die: • Den Mitarbeiter (oder das Team) mit einem eindeutigen farbigen T-Shirt darstellen. • Ein Badge (W, S, R, I) am Symbol anzeigen, um die Art des Auftrags zu kennzeichnen. • Für nicht verplante Aufträge ein leeres Symbol mit dem entsprechenden Badge anzeigen.
Beispiel: • Mario arbeitet alleine: Ein Symbol mit einem blauen T-Shirt. • Mario und Anna arbeiten zusammen: Ein Symbol mit zwei Figuren, Mario (blaues T-Shirt, Anna mit einem pinken Shirt) ist der Hauptmitarbeiter. • Ein unbesetzter Wartungsauftrag: Eine leere Figur mit einem Badge “W”. • Ein unbesetzter Serviceauftrag: Eine leere Figur mit einem Badge “S”.
3. Vorbereitung der Symbole
Für die Symbole erstellen wir PNG-Dateien, die folgende Elemente kombinieren: 1. Figuren: Einzel- und Doppelpersonen. 2. Farben: T-Shirt-Farben für die Mitarbeiter. 3. Badges: Kleine Icons mit W, S, R oder I.
Die Namen der Symbole haben natürlich festgelegte Namenskonventionen. So z.B. Rot_Hellbraun_M.png oder Rot_Hellbraun_W.png Die Zusammensetzung erfolgt innerhalb von FileMaker über eine Schleife der anzuzeigenden Aufträge, dabei wird dann auch der Name der +.png ermittelt. Die Übergabe erfolgt sowie schon in meinen letzten Beiträgen. Die Aufbereitung ist individuell. Möchte ich das ganze noch klickbar machen um weitere Informationen in einem InfoWindow anzuzeigen, möchte ich gleich ein FileMaker-Script starten usw.
Fazit
Die Individualisierung von Kartenansichten mit FileMaker und Google Maps ist eine tolle Möglichkeit, Außendienstmitarbeiter effizient zu verwalten. Durch die Kombination von Symbolen, Farben und Badges erhalten wir eine klare und visuell ansprechende Darstellung der aktuellen Arbeitsaufteilung. Nur sollten wir darauf achten, das bei vielen möglichen Kombinationen diese Vorgehensweise nicht mehr zeitgemäß ist.
So schaut die Übergabe in meinem Fall aus, z.T. befinden sich Daten die für eine andere Ansichtsart Verwendung finden mit in diesem Datensatz.
FileMaker & PHP – Integration, Möglichkeiten und die Evolution von Version 12 bis heute (leicht wehmütig)
Die Integration von FileMaker-Datenbanken mit PHP war lange Zeit kein zentraler Bestandteil vieler Webentwicklungsprojekte. Doch die Tools und Technologien, die hierfür zur Verfügung stehen, haben sich über die Jahre drastisch verändert. In diesem Beitrag werfen wir einen detaillierten Blick darauf, wie sich die Möglichkeiten seit FileMaker 17 weiterentwickelt haben und welche Vorteile die modernen Ansätze bieten. Dabei gehen wir auf Scriptaufrufe, Parameterübergaben und Unterschiede zwischen älteren und neuen Methoden ein.
Wie bin ich darauf gekommen, diesen kleinen Vergleich zu ziehen. Mir ist ein uraltes Projekt aus FileMaker 13 Zeiten wieder in die Hände gefallen. Ich hatte noch ein Backup in der iCloud gefunden. Zu dieser Zeit nutzte ich diese gerne um Daten zu sichern. Damals bauten wir das Backend in FileMaker, über IWP wurden die Daten im Webbrowser Teilnehmern der Semicon zur Verfügung gestellt. FileMaker diente als Klient am Counter und im Browser für Anmeldung, Kartenzahlung etc. Es war eine Katastrophe, was für ein Geraffel. Mehrere 1000 Zugriffe pro Stunde zwangen den Server immer wieder in die Knie. Aber wir haben sofort beschlossen, das geht im nächsten Jahr so nicht noch einmal. Ich nutze ab diesem Moment PHP und FileMaker in Kombination. Bis heute, für mich die perfekte Symbiose zweier Systeme.
1. Früher: FileMaker PHP API (bis FileMaker 17)
Vor der Einführung der FileMaker Data API (ab Version 17) war die FileMaker PHP API die Standardlösung, um eine Verbindung zwischen einer FileMaker-Datenbank und einer PHP-basierten Anwendung herzustellen. Diese API war eine PHP-Bibliothek, die speziell für FileMaker entwickelt wurde und direkt mit der Web Publishing Engine (WPE) des FileMaker Servers interagierte.
Merkmale der FileMaker PHP API • Eigene Klassenstruktur: Die API stellte Klassen wie FileMaker, FileMaker_Layout, und FileMaker_Command_Find bereit. • Datenabruf: Abfragen wurden durch spezielle Methoden ausgeführt. Ergebnisse kamen als serialisierte PHP-Arrays zurück. • Skriptausführung: FileMaker-Skripte konnten durch die Methode setScript() aufgerufen werden. • Beschränkt auf WPE: Die WPE musste auf dem FileMaker Server aktiviert sein, um die PHP API zu verwenden.
Mal ein kleines Beispiel:
getLayout('DeinLayout');
$request = $fm->newFindCommand($layout);
$request->addFindCriterion('Feldname', 'Wert');
$request->setScript('Skriptname', 'Parameterwert'); // Skript und Parameter setzen
$result = $request->execute();
if (FileMaker::isError($result)) {
echo 'Fehler: ' . $result->getMessage();
} else {
echo 'Skript erfolgreich ausgeführt.';
}
?>
Einschränkungen • Die API war schwergewichtig und teilweise langsam. • Abhängigkeit von der WPE machte sie weniger flexibel. • Kein modernes JSON-Format, sondern serialisierte Arrays. • Abkündigung mit der Einführung der FileMaker Data API.
Aber es hatte auch was für sich. In Gedanken bin ich immer dem FileMaker nahe geblieben. Layouts, Tabellen, Script-Namen. Als wenn ich mit FileMaker entwickeln würde, nur mit reinem Quellcode.
2. Heute: FileMaker Data API (ab FileMaker 17)
Die Einführung der FileMaker Data API markierte einen Wendepunkt in der Integration von FileMaker-Daten mit externen Anwendungen. Die neue REST-basierte API macht es einfacher, FileMaker-Daten mit Standard-HTTP-Technologien zu verwalten.
Merkmale der FileMaker Data API • RESTful Architektur: Kommunikation erfolgt über HTTP-Methoden wie GET, POST, PATCH und DELETE. • JSON-Datenformat: Anfragen und Antworten erfolgen in leicht verständlichem JSON. • Skriptausführung: Skripte können direkt über Parameter in der Anfrage ausgeführt werden. • Plattformunabhängig: Kein PHP-Modul erforderlich, funktioniert mit jedem HTTP-Client.
Skriptausführung mit der Data API
Die Data API ermöglicht die Ausführung von FileMaker-Skripten direkt während eines HTTP-Requests. Parameter können bequem als JSON übergeben werden.
Beispiel Heute:
/ Funktion zum Starten des FileMaker-Scripts
function startFileMakerScript(orderNumber) {
if (!orderNumber || orderNumber === "Keine") {
alert("Keine gültige Auftragsnummer vorhanden.");
return;
}
const fileMakerScriptUrl = `fmp://$/DeineDatenbank?script=DeinScript¶m=${encodeURIComponent(orderNumber)}`;
console.log(`Starte FileMaker-Script mit URL: ${fileMakerScriptUrl}`);
window.open(fileMakerScriptUrl, '_blank');
}
if (!employees || employees.length === 0) {
alert("Keine passenden Mitarbeiter gefunden.");
return;
}
Vorteile der Data API • Geschwindigkeit: Die API ist schneller und effizienter als die alte PHP API. • Flexibilität: Funktioniert mit jeder Programmiersprache und nicht nur mit PHP. • Standardkonformität: Nutzung moderner Webstandards (JSON, REST). • Skalierbarkeit: Unterstützt größere Datenmengen und parallele Anfragen.
Fazit: Warum auf die Data API setzen?
Die Data API bietet eine deutlich modernere, schnellere und flexiblere Möglichkeit, mit FileMaker-Daten zu arbeiten. Für neue Projekte ist sie der klare Favorit, da sie standardisierte Technologien nutzt und unabhängig von einer spezifischen Programmiersprache ist. Es macht auch unheimlichen Spaß, FileMaker Schwächen durch HTML/PHP/Java-Script zu kompensieren. Siehe meinem Beitrag zum Thema Portale innerhalb von FileMaker Portalen anzeigen.
Ein altes Bild zu diesem Projekt. Semicon 2013 oder 2014
Vergleich: Mitarbeiterzuordnung mit und ohne KI-Unterstützung
In diesem Blog vergleichen wir zwei Ansätze zur automatischen Zuordnung von Mitarbeitern basierend auf Standort und Verfügbarkeit. Der erste Ansatz nutzt eine KI, um die besten Mitarbeiter auszuwählen, während der zweite Ansatz dies mithilfe von reinem PHP realisiert. Beide Methoden liefern wertvolle Ergebnisse, doch sie haben unterschiedliche Vor- und Nachteile. Eines aber gleich vorneweg, KI ist cool, es ist extrem flexibel, treibt aber mich persönlich an den Rand der Verzweiflung. Warum? Übergebe ich 5 mal die gleichen Daten an die KI, z.B. in meiner Anwendung in folgender Form:
testserver.de/php_calen…|Mario,52.5814763,13.3057333,9:30:00,11:00:00,24204|Mario,52.5346344,13.4224666,12:00:00,13:00:00,22664|Philipp,52.5346344,13.4224666,7:00:00,8:00:00,22664|Philipp,52.4702886,13.2930662,13:00:00,14:00:00,24500|David,52.4702886,13.2930662,10:00:00,11:00:00,24531|Jennifer,52.5035525,13.4176949,9:30:00,10:22:30,24542|Philipp,52.5035525,13.4176949,14:00:00,14:52:30,24543|André,52.5035525,13.4176949,7:30:00,8:22:30,24544|Jennifer,52.6053036,13.3540889,11:00:00,12:30:00,24495|Martin,52.5727963,13.4187507,15:00:00,16:00:00,24485
Dann habe ich zu mindesten zwei verschiedene Ergebnisse. Wenn es ganz schlecht läuft, habe ich 5 verschiedene Ergebnisse.
Code-Beispiel 1: Mitarbeiterzuordnung ohne KI Der folgende PHP-Code sortiert und bewertet Mitarbeiter basierend auf ihrer Entfernung, Verfügbarkeit und Priorität.
$fields[0],
'lat' => (float)$fields[1],
'lng' => (float)$fields[2],
'startTime' => $fields[3],
'endTime' => $fields[4],
'orderNumber' => $fields[5],
];
}
}
if (empty($parsedData)) {
die("Keine gültigen Mitarbeiterdaten empfangen.");
}
$supportRequest = $parsedData[0];
$remainingEmployees = array_slice($parsedData, 1);
// Entfernen des Anforderers aus der Liste
$remainingEmployees = array_filter($remainingEmployees, function ($employee) use ($supportRequest) {
return $employee['name'] !== $supportRequest['name'] ||
$employee['lat'] !== $supportRequest['lat'] ||
$employee['lng'] !== $supportRequest['lng'];
});
// Entfernung und Priorität berechnen
foreach ($remainingEmployees as &$employee) {
$employee['distance'] = round(haversine(
$supportRequest['lat'], $supportRequest['lng'],
$employee['lat'], $employee['lng']
), 2);
$timeToReach = strtotime($supportRequest['startTime']) - strtotime($employee['endTime']);
$timeToWait = strtotime($employee['startTime']) - strtotime($supportRequest['endTime']);
if ($employee['distance'] <= 5 && $timeToReach >= 0 && $timeToReach <= 3600) {
$employee['priority'] = "high";
} elseif ($employee['distance'] <= 10) {
$employee['priority'] = "medium";
} else {
$employee['priority'] = "low";
}
$employee['time'] = "{$employee['startTime']} - {$employee['endTime']}";
}
usort($remainingEmployees, function ($a, $b) {
$priorityOrder = ['high' => 1, 'medium' => 2, 'low' => 3];
return $priorityOrder[$a['priority']] <=> $priorityOrder[$b['priority']];
});
$analysisResult = $remainingEmployees;
?>
Vor- und Nachteile
Vorteile ohne KI: 1. Kosten: Keine Abhängigkeit von KI-Diensten wie GPT-4 reduziert die laufenden Kosten erheblich. 2. Kontrolle: Logik und Priorisierungsregeln können exakt definiert und angepasst werden. 3. Performance: Direkte Verarbeitung auf dem Server führt zu schnelleren Ergebnissen.
Nachteile ohne KI: 1. Flexibilität: Änderungen in den Anforderungen erfordern Anpassungen im Code. 2. Komplexität: Erstellen neuer Algorithmen für komplexere Szenarien erfordert Zeit und Fachwissen.
Code-Beispiel 2: Mitarbeiterzuordnung mit KI Hier wird eine KI verwendet, um Mitarbeiter basierend auf Standort und Verfügbarkeit zu priorisieren. Der PHP-Code sendet die Daten an eine KI-API und verarbeitet die Antwort.
Mitarbeiterzuordnung: Ein PHP-basiertes Tool zur OptimierungVor- und Nachteile
Vorteile mit KI: 1. Flexibilität: Anpassungen an den Anforderungen können durch Änderungen der Anweisungen an die KI erfolgen. Dies kann sogar vom Kunden durchgeführt werden wenn z.B. die Anforderungen in FileMaker definiert werden und dann an die KI gesendet werden. 2. Intelligenz: Komplexere Logiken und Datenmuster können leichter berücksichtigt werden.
Nachteile mit KI: 1. Kosten: Jeder API-Aufruf verursacht Kosten, die sich bei häufiger Nutzung summieren können. 2. Abhängigkeit: Funktionalität hängt von der Verfügbarkeit des KI-Dienstes ab. 3. Performance: Zusätzliche Latenz durch API-Aufrufe.
Fazit
Beide Ansätze haben ihre Berechtigung. Der KI-gestützte Ansatz eignet sich für dynamische und komplexe Anforderungen, während die reine PHP-Lösung ideal für festgelegte und kostenbewusste Szenarien ist.
Welcher Ansatz für dich geeignet ist, hängt von deinen spezifischen Anforderungen und Prioritäten ab. Für mich ist nach dem Test klar, die KI werde ich integrieren, aber nur bei extrem komplexen Prozessen. Gedanklich gehe ich dann in die Richtung, Komplette Tagesplanung für ein Team aus z.B. 10-15 Mitarbeitern mit 30-40 Einsätzen in einem Stadtgebiet verstreut.
Mitarbeiterzuordnung: Ein PHP-basiertes Tool zur Visualisierung und Priorisierung
Dieses Projekt kombiniert PHP, die Haversine-Formel und die Google Maps API, um die besten Mitarbeiter für einen Unterstützungsantrag basierend auf Standort und Verfügbarkeit auszuwählen. Das Ergebnis wird auf einer interaktiven Karte dargestellt, und eine Mitarbeiterliste zeigt alle relevanten Details wie Entfernung und Priorität. Der Grund, viele Mitarbeiter sind bei unterschiedlichen Kunden im Einsatz. Es kann aber notwendig sein, das ein zweiter oder dritter Mitarbeiter für diesen Einsatz benötigt werden. Schwierig die Mitarbeiter aus dem Kopf heraus zuordnen zu wollen.
Überblick
Unser Ziel ist es, ein System zu erstellen, das: • Mitarbeiter basierend auf Entfernung und zeitlicher Verfügbarkeit priorisiert. • Standorte auf einer Karte visualisiert. • Überlappende Standorte automatisch verschiebt, um sie sichtbar zu machen. • Eine übersichtliche Mitarbeiterliste generiert.
PHP: Entfernung und Datenverarbeitung
Im folgenden PHP-Skript berechnen wir die Entfernung zwischen Standorten mit der Haversine-Formel, filtern die Mitarbeiter und senden die Daten an eine KI-Analyse.
$fields[0],
'lat' => (float)$fields[1],
'lng' => (float)$fields[2],
'startTime' => $fields[3],
'endTime' => $fields[4],
];
}
}
// Wenn keine gültigen Daten vorhanden sind
if (empty($parsedData)) {
die("Keine gültigen Mitarbeiterdaten empfangen.");
}
// Der Mitarbeiter, der Unterstützung benötigt
$supportRequest = $parsedData[0];
$remainingEmployees = array_slice($parsedData, 1);
// Entfernung berechnen und in das Array hinzufügen
foreach ($remainingEmployees as &$employee) {
$employee['distance'] = round(haversine(
$supportRequest['lat'], $supportRequest['lng'],
$employee['lat'], $employee['lng']
), 2);
}
// Anfrage an KI zur Analyse senden
$payload = [
'supportRequest' => $supportRequest,
'employees' => $remainingEmployees,
];
// Die Anfrage an die OpenAI-API bleibt unverändert und liefert die Ergebnisse
// JSON-Analyse bleibt wie im Skript
?>
Visualisierung mit Google Maps API
Hier zeigen wir, wie die Ergebnisse visualisiert werden, einschließlich der dynamischen Verschiebung überlappender Marker und einer dynamischen Mitarbeiterliste.
<script>
function initMap() {
const map = new google.maps.Map(document.getElementById('map'), {
zoom: 10,
center: { lat: <?php echo $supportRequest['lat']; ?>, lng: <?php echo $supportRequest['lng']; ?> },
});
const employees = <?php echo json_encode($analysisResult); ?>;
// Unterstützungsmarker hinzufügen
new google.maps.Marker({
position: { lat: <?php echo $supportRequest['lat']; ?>, lng: <?php echo $supportRequest['lng']; ?> },
map: map,
title: "Unterstützungsantrag",
});
// Mitarbeiter hinzufügen
const OFFSET_DISTANCE = 0.001;
const seenLocations = new Map();
employees.forEach((employee) => {
let key = `${employee.lat},${employee.lng}`;
if (seenLocations.has(key)) {
const offset = seenLocations.get(key) + 1;
employee.lat += OFFSET_DISTANCE * offset;
employee.lng += OFFSET_DISTANCE * offset;
seenLocations.set(key, offset);
} else {
seenLocations.set(key, 0);
}
new google.maps.Marker({
position: { lat: employee.lat, lng: employee.lng },
map: map,
title: `${employee.name} - ${employee.distance} km`,
});
});
}
window.onload = initMap;
</script>
Was übergeben wir aus FileMaker
https://deine_url.de/ki_calendar.php?data=André,52.5035525,13.4176949,7:30:00,8:22:30|Mario,52.5814763,13.3057333,9:30:00,11:00:00|Mario,52.5346344,13.4224666,12:00:00,13:00:00|,52.5346344,13.4224666,7:00:00,8:00:00|Philipp,52.4702886,13.2930662,13:00:00,14:00:00|David,52.4702886,13.2930662,10:00:00,11:00:00|Jennifer,52.5035525,13.4176949,9:30:00,10:22:30|Philipp,52.5035525,13.4176949,14:00:00,14:52:30|André,52.5035525,13.4176949,7:30:00,8:22:30|Jennifer,52.6053036,13.3540889,11:00:00,12:30:00|Martin,52.5727963,13.4187507,15:00:00,16:00:00
Fazit
Die Rolle der KI in unserem Projekt
Bei diesem Projekt haben wir die GPT-4 API von OpenAI genutzt, eine hochmoderne KI, die auf natürliche Sprachverarbeitung spezialisiert ist. Die KI übernimmt dabei eine entscheidende Rolle:
Aufgaben der KI 1. Analyse der Daten: Die KI wertet die übermittelten Daten aus, einschließlich der Standorte und Verfügbarkeiten der Mitarbeiter, sowie der geforderten Zeitspanne. Sie trifft Entscheidungen, welche Mitarbeiter am besten geeignet sind, basierend auf: • Geografischer Nähe (Entfernung). • Zeitlicher Verfügbarkeit (Überlappung mit der Anforderungszeit). • Priorisierungskriterien. 2. Priorisierung der Mitarbeiter: Die KI sortiert die Mitarbeiter in Prioritätsklassen (hoch, mittel, niedrig), um Entscheidungsprozesse zu erleichtern. Dies hilft besonders bei komplexen Szenarien mit vielen Teilnehmern und unterschiedlichen Anforderungen. 3. Flexible Verarbeitung: Mit der eingebauten Sprachverarbeitungsfähigkeit kann die KI auf benutzerdefinierte Regeln und neue Anforderungen reagieren. Im Falle unseres Projekts wird sichergestellt, dass: • Der Supportanforderer (Mario) nicht als Unterstützer in die Liste aufgenommen wird. • Die Ergebnisse stets im JSON-Format zurückgegeben werden, damit sie direkt weiterverarbeitet werden können.
Warum GPT-4? • Komplexe Entscheidungen: GPT-4 kann nicht nur einfache Regeln anwenden, sondern auch inhaltlich komplexe Daten wie geografische Koordinaten, Zeitfenster und Prioritäten verknüpfen. • Flexibilität: Änderungen in den Anforderungen (z. B. neue Priorisierungsregeln) lassen sich einfach umsetzen, indem wir die KI-Prompts anpassen. • Effizienz: Im Gegensatz zu einer festen Programmierung ermöglicht die KI schnelle Analysen und Rückmeldungen, ohne den PHP-Code manuell anzupassen.
Das Projekt zeigt, wie sich PHP, eine KI-API und Google Maps zu einem leistungsstarken Logistik-Tool kombinieren lassen. Dies ist natürlich nur eine erste Version und verarbeitet nur wenige Daten.
Optimierung von Google Maps zur Verwaltung mehrerer Aufträge mit überlappenden Geodaten
In der modernen Logistik und Auftragsverwaltung sind präzise Karten mit mehreren Aufträgen ein unverzichtbares Werkzeug. Doch was passiert, wenn mehrere Aufträge dieselbe Geoposition teilen? Zu unterscheiden sind diese Marker nur über die Label. Diese zeigen in diesem Projekt die Auftragsnummer an. Ist diese unleserlich, dann ist klar, das liegen mehrere Marker übereinander. Unser jüngstes Projekt konzentrierte sich auf die Visualisierung solcher Szenarien, einschließlich der farblichen Hervorhebung und Gruppierung überlappender Marker sowie der optimierten Datenübertragung an externe Systeme wie FileMaker, in unserem Fall ausschließlich FileMaker.
Herausforderung
Das Ziel war es, eine dynamische Google Maps-Anwendung zu entwickeln, die: 1. Mehrere Aufträge darstellt, auch wenn sie die gleiche Position haben. Gleiche Positionen bedeuten, wir haben die gleichen Geo-Daten bzw. Hausnummer, Straße und PLZ sind identisch. 2. Farbcodierungen für solche „überlappenden“ Marker nutzt, um sie besser erkennbar zu machen. 3. Detaillierte Informationen über jeden Auftrag in einem Infowindow anzeigt. 4. Die optimierte Reihenfolge der Aufträge nahtlos an FileMaker überträgt.
Unsere Lösung
1 Marker-Anpassung für überlappende Geodaten
Wir haben eine Kartenfunktion implementiert, die doppelte Marker an derselben Position erkennt und diese farblich hervorhebt. Dabei haben wir: • Einen blauen Marker für Einzelaufträge verwendet. • Grüne Marker eingeführt, um überlappende Positionen zu kennzeichnen.
Zusätzlich zeigt ein Infowindow bei Klick auf einen Marker alle zugehörigen Auftragsnummern an. Über die angezeigten Auftragsnummer können per Klick, alle relevanten Daten innerhalb von FileMaker aufgerufen werden.
2 Optimierung der Datenübertragung
Wir haben die Datenübertragung so optimiert, dass nur relevante Informationen gesendet werden. Im Vorfeld wurde schon durch ein PHP-Script eine Vorauswahl getroffen. Dieses kann natürlich auch direkt über FileMaker erfolgen: • Origin: Die Startposition wurde durch die echte Auftrags-ID ersetzt. • Waypoints: Es wurden maximal neun Wegpunkte übergeben. • Destination: Das Ziel wurde als letzter Punkt hinzugefügt.
3 Dynamische Gruppierung
Durch die Implementierung einer Map-Datenstruktur wurden überlappende Marker gesammelt und in einem einzigen Marker angezeigt. Der Tooltip zeigt auf Wunsch alle zugehörigen Aufträge an.
Technische Highlights
Marker mit Farbcodierung
const markerColor = location.ids.length > 1 ? '#00FF00' : '#4285F4'; // Grün für mehrere IDs
const markerLabel = location.ids.length > 1 ? 'Mehrere' : location.label;
const marker = new google.maps.Marker({
position: location.position,
map: map,
label: {
text: markerLabel,
color: '#000',
fontSize: '12px',
fontWeight: 'bold',
},
icon: {
path: google.maps.SymbolPath.CIRCLE,
scale: 8,
fillColor: markerColor,
fillOpacity: 1,
strokeColor: '#FFF',
strokeWeight: 2,
labelOrigin: new google.maps.Point(0, -5),
},
});
Unser InfoWindows mit mehreren Auftragsnummer:
const contentString = `
Auftragsnummern:
${location.ids.map(id => `
Auftrag ${id}
`).join('
')}
Anlagen:
${location.facilities}
`;
marker.addListener('click', () => {
infowindow.setContent(contentString);
infowindow.open(map, marker);
});
Optimierte Reihenfolge an FileMaker senden, dort werden die Daten in Reihenfolge gebracht und können weiter verarbeitet werden.
function sendToFileMaker() {
if (optimizedOrder.length > 0) {
const originId = ;
const updatedOrder = [originId, ...optimizedOrder.slice(1)];
const filemakerUrl = `fmp://$/Deine Datei?script=DeinFMScript¶m=${encodeURIComponent(updatedOrder.join('\n'))}`;
window.location.href = filemakerUrl;
} else {
alert('Die Route ist noch nicht optimiert. Bitte warten.');
}
}
Die Datenübergabe erfolgt wie immer in der Art -deine_url_de/maps.php?json=true&origin=52.5212262,13.3340740 &destination=52.5070279,13.345529 &waypoints=52.4897075,13.3290075|52.4902317,13.355636|52.5037865,13.3271369|52.504083,13.3386575&auftrag=24501|24510|24547|24551|24573|24580&facilities=6039|1940|4540|5036|6634|6545 Zusammenstellen der Daten erfolgt über Schleifen, SQL oder Listen die per Referenzen die richtigen Daten enthalten.
Wie in den letzten Beiträgen schon beschrieben, nutzen wir ein WebViewer in FileMaker.
Fazit
Unsere Lösung zeigt, wie smarte Anpassungen in Visualisierungen und Datenübertragungen den Unterschied machen können. Mit farblich abgestimmten Markern, informativen Pop-ups und cleveren Datenstrukturen haben wir nicht nur die Benutzerfreundlichkeit auf ein neues Level gehoben, sondern auch die Effizienz der Prozesse ordentlich gepusht.
Ein schöner Tag....
Meine Frau weiß genau was ein Programmierer zum arbeiten benötigt. Viel Cola…. Danke für meinen schönen Geburtstag 🎂 ❤️
Vor- und Nachteile der Haverschen Formel im Vergleich zur Google Maps API für Entfernungsberechnungen
Die genaue Berechnung von Entfernungen ist ein zentraler Bestandteil vieler geografischer und logistischer Anwendungen. Dabei stehen oft zwei Methoden im Fokus: die Haversche Formel und die Entfernungsberechnung mithilfe der Google Maps API. Doch welche Methode eignet sich für welchen Anwendungsfall, und worin liegen ihre Vor- und Nachteile?
Was ist die Haversche Formel?
Die Haversche Formel ist eine mathematische Methode zur Berechnung der kürzesten Entfernung zwischen zwei Punkten auf der Oberfläche einer Kugel. Diese Methode berücksichtigt die Krümmung der Erde, geht jedoch von einer idealisierten kugelförmigen Erde aus.
Die Formel lautet:
a = sin²(Δφ / 2) + cos(φ₁) * cos(φ₂) * sin²(Δλ / 2) c = 2 * atan2(√a, √(1-a)) d = R * c Variablenbeschreibung: • φ₁, φ₂: Breitengrade der Punkte • λ₁, λ₂: Längengrade der Punkte • R: Erdradius (ca. 6.371 km) • d: Ergebnis der Entfernung
Vorteile der Haverschen Formel 1. Unabhängigkeit: Sie benötigt nur die geografischen Koordinaten der Punkte (Breitengrad und Längengrad). 2. Effizienz: Keine externe API-Abfrage notwendig; Berechnungen können lokal durchgeführt werden. 3. Einfache Implementierung: Kann in praktisch jeder Programmiersprache leicht umgesetzt werden.
Nachteile der Haverschen Formel 1. Nur Luftlinie: Die Berechnung liefert die kürzeste Entfernung auf einer Kugel, berücksichtigt jedoch keine tatsächlichen Straßen, Hindernisse oder andere geografische Gegebenheiten. 2. Genauigkeit: Die Annahme einer perfekten Kugel führt zu leichten Abweichungen, da die Erde keine Kugel ist. Das kann im allgemeinen vernachlässigt werden, wenn wir z.B. ein Stadtgebiet betrachten wie Berlin, dann interessiert uns die Krümmung der Erde wenig. Viel schlimmer ist die Vernachlässigung der Straßenführung.
Wie funktioniert die Entfernungsberechnung in der Google Maps API?
Die Google Maps API verwendet eine komplexere Methodik zur Berechnung von Entfernungen. Dabei werden reale Straßennetze, Verkehrsdaten und andere Faktoren berücksichtigt, um die tatsächlich benötigte Strecke und Zeit zu ermitteln. 1. Schritt 1: Übermittlung der Koordinaten und Route per API-Call. 2. Schritt 2: Berechnung der Entfernung und/oder Dauer anhand von Straßendaten, Verkehrsbedingungen und anderen Faktoren. 3. Schritt 3: Rückgabe detaillierter Daten, z. B. Entfernung, Dauer und Streckenführung.
Vorteile der Google Maps API 1. Reale Entfernungen: Liefert die tatsächliche Strecke basierend auf Straßen- und Verkehrsdaten. 2. Zusätzliche Informationen: Neben der Entfernung auch Zeitdauer, Wegbeschreibungen und Verkehrsinformationen verfügbar. 3. Hohe Genauigkeit: Ideal für Routenplanung und logistische Anwendungen.
Nachteile der Google Maps API 1. Kosten: Ab einer bestimmten Anzahl an Anfragen können Gebühren anfallen. 2. Abhängigkeit von externen Diensten: Funktioniert nur mit einer stabilen Internetverbindung. 3. Komplexität: Die Integration erfordert API-Schlüssel und ein grundlegendes Verständnis der API-Dokumentation.
Um die Google Maps API nutzen zu können, benötigen wir einen API-Schlüssel, den wir in der Google Cloud Console erstellen. Dieser Schlüssel ermöglicht den Zugriff auf verschiedene Dienste, darunter die Distance Matrix API oder die Directions API.
- Beispiel: Entfernungsmessung mit der Directions API
Die Directions API eignet sich hervorragend, um Entfernungen zwischen mehreren Punkten zu berechnen. Hier ein Beispiel:
API-Aufruf
Der Aufruf erfolgt durch eine URL wie diese: https://maps.googleapis.com/maps/api/directions/json?origin=52.515956,13.388512&destination=52.4981845,13.4610157&waypoints=52.520008,13.404954|52.529407,13.397634&key=DEIN_API_KEY
• origin: Startpunkt
• destination: Zielpunkt
• waypoints: Zwischenstationen, durch | getrennt
• key: Der API-Schlüssel
Der Rückgabewert der API ist ein JSON-Objekt. Dieses JSON enthält Details zur Route, darunter Entfernungen, Fahrzeiten und Wegbeschreibungen.
Aufruf:
<?php
// API-Schlüssel
$apiKey = 'DEIN_API_KEY';
// Parameter
$origin = '52.515956,13.388512';
$destination = '52.4981845,13.4610157';
$waypoints = '52.520008,13.404954|52.529407,13.397634';
// API-URL zusammenbauen
$url = "https://maps.googleapis.com/maps/api/directions/json?" .
"origin=" . urlencode($origin) .
"&destination=" . urlencode($destination) .
"&waypoints=" . urlencode($waypoints) .
"&key=" . $apiKey;
// API-Anfrage
$response = file_get_contents($url);
$data = json_decode($response, true);
// Ausgabe der Entfernungen
if ($data['status'] === 'OK') {
foreach ($data['routes'][0]['legs'] as $leg) {
echo "Start: " . $leg['start_address'] . "\\n";
echo "Ziel: " . $leg['end_address'] . "\\n";
echo "Entfernung: " . $leg['distance']['text'] . "\\n";
echo "Dauer: " . $leg['duration']['text'] . "\\n";
echo "-----------------\\n";
}
} else {
echo "Fehler: " . $data['status'];
}
?>
Die JSON Rückgabe würde so aussehen:
{
"status": "OK",
"routes": [
{
"legs": [
{
"start_address": "Berlin Hauptbahnhof, Berlin, Germany",
"end_address": "Alexanderplatz, Berlin, Germany",
"distance": {
"text": "3.4 km",
"value": 3400
},
"duration": {
"text": "10 mins",
"value": 600
}
},
{
"start_address": "Alexanderplatz, Berlin, Germany",
"end_address": "Brandenburger Tor, Berlin, Germany",
"distance": {
"text": "2.1 km",
"value": 2100
},
"duration": {
"text": "7 mins",
"value": 420
}
}
],
"summary": "Route through Berlin",
"bounds": {
"northeast": {
"lat": 52.531677,
"lng": 13.40732
},
"southwest": {
"lat": 52.49677,
"lng": 13.37889
}
}
}
]
}
Erklärung der JSON-Felder • status: Gibt den Status der API-Abfrage zurück. Hier ist der Wert “OK”, was bedeutet, dass die Anfrage erfolgreich war. • routes: Enthält eine Liste von möglichen Routen. Jede Route hat Details wie die legs, summary, und bounds. • legs: Repräsentiert einzelne Abschnitte einer Route (z. B. von einem Waypoint zum nächsten). • start_address: Startpunkt dieses Abschnitts. • end_address: Endpunkt dieses Abschnitts. • distance: Entfernung in Text (text) und in Metern (value). • duration: Geschätzte Fahrzeit in Text (text) und in Sekunden (value). • summary: Eine kurze Beschreibung der Route. • bounds: Geografische Grenzen der Route, definiert durch northeast und southwest Ecken.
In FileMaker kannst du JSON-Daten mit den eingebauten JSON-Funktionen verarbeiten. Über ein Insert from URL, so in der Art: Setzte Variable $$URL Wert https://maps.googleapis.com/maps/api/directions/json?origin=Berlin&destination=Munich&key=DEIN_API_KEY
Flexibler wird das ganze natürlich wenn ich die URL schon als Variable vorliegen habe, aber das ist abhängig von der Art und Weise des Entwicklers. Die Antwort (Ziel) speichern wir in einer Variablen z.B. $$JSON
Nun könnten wir diesen Bereich auslesen:
{
"routes": [
{
"legs": [
{
"start_address": "Berlin Hauptbahnhof, Berlin, Germany",
"end_address": "Alexanderplatz, Berlin, Germany",
"distance": {
"text": "3.4 km",
"value": 3400
},
"duration": {
"text": "10 mins",
"value": 600
}
}
]
}
]
}
Variable setzen $start = Wert gleich JSONGetElement ( $json ; “routes[0].legs[0].start_address” )
Variable setzen $distance = Wert gleich JSONGetElement ( $json ; “routes[0].legs[0].distance.text” )
Das über eine Schleife durch alle Elemente der JSON Rückantwort. Die weitere Verarbeitung ist dann an den Zweck gebunden.
Set Variable [ $i ; Value: 0 ]
Set Variable [ $legsCount ; Value: JSONListKeys ( $json ; "routes[0].legs" ) ]
Loop
Exit Loop If [ $i ≥ $legsCount ]
Set Variable [ $startAddress ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].start_address" ) ]
Set Variable [ $endAddress ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].end_address" ) ]
Set Variable [ $distance ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].distance.text" ) ]
Set Variable [ $duration ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].duration.text" ) ]
New Record/Request
Set Field [ Tabelle::StartAdresse ; $startAddress ]
Set Field [ Tabelle::ZielAdresse ; $endAddress ]
Set Field [ Tabelle::Entfernung ; $distance ]
Set Field [ Tabelle::Dauer ; $duration ]
Set Variable [ $i ; $i + 1 ]
End Loop
Das Fazit. Die Google Maps API und die Haversche Formel sind zwei leistungsfähige Werkzeuge zur Entfernungsberechnung. Während die Haversche Formel durch ihre Einfachheit punktet, liefert die Google Maps API präzisere Ergebnisse für reale Anwendungsfälle. Die Wahl hängt letztlich von den Anforderungen an Genauigkeit und Komplexität ab. Ich persönlich nutze die Haversche Formel gern um schon eine Vorauswahl der zu übertragenden Werte zu treffen. Dann muss ich keine 100 Geo-Daten an die Maps API übertragen, es reichen auch 10.
Optimierte Routenplanung mit Google Maps und FileMaker
In der heutigen digitalen Arbeitswelt spielen nahtlose Integrationen zwischen verschiedenen Systemen eine entscheidende Rolle. Besonders bei der Optimierung von Routen für Außendienstmitarbeiter oder Logistikunternehmen ist es wichtig, sowohl Zeit als auch Kosten zu sparen. Dieser Blog-Post zeigt, wie man Google Maps für die dynamische Routenplanung nutzt und gleichzeitig Daten in FileMaker integriert.
Das Problem
Viele Unternehmen stehen vor der Herausforderung, eine Vielzahl von Wegpunkten (Aufträgen) optimal zu sortieren, um eine effiziente Route zu erstellen. Dies erfordert Tools, die nicht nur Kartenansichten bereitstellen, sondern auch die Reihenfolge der Stopps optimieren und diese Informationen zurück an das System (in diesem Fall FileMaker) senden können.
Die Lösung
Das folgende PHP-Script löst dieses Problem, indem es: 1. Google Maps API verwendet, um Wegpunkte zu optimieren. 2. Die optimierte Reihenfolge als Liste darstellt. 3. Ein FileMaker-Script auslöst, um diese Daten für weitere Prozesse zu nutzen.
Der erste Schritt steht darin die Daten die benötigt werden innerhalb von FileMaker zu sammeln. Dies ist möglich über die Erstellung einer Variable per Listenfunktion, SQL oder per Schleife. Wie auch immer die Umsetzung erfolgt, am Ende benötigen wir eine URL die wir an unser PHP-Script senden können. Enthalten sein müssen, die Geo-Daten und natürlich eindeutige IDs aus FileMaker damit diese Daten später auch wieder in FileMaker verarbeitet werden können. Eine URL sollte diesen Aufbau haben: https://dein-server.de/maps.php?json=true&origin=52.5212262,13.3340740 &destination=52.5070279,13.345529 &waypoints=52.4897075,13.3290075|52.4902317,13.355636|52.5037865,13.3271369|52.504083,13.3386575&auftrag=24501|24510|24547|24551|24573|24580&facilities=6039|1940|4540|5036|6634|6545 Diese werden dann über den FM-Befehl, -AUS URL einfügen- übergeben. Wie der Aufbau innerhalb von FileMaker funktioniert ist selbstredend. Ein WebViewer innerhalb von FileMaker muss natürlich vorhanden sein. Die Rückgabe muss an den WebViewer z.B. eine globale Variable erfolgen.
Das PHP Script:
<?php
// API-Schlüssel für Google Maps
$apiKey = 'Ihr_Google_Maps_API_Schlüssel';
// Werte aus GET-Parametern holen oder Standardwerte setzen
$origin = isset($_GET['origin']) ? $_GET['origin'] : '52.515956,13.388512';
$destination = isset($_GET['destination']) ? $_GET['destination'] : '52.4981845,13.4610157';
$waypoints = isset($_GET['waypoints']) ? $_GET['waypoints'] : '';
$auftrag = isset($_GET['auftrag']) ? explode('|', $_GET['auftrag']) : [];
$facilities = isset($_GET['facilities']) ? explode('|', $_GET['facilities']) : [];
// Wegpunkte in ein Array umwandeln
$waypointsArray = explode('|', $waypoints);
?>
- Origin (Startpunkt)
Der Origin ist der Ausgangspunkt der Route. • Es handelt sich um die Position, von der die Route beginnt. • In der Regel wird sie als geografische Koordinate angegeben (z. B. 52.515956,13.388512 für Berlin). • Beispiel: Eine zentrale Lagerhalle oder der Startpunkt eines Fahrers.
- Destination (Endpunkt)
Die Destination ist das Ziel der Route. • Es ist der Punkt, an dem die Route endet. • Ähnlich wie der Origin wird auch die Destination als geografische Koordinate angegeben. • Beispiel: Der Zielort eines Lieferauftrags.
- Waypoint (Zwischenstation)
Ein Waypoint ist eine oder mehrere Zwischenstationen entlang der Route. • Es handelt sich um Orte, die der Fahrer besuchen muss, bevor er sein Ziel (Destination) erreicht. • Waypoints können ebenfalls als Koordinaten (z. B. 52.5062585,13.2845797) angegeben werden. • Sie werden oft verwendet, um Stopps bei Kunden, Lieferstationen oder Servicepunkten darzustellen. • Google Maps erlaubt, mehrere Waypoints anzugeben, um komplexe Routen zu erstellen.
Das Script liest die Parameter origin, destination, waypoints, auftrag, und facilities, um sie für die Routenplanung vorzubereiten. Diese Parameter könnten direkt aus einer FileMaker-Datenbank oder einer anderen Quelle kommen.
Die Routenoptimierung
Das Herzstück des Scripts ist die Funktion initMap():
function initMap() { const map = new google.maps.Map(document.getElementById(‘map’), { zoom: 13, center: { lat: , lng: }, });
const directionsService = new google.maps.DirectionsService();
const directionsRenderer = new google.maps.DirectionsRenderer({ map: map });
directionsService.route(
{
origin: locations[0].position,
destination: locations[locations.length - 1].position,
waypoints: locations.slice(1, -1).map(location => ({
location: location.position,
stopover: true,
})),
travelMode: google.maps.TravelMode.DRIVING,
optimizeWaypoints: true,
},
(result, status) => {
if (status === 'OK') {
directionsRenderer.setDirections(result);
const waypointOrder = result.routes[0].waypoint_order.map(index => locations[index + 1].label);
optimizedOrder = [locations[0].label, ...waypointOrder, locations[locations.length - 1].label];
} else {
console.error('Error:', status);
}
}
);
}
Die Funktion ruft die Google Maps Directions API auf, um die optimale Reihenfolge der Wegpunkte zu berechnen. Diese Reihenfolge wird in optimizedOrder gespeichert.
Integration mit FileMaker
Das Script enthält einen Button, der die optimierte Reihenfolge an ein FileMaker-Script übergibt:
function sendToFileMaker() {
if (optimizedOrder.length > 0) {
const filemakerUrl = fmp://$/DEINE_DATEI?script=(0002)_Planung_Direkt_aus_Maps_holen¶m=${encodeURIComponent(optimizedOrder.join('\n'))};
window.location.href = filemakerUrl;
} else {
alert(‘Die Route ist noch nicht optimiert. Bitte warten.');
}
}
Dieser Button ermöglicht es, die optimierten Daten direkt in FileMaker zu laden, wo sie für weitere Aktionen wie die Gruppierung von Aufträgen oder Berichte verwendet werden können.
Vorteile der Lösung 1. Zeitersparnis: Die API optimiert die Route automatisch. 2. Nahtlose Integration: Die Übergabe an FileMaker erfolgt reibungslos. 3. Flexibilität: Die Darstellung in der Karte ermöglicht eine visuelle Kontrolle der Route. 4. Erweiterbarkeit: Zusätzliche Funktionen wie das Hinzufügen von z.B. Anlagen können leicht integriert werden.
Fazit
Dieses Script ist eine effektive Lösung für Unternehmen, die ihre Logistikprozesse optimieren möchten. Durch die Kombination von Google Maps und FileMaker wird eine leistungsstarke, flexible und leicht implementierbare Lösung geschaffen.
Als Anmerkung ist allerdings zu beachten, in diesem Fall können nur 10 Punkte verarbeitet werden. Dies erfordert eine Vorauswahl der an Google zu übergebenen Punkte. Dies kann direkt schon über die Google APIs erfolgen oder z.B. die Haversche Formel.
Zum Überblick das gesamte Script:
// Werte aus GET-Parametern holen oder Standardwerte setzen
$origin = isset($_GET['origin']) ? $_GET['origin'] : '52.515956,13.388512';
$destination = isset($_GET['destination']) ? $_GET['destination'] : '52.4981845,13.4610157';
$waypoints = isset($_GET['waypoints']) ? $_GET['waypoints'] : '';
$auftrag = isset($_GET['auftrag']) ? explode('|', $_GET['auftrag']) : [];
$facilities = isset($_GET['facilities']) ? explode('|', $_GET['facilities']) : [];
// Wegpunkte in ein Array umwandeln um Anzeige über PIN
$waypointsArray = explode('|', $waypoints);
?>
<!DOCTYPE html>
<html>
<head>
<title>Dynamische Route</title>
<script src="https://maps.googleapis.com/maps/api/js?key=DEIN_API_KEY"></script>
<script>
let optimizedOrder = []; // Variable für die optimierte Reihenfolge
function initMap() {
// Initialisiere die Karte
const map = new google.maps.Map(document.getElementById('map'), {
zoom: 13,
center: { lat: <?php echo explode(',', $origin)[0]; ?>, lng: <?php echo explode(',', $origin)[1]; ?> },
});
const locations = [
{
position: { lat: <?php echo explode(',', $origin)[0]; ?>, lng: <?php echo explode(',', $origin)[1]; ?> },
label: '<?php echo $auftrag[0] ?? "Start"; ?>',
facilities: '<?php echo $facilities[0] ?? "Keine Anlagen"; ?>',
},
<?php foreach ($waypointsArray as $index => $point): ?>
{
position: { lat: <?php echo explode(',', $point)[0]; ?>, lng: <?php echo explode(',', $point)[1]; ?> },
label: '<?php echo $auftrag[$index + 1] ?? "Waypoint"; ?>',
facilities: `<?php echo str_replace(',', '<br>', $facilities[$index + 1] ?? "Keine Anlagen"); ?>`,
},
<?php endforeach; ?>
{
position: { lat: <?php echo explode(',', $destination)[0]; ?>, lng: <?php echo explode(',', $destination)[1]; ?> },
label: '<?php echo $auftrag[count($auftrag) - 1] ?? "Ziel"; ?>',
facilities: '<?php echo $facilities[count($facilities) - 1] ?? "Keine Anlagen"; ?>',
}
];
// Details zu Markern und Kreisen hinzufügen
locations.forEach((location) => {
const marker = new google.maps.Marker({
position: location.position,
map: map,
label: {
text: location.label,
color: '#000',
fontSize: '12px',
fontWeight: 'bold',
},
});
});
map.fitBounds(bounds);
}
function sendToFileMaker() {
if (optimizedOrder.length > 0) {
const filemakerUrl = `fmp://$/DEINE_DATEI?script=Planung¶m=${encodeURIComponent(optimizedOrder.join('\n'))}`;
window.location.href = filemakerUrl;
} else {
alert('Die Route ist noch nicht optimiert. Bitte warten.');
}
}
</script>
</head>
<body onload="initMap()">
<div id="map" style="width: 100%; height: 80%;"></div>
<button onclick="sendToFileMaker()">Optimierte Reihenfolge senden</button>
</body>
</html>
Erweiterte Portale in FileMaker: Liste mit PHP und Web Viewer
Erweiterte Portale in FileMaker: Anlagenliste mit PHP und Web Viewer
FileMaker ist ein vielseitiges Werkzeug für Datenbankanwendungen. Doch manchmal stoßen wir an technische Grenzen, wie die fehlende Möglichkeit, innerhalb eines Portals ein weiteres Portal zu platzieren. Diese Einschränkung können wir mit PHP und einem Web Viewer umgehen. In diesem Blog zeigen wir, wie du Anlagen zu einem Auftrag in einem Popover-Button darstellen kannst – inklusive interaktiver Buttons, die FileMaker-Scripts ausführen. Somit wirst Du in die Lage versetzt einen Datensatz auch in FileMaker anzusprechen und nicht nur den WebViewer zur Anzeige zu nutzen. In Meinem Beispiel, gehe ich von Aufträgen aus. Diese werden über ein Portal angezeigt. Jeder Auftrag kann mehrere Anlagen, bei meinem derzeitigen Kunden, sind es halt Anlagen im Bereich der Wasserversorgung.
Das Ziel 1. Anzeigen der Anlagen eines Auftrags: Eine dynamische Liste von Anlagen, dargestellt in einem Web Viewer.
2. Interaktive Aktionen:
Buttons, die ein FileMaker-Script starten, um die jeweilige Anlage anzuzeigen.
Lösung: FileMaker + PHP
- Datenübergabe von FileMaker an PHP
Der erste Schritt ist, die relevanten Daten – z. B. eine Liste von Anlagen – an ein PHP-Script zu übergeben. Dies geschieht mit einem FileMaker-Script, das die Web Viewer-URL dynamisch setzt:
Set Variable [ $auftragID ; Aufträge::ID ] Set Variable [ $anlagenListe ; Austauschen ( List ( Anlagen::AnlagenID ) ; “¶” ; “|” ) ] Set Variable [ $url ; “https://deine-webseite.de/anlagenanzeige.php?auftrag=” & $auftragID & “&anlagen=” & $anlagenListe ] Set Web Viewer [ Object Name: “WebViewer_Anlagen” ; URL: $url ]
Es ist natürlich auch möglich dem WebViewer Dynamisch eine Globale Variable zu übergeben. Dann sage ich einfach setze Variable $$WebViewer0 $url.
Nun benötigen wir natürlich noch ein PHP Script mit der beispielhaften Bezeichnung, -anlagenanzeige.php-. Dieses muss nach Erstellung auf den entsprechenden Server geladen werden.
<?php
// Daten aus der URL übernehmen
$auftragID = $_GET['auftrag'] ?? '';
$anlagenListe = $_GET['anlagen'] ?? '';
$anlagenArray = explode('|', $anlagenListe);
// Sicherheitsmaßnahmen
$auftragID = htmlspecialchars($auftragID, ENT_QUOTES, 'UTF-8');
$anlagenArray = array_map(function($anlage) {
return htmlspecialchars($anlage, ENT_QUOTES, 'UTF-8');
}, $anlagenArray);
?>
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<title>Anlagen zu Auftrag <?= $auftragID ?></title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
.anlage { margin: 10px 0; padding: 10px; border: 1px solid #ddd; }
.anlage-btn { padding: 5px 10px; background-color: #4285F4; color: white; border: none; cursor: pointer; }
</style>
</head>
<body>
<h1>Anlagen zu Auftrag <?= $auftragID ?></h1>
<?php if (!empty($anlagenArray)): ?>
<?php foreach ($anlagenArray as $anlage): ?>
<div class="anlage">
<p>Anlage ID: <?= $anlage ?></p>
<button class="anlage-btn" onclick="openInFileMaker('<?= $anlage ?>')">Anlage öffnen</button>
</div>
<?php endforeach; ?>
<?php else: ?>
<p>Keine Anlagen gefunden.</p>
<?php endif; ?>
<script>
function openInFileMaker(anlageID) {
const fileMakerUrl = `fmp://$/DeineDatenbank?script=AnlageAnzeigen¶m=${encodeURIComponent(anlageID)}`;
window.location.href = fileMakerUrl;
}
</script>
</body>
</html>
Dieses Script: • Nimmt die Anlagenliste entgegen und zerlegt sie in ein Array. • Baut eine HTML-Darstellung mit Buttons für jede Anlage. • Bindet JavaScript ein, um bei einem Klick auf den Button ein FileMaker-Script zu starten.
- Web Viewer in FileMaker
Füge einen Web Viewer in dein Layout ein und setze dessen URL mit dem oben gezeigten FileMaker-Script. Die Daten werden beim Öffnen des Popovers automatisch geladen und angezeigt.
Ergebnis 1. Dynamische Anzeige: Die Anlagenliste wird aus der FileMaker-Datenbank geladen und dynamisch dargestellt. 2. Interaktive Aktionen: Ein Klick auf einen Button ruft die entsprechende Anlage direkt in FileMaker auf.
Vorteile dieses Ansatzes • Dynamik: Änderungen in den Datenbankeinträgen werden sofort berücksichtigt. • Erweiterbarkeit: PHP bietet dir volle Flexibilität in der Anzeige und Funktionalität. • Nutzerfreundlichkeit: Direkte Interaktion aus dem Web Viewer heraus.
Fazit
Die Kombination aus FileMaker und PHP eröffnet spannende Möglichkeiten, Einschränkungen des FileMaker-Portalsystems zu umgehen. Ob für die Darstellung von Listen, Diagrammen oder interaktiven Inhalten – mit Web Viewern kannst du deine FileMaker-Lösung erheblich erweitern. In meinem Beispielbild, wird aufgrund von übergebenen Aufträgen, per Maps API eine Reihe aller in Umgebung befindlichen Aufträge angezeigt. Ein Button öffnet noch die Maps Kartenansicht, ein Button ruft ein FileMaker Script auf, übergibt per Parameter die sortierten Aufträge an FileMaker. Weiterverarbeitung ist somit jederzeit möglich. Natürlich ist auch ein Klick auf die Auftrags ID möglich, es kann dann je nach Bedarf in FileMaker weiterverarbeitet werden.
Das neue Jahr läuft an.
Das neue Jahr läuft an.
Das neue Jahr hat begonnen und ich sitze wieder am Rechner. FileMaker über Google Maps API verbinden, Daten sortieren und anzeigen.
Unterschiede zwischen SQL innerhalb von FileMaker und Datenfindung über Referenzen
Was sind Referenzen in FileMaker?
In FileMaker werden Referenzen durch die visuelle Gestaltung der Beziehungsgraphen im Beziehungsdiagramm erstellt. Hier verbindet der Entwickler Tabellen oder Tabellenvorkommen (Table Occurrences, TOs) mithilfe von Schlüsselfeldern. Diese Verbindungen, auch als Referenzen bezeichnet, ermöglichen es, Daten effizient zwischen Tabellen zu suchen, zu filtern und anzuzeigen.
Vorteile von Referenzen in FileMaker: 1. Visuelle Klarheit: • Der Beziehungsgraph bietet eine intuitive Übersicht über die Datenstruktur und die Beziehungen zwischen den Tabellen. Dies ist besonders hilfreich für Teams und neue Entwickler. • Man sieht sofort, welche Tabellen miteinander verbunden sind und wie Daten durch die Beziehungen fließen. 2. Automatische Navigation: • FileMaker ermöglicht es, Daten aus einer referenzierten Tabelle in Layouts, Portalen oder Berechnungen zu verwenden, ohne explizit SQL-Abfragen zu schreiben. • Entwickler können Daten aus mehreren Tabellen mit minimalem Aufwand kombinieren. 3. Einfachheit bei der Fehlerbehebung: • Wenn Daten nicht korrekt angezeigt werden, können Beziehungen im Graphen leicht überprüft und korrigiert werden. • Es ist einfacher, inkorrekte Beziehungen oder Verbindungsprobleme visuell zu identifizieren. 4. Leistungsvorteile: • Referenzen sind optimiert, um Daten aus verknüpften Tabellen schnell abzurufen, besonders wenn Indexe korrekt verwendet werden. • FileMaker sorgt automatisch für die Synchronisierung und Aktualisierung von referenzierten Daten. 5. Komplexitätsmanagement: • Referenzen eignen sich hervorragend für Szenarien, in denen mehrere Tabellen in einer hierarchischen oder many-to-many-Beziehung zueinander stehen.
SQL in FileMaker
SQL wird in FileMaker hauptsächlich über die ExecuteSQL()-Funktion verwendet. Diese Funktion erlaubt es, SELECT-Abfragen auszuführen, um Daten aus Tabellen unabhängig vom Beziehungsgraphen abzurufen.
Vorteile von SQL in FileMaker: 1. Flexibilität: • SQL-Abfragen ermöglichen es, Daten ohne vorher festgelegte Beziehungen im Beziehungsgraphen abzurufen. • Entwickler können komplexe Abfragen mit Joins, Aggregatfunktionen und Bedingungen erstellen, die mit Referenzen schwer umsetzbar wären. 2. Effizienz bei der Datenaggregation: • Wenn Daten aus mehreren Tabellen aggregiert oder gefiltert werden müssen, können SQL-Abfragen dies in einem einzigen Schritt erledigen. • SQL-Abfragen sind ideal für Berichte, die sich auf große Datenmengen beziehen. 3. Reduktion von TOs (Table Occurrences): • Durch die Verwendung von SQL können Entwickler die Anzahl der Tabellenvorkommen im Beziehungsdiagramm reduzieren, was den Graphen übersichtlicher macht. 4. Unabhängigkeit von FileMaker-spezifischen Logiken: • SQL ist ein standardisierter Ansatz, der für Entwickler, die bereits Erfahrung mit relationalen Datenbanken haben, leicht verständlich ist.
Herausforderungen von SQL in FileMaker
Obwohl SQL eine leistungsstarke Funktion in FileMaker ist, gibt es einige Einschränkungen und Fallstricke, die beachtet werden müssen: 1. Tabellen- und Feldnamen: • In FileMaker können Tabellennamen und Feldnamen Leerzeichen, Sonderzeichen und andere unkonventionelle Zeichen enthalten. Das führt dazu, dass diese Namen in SQL-Abfragen in Anführungszeichen gesetzt werden müssen:
SELECT “Name”, “Adresse” FROM “Kunden”; • Es ist eine bewährte Praxis, Feldnamen ohne Leerzeichen und Sonderzeichen zu verwenden, um diese Probleme zu minimieren.
- Fehlendes Feedback: • Die ExecuteSQL()-Funktion gibt keine detaillierten Fehlermeldungen zurück. Wenn eine Abfrage fehlschlägt, erhält man lediglich ein leeres Ergebnis oder ?. • Fehlerbehebung kann dadurch zeitaufwändig sein. 3. Keine Datenbearbeitung: • ExecuteSQL() ist nur zum Lesen von Daten gedacht. Zum Einfügen, Aktualisieren oder Löschen von Daten müssen andere Methoden verwendet werden. 4. Performance bei großen Datenmengen: • Während SQL bei der Aggregation von Daten effizient ist, kann es bei komplexen Abfragen mit vielen Joins in FileMaker zu Performance-Problemen kommen.
Fazit: Referenzen und SQL in FileMaker bieten jeweils einzigartige Stärken, die auf spezifische Anforderungen abgestimmt sind. Referenzen sind ideal für einfache, visuelle Datenoperationen und garantieren eine nahtlose Integration in Layouts und Workflows. SQL hingegen eröffnet erweiterte Möglichkeiten für komplexe Datenabfragen und Berichte. Eine kluge Kombination dieser Ansätze maximiert die Effizienz und Flexibilität in FileMaker-Projekten.
Unsere neue Webseite ist online – Willkommen bei FileMaker Experts!
Unsere neue Webseite ist online – Willkommen bei FileMaker Experts!
Liebe Leserinnen und Leser, wir freuen uns riesig, euch heute unsere brandneue Webseite vorzustellen: FileMaker Experts. 🎉
Nach intensiver Planung, Gestaltung und Umsetzung ist unsere neue Online-Präsenz endlich live! Hier findet ihr alles, was ihr über unsere Dienstleistungen, Lösungen und Expertise im Bereich FileMaker, PHP und Datenbank-Engineering wissen müsst.
Was euch erwartet: • Klares Design und Übersichtlichkeit: Unsere Inhalte sind jetzt noch strukturierter, damit ihr schnell die Informationen findet, die ihr sucht. • Neue Features: Von FAQs über Blogbeiträge bis hin zu einer direkten Kontaktmöglichkeit – unsere Seite bietet alles, um euch optimal zu informieren. • Einblicke in unsere Arbeit: Schaut euch an, wie wir individuelle Datenbanklösungen entwickeln, die perfekt auf eure Bedürfnisse zugeschnitten sind.
Besucht uns unter: filemaker-experts.de
Scriptaufruf aus einem WebViewer
Wie starte ich ein FileMaker Script aus einer Webseite heraus.
Häufig haben wir das Problem, komplizierte Berechnungen ausführen zu müssen. Gerade wenn viele Datensätze betroffen sind, macht es Sinn, diese Berechnungen auszulagern. Wir übergeben einem PHP-Script alle benötigten Informationen und verarbeiten nur noch die Rückgabe. Das spart unübersichtliche FileMaker-Serverscripte die oft wie eine Blackbox sind. Kein Debugger, keine Zwischenmeldung über das Dialogfenster. Nur umständliche Rückgaben in Folge-Scripte die dann überprüft werden können. Es kann aber auch sein das wir ganz normale Funktionen z.B. Google Maps nutzen wollen. Wir können dann natürlich Daten anzeigen lassen. Adressdaten und andere Daten. Aber was wenn wir aus dem WebViewer dann den entsprechenden Datensatz aufrufen wollen? Dann müssen wir auf jeden Fall in der Lage sein, unsere Datenbank aufzurufen, ein Script und natürlich benötigen wir einen Parameter damit unser Script auch den entsprechenden Datensatz findet. So ein klassischer Aufruf läuft über die Angabe der Datenbank, auch wenn der WebViewer ja schon aus der Datenbank gestartet wurde, wir geben das Script und den Parameter an.
Gut zu sehen, der Datenbankname, der Scriptname und am Ende befindet sich der dynamische Parameter. In einem Folgepost werde ich einmal beschreiben wie wir Geo Daten übergeben, sortieren und am Ende eine Tourenplanung zurückbekommen die wir in FileMaker verarbeiten können.
Externer Login über eine URL
Im Allgemeinen ermöglicht FileMaker die Integration von externen Datenquellen und Diensten über verschiedene Methoden, einschließlich der Verwendung von URLs. Externe Logins könnten erforderlich sein, wenn Sie auf Datenbanken oder Ressourcen außerhalb von FileMaker zugreifen möchten, oder wenn Sie eine Benutzerauthentifizierung für den Zugriff auf bestimmte Informationen benötigen. Genauso kann es Notwendig sein das bestimmte Personen Zugriff auf Dateien oder Datensätze einer FileMaker Datenbank erhalten sollen. Aber wie kann ich Steuern, das nur ein bestimmter User mit bestimmter Berechtigung auf meine geteilte Datei zugreifen kann? Benötigt wird auf jeden Fall ein FileMaker-Server. Eine Datei die nur dem ersten Aufruf dient und die aus der URL gelesenen Parameter verarbeitet und die eigentliche Haupt-Datei öffnet.
FileMaker ist eine Plattform für die Entwicklung von benutzerdefinierten Apps und Datenbanklösungen. Sie eignet sich gut für den Mittelstand, da sie es Unternehmen ermöglicht, maßgeschneiderte Anwendungen zu erstellen, die speziell auf ihre individuellen Anforderungen zugeschnitten sind. Hier sind einige Gründe, warum FileMaker im Mittelstand beliebt sein könnte:
- Benutzerfreundlichkeit: FileMaker bietet eine intuitive Benutzeroberfläche, die es Nutzern ermöglicht, ohne umfangreiche Programmierkenntnisse leistungsfähige Apps zu erstellen und zu verwalten.
- Flexibilität: Mittelständische Unternehmen haben oft spezifische Anforderungen, die nicht immer von Standardsoftware abgedeckt werden. Mit FileMaker können Unternehmen ihre eigenen benutzerdefinierten Lösungen entwickeln, um ihre speziellen Anforderungen zu erfüllen.
- Schnelle Entwicklung: FileMaker ermöglicht eine relativ schnelle Entwicklung von Anwendungen im Vergleich zu traditionellen Entwicklungsplattformen. Dies kann für Mittelständler von Vorteil sein, die agile Ansätze bevorzugen.
- Integration: FileMaker bietet Möglichkeiten zur Integration mit anderen Systemen und Diensten. Dies ermöglicht es Unternehmen, ihre bestehenden Softwarelösungen nahtlos in die FileMaker-Plattform zu integrieren.
- Skalierbarkeit: Die FileMaker-Plattform ist skalierbar und kann mit dem Wachstum eines Unternehmens mitwachsen. Dies ermöglicht es Mittelständlern, ihre Anwendungen und Datenbanken entsprechend ihren sich ändernden Anforderungen anzupassen.
- Mobilfreundlichkeit: FileMaker bietet Möglichkeiten zur Entwicklung von mobilen Apps, die auf verschiedenen Geräten wie Tablets und Smartphones funktionieren. Dies ist besonders wichtig, da die Arbeitsweise von Unternehmen immer mobiler wird.
Was ist FileMaker
FileMaker ist eine Plattform für die Entwicklung von benutzerdefinierten Apps und Datenbanklösungen. Sie eignet sich gut für den Mittelstand, da sie es Unternehmen ermöglicht, maßgeschneiderte Anwendungen zu erstellen, die speziell auf ihre individuellen Anforderungen zugeschnitten sind. Hier sind einige Gründe, warum FileMaker im Mittelstand beliebt sein könnte:
-
Benutzerfreundlichkeit: FileMaker bietet eine intuitive Benutzeroberfläche, die es Nutzern ermöglicht, ohne umfangreiche Programmierkenntnisse leistungsfähige Apps zu erstellen und zu verwalten.
-
Flexibilität: Mittelständische Unternehmen haben oft spezifische Anforderungen, die nicht immer von Standardsoftware abgedeckt werden. Mit FileMaker können Unternehmen ihre eigenen benutzerdefinierten Lösungen entwickeln, um ihre speziellen Anforderungen zu erfüllen.
-
Schnelle Entwicklung: FileMaker ermöglicht eine relativ schnelle Entwicklung von Anwendungen im Vergleich zu traditionellen Entwicklungsplattformen. Dies kann für Mittelständler von Vorteil sein, die agile Ansätze bevorzugen.
-
Integration: FileMaker bietet Möglichkeiten zur Integration mit anderen Systemen und Diensten. Dies ermöglicht es Unternehmen, ihre bestehenden Softwarelösungen nahtlos in die FileMaker-Plattform zu integrieren.
-
Skalierbarkeit: Die FileMaker-Plattform ist skalierbar und kann mit dem Wachstum eines Unternehmens mitwachsen. Dies ermöglicht es Mittelständlern, ihre Anwendungen und Datenbanken entsprechend ihren sich ändernden Anforderungen anzupassen.
-
Mobilfreundlichkeit: FileMaker bietet Möglichkeiten zur Entwicklung von mobilen Apps, die auf verschiedenen Geräten wie Tablets und Smartphones funktionieren. Dies ist besonders wichtig, da die Arbeitsweise von Unternehmen immer mobiler wird.
-
Sicherheit: Die Plattform bietet Funktionen zur Sicherung von Daten und Zugriffsrechten, was besonders wichtig ist, wenn es um geschäftskritische Informationen geht.
Um FileMaker effektiv in Ihrem Betrieb einzusetzen, ist es ratsam, mit einem FileMaker-Entwickler zusammenzuarbeiten, um die spezifischen Anforderungen des Unternehmens umsetzen zu können.
Die zweite Normalform (2NF)
Die Zweite Normalform (2NF) ist ein Konzept in der Datenbanktheorie, das bei der Gestaltung von Datenbanktabellen verwendet wird, um Redundanz und Anomalien in den Daten zu vermeiden. Die 2NF baut auf der ersten Normalform (1NF) auf und stellt sicher, dass Daten in einer Tabelle zusätzlich zu den Anforderungen der 1NF bestimmte weitere Bedingungen erfüllen.
Um die 2NF zu erfüllen, muss eine Tabelle zwei Kriterien erfüllen:
Alle Nichtschlüsselattribute in der Tabelle müssen funktional von einem ganzen Schlüssel (Primärschlüssel) abhängen, nicht nur von einem Teil des Schlüssels. Mit anderen Worten, alle Nichtschlüsselattribute sollten voll funktional von der Gesamtheit des Primärschlüssels abhängen, um Redundanzen und inkonsistente Daten zu vermeiden.
So kann z.B. eine Kontaktdatenbank aus 2 Tabellen bestehen. Daten wie Name, Vorname, Straße, Land usw. Die Telefonnummer steht aber in einer anderen Tabelle. Nun wird der eine oder andere sich fragen, Warum? Ganz einfach. So ist es ja möglich das der Kontakt nicht nur eine Mobil-Nummer und eine Festnetz-Nummer hat, sondern diverse für sein Business zugeschnittenen Telefon-Nummern. Nun will ich doch aber nicht unter meiner Kontakt-Tabelle 20 oder 30 Felder für diverse Telefon-Nummern führen. Also gehen die Telefon-Nummern in eine andere Tabelle. Verbunden werden die Datensätze mit dem Primärschlüssel. In der Praxis wäre dies wahrscheinlich die Kontakt_ID. Jeder Kontakt hat seine eindeutige Kontakt_ID. Jede zum Kontakt gehörende Telefon-Nummer bekommt diese Kontakt_ID zugeordnet. Nun kann ich entweder über einen SQL-Befehl oder in FileMaker über eine Referenz ganz einfach die zum Kontakt gehörenden Nummern anzeigen lassen.
Es dürfen keine teilweisen Abhängigkeiten vorhanden sein, das heißt, Attribute sollten nicht von einem Teil des Schlüssels abhängen, sondern immer vom gesamten Schlüssel.
Wenn eine Tabelle die 2NF nicht erfüllt, kann dies zu Anomalien wie Update-Anomalien (Änderungen führen zu inkonsistenten Daten), Einfüge-Anomalien (Einfügen neuer Daten ist schwierig) und Lösch-Anomalien (Löschen von Daten führt zu unerwartetem Verlust von Informationen) führen.
Um eine Tabelle in die 2NF zu überführen, müssen teilweise abhängige Attribute in separate Tabellen ausgelagert werden, wobei Beziehungen zwischen den Tabellen durch Fremdschlüssel hergestellt werden. Dies verbessert die Datenintegrität und erleichtert das Datenmanagement.
Es ist wichtig zu beachten, dass die Normalisierung von Datenbanken ein komplexer Prozess ist, der sorgfältige Planung und Analyse erfordert, um die optimale Struktur für die Daten zu gewährleisten. Häufig ist der Planungsprozess natürlich bedingt durch Altlasten oder Fehlerhaft aufgebaute Datenbanken Hinfällig. Dann beginnt die Kernkompetenz des Datenbankentwicklers. Daten werden neu strukturiert, aufgeteilt oder aber auch gelöscht.
Ein hervorragendes Instrument dafür ist FileMaker. Über sein mächtiges Import und Export-Tool, seine einzigartige Art über Relationen Daten zu managen, können auch völlig aus der Struktur geratene Datenbanksysteme neu strukturiert, aufgebaut oder aber die Daten neu Organisiert werden.
FileMaker im Mittelstand
FileMaker ist eine Datenbankplattform, die es Unternehmen ermöglicht, benutzerdefinierte Apps zur Verwaltung und Organisation von Daten zu erstellen. Sie eignet sich gut für den Einsatz im Mittelstand, da sie eine flexible Lösung für die Datenbankentwicklung bietet, ohne dass umfangreiche Programmierkenntnisse am Anfang erforderlich sind. Hier sind einige Gründe, warum FileMaker für den Mittelstand das Perfekte Datenbanktool ist:
Einfache Entwicklung: FileMaker bietet eine benutzerfreundliche Oberfläche zur Erstellung von Datenbankanwendungen. Dies ermöglicht Mitarbeitern im Mittelstand, eigene Apps zu erstellen, um spezifische Geschäftsanforderungen zu erfüllen, ohne dass umfassende Entwicklungskenntnisse erforderlich sind. Dies gilt zumindest für den Anfang. So ist die Lernkurve am Anfang sehr flach, steigt aber rasant wenn die Ansprüche an die Software steigen.
Anpassbarkeit: Mittelständische Unternehmen haben oft einzigartige Anforderungen, die nicht von Standardsoftware abgedeckt werden. FileMaker ermöglicht die Erstellung von maßgeschneiderten Lösungen, die genau auf die Bedürfnisse des Unternehmens zugeschnitten sind. So wird der Kunde zwar seine Prozesse optimieren, aber er muss seine Prozesse nicht umstellen. Dies ist gerade für Mitarbeiter, die seit Jahren die Prozesse bestimmt und optimiert haben, sehr wichtig.
Integration: FileMaker kann mit anderen Anwendungen und Systemen integriert werden, was für den Mittelstand wichtig ist, da Unternehmen oft mit verschiedenen Softwarelösungen arbeiten. Integrationen können den Datenaustausch und die Effizienz verbessern. So ist es eigentlich möglich nahezu mit jedem System zu Kommunizieren. Über Schnittstellen wie Java-Script, JSON, XML oder PHP spricht FileMaker mit jeder Software oder aber auch Hardware.
Skalierbarkeit: FileMaker-Anwendungen können mit dem Wachstum des Unternehmens mitwachsen. Wenn das Unternehmen wächst, können weitere Funktionen und Module hinzugefügt werden, um den steigenden Anforderungen gerecht zu werden.
Datenübernahme: FileMaker besitzt ein sehr mächtiges Werkzeug zur Übernahme von Daten aus anderen Systemen. Ob nur geänderte Datensätze oder neue Datensätze importiert werden sollen, schnell und effizient ist dieser Prozess durchführbar.
Mobilität: FileMaker bietet die Möglichkeit, mobile Apps für iOS- und Android-Geräte zu entwickeln. Dies ist insbesondere für Unternehmen im Mittelstand von Vorteil, da Mitarbeiter häufig unterwegs sind und dennoch auf geschäftskritische Daten zugreifen müssen.
Sicherheit: FileMaker bietet Sicherheitsfunktionen, um die Daten der Unternehmen zu schützen. Mittelständische Unternehmen können sensible Daten speichern, während sie gleichzeitig sicherstellen, dass nur autorisierte Personen darauf zugreifen können.
Kostenkontrolle: Im Vergleich zu vielen komplexen Softwareentwicklungsprojekten kann die Entwicklung von FileMaker-Anwendungen kostengünstiger sein. Dies liegt in der schnelleren Entwicklung der Lösungen. So ist durch die Kombination von Datenbank und Oberfläche eine effektivere Umsetzung von Projektentwicklungen für den Kunden möglich.
Schnelle Implementierung: Mit FileMaker können Anwendungen vergleichsweise schnell entwickelt und implementiert werden. Änderungen in Firmenabläufen und Prozessen können schnell mit FileMaker dargestellt werden.
Home Office: Was wenn die Mitarbeiter oder aber auch Kunden aus der Ferne auf die Daten zugreifen sollen? Dafür bietet FileMaker eine einzigartige Möglichkeit. WebDirect stellt die Softwarelösung Eins zu Eins im Webbrowser dar. Mit wenigen Handgriffen ermöglicht der Handwerksbetrieb, die Kanzlei einem Berechtigtem den Zugang zum System. Natürlich funktionieren auch die üblichen Zugriffsmöglichkeiten. Per RDP, per Client oder aber auch über eigens entwickelte Webseiten.
Eine häufig unterschätzte Fähigkeit von FileMaker, kleine Änderungen. Wer kennt es nicht? Ein Feld fehlt im Layout, eine Bezeichnung ändert sich, der neue Drucker lässt Bereiche des Layouts unbeachtet und die Formulare sehen nicht mehr aus wie mit der alten Hardware. In diesen Fällen kann der Nutzer mit entsprechender Berechtigung selbst Hand anlegen. Es bedarf nicht unbedingt der Unterstützung eines Entwicklers.
Die Erste Normalform (1NF)
Die Erste Normalform (1NF) ist dann gegeben, wenn alle Informationen in einer Tabelle atomar vorliegen.
So die Definition aus entsprechender Fachliteratur.
Aber was bedeutet es ?
Es bedeutet, wir müssen alle Informationen in jeweil eine Tabellenspalte bringen.
z.B. Adressdaten ohne Normalisierung.
| Name | Straße | Ort |
|---|---|---|
| Ronny Schrader | Summterstr. 43 | 16547 Birkenwerder |
Nun die gleichen Daten in erster Normalform.
| Vorname | Nachname | Straße | Nr. | PLZ | Ort |
|---|---|---|---|---|---|
| Ronny | Schrader | Summterstr. | 43 | 16547 | Birkenwerder |
Schon haben wir die erste Normalform erstellt.
Die Nullte Normalform
Normalisierung bezeichnet den Vorgang der Strukturierung und Umorganisation eines relationalen Datenbankschemas. Daten werden in verschiedene Tabellen aufgeteilt und mittels Beziehungen miteinander verknüpft, um Redundanzen, Inkonsistenzen und Anomalien zu vermeiden und zu beseitigen.
Die Nullte Normalform ist eine der Normalformen in der Datenbankentwicklung. Die Normalformen sind ein Regelsystem, welches die Bauart von Tabellen in relationalen Datenbanken festlegt. Die Nullte Normalform ist die erste Normalform und wird auch als Grundnormalform bezeichnet. In diesem Blogpost wollen wir uns die Nullte Normalform genauer anschauen und erklären, wie sie in der Datenbankentwicklung angewendet wird.
In der Nullten Normalform werden alle Elemente der Datensammlung in einer Tabelle gespeichert.
Ein häufiges Beispiel ist die Erfassung von Adressdaten in Excel. Ob Straße, Stadt oder Postleitzahl, alle Daten befinden sich in einem Datensatz.
Was bedeutet das für die Datenhaltung? Immer wieder werden schon vorhandene Informationen erfasst. Postleitzahlen, Stadt oder auch Vornamen.
Oder was passiert, wenn in den Adressdaten nur ein oder zwei mögliche Telefonnummern erfasst werden können?
Nun habe ich schon den ersten Ansatz für eine regelkonforme Normalisierung. Telefondaten, Mailadressen, kurz alle Kommunikationswege müssen in eine weitere Tabelle ausgegliedert werden.
PLZ und auch die Stadt kann problemlos ausgegliedert werden. Wobei wir bei PLZ und Stadt den Sonderfall haben, PLZ als eindeutigen Schlüssel verwenden zu können.
Über die PLZ kann die Stadt eindeutig identifiziert werden. So hängt an der 16547, die Kleinstadt Birkenwerder. Also werde ich nur noch einmal die Kleinstadt Birkenwerder erfassen. Über den eindeutigen Schlüssel 16547, wird bei jeder Adresse automatisch Birkenwerder referenziert.
Zusammenfassend können wir sagen, die Nullte Normalform darf in der Praxis keine Anwendung finden. Sie darf lediglich bei der Anforderungsanalyse für eine Datenbankentwicklung genutzt werden.