Deploy backend update Mon Dec 1 15:20:30 CET 2025

src/controllers/trackController.ts

@@ -91,7 +91,16 @@ export class TrackController {
 
     static async create(req: Request, res: Response) {
         console.log('--- Start createTrack Controller ---');
-        const { name, geojson, properties, difficulty, type } = req.body;
+        let { name, geojson, properties, difficulty, type } = req.body;
+
+        // Extract difficulty and type from geojson.properties if not provided directly
+        if (!difficulty && geojson?.properties?.['piste:difficulty']) {
+            difficulty = geojson.properties['piste:difficulty'];
+        }
+        if (!type && geojson?.properties?.['piste:type']) {
+            type = geojson.properties['piste:type'];
+        }
+
         console.log(`Attempting to create track: Name='${name}', Difficulty='${difficulty}', Type='${type}'.`);
 
         if (!geojson || !geojson.geometry || !geojson.geometry.coordinates) {
@@ -104,7 +113,7 @@ export class TrackController {
             const trackData = {
                 name,
                 geojson: geojson.geometry,
-                properties,
+                properties: geojson.properties || properties,
                 difficulty,
                 type
             };

src/import_gpx_runs_with_names.ts

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import sql from './db';
+
+const GPX_FILE_PATH = path.join(__dirname, '../gpx_data/alps_with_names.gpx');
+
+async function importGpx() {
+    try {
+        // Ensure schema is up to date
+        console.log('Updating database schema...');
+        await sql`
+            CREATE TABLE IF NOT EXISTS routes (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(255),
+                description TEXT,
+                path JSONB, 
+                properties JSONB,
+                difficulty VARCHAR(50),
+                type VARCHAR(50),
+                created_at TIMESTAMP DEFAULT NOW()
+            );
+        `;
+        try {
+            await sql`ALTER TABLE routes ADD COLUMN IF NOT EXISTS properties JSONB;`;
+            await sql`ALTER TABLE routes ADD COLUMN IF NOT EXISTS difficulty VARCHAR(50);`;
+            await sql`ALTER TABLE routes ADD COLUMN IF NOT EXISTS type VARCHAR(50);`;
+        } catch (e) {
+            console.log('Columns might already exist, continuing...');
+        }
+
+        // Clear existing data to ensure no duplicates from previous runs
+        console.log('Clearing existing routes...');
+        await sql`DELETE FROM routes`;
+
+        console.log('Reading GPX file...');
+        const gpxContent = fs.readFileSync(GPX_FILE_PATH, 'utf-8');
+
+        // Simple regex-based parser for this specific GPX format
+        // Note: A proper XML parser would be better for production, but this avoids deps.
+        const tracks = gpxContent.split('<trk>');
+        tracks.shift(); // Remove the header part before the first <trk>
+
+        console.log(`Found ${tracks.length} tracks. Processing...`);
+
+        const seenNames = new Set<string>();
+
+        for (const trackStr of tracks) {
+            const nameMatch = trackStr.match(/<name>(.*?)<\/name>/);
+            const name = nameMatch ? nameMatch[1] : 'Unknown Track';
+
+            // Filter out tracks with no name, "Unknown Track", or names starting with "way/"
+            if (!name || name === 'Unknown Track' || name.startsWith('way/')) {
+                // console.log(`Skipping unnamed or way/ track: ${name}`);
+                continue;
+            }
+
+            // Filter out duplicates
+            if (seenNames.has(name)) {
+                console.log(`Skipping duplicate track: ${name}`);
+                continue;
+            }
+            seenNames.add(name);
+
+            const descMatch = trackStr.match(/<desc>([\s\S]*?)<\/desc>/);
+            const desc = descMatch ? descMatch[1] : '';
+
+            // Parse properties from desc (key=value format)
+            const properties: any = {};
+            desc.split('\n').forEach(line => {
+                const parts = line.split('=');
+                if (parts.length >= 2) {
+                    const key = parts[0].trim();
+                    const value = parts.slice(1).join('=').trim();
+                    properties[key] = value;
+                }
+            });
+
+            const difficulty = properties['piste:difficulty'] || null;
+            const type = properties['piste:type'] || null;
+
+            // Extract coordinates
+            const coordinates: number[][] = [];
+            const trkptRegex = /<trkpt lat="([\d.-]+)" lon="([\d.-]+)"[\s\S]*?(?:<ele>([\d.-]+)<\/ele>)?/g;
+            let match;
+            while ((match = trkptRegex.exec(trackStr)) !== null) {
+                const lat = parseFloat(match[1]);
+                const lon = parseFloat(match[2]);
+                const ele = match[3] ? parseFloat(match[3]) : 0;
+                coordinates.push([lon, lat, ele]); // GeoJSON uses [lon, lat, ele]
+            }
+
+            if (coordinates.length < 2) {
+                console.warn(`Skipping track "${name}" - not enough points.`);
+                continue;
+            }
+
+            const geojson = {
+                type: 'LineString',
+                coordinates: coordinates
+            };
+
+            // Insert into DB using postgres.js
+            await sql`
+                INSERT INTO routes (name, description, path, properties, difficulty, type)
+                VALUES (${name}, ${desc}, ${JSON.stringify(geojson)}, ${JSON.stringify(properties)}, ${difficulty}, ${type})
+                RETURNING id;
+            `;
+            // console.log(`Imported: ${name}`);
+        }
+
+        console.log('Import completed successfully!');
+    } catch (err) {
+        console.error('Error importing GPX:', err);
+    }
+    // Note: postgres.js automatically handles connection pooling and releases.
+    // Closing would terminate all connections and cause errors in the running server.
+}
+
+importGpx();