@internetderdinge/api 1.224.2

package/src/devices/devices.controller.ts

@@ -0,0 +1,276 @@
+import httpStatus from "http-status";
+import mongoose from "mongoose";
+import multer from "multer";
+import type { Request, Response } from "express";
+import pick from "../utils/pick.js";
+import ApiError from "../utils/ApiError.js";
+import catchAsync from "../utils/catchAsync.js";
+import * as devicesService from "./devices.service.js";
+import * as iotDevicesService from "../iotdevice/iotdevice.service.js";
+import { filterOptions } from "../utils/filterOptions.js";
+import { isAdmin } from "../middlewares/validateAdmin.js";
+
+const createEntry = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const user = await devicesService.createDevice(req.body);
+    res.status(httpStatus.CREATED).send(user);
+  },
+);
+
+const registerDevice = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const checkDevice = await devicesService.getDeviceByDeviceId(
+      req.params.deviceId,
+    );
+
+    if (checkDevice) {
+      const iotDevices = await iotDevicesService.activateDevice(
+        req.params.deviceId,
+        req.body.organization,
+        true,
+      );
+
+      // Get Events if update is happening
+      if (iotDevices.activation_status === "success") {
+        if (checkDevice.organization.equals(req.body.organization)) {
+          res.status(httpStatus.CONFLICT).send({
+            message:
+              "Device is already existing and registered in this organization, no hardware reset detected",
+            device: checkDevice,
+          });
+        } else {
+          throw new ApiError(
+            httpStatus.CONFLICT,
+            "Device is already existing and registered in another organization, no hardware reset detected",
+          );
+        }
+      } else {
+        // Delete device if already existing but not activation_status
+        await devicesService.deleteById(checkDevice.id, false);
+      }
+
+      res.status(httpStatus.CREATED).send(iotDevices);
+    } else {
+      const devices = await devicesService.registerDevice({
+        id: req.params.deviceId,
+        body: req.body,
+      });
+      res.status(httpStatus.CREATED).send(devices);
+    }
+  },
+);
+
+const getEntries = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const filter = pick(req.query, ["name", "role"]);
+    const options = pick(req.query, ["sortBy", "limit", "page"]);
+    const result = await devicesService.queryDevices(filter, options);
+    res.send(result);
+  },
+);
+
+const queryDevicesByUser = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const filter = pick(req.query, ["name", "role", "organization", "patient"]);
+    const options = pick(req.query, ["sortBy", "limit", "page"]);
+
+    options.limit = 1000;
+
+    const filteredOptions = filterOptions(req.query, filter, {
+      objectIds: ["_id", "patient"],
+      search: [
+        "meta.name",
+        "deviceId",
+        "payment.id",
+        "payment.customer",
+        "kind",
+        "patientData.meta.firstName",
+        "patientData.meta.lastName",
+      ],
+    });
+
+    const optionsPopulate = {
+      ...options,
+      populate: "patientData",
+    };
+
+    const result = await devicesService.queryDevicesByUser(
+      filteredOptions,
+      optionsPopulate,
+    );
+
+    if (
+      req.currentUser?.role &&
+      req.currentUser.role === "onlyself" &&
+      result?.results
+    ) {
+      const currentUserId = new mongoose.Types.ObjectId(req.currentUser.id);
+      result.results = result.results.filter((user) => {
+        // Prefer value comparison over object reference comparison
+        return currentUserId.equals(user.patient);
+        // Alternatively:
+        // return String(user.patient) === String(req.currentUser.id);
+      });
+    }
+
+    res.send(result);
+  },
+);
+
+const getEntry = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getByIdWithIoT(req.params.deviceId);
+
+    if (!device) {
+      throw new ApiError(httpStatus.NOT_FOUND, "Device not found");
+    }
+    res.send(device);
+  },
+);
+
+const getImageById = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getImageById(
+      req.params.deviceId,
+      req.params.uuid,
+    );
+    if (!device) {
+      throw new ApiError(httpStatus.NOT_FOUND, "Device not found");
+    }
+    res.send(device);
+  },
+);
+
+const updateEntry = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    // TODO: Remove in newer versions
+    const { updatedAt, createdAt, payment, iotDevice, ...newBody } = req.body;
+
+    const body = {
+      ...newBody,
+      shadow:
+        typeof req.body?.shadow === "object" ? req.body.shadow : undefined,
+    };
+
+    if (isAdmin(res.req.auth) && payment) {
+      body.payment = payment;
+    }
+
+    const device = await devicesService.updateById(req.params.deviceId, body); //TODO: remove shadow
+
+    if (isAdmin(res.req.auth) && iotDevice && device.deviceId) {
+      const iotDeviceUpdate = await iotDevicesService.updateDevice(
+        device.deviceId,
+        iotDevice,
+      );
+    }
+
+    res.send(device);
+  },
+);
+
+const getEvents = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const events = await iotDevicesService.getEvents({
+      ...req.query,
+      createdAt: device.createdAt,
+      DeviceId: device.deviceId,
+    });
+    res.send({ ...events, device });
+  },
+);
+
+const deleteEntry = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const entry = await devicesService.deleteById(req.params.deviceId);
+    //res.status(httpStatus.NO_CONTENT).send();
+    res.send(entry);
+  },
+);
+
+const pingDevice = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getByIdWithIoT(req.params.deviceId);
+    const ping = await iotDevicesService.pingDevice(device.deviceId, req.query);
+    res.send({ device, ping });
+  },
+);
+
+export const resetDevice = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getByIdWithIoT(req.params.deviceId);
+    const reset = await iotDevicesService.resetDevice(
+      device.deviceId,
+      req.body,
+    );
+    res.send({ device, reset });
+  },
+);
+
+const ledLight = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getByIdWithIoT(req.params.deviceId);
+    const ping = await iotDevicesService.ledLightHint(
+      device.deviceId,
+      req.body,
+    );
+    res.send({ device, ping });
+  },
+);
+
+const rebootDevice = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getByIdWithIoT(req.params.deviceId);
+    const reboot = await iotDevicesService.rebootDevice(device.deviceId);
+    res.send({ device, reboot });
+  },
+);
+
+const updateSingleImageMeta = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getById(req.params.deviceId);
+
+    const { uuid, ...body } = req.body;
+    const deviceUpdate = await devicesService.updateById(req.params.deviceId, {
+      meta: { ...device.meta, file: uuid },
+    });
+    const deviceMeta = await devicesService.updateSingleImageMeta(
+      device.deviceId,
+      body,
+    );
+    res.send({ deviceMeta, deviceUpdate });
+  },
+);
+
+const uploadSingleImage = catchAsync(
+  async (req: Request, res: Response): Promise<void> => {
+    const device = await devicesService.getById(req.params.deviceId);
+
+    const iotUpload = await iotDevicesService.uploadSingleImage({
+      deviceName: device.deviceId,
+      buffer: req.files[0].buffer,
+      deviceId: req.params.deviceId,
+      uuid: req.body.uuid,
+    });
+
+    res.send(iotUpload);
+  },
+);
+
+export {
+  createEntry,
+  getEntries,
+  queryDevicesByUser,
+  getEvents,
+  getImageById,
+  registerDevice,
+  pingDevice,
+  ledLight,
+  rebootDevice,
+  uploadSingleImage,
+  updateSingleImageMeta,
+  getEntry,
+  updateEntry,
+  deleteEntry,
+};

package/src/devices/devices.model.ts

@@ -0,0 +1,126 @@
+import mongoose, { Schema, Document, Model, Types } from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index.js";
+import { ensureSameOrganization } from "../middlewares/mongooseValidations/ensureSameOrganization.js";
+
+interface IDevice extends Document {
+  name?: string;
+  meta?: Record<string, any>;
+  organization?: mongoose.Types.ObjectId;
+  patient?: mongoose.Types.ObjectId;
+  paper?: mongoose.Types.ObjectId;
+  timezone?: string;
+  deviceId?: string;
+  kind?: string;
+  eventDate?: Date;
+  payment?: Record<string, any>;
+  loadedAt?: Date;
+  patientData?: any; // Replace `any` with the actual type if available
+}
+
+const deviceSchema = new Schema(
+  {
+    name: {
+      type: String,
+    },
+    meta: { type: Object },
+    organization: {
+      type: Schema.Types.ObjectId,
+      ref: "Organization",
+      immutable: true,
+    },
+    patient: { type: Schema.Types.ObjectId, ref: "User" },
+    paper: { type: mongoose.Schema.Types.ObjectId, ref: "Paper" },
+    timezone: { type: String },
+    deviceId: { type: String, immutable: true },
+    kind: { type: String, immutable: true },
+    eventDate: { type: Date },
+    payment: { type: Object },
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+  },
+);
+
+deviceSchema.virtual("patientData", {
+  ref: "User",
+  localField: "patient",
+  foreignField: "_id",
+  justOne: true,
+});
+
+function addIotDevice(schema: Schema<IDevice>): void {
+  schema
+    .virtual("loadedAt")
+    .get(function (this: IDevice) {
+      return this._loadedAt;
+    })
+    .set(function (this: IDevice, v: Date) {
+      this._loadedAt = v;
+    });
+
+  schema.post(["find", "findOne"], function (docs: IDevice | IDevice[] | null) {
+    // nothing was found, bail out
+    if (!docs) {
+      return;
+    }
+
+    // normalize to array
+    const docsArray = Array.isArray(docs) ? docs : [docs];
+    const now = new Date();
+
+    for (const doc of docsArray) {
+      if (doc) {
+        doc.loadedAt = now;
+      }
+    }
+  });
+}
+
+/**
+ * Ensure patient is member of the same organization
+ */
+deviceSchema.pre<IDevice>("save", async function (next) {
+  if (!this.patient) return next();
+  try {
+    await ensureSameOrganization(
+      this.patient,
+      this.organization!,
+      mongoose.model("User"),
+    );
+    next();
+  } catch (err) {
+    next(err as Error);
+  }
+});
+
+deviceSchema.pre("findOneAndUpdate", async function (next) {
+  const update = this.getUpdate() as any;
+  if (!update?.patient) return next();
+  try {
+    // need org from the existing doc
+    const device = await this.model
+      .findOne(this.getQuery())
+      .select("organization");
+    await ensureSameOrganization(
+      update.patient,
+      device!.organization,
+      mongoose.model("User"),
+    );
+    next();
+  } catch (err) {
+    next(err as Error);
+  }
+});
+
+// Add the IoT device functionality
+addIotDevice(deviceSchema);
+
+// Add plugins that convert mongoose to JSON and enable pagination
+deviceSchema.plugin((schema: Schema) => toJSON(schema, true));
+deviceSchema.plugin(paginate);
+
+const Devices: Model<IDevice> = mongoose.model<IDevice>("Device", deviceSchema);
+
+export default Devices;

package/src/devices/devices.route.ts

@@ -0,0 +1,198 @@
+import { Router } from "express";
+import multer from "multer";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs.js";
+import type { RouteSpec } from "../types/routeSpec";
+import auth from "../middlewares/auth.js";
+import {
+  validateBodyOrganization,
+  validateQueryOrganization,
+} from "../middlewares/validateOrganization.js";
+import { validateQuerySearchUserAndOrganization } from "../middlewares/validateQuerySearchUserAndOrganization.js";
+import { validateDevice } from "../middlewares/validateDevice.js";
+import { validateDeviceUserOrganization } from "../middlewares/validateDeviceUserOrganization.js";
+import * as devicesController from "./devices.controller.js";
+import { resetDevice } from "./devices.controller.js";
+import {
+  createDeviceSchema,
+  queryDevicesSchema,
+  getDeviceSchema,
+  updateDeviceSchema,
+  deleteDeviceSchema,
+  getEventsSchema,
+  pingDeviceSchema,
+  registerDeviceSchema,
+  ledLightSchema,
+  rebootDeviceSchema,
+  getImageSchema,
+  updateSingleImageMetaSchema,
+  uploadSingleImageSchema,
+  resetDeviceSchema,
+} from "./devices.validation.js";
+import {
+  deviceResponseSchema,
+  devicesResponseSchema,
+  eventResponseSchema,
+  genericResponseSchema,
+  imageResponseSchema,
+  uploadResponseSchema,
+  resetResponseSchema,
+} from "./devices.schemas.js";
+import {
+  validateOrganizationDelete,
+  validateOrganizationUpdate,
+} from "../middlewares/validateAction.js";
+
+export const devicesRouteSpecs: RouteSpec[] = [
+  {
+    method: "post",
+    path: "/",
+    validate: [
+      auth("manageUsers"),
+      validateBodyOrganization,
+      validateOrganizationDelete,
+    ],
+    requestSchema: createDeviceSchema,
+    responseSchema: deviceResponseSchema,
+    handler: devicesController.createEntry,
+    summary: "Create a new device",
+    description:
+      "Create a new device and associate it with the current organization.",
+  },
+  {
+    method: "get",
+    path: "/",
+    validate: [auth("getUsers"), validateQuerySearchUserAndOrganization],
+    requestSchema: queryDevicesSchema,
+    responseSchema: devicesResponseSchema,
+    handler: devicesController.queryDevicesByUser,
+    summary: "Query devices by user",
+    description:
+      "Retrieve a paginated list of devices visible to the authenticated user.",
+  },
+  {
+    method: "get",
+    path: "/events/:deviceId",
+    validate: [auth("getUsers"), validateDevice],
+    requestSchema: getEventsSchema,
+    responseSchema: eventResponseSchema.array(),
+    handler: devicesController.getEvents,
+    summary: "Get events for a device",
+    description:
+      "Fetch a chronological list of events generated by the specified device.",
+  },
+  {
+    method: "get",
+    path: "/:deviceId",
+    validate: [auth("getUsers"), validateDevice],
+    requestSchema: getDeviceSchema,
+    responseSchema: deviceResponseSchema,
+    handler: devicesController.getEntry,
+    summary: "Get a device by ID",
+    description:
+      "Retrieve detailed information for the device identified by its ID.",
+  },
+  {
+    method: "post",
+    path: "/:deviceId",
+    handler: devicesController.deleteEntry,
+    summary: "Delete a device",
+    description: "Remove the specified device from the system.",
+  },
+  {
+    method: "post",
+    path: "/registerdevice/:deviceId",
+    validate: [
+      auth("getUsers"),
+      validateBodyOrganization,
+      validateOrganizationDelete,
+    ],
+    requestSchema: registerDeviceSchema,
+    responseSchema: genericResponseSchema,
+    handler: devicesController.registerDevice,
+    summary: "Register a device",
+    description:
+      "Associate an existing device with the authenticated organization.",
+  },
+  {
+    method: "post",
+    path: "/ledlight/:deviceId",
+    validate: [auth("getUsers"), validateDevice],
+    requestSchema: ledLightSchema,
+    responseSchema: genericResponseSchema,
+    handler: devicesController.ledLight,
+    summary: "Set LED light on device",
+    description:
+      "Turn the device’s LED on or off, or set its color/brightness.",
+    memoOnly: true,
+  },
+  {
+    method: "get",
+    path: "/ping/:deviceId",
+    validate: [auth("getUsers"), validateDevice],
+    requestSchema: pingDeviceSchema,
+    responseSchema: genericResponseSchema,
+    handler: devicesController.pingDevice,
+    summary: "Ping a device",
+    description:
+      "Check connectivity and round-trip time to the specified device.",
+  },
+  {
+    method: "post",
+    path: "/reset/:deviceId",
+    validate: [auth("getUsers"), validateDevice, validateOrganizationDelete],
+    requestSchema: resetDeviceSchema,
+    responseSchema: resetResponseSchema,
+    handler: resetDevice,
+    summary: "Reset the sensors of a device",
+    description:
+      "Remotely reset all sensors on the target device to factory defaults.",
+  },
+  {
+    method: "post",
+    path: "/reboot/:deviceId",
+    validate: [auth("getUsers"), validateDevice, validateOrganizationDelete],
+    requestSchema: rebootDeviceSchema,
+    responseSchema: genericResponseSchema,
+    handler: devicesController.rebootDevice,
+    summary: "Reboot a device",
+    description: "Initiate a remote reboot of the specified device.",
+  },
+  {
+    method: "get",
+    path: "/image/:deviceId/:uuid",
+    validate: [auth("getUsers"), validateDevice],
+    requestSchema: getImageSchema,
+    responseSchema: imageResponseSchema,
+    handler: devicesController.getImageById,
+    summary: "Fetch an image by UUID",
+    description:
+      "Download a previously uploaded image for the device by its UUID.",
+  },
+  {
+    method: "post",
+    path: "/updateSingleImageMeta/:deviceId",
+    validate: [auth("getUsers"), validateDevice],
+    requestSchema: updateSingleImageMetaSchema,
+    responseSchema: uploadResponseSchema,
+    handler: devicesController.updateSingleImageMeta,
+    summary: "Update image metadata",
+    description:
+      "Modify metadata (e.g., title, tags) for an existing device image.",
+  },
+  {
+    method: "post",
+    path: "/uploadSingleImage/:deviceId",
+    validate: [auth("getUsers"), multer().array("picture", 2), validateDevice],
+    requestSchema: uploadSingleImageSchema,
+    responseSchema: uploadResponseSchema,
+    handler: devicesController.uploadSingleImage,
+    summary: "Upload one or two images",
+    description:
+      "Upload up to two image files to the device for processing or storage.",
+  },
+];
+
+const router: Router = Router();
+buildRouterAndDocs(router, devicesRouteSpecs, "/devices", ["Devices"]);
+
+export default router;

package/src/devices/devices.schemas.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { zObjectId } from "../utils/zValidations.js";
+
+export const deviceResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  serialNumber: z.string().optional(),
+  status: z.enum(["online", "offline", "error"]),
+  createdAt: z.string(), // ISO timestamp
+  updatedAt: z.string(), // ISO timestamp
+  // ...other device fields...
+});
+
+export const devicesResponseSchema = deviceResponseSchema.array();
+
+export const eventResponseSchema = z.object({
+  id: z.string(),
+  deviceId: z.string(),
+  type: z.string(),
+  payload: z.record(z.any()),
+  timestamp: z.string(), // ISO timestamp
+  // ...other event fields...
+});
+
+export const genericResponseSchema = z.object({
+  message: z.string(),
+});
+
+export const imageResponseSchema = z.object({
+  uuid: z.string(),
+  deviceId: z.string(),
+  url: z.string().url(),
+  metadata: z
+    .object({
+      width: z.number().optional(),
+      height: z.number().optional(),
+      size: z.number().optional(), // bytes
+      // ...other metadata fields...
+    })
+    .optional(),
+  uploadedAt: z.string(), // ISO timestamp
+});
+
+export const checkoutSessionResponseSchema = z.object({
+  sessionId: z.string(),
+  url: z.string().url(),
+});
+
+export const customerPortalSessionResponseSchema = z.object({
+  url: z.string().url(),
+});
+
+export const subscriptionResponseSchema = z.object({
+  status: z.enum(["active", "past_due", "canceled", "unpaid"]),
+  currentPeriodStart: z.string(), // ISO timestamp
+  currentPeriodEnd: z.string(), // ISO timestamp
+  plan: z.object({
+    id: z.string(),
+    amount: z.number(),
+    currency: z.string(),
+    interval: z.enum(["day", "week", "month", "year"]),
+    // ...other plan fields...
+  }),
+  // ...other subscription fields...
+});
+
+export const uploadResponseSchema = z.object({
+  filenames: z.array(z.string()),
+  urls: z.array(z.string().url()),
+  // ...other upload result fields...
+});
+
+export const pingDeviceSchema = {
+  params: z.object({
+    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+  }),
+  query: z.object({
+    dataResponse: z
+      .string()
+      .openapi({ description: "Data response", example: "false" }),
+  }),
+};
+
+export const resetResponseSchema = z.object({
+  message: z.string().openapi({
+    example:
+      "Reset all Variables and Memory and reboot Device: nrf-352656106701140",
+    description: "Response message from reset operation",
+  }),
+  success: z.boolean().openapi({
+    example: true,
+    description: "Indicates if the reset operation was successful",
+  }),
+});