Website POST request Handling

src/website/pages/api/aisships/index.ts

@@ -21,13 +21,44 @@ export default async function handler(
         });
         res.status(200).json({ success: true, data: aisships });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
       }
       break;
+
+    case 'POST':
+      try {
+        const { ships, timestamp } = req.body;
+
+        if (!Array.isArray(ships) || typeof timestamp !== 'string') {
+          return res.status(400).json({ success: false, message: "Invalid AISShips data format" });
+        }
+
+        for (const ship of ships) {
+          if (
+            typeof ship.id !== 'number' ||
+            typeof ship.latitude !== 'number' ||
+            typeof ship.longitude !== 'number' ||
+            typeof ship.cog !== 'number' ||
+            typeof ship.rot !== 'number' ||
+            typeof ship.sog !== 'number' ||
+            typeof ship.width !== 'number' ||
+            typeof ship.length !== 'number'
+          ) {
+            return res.status(400).json({ success: false, message: "Invalid ship object format" });
+          }
+        }
+
+        const newAISShips = new AISShips({ ships, timestamp });
+        await newAISShips.save();
+
+        res.status(201).json({ success: true, message: "AISShips data stored", data: newAISShips });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }

src/website/pages/api/batteries/index.ts

@@ -20,13 +20,38 @@ export default async function handler(
         });
         res.status(200).json({ success: true, data: batteries });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
       }
       break;
+
+    case 'POST':
+      try {
+        const { batteries, timestamp } = req.body;
+
+        if (!Array.isArray(batteries) || typeof timestamp !== 'string') {
+          return res.status(400).json({ success: false, message: "Invalid Batteries data format" });
+        }
+
+        for (const battery of batteries) {
+          if (
+            typeof battery.voltage !== 'number' ||
+            typeof battery.current !== 'number'
+          ) {
+            return res.status(400).json({ success: false, message: "Invalid battery object format" });
+          }
+        }
+
+        const newBatteries = new Batteries({ batteries, timestamp });
+        await newBatteries.save();
+
+        res.status(201).json({ success: true, message: "Batteries data stored", data: newBatteries });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }

src/website/pages/api/generic-sensors/index.ts

@@ -18,15 +18,46 @@ export default async function handler(
           _id: 0,
           __v: 0,
         });
+
         res.status(200).json({ success: true, data: genericSensors });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
+    case 'POST':
+      try {
+        const { genericSensors, timestamp } = req.body;
+
+        if (!Array.isArray(genericSensors) || typeof timestamp !== 'string') {
+          return res.status(400).json({ success: false, message: "Invalid GenericSensors data format" });
+        }
+
+        const processedSensors = genericSensors.map(sensor => ({
+          id: sensor.id,
+          data: typeof sensor.data === "bigint" ? sensor.data.toString() : sensor.data
+        }));
+
+        const newGenericSensors = new GenericSensors({ genericSensors: processedSensors, timestamp });
+        await newGenericSensors.save();
+
+        res.status(201).json({ success: true, message: "GenericSensors data stored", data: newGenericSensors });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
+    case 'DELETE':
+      try {
+        await GenericSensors.deleteMany({});
+        res.status(200).json({ success: true, message: "All GenericSensors data deleted" });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
       }
       break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }

src/website/pages/api/globalpath/index.ts

@@ -21,13 +21,57 @@ export default async function handler(
         });
         res.status(200).json({ success: true, data: gPath });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
       }
       break;
+
+    case 'POST':
+      try {
+        let globalPathData = req.body;
+
+        if (!Array.isArray(globalPathData)) {
+          globalPathData = [globalPathData];
+        }
+
+        const processedPaths = globalPathData.map(entry => {
+          if (!Array.isArray(entry.waypoints)) {
+            throw new Error("Invalid GlobalPath data format");
+          }
+
+          for (const waypoint of entry.waypoints) {
+            if (
+              typeof waypoint.latitude !== 'number' ||
+              typeof waypoint.longitude !== 'number'
+            ) {
+              throw new Error("Invalid waypoint object format");
+            }
+          }
+
+          return {
+            waypoints: entry.waypoints,
+            timestamp: entry.timestamp || new Date().toISOString()
+          };
+        });
+
+        const newGlobalPaths = await GlobalPath.insertMany(processedPaths);
+
+        res.status(201).json({ success: true, message: "GlobalPath data stored", data: newGlobalPaths });
+      } catch (error) {
+        res.status(400).json({ success: false, message: error.message });
+      }
+      break;
+
+    case 'DELETE':
+      try {
+        await GlobalPath.deleteMany({});
+        res.status(200).json({ success: true, message: "All GlobalPath data cleared" });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }

src/website/pages/api/gps/index.ts

@@ -17,13 +17,50 @@ export default async function handler(
         const gps: GPSDocument[] = await GPS.find({}).select('-_id -__v');
         res.status(200).json({ success: true, data: gps });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
       }
       break;
+
+    case 'POST':
+      try {
+        let gpsData = req.body;
+
+        if (!Array.isArray(gpsData)) {
+          gpsData = [gpsData];
+        }
+
+        for (const data of gpsData) {
+          const { latitude, longitude, speed, heading, timestamp } = data;
+          if (
+            typeof latitude !== 'number' ||
+            typeof longitude !== 'number' ||
+            typeof speed !== 'number' ||
+            typeof heading !== 'number' ||
+            typeof timestamp !== 'string'
+          ) {
+            return res.status(400).json({ success: false, message: "Invalid GPS data format" });
+          }
+        }
+
+        const newGPSData = await GPS.insertMany(gpsData);
+
+        res.status(201).json({ success: true, message: "GPS data stored", data: newGPSData });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
+    case 'DELETE':
+      try {
+        await GPS.deleteMany({});
+        res.status(200).json({ success: true, message: "All GPS data cleared" });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }

src/website/pages/api/localpath/index.ts

@@ -14,20 +14,59 @@ export default async function handler(
   switch (method) {
     case 'GET':
       try {
-        const localPath: LocalPathDocument[] = await LocalPath.find({}).select({
+        const localPaths: LocalPathDocument[] = await LocalPath.find({}).select({
           'waypoints._id': 0,
           _id: 0,
           __v: 0,
         });
-        res.status(200).json({ success: true, data: localPath });
+        res.status(200).json({ success: true, data: localPaths });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
       }
       break;
+
+    case 'POST':
+      try {
+        let localPathData = req.body;
+
+        if (!Array.isArray(localPathData)) {
+          localPathData = [localPathData];
+        }
+
+        for (const entry of localPathData) {
+          if (!Array.isArray(entry.waypoints) || typeof entry.timestamp !== 'string') {
+            return res.status(400).json({ success: false, message: "Invalid LocalPath data format" });
+          }
+
+          for (const waypoint of entry.waypoints) {
+            if (
+              typeof waypoint.latitude !== 'number' ||
+              typeof waypoint.longitude !== 'number'
+            ) {
+              return res.status(400).json({ success: false, message: "Invalid waypoint object format" });
+            }
+          }
+        }
+
+        const newLocalPaths = await LocalPath.insertMany(localPathData);
+
+        res.status(201).json({ success: true, message: "LocalPath data stored", data: newLocalPaths });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
+    case 'DELETE':
+      try {
+        await LocalPath.deleteMany({});
+        res.status(200).json({ success: true, message: "All LocalPath data cleared" });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }

src/website/pages/api/wind-sensors/index.ts

@@ -20,13 +20,38 @@ export default async function handler(
         });
         res.status(200).json({ success: true, data: windSensors });
       } catch (error) {
-        res
-          .status(400)
-          .json({ success: false, message: (error as Error).message });
+        res.status(400).json({ success: false, message: (error as Error).message });
       }
       break;
+
+    case 'POST':
+      try {
+        const { windSensors, timestamp } = req.body;
+
+        if (!Array.isArray(windSensors) || typeof timestamp !== 'string') {
+          return res.status(400).json({ success: false, message: "Invalid WindSensors data format" });
+        }
+
+        for (const sensor of windSensors) {
+          if (
+            typeof sensor.speed !== 'number' ||
+            typeof sensor.direction !== 'number'
+          ) {
+            return res.status(400).json({ success: false, message: "Invalid wind sensor object format" });
+          }
+        }
+
+        const newWindSensors = new WindSensors({ windSensors, timestamp });
+        await newWindSensors.save();
+
+        res.status(201).json({ success: true, message: "WindSensors data stored", data: newWindSensors });
+      } catch (error) {
+        res.status(500).json({ success: false, message: (error as Error).message });
+      }
+      break;
+
     default:
-      res.status(400).json({ success: false });
+      res.status(405).json({ success: false, message: "Method Not Allowed" });
       break;
   }
 }