Feat/transfer routes

app/lib/devices-service.server.ts

@@ -0,0 +1,99 @@
+import { Device, User } from '~/schema'
+import {
+	deleteDevice as deleteDeviceById,
+} from '~/models/device.server'
+import { verifyLogin } from '~/models/user.server'
+import { z } from 'zod'
+
+export const BoxesQuerySchema = z.object({
+	format: z.enum(["json", "geojson"]  ,{
+		errorMap: () => ({ message: "Format must be either 'json' or 'geojson'" }),
+	  }).default("json"),
+	minimal: z.enum(["true", "false"]).default("false")
+	  .transform((v) => v === "true"),
+	full: z.enum(["true", "false"]).default("false")
+	  .transform((v) => v === "true"),
+	limit: z
+	  .string()
+	  .default("5")
+	  .transform((val) => parseInt(val, 10))
+	  .refine((val) => !isNaN(val), { message: "Limit must be a number" })
+	  .refine((val) => val >= 1, { message: "Limit must be at least 1" })
+	  .refine((val) => val <= 20, { message: "Limit must not exceed 20" }),
+
+	name: z.string().optional(),
+	date: z
+      .union([z.string().datetime(), z.array(z.string().datetime())])
+      .transform((val) => (Array.isArray(val) ? val : [val]))
+      .refine((arr) => arr.length >= 1 && arr.length <= 2, {
+        message: "Date must contain 1 or 2 timestamps",
+      })
+      .optional(),
+	phenomenon: z.string().optional(),
+	grouptag: z.string().transform((v) => [v]).optional(),
+	model: z.string().transform((v) => [v]).optional(),
+	exposure: z.string().transform((v) => [v]).optional(),
+
+	near: z
+	  .string()
+	  .regex(/^[-+]?\d+(\.\d+)?,[-+]?\d+(\.\d+)?$/, {
+		message: "Invalid 'near' parameter format. Expected: 'lat,lng'",
+	  })
+	  .transform((val) => val.split(",").map(Number) as [number, number])
+	  .optional(),
+
+	maxDistance: z.string().transform((v) => Number(v)).optional(),
+
+	bbox: z
+	  .string()
+	  .transform((val) => {
+		const coords = val.split(",").map(Number);
+		if (coords.length !== 4 || coords.some((n) => isNaN(n))) {
+		  throw new Error("Invalid bbox parameter");
+		}
+		const [swLng, swLat, neLng, neLat] = coords;
+		return {
+		  coordinates: [
+			[
+			  [swLat, swLng],
+			  [neLat, swLng],
+			  [neLat, neLng],
+			  [swLat, neLng],
+			  [swLat, swLng],
+			],
+		  ],
+		};
+	  })
+	  .optional(),
+
+	fromDate: z.string().datetime().transform((v) => new Date(v)).optional(),
+	toDate: z.string().datetime().transform((v) => new Date(v)).optional(),
+  }).refine(
+    (data) =>
+      !(data.date && !data.phenomenon) && !(data.phenomenon && !data.date),
+    {
+      message: "Date and phenomenon must be used together",
+      path: ["date"],
+    }
+  );
+
+
+  export type BoxesQueryParams = z.infer<typeof BoxesQuerySchema>;
+
+/**
+ * Deletes a device after verifiying that the user is entitled by checking
+ * the password.
+ * @param user The user deleting the device
+ * @param password The users password to verify
+ * @returns True if the device was deleted, otherwise false or "unauthorized"
+ * if the user is not entitled to delete the device with the given parameters
+ */
+export const deleteDevice = async (
+	user: User,
+	device: Device,
+	password: string,
+): Promise<boolean | 'unauthorized'> => {
+	const verifiedUser = await verifyLogin(user.email, password)
+	if (verifiedUser === null) return 'unauthorized'
+	return (await deleteDeviceById({ id: device.id })).count > 0
+}

app/lib/measurement-service.server.ts

@@ -0,0 +1,27 @@
+import { getDeviceWithoutSensors } from "~/models/device.server";
+import { getSensorsWithLastMeasurement } from "~/models/sensor.server";
+
+/**
+ *
+ * @param boxId
+ * @param sensorId
+ * @param count
+ */
+export const getLatestMeasurements = async (
+  boxId: string,
+  sensorId: string | undefined,
+  count: number | undefined,
+): Promise<any | null> => {
+  const device = await getDeviceWithoutSensors({ id: boxId });
+  if (!device) return null;
+
+  const sensorsWithMeasurements = await getSensorsWithLastMeasurement(
+    device.id,
+    sensorId,
+    count,
+  );
+  if (sensorId !== undefined) return sensorsWithMeasurements; // single sensor, no need for having info about device
+
+  (device as any).sensors = sensorsWithMeasurements;
+  return device;
+};

app/lib/openapi.ts

@@ -1,10 +1,15 @@
 import swaggerJsdoc from "swagger-jsdoc";
 
+const DEV_SERVER = {
+  url: "http://localhost:3000",
+  description: "Development server",
+};
+
 const options: swaggerJsdoc.Options = {
   definition: {
     openapi: "3.0.0",
     info: {
-      title: "",
+      title: "openSenseMap API",
       version: "1.0.0",
       description: `## Documentation of the routes and methods to manage users, stations (also called boxes or senseBoxes), and measurements in the openSenseMap API. You can find the API running at [https://opensensemap.org/api/](https://opensensemap.org/api/).
 # Timestamps
@@ -46,14 +51,11 @@ const options: swaggerJsdoc.Options = {
 ## If there is something unclear or there is a mistake in this documentation please open an [issue](https://github.com/openSenseMap/frontend/issues/new) in the GitHub repository.`,
     },
     servers: [
+      ...(process.env.NODE_ENV !== "production" ? [DEV_SERVER] : []),
       {
         url: process.env.OSEM_API_URL || "https://opensensemap.org/api", // Uses environment variable or defaults to production URL
         description: "Production server",
       },
-      {
-        url: "http://localhost:3000",
-        description: "Development server",
-      },
     ],
     components: {
       schemas: {

app/lib/transfer-service.server.ts

@@ -0,0 +1,129 @@
+import { createTransfer, getTransfer, removeTransfer, TransferCode } from "~/models/transfer.server";
+import { getDevice } from "~/models/device.server";
+import { claim, Claim, device } from "~/schema";
+import { drizzleClient } from "~/db.server";
+import { eq } from "drizzle-orm";
+
+
+export const createBoxTransfer = async (
+    userId: string,
+    boxId: string,
+    expiresAt?: string
+  ): Promise<TransferCode> => {
+    const box = await getDevice({id: boxId});
+    if (!box) {
+      throw new Error("Box not found");
+    }
+
+    if (box.user.id !== userId) {
+      throw new Error("You don't have permission to transfer this box");
+    }
+
+    let expirationDate: Date;
+    if (expiresAt) {
+      expirationDate = new Date(expiresAt);
+      if (isNaN(expirationDate.getTime())) {
+        throw new Error("Invalid expiration date format");
+      }
+    } else {
+      expirationDate = new Date();
+      expirationDate.setHours(expirationDate.getHours() + 24);
+    }
+
+    if (expirationDate <= new Date()) {
+      throw new Error("Expiration date must be in the future");
+    }
+
+    const transferCode = await createTransfer(boxId, userId, expirationDate);
+
+    return transferCode;
+  };
+
+  export const getBoxTransfer = async (
+    boxId: string,
+  ): Promise<Claim> => {
+    const transfer = await getTransfer({id: boxId});
+    if (!transfer) {
+      throw new Error("Transfer not found");
+    }
+
+    // if (transfer.user.id !== userId) {
+    //   throw new Error("You don't have permission to transfer this box");
+    // }
+    return transfer;
+  };  
+
+export const removeBoxTransfer = async (
+    userId: string,
+    boxId: string,
+    token: string
+  ): Promise<void> => {
+    const box = await getDevice({id: boxId});
+    if (!box) {
+      throw new Error("Box not found");
+    }
+
+    if (box.user.id !== userId) {
+      throw new Error("You don't have permission to remove this transfer");
+    }
+
+    await removeTransfer(boxId, token);
+  };  
+
+  export const claimBoxTransfer = async (userId: string, token: string) => {
+    const [activeClaim] = await drizzleClient
+      .select()
+      .from(claim)
+      .where(eq(claim.token, token))
+      .limit(1);
+
+    if (!activeClaim) {
+      throw new Error("Invalid or expired transfer token");
+    }
+
+    if (activeClaim.expiresAt && activeClaim.expiresAt <= new Date()) {
+      throw new Error("Transfer token has expired");
+    }
+
+    const [box] = await drizzleClient
+      .select()
+      .from(device)
+      .where(eq(device.id, activeClaim.boxId))
+      .limit(1);
+
+    if (!box) {
+      throw new Error("Device not found");
+    }
+
+    await drizzleClient
+      .update(device)
+      .set({ userId })
+      .where(eq(device.id, activeClaim.boxId));
+
+    await drizzleClient
+      .delete(claim)
+      .where(eq(claim.id, activeClaim.id));
+
+    return { message: "Device successfully claimed!", boxId: activeClaim.boxId };
+  };  
+
+export const validateTransferParams = (
+    boxId?: string,
+    expiresAt?: string
+  ): { isValid: boolean; error?: string } => {
+    if (!boxId || boxId.trim() === "") {
+      return { isValid: false, error: "Box ID is required" };
+    }
+
+    if (expiresAt) {
+      const date = new Date(expiresAt);
+      if (isNaN(date.getTime())) {
+        return { isValid: false, error: "Invalid date format" };
+      }
+      if (date <= new Date()) {
+        return { isValid: false, error: "Expiration date must be in the future" };
+      }
+    }
+
+    return { isValid: true };
+  };