joachim/location-mqtt-tracker-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Edit files

Browse Source
This commit is contained in:
Joachim Hummel
2025-11-24 20:33:15 +00:00
parent 843e93a274
commit b1190e2e50
14 changed files with 846 additions and 1207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
app/api/export/csv/route.ts Normal file
View File

@@ -0,0 +1,143 @@
import { NextRequest, NextResponse } from "next/server";
import { locationDb, userDb } from "@/lib/db";
import { auth } from "@/lib/auth";
import { calculateDistance, RateLimitedGeocoder } from "@/lib/geo-utils";
/**
* GET /api/export/csv
*
* Export location data as CSV for Lexware digital logbook
*
* Query parameters:
* - username: Filter by device tracker ID
* - startTime: Custom range start (ISO string)
* - endTime: Custom range end (ISO string)
* - includeGeocoding: Whether to include addresses (default: false for preview)
*/
export async function GET(request: NextRequest) {
try {
// Check authentication
const session = await auth();
if (!session?.user) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
// Get user's allowed device IDs
const userId = (session.user as any).id;
const role = (session.user as any).role;
const sessionUsername = session.user.name || '';
const userDeviceIds = userDb.getAllowedDeviceIds(userId, role, sessionUsername);
if (userDeviceIds.length === 0) {
return new NextResponse("Keine Geräte verfügbar", { status: 403 });
}
const searchParams = request.nextUrl.searchParams;
const username = searchParams.get('username') || undefined;
const startTime = searchParams.get('startTime') || undefined;
const endTime = searchParams.get('endTime') || undefined;
const includeGeocoding = searchParams.get('includeGeocoding') === 'true';
// Fetch locations from database
let locations = locationDb.findMany({
user_id: 0,
username,
startTime,
endTime,
limit: 10000, // High limit for exports
});
// Filter by user's allowed devices
locations = locations.filter(loc => loc.username && userDeviceIds.includes(loc.username));
if (locations.length === 0) {
return new NextResponse("Keine Daten im gewählten Zeitraum", { status: 404 });
}
// Sort chronologically (oldest first) for proper distance calculation
locations.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
// Initialize geocoder if needed
const geocoder = includeGeocoding ? new RateLimitedGeocoder() : null;
// Build CSV
const csvRows: string[] = [];
// Header
csvRows.push('Datum,Uhrzeit,Latitude,Longitude,Adresse,Distanz (km),Geschwindigkeit (km/h),Gerät');
// Process each location
for (let i = 0; i < locations.length; i++) {
const loc = locations[i];
const lat = Number(loc.latitude);
const lon = Number(loc.longitude);
// Calculate distance from previous point
let distance = 0;
if (i > 0) {
const prevLoc = locations[i - 1];
distance = calculateDistance(
Number(prevLoc.latitude),
Number(prevLoc.longitude),
lat,
lon
);
}
// Geocode if requested
let address = `${lat.toFixed(6)}, ${lon.toFixed(6)}`;
if (geocoder) {
address = await geocoder.geocode(lat, lon);
}
// Format timestamp (German format)
const date = new Date(loc.timestamp);
const dateStr = date.toLocaleDateString('de-DE', {
year: 'numeric',
month: '2-digit',
day: '2-digit',
});
const timeStr = date.toLocaleTimeString('de-DE', {
hour: '2-digit',
minute: '2-digit',
second: '2-digit',
});
// Speed (may be null)
const speed = loc.speed != null ? Number(loc.speed).toFixed(1) : '';
// Device name
const deviceName = loc.username || 'Unbekannt';
// Build CSV row - properly escape address field
const escapedAddress = address.includes(',') ? `"${address}"` : address;
const distanceStr = distance.toFixed(3).replace('.', ','); // German decimal separator
csvRows.push(
`${dateStr},${timeStr},${lat.toFixed(6)},${lon.toFixed(6)},${escapedAddress},${distanceStr},${speed},${deviceName}`
);
}
const csv = csvRows.join('\n');
// Return CSV with proper headers
const filename = `fahrtenbuch_${startTime ? new Date(startTime).toISOString().split('T')[0] : 'alle'}_${endTime ? new Date(endTime).toISOString().split('T')[0] : 'alle'}.csv`;
return new NextResponse(csv, {
headers: {
'Content-Type': 'text/csv; charset=utf-8',
'Content-Disposition': `attachment; filename="${filename}"`,
},
});
} catch (error) {
console.error("Error exporting CSV:", error);
return NextResponse.json(
{
error: "Failed to export CSV",
details: error instanceof Error ? error.message : "Unknown error"
},
{ status: 500 }
);
}
}

4
app/api/locations/ingest/route.ts
View File

@@ -4,8 +4,8 @@ import { locationDb, Location } from '@/lib/db';
/**
* POST /api/locations/ingest
*
* Endpoint for n8n to push location data to local SQLite cache.
* This is called AFTER n8n stores the data in NocoDB.
* Endpoint for external systems to push location data to local SQLite cache.
* Can be used for bulk imports or external integrations.
*
* Expected payload (single location or array):
* {

124
app/api/locations/route.ts
View File

@@ -3,15 +3,11 @@ import type { LocationResponse } from "@/types/location";
import { locationDb, Location, deviceDb, userDb } from "@/lib/db";
import { auth } from "@/lib/auth";
const N8N_API_URL = process.env.N8N_API_URL || "https://n8n.example.com/webhook/location";
/**
* GET /api/locations
*
* Hybrid approach:
* 1. Fetch fresh data from n8n webhook
* 2. Store new locations in local SQLite cache
* 3. Return filtered data from SQLite (enables 24h+ history)
* Fetches location data from local SQLite cache.
* The MQTT subscriber automatically writes new locations to the cache.
*
* Query parameters:
* - username: Filter by device tracker ID
@@ -19,7 +15,6 @@ const N8N_API_URL = process.env.N8N_API_URL || "https://n8n.example.com/webhook/
* - startTime: Custom range start (ISO string)
* - endTime: Custom range end (ISO string)
* - limit: Maximum number of records (default: 1000)
* - sync: Set to 'false' to skip n8n fetch and read only from cache
*/
export async function GET(request: NextRequest) {
try {
@@ -58,87 +53,8 @@ export async function GET(request: NextRequest) {
const limit = searchParams.get('limit')
? parseInt(searchParams.get('limit')!, 10)
: 1000;
const sync = searchParams.get('sync') !== 'false'; // Default: true
// Variable to store n8n data as fallback
let n8nData: LocationResponse | null = null;
// Step 1: Optionally fetch and sync from n8n
if (sync) {
try {
const response = await fetch(N8N_API_URL, {
cache: "no-store",
signal: AbortSignal.timeout(3000), // 3 second timeout
});
if (response.ok) {
const data: LocationResponse = await response.json();
// Debug: Log first location from n8n
if (data.history && data.history.length > 0) {
console.log('[N8N Debug] First location from n8n:', {
username: data.history[0].username,
speed: data.history[0].speed,
speed_type: typeof data.history[0].speed,
speed_exists: 'speed' in data.history[0],
battery: data.history[0].battery,
battery_type: typeof data.history[0].battery,
battery_exists: 'battery' in data.history[0]
});
}
// Normalize data: Ensure speed and battery fields exist (treat 0 explicitly)
if (data.history && Array.isArray(data.history)) {
data.history = data.history.map(loc => {
// Generate display_time in German locale (Europe/Berlin timezone)
const displayTime = new Date(loc.timestamp).toLocaleString('de-DE', {
timeZone: 'Europe/Berlin',
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
second: '2-digit'
});
return {
...loc,
display_time: displayTime,
// Explicit handling: 0 is valid, only undefined/null → null
speed: typeof loc.speed === 'number' ? loc.speed : (loc.speed !== undefined && loc.speed !== null ? Number(loc.speed) : null),
battery: typeof loc.battery === 'number' ? loc.battery : (loc.battery !== undefined && loc.battery !== null ? Number(loc.battery) : null),
};
});
}
// Store n8n data for fallback
n8nData = data;
// Store new locations in SQLite
if (data.history && Array.isArray(data.history) && data.history.length > 0) {
// Get latest timestamp from our DB
const stats = locationDb.getStats();
const lastLocalTimestamp = stats.newest || '1970-01-01T00:00:00Z';
// Filter for only newer locations
const newLocations = data.history.filter(loc =>
loc.timestamp > lastLocalTimestamp
);
if (newLocations.length > 0) {
const inserted = locationDb.createMany(newLocations as Location[]);
console.log(`[Location Sync] Inserted ${inserted} new locations from n8n`);
}
}
}
} catch (syncError) {
// n8n not reachable - that's ok, we'll use cached data
console.warn('[Location Sync] n8n webhook not reachable, using cache only:',
syncError instanceof Error ? syncError.message : 'Unknown error');
}
}
// Step 2: Read from local SQLite with filters
// Read from local SQLite with filters
let locations = locationDb.findMany({
user_id: 0, // Always filter for MQTT devices
username,
@@ -151,38 +67,6 @@ export async function GET(request: NextRequest) {
// Filter locations to only include user's devices
locations = locations.filter(loc => loc.username && userDeviceIds.includes(loc.username));
// Step 3: If DB is empty, use n8n data as fallback
if (locations.length === 0 && n8nData && n8nData.history) {
console.log('[API] DB empty, using n8n data as fallback');
// Filter n8n data if needed
let filteredHistory = n8nData.history;
// Filter by user's devices
filteredHistory = filteredHistory.filter(loc => loc.username && userDeviceIds.includes(loc.username));
if (username) {
filteredHistory = filteredHistory.filter(loc => loc.username === username);
}
// Apply time filters
if (startTime && endTime) {
// Custom range
filteredHistory = filteredHistory.filter(loc =>
loc.timestamp >= startTime && loc.timestamp <= endTime
);
} else if (timeRangeHours) {
// Quick filter
const cutoffTime = new Date(Date.now() - timeRangeHours * 60 * 60 * 1000).toISOString();
filteredHistory = filteredHistory.filter(loc => loc.timestamp >= cutoffTime);
}
return NextResponse.json({
...n8nData,
history: filteredHistory,
total_points: filteredHistory.length,
});
}
// Normalize locations: Ensure speed, battery, and display_time are correct
locations = locations.map(loc => {
// Generate display_time if missing or regenerate from timestamp
@@ -207,7 +91,7 @@ export async function GET(request: NextRequest) {
// Get actual total count from database (not limited by 'limit' parameter)
const stats = locationDb.getStats();
// Step 4: Return data in n8n-compatible format
// Return data in standard format
const response: LocationResponse = {
success: true,
current: locations.length > 0 ? locations[0] : null,

86
app/api/locations/sync/route.ts
View File

@@ -1,86 +0,0 @@
import { NextResponse } from 'next/server';
import { auth } from '@/lib/auth';
import { locationDb, Location } from '@/lib/db';
import type { LocationResponse } from "@/types/location";
const N8N_API_URL = process.env.N8N_API_URL || "https://n8n.example.com/webhook/location";
/**
* POST /api/locations/sync (ADMIN only)
*
* Manually sync location data from n8n webhook to local SQLite cache.
* This fetches all available data from n8n and stores only new records.
*
* Useful for:
* - Initial database population
* - Recovery after downtime
* - Manual refresh
*/
export async function POST() {
try {
// ADMIN only
const session = await auth();
if (!session?.user || (session.user as any).role !== 'ADMIN') {
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
}
// Get stats before sync
const statsBefore = locationDb.getStats();
// Fetch from n8n webhook
const response = await fetch(N8N_API_URL, {
cache: "no-store",
signal: AbortSignal.timeout(10000), // 10 second timeout for manual sync
});
if (!response.ok) {
throw new Error(`n8n webhook returned ${response.status}`);
}
const data: LocationResponse = await response.json();
let insertedCount = 0;
// Store new locations in SQLite
if (data.history && Array.isArray(data.history) && data.history.length > 0) {
// Get latest timestamp from our DB
const lastLocalTimestamp = statsBefore.newest || '1970-01-01T00:00:00Z';
// Filter for only newer locations
const newLocations = data.history.filter(loc =>
loc.timestamp > lastLocalTimestamp
);
if (newLocations.length > 0) {
insertedCount = locationDb.createMany(newLocations as Location[]);
console.log(`[Manual Sync] Inserted ${insertedCount} new locations from n8n`);
}
}
// Get stats after sync
const statsAfter = locationDb.getStats();
return NextResponse.json({
success: true,
synced: insertedCount,
n8nTotal: data.total_points || data.history.length,
before: {
total: statsBefore.total,
newest: statsBefore.newest,
},
after: {
total: statsAfter.total,
newest: statsAfter.newest,
},
});
} catch (error) {
console.error('Sync error:', error);
return NextResponse.json(
{
error: 'Failed to sync locations',
details: error instanceof Error ? error.message : 'Unknown error'
},
{ status: 500 }
);
}
}