add Wigle API dummy script

Reviewed-on: #8

README.md

@@ -10,7 +10,7 @@ TODO
 ### Database
 **Change name of database and credentials as you like!**
 
-- Create new database: `CREATE DATABASE locationhub;`
+- Create new database: `CREATE DATABASE dev_locationhub;`
 - Create new user for database: `GRANT ALL PRIVILEGES ON dev_locationhub.* TO 'dbuser'@'localhost' IDENTIFIED BY '1234';`
 - Import tables: `/usr/bin/mariadb -u dbuser -p1234 dev_locationhub < server/sql/tables.sql`
 

server/.env.template

@@ -4,9 +4,9 @@ DB_PASSWORD=""
 DB_HOST=""
 DB_DIALECT=""
 DB_PORT=""
-WIGLE_TOKEN=""
+WIGLE_TOKEN="" # Go to account and generate token "Encoded for use"
 WIGLE_BASE_URL="https://api.wigle.net"
 WIGLE_NETWORK_SEARCH="/api/v2/network/search"
-GET_LOCATION_WIFI_MAX_AGE=1209600000 # 14 Tage in Millisekunden (14 * 24 * 60 * 60 * 1000)
+GET_LOCATION_WIFI_MAX_AGE=1209600000 # 14 days in milliseconds (14 * 24 * 60 * 60 * 1000)
 GET_LOCATION_WIFI_MAX=10000          
 GET_LOCATION_WIFI_PRIMITIVE=true  

server/package.json

@@ -13,11 +13,11 @@
   "license": "ISC",
   "devDependencies": {
     "@types/express": "^5.0.0",
+    "@types/memoizee": "^0.4.11",
     "@types/node": "^22.10.2",
     "nodemon": "^3.1.9",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.2",
-    "@types/memoizee": "^0.4.11"
+    "typescript": "^5.7.2"
   },
   "dependencies": {
     "cors": "^2.8.5",

server/scripts/wigle-dummy.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""" Author:                     Hendrik Schutter, mail@hendrikschutter.com
+"""
+
+import requests
+import os
+import json
+import argparse
+import random
+import http.server
+import json
+from urllib.parse import urlparse, parse_qs
+
+port = 8000
+
+def generateDummyResponse(netid):
+    response_payload = {
+        "success": True,
+        "totalResults": 1,
+        "first": 0,
+        "last": 0,
+        "resultCount": 1,
+        "results": [
+            {
+                "trilat": random.uniform(-90, 90),
+                "trilong": random.uniform(-180, 180),
+                "ssid": "Wifi-Name",
+                "qos": 0,
+                "transid": "string",
+                "firsttime": "2025-01-02T16:48:28.368Z",
+                "lasttime": "2025-01-02T16:48:28.368Z",
+                "lastupdt": "2025-01-02T16:48:28.368Z",
+                "netid": netid,
+                "name": "string",
+                "type": "string",
+                "comment": "string",
+                "wep": "string",
+                "bcninterval": 0,
+                "freenet": "string",
+                "dhcp": "string",
+                "paynet": "string",
+                "userfound": False,
+                "channel": 0,
+                "rcois": "string",
+                "encryption": "none",
+                "country": "string",
+                "region": "string",
+                "road": "string",
+                "city": "string",
+                "housenumber": "string",
+                "postalcode": "string",
+            }
+        ],
+        "searchAfter": "string",
+        "search_after": 0,
+    }
+
+    return response_payload
+
+class SimpleHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        # Parse the URL and query parameters
+        parsed_url = urlparse(self.path)
+        if parsed_url.path == "/api/v2/network/search":
+            query_params = parse_qs(parsed_url.query)
+            netid = query_params.get("netid", [""])[0]
+
+            # Send response headers
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.end_headers()
+
+            # Send the JSON response
+            self.wfile.write(json.dumps(generateDummyResponse(netid)).encode("utf-8"))
+        else:
+            # Handle 404 Not Found
+            self.send_response(404)
+            self.end_headers()
+            self.wfile.write(b"Not Found")
+
+def main():
+    server = http.server.HTTPServer(("127.0.0.1", port), SimpleHTTPRequestHandler)
+    print(f"Server running on http://127.0.0.1:{port}/api/v2/network/search'...")
+    server.serve_forever()
+
+if __name__ == "__main__":
+    main()

server/sql/tables.sql

@@ -18,8 +18,8 @@ CREATE TABLE IF NOT EXISTS wifi_scan (
     lp_ttn_end_device_uplinks_id UUID,
     mac VARCHAR(255),
     rssi NUMERIC,
-    latitude DOUBLE,
-    longitude DOUBLE,
+    latitude DOUBLE NOT NULL,
+    longitude DOUBLE NOT NULL,
     created_at_utc TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     updated_at_utc TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
     FOREIGN KEY (lp_ttn_end_device_uplinks_id) REFERENCES lp_ttn_end_device_uplinks(lp_ttn_end_device_uplinks_id)
@@ -46,6 +46,8 @@ CREATE TABLE IF NOT EXISTS location (
     wifi_longitude DOUBLE,
     gnss_latitude DOUBLE,
     gnss_longitude DOUBLE,
+    ttn_gw_latitude DOUBLE,
+    ttn_gw_longitude DOUBLE,
     created_at_utc TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     updated_at_utc TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
     FOREIGN KEY (lp_ttn_end_device_uplinks_id) REFERENCES lp_ttn_end_device_uplinks(lp_ttn_end_device_uplinks_id)

server/src/controller/ttnController.ts

@@ -28,7 +28,8 @@ router.post(
   async (req: Request, res: Response) => {
     try {
       const message = req.body as TtnMessage;
-      const { lp_ttn_end_device_uplinks_id } =
+      // Create uplink record
+      const { lp_ttn_end_device_uplinks_id, latitude, longitude } =
         await lpTtnEndDeviceUplinksService.createUplink({
           device_id: message.end_device_ids.device_id,
           application_ids:
@@ -78,6 +79,7 @@ router.post(
           latitude: g.latitude,
           longitude: g.longitude,
         })),
+        gnssLocation: { latitude, longitude }
       };
 
       domainEventEmitter.emit(TtnMessageReceivedEventName, event);

server/src/event/ttnMessageReceivedEvent.ts

@@ -11,4 +11,8 @@ export type TtnMessageReceivedEvent = {
     longitude: number;
     altitude: number;
   }[];
+  gnssLocation: {
+    latitude?: number;
+    longitude?: number;
+  }
 };

server/src/eventHandler/ttnMessageReceivedEventHandler.ts

@@ -3,11 +3,162 @@ import {
   TtnMessageReceivedEvent,
   TtnMessageReceivedEventName,
 } from "../event/ttnMessageReceivedEvent";
+import { container } from "tsyringe";
+import { LocationService } from "../services/locationService";
+import { WifiScanService } from "../services/wifiScanService";
+import { getLocationForWifiMemoized } from "../proxy/wigle";
+import { WifiScan } from "../models/wifiScan";
+
+const locationService = container.resolve(LocationService);
+const wifiScanService = container.resolve(WifiScanService);
+
+const CalculateTtnGatewayLocation = (event: TtnMessageReceivedEvent) => {
+  // Get location based on TTN Gateways
+  const virtualLocation = {
+    latitude: undefined as number | undefined,
+    longitude: undefined as number | undefined,
+  };
+
+  if (!event.ttnGateways || event.ttnGateways.length === 0) {
+    console.log("No TTN Gateway location received!")
+  } else {
+    let totalWeight = 0;
+    let weightedLatitude = 0;
+    let weightedLongitude = 0;
+
+    event.ttnGateways.forEach(gw => {
+      const weight = 1 / Math.abs(gw.rssi); // Higher RSSI (closer to 0) gives more weight
+      totalWeight += weight;
+      weightedLatitude += gw.latitude * weight;
+      weightedLongitude += gw.longitude * weight;
+    });
+
+    // Calculate the weighted average to get the virtual location
+    virtualLocation.latitude = weightedLatitude / totalWeight;
+    virtualLocation.longitude = weightedLongitude / totalWeight;
+    console.log("Tracker location based on TTN Gateway location:", virtualLocation);
+  }
+  return {
+    ttn_latitude: virtualLocation.latitude,
+    ttn_longitude: virtualLocation.longitude,
+  };
+};
+
+const CalculateWifiLocation = async (event: TtnMessageReceivedEvent) => {
+  // Get location based on WiFi Scans
+  const virtualLocation = {
+    latitude: undefined as number | undefined,
+    longitude: undefined as number | undefined,
+  };
+
+  if (!event.wifis || event.wifis.length === 0) {
+    console.log("No WiFi scans received!")
+  } else {
+    // Process Wi-Fi data to compute weighted location
+    let wifiScans = await Promise.all(
+      event.wifis.map(async (wifi) => {
+        // Create new WiFi Scan entry if wigle.net reported location
+        const apiResponse = await getLocationForWifiMemoized(wifi.mac);;
+        // Only return valid data wifiScans (location for MAC was found)
+        if ((apiResponse?.success == true) && (apiResponse.totalResults > 0)) {
+          return {
+            lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id,
+            mac: wifi.mac,
+            rssi: wifi.rssi,
+            latitude: apiResponse?.results[0].trilat,
+            longitude: apiResponse?.results[0].trilong,
+          }
+        }
+        return undefined;
+      })
+    );
+
+    const wifiScansFiltered = wifiScans.filter(w => (w !== undefined));
+
+    // Store valid wifiScans into DB
+    const locatedWifiScans = await wifiScanService.createWifiScans(wifiScansFiltered);
+
+    if (locatedWifiScans.length !== 0) {
+      const { totalWeight, weightedLatitude, weightedLongitude } =
+        locatedWifiScans.reduce(
+          (acc, { latitude, longitude, rssi }) => {
+            const weight = 1 / Math.abs(rssi);
+            acc.totalWeight += weight;
+            acc.weightedLatitude += latitude * weight;
+            acc.weightedLongitude += longitude * weight;
+            return acc;
+          },
+          {
+            totalWeight: 0,
+            weightedLatitude: 0,
+            weightedLongitude: 0,
+          }
+        );
+
+      // Calculate the weighted average to get the virtual location
+      virtualLocation.latitude = weightedLatitude / totalWeight;
+      virtualLocation.longitude = weightedLongitude / totalWeight;
+
+      console.log("Tracker location based on WiFi Scan location:", virtualLocation);
+    }
+  }
+  return {
+    wifi_latitude: virtualLocation.latitude,
+    wifi_longitude: virtualLocation.longitude,
+  };
+};
+
+const CalculateGnssLocation = (event: TtnMessageReceivedEvent) => {
+  // Get location based on reported GNSS
+  if (event.gnssLocation.latitude === undefined || event.gnssLocation.longitude === undefined) {
+    console.log("No valid GNSS location received!");
+  }
+
+  return {
+    gnss_latitude: event.gnssLocation.latitude,
+    gnss_longitude: event.gnssLocation.longitude,
+  };
+};
 
 domainEventEmitter.on(
   TtnMessageReceivedEventName,
   async (event: TtnMessageReceivedEvent) => {
     console.log(event);
-    // TODO Hendrik 🚀
+
+    var wifi_based_latitude: number | undefined = undefined;
+    var wifi_based_longitude: number | undefined = undefined;
+    var gnss_based_latitude: number | undefined = undefined;
+    var gnss_based_longitude: number | undefined = undefined;
+    var ttn_gw_based_latitude: number | undefined = undefined;
+    var ttn_gw_based_longitude: number | undefined = undefined;
+
+    if (event.ttnGateways && event.ttnGateways.length > 0) {
+      const virtualLocation = CalculateTtnGatewayLocation(event);
+      ttn_gw_based_latitude = virtualLocation.ttn_latitude;
+      ttn_gw_based_longitude = virtualLocation.ttn_longitude;
+    }
+
+    if (event.wifis && event.wifis.length > 0) {
+      const virtualLocation = await CalculateWifiLocation(event);
+      wifi_based_latitude = virtualLocation.wifi_latitude;
+      wifi_based_longitude = virtualLocation.wifi_longitude;
+    }
+
+    const virtualLocation = CalculateGnssLocation(event);
+    gnss_based_latitude = virtualLocation.gnss_latitude;
+    gnss_based_longitude = virtualLocation.gnss_longitude;
+
+    const newLocation = await locationService.createLocation({
+      lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id,
+      ttn_gw_latitude: ttn_gw_based_latitude,
+      ttn_gw_longitude: ttn_gw_based_longitude,
+      gnss_latitude: gnss_based_latitude,
+      gnss_longitude: gnss_based_longitude,
+      wifi_latitude: wifi_based_latitude,
+      wifi_longitude: wifi_based_longitude,
+    });
+
+    console.log(newLocation)
   }
 );
+

server/src/index.ts

@@ -25,5 +25,5 @@ app.use("/api/locations", locationRoutes);
 app.use("/api/ttn", ttnRoutes);
 
 app.listen(PORT, () => {
-  console.log(`🚀 Server läuft auf http://localhost:${PORT}`);
+  console.log(`🚀 Server runs here: http://localhost:${PORT}`);
 });

server/src/models/location.ts

@@ -8,6 +8,8 @@ export class Location extends Model {
   public wifi_longitude!: number;
   public gnss_latitude!: number;
   public gnss_longitude!: number;
+  public ttn_gw_latitude!: number;
+  public ttn_gw_longitude!: number;
   public created_at_utc!: Date;
   public updated_at_utc!: Date;
 }
@@ -40,6 +42,14 @@ Location.init(
       type: DataTypes.NUMBER,
       allowNull: true,
     },
+    ttn_gw_latitude: {
+      type: DataTypes.NUMBER,
+      allowNull: true,
+    },
+    ttn_gw_longitude: {
+      type: DataTypes.NUMBER,
+      allowNull: true,
+    },
     created_at_utc: {
       type: DataTypes.DATE,
       defaultValue: DataTypes.NOW,

server/src/proxy/wigle.ts

@@ -51,12 +51,17 @@ export const getLocationForWifi = async (
       method: "GET",
       headers: {
         "Content-Type": "application/json",
-        Cookie: `auth=${process.env.WIGLE_TOKEN}`,
+        Authorization: `Basic ${process.env.WIGLE_TOKEN}`,
       },
     });
-    return await response.json();
+    if (response.ok) {
+      return await response.json();
+    }
+    console.log(response.status);
+    return undefined;
+
   } catch (error) {
-    console.error("Fehler beim Aufruf des Services:", error);
+    console.error("Error during call of API wigle.net:", error);
   }
 };