Ronny Schrader

Während meiner Arbeit an der serverseitigen PDF-Generierung mit ZUGFeRD wurde mir schnell klar, dass viele Kunden zunehmend auf den UBL-Standard setzen – gerade im internationalen Kontext oder in Verbindung mit elektronischen Rechnungsplattformen. Also habe ich kurzerhand ein eigenes PHP-Skript geschrieben, das auf POST-Daten aus FileMaker oder anderen Quellen reagiert und daraus eine gültige UBL-Rechnung im XML-Format erstellt.

Wie so oft war der Aufbau des XML-Dokuments der anspruchsvollste Teil. Viele Details wie Namespaces, Pflichtfelder und ISO-konforme Datums- und Betragsformate mussten exakt stimmen. Außerdem wollte ich vermeiden, dass mein System bei fehlenden Daten abstürzt – darum habe ich Fallbacks eingebaut und ein eigenes Logging-System integriert.

Das Skript liest die Rechnungsdaten, Kunden- und Lieferantendaten sowie die Rechnungspositionen ein, berechnet die Summen und schreibt daraus ein vollständiges XML-Dokument nach dem UBL 2.1-Standard, das sich z. B. auch für die XRechnung weiterverwenden lässt. Die resultierende Datei ist kompatibel mit Plattformen wie PEPPOL, eRechnung.gv.at oder Zentralplattformen der öffentlichen Hand.

Die Daten werden in FileMaker gesammelt, das ganze klassisch über schleifen. Die Daten werden über ein einfaches application/x-www-form-urlencoded-POST-Request übergeben. Alle Felder werden als Key-Value-Paare übermittelt. Die Rechnungspositionen (line items) sind dabei als kompaktes Raw-String-Feld lineItemsRaw codiert, das einzelne Positionen mit | trennt und innerhalb der Position durch ; strukturiert ist.

FileMaker bietet zwar mittlerweile solide Funktionen für JSON-Manipulation – aber bei 25+ Feldern und einer schlichten Punkt-zu-Punkt-Kommunikation mit meinem PHP-Skript war mir das einfach zu umständlich. Ich wollte keine JSON-Parser-Bastelei, sondern einfach Daten senden. Daher nutze ich application/x-www-form-urlencoded, was mit curl ohnehin besser lesbar ist und mir in PHP direkt über $_POST zur Verfügung steht.

“-X POST " & “–header "Content-Type: application/x-www-form-urlencoded" " & “–data " & Zitat ( “invoiceNumber=” & $invoiceNumber & “&invoiceDate=” & $invoiceDate & “&invoiceCurrencyCode=” & $invoiceCurrencyCode & “&invoiceTypeCode=” & $invoiceTypeCode & “&dueDate=” & $dueDate & “&paymentTerms=” & $paymentTerms & “&deliveryTerms=” & $deliveryTerms &

“&sellerName=” & $sellerName & “&sellerStreet=” & $sellerStreet & “&sellerPostalCode=” & $sellerPostalCode & “&sellerCity=” & $sellerCity & “&sellerCountryCode=” & $sellerCountryCode & “&sellerTaxID=” & $sellerTaxID &

“&lieferschein_nr=” & $lieferschein_nr & “&kunden_nr=” & $kunden_nr &

“&buyerName=” & $buyerName & “&buyerStreet=” & $buyerStreet & “&buyerPostalCode=” & $buyerPostalCode & “&buyerCity=” & $buyerCity & “&buyerCountryCode=” & $buyerCountryCode & “&buyerTaxID=” & $buyerTaxID &

“&paymentMeansCode=” & $paymentMeansCode & “&payeeFinancialInstitution=” & $payeeFinancialInstitution & “&payeeIBAN=” & $payeeIBAN & “&payeeBIC=” & $payeeBIC & “&paymentReference=” & $paymentReference &

“&taxRate=” & $taxRate & “&taxAmount=” & $taxAmount & “&taxableAmount=” & $taxableAmount & “&taxCategoryCode=” & $taxCategoryCode &

“&totalNetAmount=” & $totalNetAmount & “&totalTaxAmount=” & $totalTaxAmount & “&totalGrossAmount=” & $totalGrossAmount & “&lineItemsRaw=” & $lineItemsRaw )

$dom = new DOMDocument('1.0', 'UTF-8');
$dom->formatOutput = true;

$invoice = $dom->createElementNS(
    'urn:oasis:names:specification:ubl:schema:xsd:Invoice-2',
    'Invoice'
);
$invoice->setAttribute('xmlns:cac', 'urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2');
$invoice->setAttribute('xmlns:cbc', 'urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2');
$dom->appendChild($invoice);

// Standardfelder setzen
$invoice->appendChild($dom->createElement('cbc:UBLVersionID', '2.1'));
$invoice->appendChild($dom->createElement('cbc:CustomizationID', 
    'urn:cen.eu:en16931:2017#compliant#urn:xoev-de:kosit:standard:xrechnung_2.0'));

$invoice->appendChild($dom->createElement('cbc:ID', $invoiceNumber));
$invoice->appendChild($dom->createElement('cbc:IssueDate', $invoiceDate));
$invoice->appendChild($dom->createElement('cbc:InvoiceTypeCode', '380'));
$invoice->appendChild($dom->createElement('cbc:DocumentCurrencyCode', 'EUR'));

Der Aufbau geht dann weiter über Verkäufer- und Käuferdaten, Zahlungsinformationen, steuerliche Angaben und natürlich die Rechnungspositionen, die als cac:InvoiceLine-Blöcke angelegt werden.

Die Daten werden direkt auf dem Server verarbeitet, im Anschluss kann ich die XML-Datei wieder in ein FileMaker-Feld laden (Aus URL einfügen).

Da ich mit horstoeko/zugferd arbeite, wird in der Folgeversion noch die Validierung erfolgen. Die derzeit händische, zeigt alle Werte, keine Fehler, keine Warnungen.

Die Verwaltung von Aufgaben kann schnell unübersichtlich werden, wenn viele Prozesse gleichzeitig laufen und verschiedene Mitarbeiter involviert sind. Eine klassische Methode zur Visualisierung solcher Abläufe ist die Kanban-Tafel, die durch ihre intuitive Struktur einen schnellen Überblick über den Status der einzelnen Aufgaben bietet. Doch während viele Tools auf dem Markt existieren, soll in diesem Artikel eine maßgeschneiderte Lösung direkt in FileMaker realisiert werden – mit Hilfe von PHP und JavaScript in einem Webviewer. Es gibt natürlich eine FileMaker-Eigene Implementierung über die Add-ons. Mir persönlich ist diese Möglichkeit aber zu eingeschränkt. So sind die Tafeln nicht Dynamisch, ich kann z.B. keine Symbole oder Bilder mit integrieren und die Steuerung der Abläufe ist nicht richtig konsistent.

Deshalb die Idee, ich setze das einfach mit PHP, Java-Script über den WebViewer von FileMaker um. Das Ziel ist es, eine interaktive Kanban-Tafel direkt in FileMaker zu integrieren, die alle relevanten Aufgaben übersichtlich darstellt und es ermöglicht, diese per Drag & Drop zwischen den verschiedenen Status-Spalten zu verschieben. Diese Statusänderungen sollen dann automatisch an FileMaker zurückgemeldet werden, sodass keine doppelte Pflege von Daten notwendig ist. Die Techniken dahinter: -PHP als Schnittstelle zur Verarbeitung und Bereitstellung der Daten. -JavaScript mit jQuery UI für die interaktive Drag & Drop-Funktionalität. -FileMaker-Skripte, um die Änderungen zurück in die FileMaker-Datenbank zu schreiben.

Als erstes müssen wir uns klar werden wie die Daten an das PHP-Script übergeben werden. Ich persönlich nutze gern die Möglichkeit Einträge mit einem Pipe getrennt zu übertragen. Das lässt sich in FileMaker wunderbar über eine Schleife realisieren. In meinem Beispiel werden verschiedene ID,s übertragen.

Damit die Kanban-Ansicht ihre Inhalte aus FileMaker beziehen kann, müssen die relevanten Daten über eine URL in PHP übergeben werden. Dazu werden die folgenden Parameter als GET-Request an eine PHP-Datei gesendet:

projects: Enthält die Auftragsnummern. staff: Enthält die zugeordneten Mitarbeiter. anlage: Enthält die Referenz zur Anlage. status: Gibt den aktuellen Status der Aufgabe an (z. B. “In Planung” oder “Erledigt”). task: Enthält die eindeutige Task-ID (Aufgaben ID) zur Identifikation. image: Gibt den Namen des Symbols an, das in der Kanban-Karte angezeigt werden soll.

Meine fertige URL schaut ungefähr so aus: https://maeine_url_.de/cap/kanban.php?projects=24944|24945|24946&staff=STA020|STA023|STA025&anlage=B14C380C-4329-E54B-ACA1-B2054C5D4B3A|B14C380C-4329-E54B-ACA1-B2054C5D4B3A&status=Erledigt|In Planung|Material bestellt&task=TSK004729|TSK004730|TSK004731&image=Blau|Gelb|Rot

Der Weg diese zu generieren sollte klar sein. Per Schleife durch die Aufgaben, entweder gefiltert nach Datum oder Zeitraum etc. Nun wird dieser Wert in eine Globale Variable geschrieben z.B. $$URL. Dann der FileMaker Befehl, aus URL einfügen. Dabei generieren wir eine Variable z.B. $$URL_WEBVIEWER. Diese kommt dann als Inhalt in unseren Webviewer den wir uns innerhalb eines FileMaker-Layouts platzieren.

Unser Script:

<?php
// Header für UTF-8 Encoding
header("Content-Type: text/html; charset=UTF-8");

// Daten aus der URL holen
$projects = isset($_GET['projects']) ? explode('|', $_GET['projects']) : [];
$staff = isset($_GET['staff']) ? explode('|', $_GET['staff']) : [];
$anlage = isset($_GET['anlage']) ? explode('|', $_GET['anlage']) : [];
$status = isset($_GET['status']) ? explode('|', $_GET['status']) : [];
$task = isset($_GET['task']) ? explode('|', $_GET['task']) : [];
$images = isset($_GET['image']) ? explode('|', $_GET['image']) : [];

// Basis-URL für die Icons
$imageBaseUrl = "http://Deine_URL.de/GoogleMarkers/";

// Status und Farben definieren
$status_colors = [
    "Material bestellt" => "#FFD700", // Gelb
    "In Planung" => "#FFA500", // Orange
    "Verplant" => "#FF4500", // Dunkelorange
    "Ausgeführt" => "#008000", // Grün
    "Angebot folgt" => "#FF0000", // Rot
    "Erledigt" => "#808080" // Grau
];

// Spalten für das Kanban-Board
$columns = ["Material bestellt", "In Planung", "Verplant", "Ausgeführt", "Angebot folgt", "Erledigt"];

// Aufgaben nach Status sortieren
$tasks_by_status = [];
foreach ($status as $index => $task_status) {
    $tasks_by_status[$task_status][] = [
        "id" => $task[$index] ?? "TSK-Unbekannt",
        "project" => $projects[$index] ?? "Unbekannt",
        "staff" => $staff[$index] ?? "Kein Mitarbeiter",
        "anlage" => $anlage[$index] ?? "Keine Anlage",
        "image" => isset($images[$index]) && !empty($images[$index]) ? $imageBaseUrl . $images[$index] . ".png" : "",
        "status" => $task_status
    ];
}
?>

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <title>Aufgaben Board</title>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.12.1/jquery-ui.min.js"></script>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f4;
        }
        .kanban-board {
            display: flex;
            justify-content: space-between;
            padding: 20px;
            gap: 10px;
        }
        .kanban-column {
            width: 16%;
            min-height: 400px;
            background: #ddd;
            padding: 10px;
            border-radius: 5px;
            display: flex;
            flex-direction: column;
            align-items: center;
        }
        .kanban-card {
            background: white;
            padding: 10px;
            margin-bottom: 10px;
            border-radius: 5px;
            box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.1);
            cursor: grab;
            width: 90%;
            text-align: center;
            transition: background-color 0.3s;
            position: relative;
        }
        .kanban-card img {
            position: absolute;
            top: 5px;
            left: 5px;
            width: 20px;
            height: 20px;
        }
        .sortable {
            width: 100%;
            min-height: 50px;
        }
        .sortable-placeholder {
            background: #ccc;
            height: 50px;
            border-radius: 5px;
            margin-bottom: 10px;
            width: 90%;
        }
    </style>
</head>
<body>

<h2 style="text-align: center;">Aufgaben Board</h2>

<div class="kanban-board">
    <?php foreach ($columns as $column): ?>
        <div class="kanban-column" id="<?= htmlspecialchars($column) ?>">
            <h3><?= htmlspecialchars($column) ?></h3>
            <div class="sortable" id="sortable-<?= htmlspecialchars($column) ?>">
                <?php if (!empty($tasks_by_status[$column])): ?>
                    <?php foreach ($tasks_by_status[$column] as $task): ?>
                        <div class="kanban-card"
                            id="<?= htmlspecialchars($task['id']) ?>"
                            data-task-id="<?= htmlspecialchars($task['id']) ?>"
                            data-status="<?= htmlspecialchars($task['status']) ?>"
                            style="background-color: <?= $status_colors[$column] ?? '#ffffff' ?>;">
                            
                            <?php if (!empty($task['image'])): ?>
                                <img src="<?= $task['image'] ?>" alt="Symbol">
                            <?php endif; ?>

                            <strong>Auftrag:</strong> <?= htmlspecialchars($task["project"]) ?><br>
                            <strong>Anlage:</strong> <?= htmlspecialchars($task["anlage"]) ?><br>
                            <strong>Mitarbeiter:</strong> <?= htmlspecialchars($task["staff"]) ?>
                        </div>
                    <?php endforeach; ?>
                <?php endif; ?>
            </div>
        </div>
    <?php endforeach; ?>
</div>

<script>
    // Status und zugehörige Farben
    var statusColors = {
        "Material bestellt": "#FFD700", // Gelb
        "In Planung": "#FFA500", // Orange
        "Verplant": "#FF4500", // Dunkelorange
        "Ausgeführt": "#008000", // Grün
        "Angebot folgt": "#FF0000", // Rot
        "Erledigt": "#808080" // Grau
    };

    $(document).ready(function() {
        console.log(" jQuery und jQuery-UI wurden geladen.");

        $(".sortable").sortable({
            connectWith: ".sortable",
            placeholder: "sortable-placeholder",
            revert: true,
            start: function(event, ui) {
                console.log("Drag gestartet für:", ui.item.attr("id"));
            },
            stop: function(event, ui) {
                var newStatus = ui.item.closest(".kanban-column").attr("id");
                var taskId = ui.item.attr("id");

                console.log("Aufgabe verschoben:", taskId, "Neuer Status:", newStatus);

                // Neue Farbe setzen
                if (statusColors[newStatus]) {
                    ui.item.css("background-color", statusColors[newStatus]);
                }

                // FileMaker-Skript über fmp:// URL aufrufen
                var fileMakerScriptURL = "fmp://$/Deine_Datei?script=UpdateTaskStatus&param=" + encodeURIComponent(taskId + "|" + newStatus);
                console.log(" FileMaker-Skript aufrufen:", fileMakerScriptURL);

                // WebViewer öffnet FileMaker-Skript
                window.location = fileMakerScriptURL;
            }
        }).disableSelection();
    });
</script>

</body>
</html>

Die Updates der Änderungen werden über ein kleines weiteres PHP Script abgefangen.

<?php
// POST-Daten empfangen
$taskId = $_POST['id'] ?? null;
$newStatus = $_POST['status'] ?? null;

if ($taskId && $newStatus) {
	// Hier würdest du die Daten in FileMaker oder einer Datenbank speichern
	file_put_contents("kanban_log.txt", "ID: $taskId -> $newStatus\n", FILE_APPEND);
	echo "OK";
} else {
	echo "Fehler: Ungültige Daten";
}
?>

Führe ich nun eine Änderung durch, wird das FileMaker-Script -UpdateTaskStatus- aufgerufen, es übergibt als Parameter die Task-ID und den neuen Status. Damit habe ich natürlich die Möglichkeit im Hintergrund sofort die Änderungen zu verarbeiten. Also, neues Fenster, 1x1 px, bei -30000px. Dort suche ich die Task-ID und ändere den Status. Fenster schließen und der Vorgang ist abgeschlossen.

FileMaker bietet mit Portalen eine gute Möglichkeit, Listen anzuzeigen. Doch wenn der Platz begrenzt ist, stößt man schnell an Grenzen. Ein Web Viewer bietet hier eine flexible Lösung, um Inhalte dynamisch darzustellen – inklusive automatischer Anpassung der Schriftgröße und Zeilenhöhe! Hintergrund, ein Kunde hat Formulare die mit Nadeldrucker geschrieben werden. Es ist also nicht möglich die Struktur des Ausdruckes zu ändern. Alles muss auf diese Seite. Bisher war es kein Problem, es gab für bestimmte Vorgänge einen Ansprechpartner mit Telefonnummer. Nun können es aber auch 2 oder drei Ansprechpartner sein. Was nun? Dann muss die Schriftart dynamisch kleiner werden. Das ganze geht auch mit FileMaker, aber wie bekomme ich dann das Portal dynamisch kleiner. Ich weiss nicht. Also bin ich auf die Idee gekommen, die Anzeige über den WebViewer laufen zu lassen.

Dabei ist es ein ganz einfacher Prozess: 1.bauen einer Liste in einer Variablen, die Einträge Namen und Telefon 1 und Telefon zwei werden ganz einfach über einen Pipe getrennt.

2. Wir legen unds ein WebViewer in das Drucklayout, benannt z.B. -Telefonliste- , als URL bzw. Inhalt eine globale Variable, z.B. $$HTML.

3. Wir gehen wieder in unser Script, legen eine Variable an -$$HTML- die se hat folgenden Inhalt:

Set Variable [ $$html ;
"data:text/html," & 
"" & Char(10) & 
"" & Char(10) & 
"" & Char(10) & 
"    " & Char(10) & 
"    " & Char(10) & 
“” & Char(10) &
“” & Char(10) &
“
” &
Substitute ( $$namen_liste ; “¶” ; Char(10) ) &

“
” & Char(10) &

“” & Char(10) &
“”
]

Wenn jetzt das Script ausgeführt wird, haben wir dynamisch die Größe der Schriftart und der Zeilenabstände. Wenn es noch nicht passt, muss nur an dieser Stelle geändert werden. Für mich eine kleine perfekte Lösung um das Platzproblem zu lösen.

Häufig sprechen wir über Geodaten – doch wie bekommen wir diese eigentlich in unsere FileMaker-Datenbank? In vielen meiner kurzen Anrisse, geht es immer wieder um Geo-Daten. Wir übertragen sie in Richtung Google-Maps, in verschiedensten Formen. Nur wir benötigen diese im ersten Schritt. Wenn Sie eine Adresse in Latitude (Breitengrad) und Longitude (Längengrad) umwandeln möchten, bietet sich die Nutzung der Google Geocoding API an. Aber seien wir ehrlich: Niemand hat Lust, sich mit komplexen JSON-Daten oder unnötigem Ballast herumzuschlagen. Darum haben wir uns eine besonders „faule“, aber effektive Lösung überlegt: Wir lassen uns einfach nur die beiden benötigten Geodaten ausgeben – fertig. Ich erhalte eine Variable mit zwei Elementen. Diese kann ich dann in FileMaker mit zwei Scriptschritten weiterverarbeiten.

Warum Geodaten in FileMaker nutzen?

Geodaten können in einer Datenbank unglaublich vielseitig eingesetzt werden: • Visualisierung: Stellen Sie Adressen als Marker in Google Maps dar. • Navigation: Berechnen Sie Routen und Entfernungen. • Datenanalyse: Prüfen Sie, welche Kunden sich in einem bestimmten Radius befinden.

Die Herausforderung? FileMaker arbeitet am besten mit einfachen, strukturierten Daten. Darum konzentrieren wir uns auf die Essenz: Breitengrad und Längengrad.

Die „faule“ Lösung: Minimalistische Datenabfrage

Statt alle Details wie die formattierte Adresse oder die Geometrie-Typen der Google Geocoding API zu verarbeiten, nutzen wir ein PHP-Skript, das uns genau die zwei benötigten Werte zurückgibt: Latitude und Longitude, getrennt durch einen Zeilenumbruch. So lassen sich die Daten in FileMaker besonders einfach integrieren.

Mein Beispiel:

< ?php
// API-Key hier einfügen
$apiKey = "hier der Goggle API-Key";

// Parameter prüfen
if (isset($_GET['params'])) {
    $params = explode('|', $_GET['params']); // Erwartet: Straße|PLZ|Stadt
    if (count($params) >= 3) {
        $street = trim($params[0]); // Straße und Hausnummer
        $city = trim($params[2]);   // Stadt
        $zip = trim($params[1]);    // Postleitzahl
        $country = isset($params[3]) ? trim($params[3]) : "DE"; // Standard: Deutschland

        // Adresse zusammenstellen
        $addressComponents = array_filter([$street, $city, $zip, $country]); // Entfernt leere Werte
        $address = implode(',', $addressComponents);

        $url = "[maps.googleapis.com/maps/api/...](https://maps.googleapis.com/maps/api/geocode/json?address=)" . urlencode($address) . "&key={$apiKey}";

        // API-Anfrage senden
        $response = file_get_contents($url);

        // Prüfen, ob die Antwort erfolgreich war
        if ($response === false) {
            echo "Fehler beim Abrufen der API\n";
            exit;
        }

        // API-Antwort decodieren
        $data = json_decode($response, true);

        // Ergebnisse prüfen
        if ($data['status'] === "OK" && isset($data['results'][0]['geometry']['location'])) {
            $location = $data['results'][0]['geometry']['location'];
            // Nur Latitude und Longitude ausgeben, getrennt durch Zeilenumbruch
            echo $location['lat'] . "\n" . $location['lng'];
        } else {
            echo "Keine Geodaten gefunden\n";
        }
    } else {
        echo "Ungültiges Format. Erwartet: Straße|PLZ|Stadt\n";
    }
} else {
    echo "Parameter 'params' fehlt. Erwartet: Straße|PLZ|Stadt\n";
}

Das ganze sind 45 Zeilen Code. In FileMaker hätte ich die JSON-Rückgabe erstmal umständlich zerlegen müssen. Über diese Form bekomme ich einen Parameter mit z.B. diesen Werten.

52.6033116 13.3534074

Dafür habe ich lediglich die Straße, PLZ und Stadt übertragen. Natürlich auch das auf ganz leichte Weise.

ihr-server.de/geocode.p… Ring 83|13435|Berlin

Getrennt durch einen Pipe, werden die Daten in eine FileMaker-Variable geschrieben. Über den FM-Befehl -aus URL einfügen- bekomme ich dann die beiten gewünschten Werte zurück und kann sie einfach in zwei FileMaker Felder schreiben.

Mein Fazit, manchmal lohnt es sich, Dinge einfach zu halten – und unsere „faule“ Lösung ist das beste Beispiel dafür. Mit nur einem Skript und einem einfachen Aufruf können Sie Geodaten in FileMaker integrieren und so Ihre Datenbank erweitern. Probieren Sie es aus und lassen Sie Ihre Adressen lebendig werden!

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.

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

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.

Meine Frau weiß genau was ein Programmierer zum arbeiten benötigt. Viel Cola…. Danke für meinen schönen Geburtstag 🎂 ❤️

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.

2. 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.

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);
?>

1. 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.

2. 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.

3. 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&param=${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&param=${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>