feat: endpoint impl.

server/src/controller/ttnController.ts

@@ -0,0 +1,105 @@
+import express, { Request, Response } from "express";
+import { container } from "tsyringe";
+import { domainEventEmitter } from "../config/eventEmitter";
+import {
+  TtnMessageReceivedEvent,
+  TtnMessageReceivedEventName,
+} from "../event/ttnMessageReceivedEvent";
+import { validateData } from "../middleware/validationMiddleware";
+import { TtnMessage } from "../models/ttnMessage";
+import { LpTtnEndDeviceUplinksService } from "../services/lpTtnEndDeviceUplinksService";
+import { TtnGatewayReceptionService } from "../services/ttnGatewayReceptionService";
+import { WifiScanService } from "../services/wifiScanService";
+import { ttnMessageValidator } from "../validation/ttn/ttnMessageValidation";
+
+const lpTtnEndDeviceUplinksService = container.resolve(
+  LpTtnEndDeviceUplinksService
+);
+const ttnGatewayReceptionService = container.resolve(
+  TtnGatewayReceptionService
+);
+const wifiScanService = container.resolve(WifiScanService);
+
+const router = express.Router();
+
+router.post(
+  "/webhook",
+  validateData(ttnMessageValidator),
+  async (req: Request, res: Response) => {
+    try {
+      const message = req.body as TtnMessage;
+      const { lp_ttn_end_device_uplinks_id } =
+        await lpTtnEndDeviceUplinksService.createUplink({
+          device_id: message.end_device_ids.device_id,
+          application_ids:
+            message.end_device_ids.application_ids.application_id,
+          dev_eui: message.end_device_ids.dev_eui,
+          join_eui: message.end_device_ids.join_eui,
+          dev_addr: message.end_device_ids.dev_addr,
+          received_at_utc: new Date(message.received_at),
+          battery: message.uplink_message.decoded_payload?.messages[0].find(
+            (e) => e.type === "Battery"
+          )?.measurementValue,
+          latitude: 0 /*
+        message.uplink_message.decoded_payload.messages[0].find(
+          (e) => e.type === "Latitude"
+        )?.measurementValue
+        */,
+          longitude: 0,
+          /*
+        message.uplink_message.decoded_payload.messages[0].find(
+          (e) => e.type === "Longitude"
+        )?.measurementValue
+        */
+        });
+
+      const wifiScans =
+        message.uplink_message.decoded_payload?.messages[0]
+          .find((e) => e.type === "Wi-Fi Scan")
+          ?.measurementValue?.map((w) => ({
+            lp_ttn_end_device_uplinks_id,
+            mac: w.mac,
+            rssi: w.rssi,
+          })) ?? [];
+
+      const ttnGatewayReceptions = message.uplink_message.rx_metadata.map(
+        (g) => ({
+          lp_ttn_end_device_uplinks_id,
+          gateway_id: g.gateway_ids.gateway_id,
+          eui: g.gateway_ids.eui,
+          rssi: g.rssi,
+          latitude: g.location.latitude,
+          longitude: g.location.longitude,
+          altitude: g.location.altitude,
+        })
+      );
+
+      const event: TtnMessageReceivedEvent = {
+        lp_ttn_end_device_uplinks_id,
+        wifis: wifiScans.map((w) => ({ mac: w.mac, rssi: w.rssi })),
+        ttnGateways: ttnGatewayReceptions.map((g) => ({
+          rssi: g.rssi,
+          altitude: g.altitude,
+          latitude: g.latitude,
+          longitude: g.longitude,
+        })),
+      };
+
+      domainEventEmitter.emit(TtnMessageReceivedEventName, event);
+
+      await Promise.all([
+        wifiScanService.createWifiScans(wifiScans),
+        ttnGatewayReceptionService.createGatewayReceptions(
+          ttnGatewayReceptions
+        ),
+      ]);
+
+      res.status(200);
+    } catch (error) {
+      console.log(error);
+      res.status(500).json({ error: "Error creating uplink" });
+    }
+  }
+);
+
+export default router;