feat: auto-link fuel imports to existing or new locations

For each RoadTrip fuel entry, the import flow now tries to attach a
fuelStation locationId by: (1) nearest existing station within 100m
of the entry's coordinates, then (2) case- and whitespace-insensitive
match on the entry's location name, then (3) creating a new
fuelStation when only a name is available. Newly-created stations
are reused for subsequent records in the same import so a CSV with
many fills at the same fresh station does not produce duplicates.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mightea

app/routes/motorcycle.detail.tsx

@@ -548,36 +548,93 @@ export async function clientAction({ request }: Route.ClientActionArgs) {
     const recordsJson = formData.get("records") as string;
     const records = JSON.parse(recordsJson) as any[];
 
-    const values = records.map(record => {
-      const currency = record.currency || "CHF";
-      const rate = record.currencyRate || getCurrencyFactor(currency);
-
-      return {
-        motorcycleId,
-        type: "fuel" as const,
-        date: record.date.split("T")[0],
-        odo: record.odo,
-        cost: record.cost,
-        currency: currency,
-        fuelType: record.fuelType,
-        fuelAmount: record.fuelAmount,
-        pricePerUnit: record.pricePerUnit,
-        normalizedCost: (record.cost || 0) * rate,
-        description: null
-      };
-    });
+    const { getLocations } = await import("~/services/settings");
+    const { findNearestWithinRadius, normalizeLocationName } = await import("~/utils/geo");
+    const userLocations = await getLocations(token, user.id);
+
+    type KnownStation = { id: number; name: string; latitude: number | null; longitude: number | null };
+    const knownFuelStations: KnownStation[] = userLocations
+      .filter((l: any) => l.type === "fuelStation")
+      .map((l: any) => ({
+        id: l.id,
+        name: l.name,
+        latitude: l.latitude ?? null,
+        longitude: l.longitude ?? null,
+      }));
+
+    const resolveLocationId = async (record: any): Promise<number | null> => {
+      const hasCoords =
+        typeof record.latitude === "number" && typeof record.longitude === "number";
+      const rawName = typeof record.locationName === "string" ? record.locationName.trim() : "";
+      const hasName = rawName.length > 0;
+
+      if (hasCoords) {
+        const match = findNearestWithinRadius(
+          { latitude: record.latitude, longitude: record.longitude },
+          knownFuelStations,
+          100,
+        );
+        if (match) return match.id;
+      }
+
+      if (hasName) {
+        const target = normalizeLocationName(rawName);
+        const match = knownFuelStations.find((l) => normalizeLocationName(l.name) === target);
+        if (match) return match.id;
+      }
 
-    if (values.length > 0) {
+      if (hasName) {
+        const created = await createLocation(token, {
+          name: rawName,
+          type: "fuelStation",
+          userId: user.id,
+          latitude: hasCoords ? record.latitude : null,
+          longitude: hasCoords ? record.longitude : null,
+        });
+        if (created && typeof created.id === "number") {
+          knownFuelStations.push({
+            id: created.id,
+            name: created.name,
+            latitude: created.latitude ?? null,
+            longitude: created.longitude ?? null,
+          });
+          return created.id;
+        }
+      }
+
+      return null;
+    };
+
+    if (records.length > 0) {
       try {
         // Send requests sequentially to avoid overwhelming the backend/proxy
-        for (const record of values) {
+        // and to let later records reuse locations created during this import.
+        for (const record of records) {
+          const currency = record.currency || "CHF";
+          const rate = record.currencyRate || getCurrencyFactor(currency);
+          // eslint-disable-next-line no-await-in-loop
+          const locationId = await resolveLocationId(record);
+          const payload = {
+            motorcycleId,
+            type: "fuel" as const,
+            date: record.date.split("T")[0],
+            odo: record.odo,
+            cost: record.cost,
+            currency,
+            fuelType: record.fuelType,
+            fuelAmount: record.fuelAmount,
+            pricePerUnit: record.pricePerUnit,
+            normalizedCost: (record.cost || 0) * rate,
+            locationId,
+            description: null,
+          };
           // eslint-disable-next-line no-await-in-loop
           await fetchFromBackend(`/motorcycles/${motorcycleId}/maintenance`, {
             method: "POST",
-            body: JSON.stringify(record),
+            body: JSON.stringify(payload),
           }, token);
         }
-        return data({ success: true, intent: "importFuelData", count: values.length });
+        return data({ success: true, intent: "importFuelData", count: records.length });
       } catch (e: any) {
         return data({ success: false, intent: "importFuelData", error: e.message || "Import fehlgeschlagen" }, { status: 500 });
       }

app/utils/geo.ts

@@ -0,0 +1,49 @@
+const EARTH_RADIUS_METERS = 6_371_000;
+
+const toRad = (deg: number) => (deg * Math.PI) / 180;
+
+export function haversineMeters(
+  lat1: number,
+  lon1: number,
+  lat2: number,
+  lon2: number,
+): number {
+  const dLat = toRad(lat2 - lat1);
+  const dLon = toRad(lon2 - lon1);
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.sqrt(a));
+}
+
+interface GeoPoint {
+  latitude: number | null;
+  longitude: number | null;
+}
+
+export function normalizeLocationName(name: string): string {
+  return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+export function findNearestWithinRadius<T extends GeoPoint>(
+  target: { latitude: number; longitude: number },
+  candidates: readonly T[],
+  maxMeters: number,
+): T | null {
+  let best: T | null = null;
+  let bestDistance = Infinity;
+  for (const candidate of candidates) {
+    if (candidate.latitude === null || candidate.longitude === null) continue;
+    const distance = haversineMeters(
+      target.latitude,
+      target.longitude,
+      candidate.latitude,
+      candidate.longitude,
+    );
+    if (distance <= maxMeters && distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}

tests/utils/geo.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { haversineMeters, findNearestWithinRadius, normalizeLocationName } from "~/utils/geo";
+
+describe("normalizeLocationName", () => {
+  it("lowercases", () => {
+    expect(normalizeLocationName("Migrol Bern")).toBe("migrol bern");
+  });
+
+  it("trims surrounding whitespace", () => {
+    expect(normalizeLocationName("  Shell  ")).toBe("shell");
+  });
+
+  it("collapses internal whitespace", () => {
+    expect(normalizeLocationName("Migrol   Bern\tWest")).toBe("migrol bern west");
+  });
+
+  it("treats two casings of the same name as equal", () => {
+    expect(normalizeLocationName("BP TANKSTELLE")).toBe(normalizeLocationName("bp tankstelle"));
+  });
+});
+
+describe("haversineMeters", () => {
+  it("returns 0 for identical points", () => {
+    expect(haversineMeters(47.041214, 9.432396, 47.041214, 9.432396)).toBe(0);
+  });
+
+  it("matches a known distance (Zurich HB ↔ Bern HB ≈ 95 km)", () => {
+    const meters = haversineMeters(47.378177, 8.540192, 46.948832, 7.439136);
+    expect(meters).toBeGreaterThan(94_000);
+    expect(meters).toBeLessThan(97_000);
+  });
+
+  it("treats a ~100m offset as ~100m", () => {
+    // 1° latitude ≈ 111_111 m, so 0.0009° ≈ 100 m.
+    const meters = haversineMeters(47.0, 9.0, 47.0009, 9.0);
+    expect(meters).toBeGreaterThan(90);
+    expect(meters).toBeLessThan(110);
+  });
+});
+
+describe("findNearestWithinRadius", () => {
+  const target = { latitude: 47.0, longitude: 9.0 };
+
+  it("returns null when the candidate list is empty", () => {
+    expect(findNearestWithinRadius(target, [], 100)).toBeNull();
+  });
+
+  it("returns null when every candidate is outside the radius", () => {
+    const candidates = [
+      { id: 1, latitude: 47.01, longitude: 9.0 }, // ~1.1 km north
+      { id: 2, latitude: 47.0, longitude: 9.01 }, // ~750 m east
+    ];
+    expect(findNearestWithinRadius(target, candidates, 100)).toBeNull();
+  });
+
+  it("returns the nearest candidate when multiple are within the radius", () => {
+    const candidates = [
+      { id: "far",   latitude: 47.0008, longitude: 9.0 }, // ~89 m
+      { id: "near",  latitude: 47.0003, longitude: 9.0 }, // ~33 m
+      { id: "outer", latitude: 47.001,  longitude: 9.0 }, // ~111 m (out)
+    ];
+    expect(findNearestWithinRadius(target, candidates, 100)?.id).toBe("near");
+  });
+
+  it("ignores candidates with null coordinates", () => {
+    const candidates = [
+      { id: 1, latitude: null, longitude: null },
+      { id: 2, latitude: 47.0003, longitude: 9.0 },
+    ];
+    expect(findNearestWithinRadius(target, candidates, 100)?.id).toBe(2);
+  });
+
+  it("includes a candidate exactly at the boundary", () => {
+    // 0.0009° ≈ 100 m, so this point is right around the radius edge.
+    const candidates = [{ id: 1, latitude: 47.0009, longitude: 9.0 }];
+    expect(findNearestWithinRadius(target, candidates, 110)?.id).toBe(1);
+  });
+});