@internetderdinge/api 1.229.0 → 1.229.2

package/dist/src/config/roles.js

@@ -0,0 +1,11 @@
+const allRoles = {
+    user: [],
+    admin: ['getUsers', 'manageUsers'],
+    patient: [],
+};
+export const roles = Object.keys(allRoles);
+export const roleRights = new Map(Object.entries(allRoles));
+export default {
+    roles,
+    roleRights,
+};

package/dist/src/config/tokens.cjs

@@ -0,0 +1,10 @@
+"use strict";
+const tokenTypes = {
+    ACCESS: 'access',
+    REFRESH: 'refresh',
+    RESET_PASSWORD: 'resetPassword',
+    VERIFY_EMAIL: 'verifyEmail',
+};
+module.exports = {
+    tokenTypes,
+};

package/dist/src/devices/devices.controller.js

@@ -0,0 +1,172 @@
+// @ts-nocheck
+import httpStatus from "http-status";
+import mongoose from "mongoose";
+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, res) => {
+    const user = await devicesService.createDevice(req.body);
+    res.status(httpStatus.CREATED).send(user);
+});
+const registerDevice = catchAsync(async (req, res) => {
+    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, res) => {
+    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, res) => {
+    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, res) => {
+    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, res) => {
+    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, res) => {
+    // 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, res) => {
+    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, res) => {
+    const entry = await devicesService.deleteById(req.params.deviceId);
+    //res.status(httpStatus.NO_CONTENT).send();
+    res.send(entry);
+});
+const pingDevice = catchAsync(async (req, res) => {
+    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, res) => {
+    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, res) => {
+    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, res) => {
+    const device = await devicesService.getByIdWithIoT(req.params.deviceId);
+    const reboot = await iotDevicesService.rebootDevice(device.deviceId);
+    res.send({ device, reboot });
+});
+const updateSingleImageMeta = catchAsync(async (req, res) => {
+    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, res) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const files = req.files;
+    if (!files || files.length === 0) {
+        throw new ApiError(httpStatus.BAD_REQUEST, "No image file uploaded");
+    }
+    const iotUpload = await iotDevicesService.uploadSingleImage({
+        deviceName: device.deviceId,
+        buffer: 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/dist/src/devices/devices.model.js

@@ -0,0 +1,94 @@
+// @ts-nocheck
+import mongoose, { Schema } from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index.js";
+import { ensureSameOrganization } from "../middlewares/mongooseValidations/ensureSameOrganization.js";
+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
+        .virtual("loadedAt")
+        .get(function () {
+        return this._loadedAt;
+    })
+        .set(function (v) {
+        this._loadedAt = v;
+    });
+    schema.post(["find", "findOne"], function (docs) {
+        // 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("save", async function (next) {
+    if (!this.patient)
+        return next();
+    try {
+        await ensureSameOrganization(this.patient, this.organization, mongoose.model("User"));
+        next();
+    }
+    catch (err) {
+        next(err);
+    }
+});
+deviceSchema.pre("findOneAndUpdate", async function (next) {
+    const update = this.getUpdate();
+    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);
+    }
+});
+// Add the IoT device functionality
+addIotDevice(deviceSchema);
+// Add plugins that convert mongoose to JSON and enable pagination
+deviceSchema.plugin((schema) => toJSON(schema, true));
+deviceSchema.plugin(paginate);
+const Devices = mongoose.models.Device ||
+    mongoose.model("Device", deviceSchema);
+export default Devices;

package/dist/src/devices/devices.route.js

@@ -0,0 +1,153 @@
+import { Router } from "express";
+import multer from "multer";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs.js";
+import auth from "../middlewares/auth.js";
+import { validateBodyOrganization, } from "../middlewares/validateOrganization.js";
+import { validateQuerySearchUserAndOrganization } from "../middlewares/validateQuerySearchUserAndOrganization.js";
+import { validateDevice } from "../middlewares/validateDevice.js";
+import * as devicesController from "./devices.controller.js";
+import { resetDevice } from "./devices.controller.js";
+import { createDeviceSchema, queryDevicesSchema, getDeviceSchema, 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, } from "../middlewares/validateAction.js";
+export const devicesRouteSpecs = [
+    {
+        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();
+buildRouterAndDocs(router, devicesRouteSpecs, "/devices", ["Devices"]);
+export default router;

package/dist/src/devices/devices.schemas.js

@@ -0,0 +1,84 @@
+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.string(), z.any()),
+    timestamp: z.string(), // ISO timestamp
+    // ...other event fields...
+});
+export const genericResponseSchema = z
+    .record(z.string(), z.any())
+    .openapi({ description: "Generic response payload" });
+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({
+    key: z.string().optional(),
+    similarityPercentage: z.number().nullable().optional(),
+    skippedUpload: z.boolean().optional(),
+})
+    .openapi({ description: "Upload response payload" });
+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",
+    }),
+});