@internetderdinge/api 1.224.2

package/src/devices/devices.service.ts

@@ -0,0 +1,320 @@
+import httpStatus from "http-status";
+import Device from "./devices.model.js";
+import ApiError from "../utils/ApiError.js";
+import iotDevicesService from "../iotdevice/iotdevice.service.js";
+
+import { promisify } from "util";
+import { getSignedFileUrl } from "../files/upload.service";
+import { deviceByDeviceName, deviceKindHasFeature } from "@wirewire/helpers";
+
+import type { DeviceDocument, DeviceInput } from "./devices.model.js";
+import type { ApiErrorType } from "../utils/ApiError.js";
+import type { IoTDeviceResponse } from "../iotdevice/iotdevice.service.js";
+import * as usersService from "../users/users.service";
+
+const setTimeoutAsync = promisify(setTimeout);
+
+/**
+ * Register a new device
+ */
+export const registerDevice = async ({
+  id,
+  body,
+}: {
+  id: string;
+  body: DeviceInput;
+}): Promise<IoTDeviceResponse & { createdDevice?: DeviceDocument }> => {
+  const iotDevices = await iotDevicesService.activateDevice(
+    id,
+    body.organization,
+    body.enable,
+  );
+
+  if (iotDevices.activation_status === "success") {
+    let patient;
+    if (body.patient) {
+      patient = await usersService.getById(body.patient);
+    }
+
+    const deviceListData = deviceByDeviceName(id);
+
+    const createdDevice = await Device.create({
+      deviceId: id,
+      ...body,
+      kind: deviceListData.id,
+      meta: {
+        name:
+          patient && patient.meta?.firstName
+            ? `${patient.meta.firstName} ${patient.meta.lastName} ANABOX smart`
+            : undefined,
+      },
+    });
+    return { ...iotDevices, createdDevice };
+  }
+  return iotDevices;
+};
+
+export const getAllDevices = async (): Promise<DeviceDocument[]> => {
+  return Device.find();
+};
+
+export const createDevice = async (
+  userBody: DeviceInput,
+): Promise<DeviceDocument> => {
+  return Device.create(userBody);
+};
+
+export const populateIotDevice = async (e: {
+  deviceId: string;
+}): Promise<IoTDeviceResponse | null> => {
+  const iotDevices = await iotDevicesService.getDevice([e.deviceId]);
+
+  try {
+    if (iotDevices) {
+      const iotDevice = iotDevices.message.find(
+        (c) => c.serialNumber === e.deviceId,
+      );
+      return iotDevice || null;
+    }
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+  return null;
+};
+
+export const populateIotShadow = async (
+  e: { deviceId: string },
+  shadowName: string,
+): Promise<any> => {
+  const iotDevices = await iotDevicesService.shadowAlarmGet(
+    e.deviceId,
+    shadowName,
+  );
+  return iotDevices;
+};
+
+export const populateDeviceStatus = async (e: {
+  deviceId: string;
+  kind: string;
+}): Promise<any> => {
+  if (!e.deviceId) return null;
+  const deviceStatus = await iotDevicesService.getDeviceStatus(
+    e.deviceId,
+    e.kind,
+  );
+  return deviceStatus;
+};
+
+export const populateDeviceImage = async (
+  deviceId: string,
+  uuid: string,
+): Promise<string> => {
+  const fileName = `ePaperImages/${deviceId}+${uuid}.png`;
+  const url = await getSignedFileUrl({ fileName });
+  return url;
+};
+
+export const populateIotDevices = async (
+  data: DeviceDocument[],
+): Promise<any[]> => {
+  const nrfList = data.map((e) => e.deviceId);
+  const iotDevices = await iotDevicesService.getDevice(nrfList);
+
+  if (iotDevices) {
+    return data.map((e) => {
+      const iotDevice = iotDevices.message.find(
+        (c) => c.serialNumber === e.deviceId,
+      );
+      if (e.kind === "anabox-smart") return { ...e.toJSON(), iotDevice };
+      return e;
+    });
+  }
+  return data;
+};
+
+export const queryDevicesByUser = async (
+  filter: any,
+  options: any,
+): Promise<any> => {
+  const devices = await Device.paginate(filter, options);
+  return devices;
+};
+
+export const getDeviceByUserId = async (
+  patient: string,
+): Promise<DeviceDocument | null> => {
+  return Device.findOne({ patient });
+};
+
+export const getById = async (id: string): Promise<DeviceDocument> => {
+  const device = await Device.findById(id);
+  //if (!device) throw new ApiError(httpStatus.NOT_FOUND, `Device not found id: ${id}`);
+  return device;
+};
+
+export const getImageById = async (
+  id: string,
+  uuid: string,
+): Promise<{ url: string }> => {
+  const url = await populateDeviceImage(id, uuid);
+  return { url };
+};
+
+export const getByIdWithIoT = async (id: string): Promise<any> => {
+  const device = await getById(id);
+  if (!device) {
+    throw new ApiError(httpStatus.NOT_FOUND, `Device not found id: ${id}`);
+  }
+  const deviceJSON = device.toJSON();
+  const iotDevice = await populateIotDevice(device);
+  const shadow = await populateIotShadow(device, "settings");
+  const deviceStatus = await populateDeviceStatus(device);
+
+  deviceJSON.iotDevice = iotDevice;
+  deviceJSON.shadow = shadow;
+  deviceJSON.deviceStatus = deviceStatus;
+
+  return deviceJSON;
+};
+
+export const getDeviceByDeviceId = async (
+  deviceId: string,
+): Promise<DeviceDocument | null> => {
+  return Device.findOne({ deviceId });
+};
+
+export const updatePaymentById = async (
+  deviceId: string,
+  updateBody: any,
+): Promise<void> => {
+  const device = await getById(deviceId);
+  device.payment = updateBody;
+  await device.save();
+};
+
+export const updateById = async (
+  userId: string,
+  updateBody: any,
+): Promise<any> => {
+  const device = await getById(userId);
+
+  Object.assign(device, updateBody);
+
+  await device.save();
+
+  const shadowBody = {
+    state: {
+      reported: {},
+    },
+  };
+
+  if (device.kind === "anabox-smart") {
+    shadowBody.state.reported.take_offset_time = updateBody.takeOffsetTime;
+    shadowBody.state.reported.alarm_enable = updateBody.alarmEnable;
+  }
+  if (deviceKindHasFeature("epaper", device.kind)) {
+    const sleepTime = parseInt(device.meta?.sleepTime);
+    shadowBody.state.reported.sleepTime = isNaN(sleepTime) ? 3600 : sleepTime;
+    shadowBody.state.reported.clearScreen = true;
+    shadowBody.state.reported.showOverlay =
+      device.meta?.showOverlay === undefined ? true : device.meta?.showOverlay;
+  }
+
+  // console.log('shadowBody', updateBody, shadowBody, device.kind);
+
+  const shadowNew = await iotDevicesService.shadowAlarmUpdate(
+    device.deviceId,
+    shadowBody,
+    "settings",
+  );
+
+  const iotDevice = await populateIotDevice(device);
+  const shadow = await populateIotShadow(device);
+  const deviceJSON = device.toJSON();
+  deviceJSON.iotDevice = iotDevice;
+  deviceJSON.shadow = shadow;
+  return deviceJSON;
+};
+
+export const updateSingleImageMeta = async (
+  deviceId: string,
+  shadowNew: any,
+): Promise<any> => {
+  const shadowBody = {
+    state: {
+      reported: shadowNew,
+    },
+  };
+
+  const shadowResult = await iotDevicesService.shadowAlarmUpdate(
+    deviceId,
+    shadowBody,
+    "settings",
+  );
+  return shadowResult;
+};
+
+export const deleteById = async (
+  userId: string,
+  deleteFromIotApi = true,
+): Promise<DeviceDocument> => {
+  const device = await getById(userId);
+  if (!device) {
+    throw new ApiError(httpStatus.NOT_FOUND, "Device not found");
+  }
+
+  if (device.kind === "anabox-smart" && deleteFromIotApi) {
+    const iotDevice = await iotDevicesService.activateDevice(
+      device.deviceId,
+      device.organization,
+      false,
+      true,
+    );
+    if (!iotDevice) {
+      throw new ApiError(
+        httpStatus.NOT_FOUND,
+        "Anabox-Smart Device could not be unlinked.",
+      );
+    }
+  }
+
+  if (deviceKindHasFeature("epaper", device.kind) && deleteFromIotApi) {
+    const iotDevice = await iotDevicesService.activateDevice(
+      device.deviceId,
+      device.organization,
+      false,
+      true,
+    );
+
+    if (!iotDevice) {
+      throw new ApiError(
+        httpStatus.NOT_FOUND,
+        "Epaper device could not be unlinked.",
+      );
+    }
+  }
+
+  await device.deleteOne();
+  return device;
+};
+
+export default {
+  getById,
+  getByIdWithIoT,
+  getDeviceByUserId,
+  getDeviceByDeviceId,
+  getImageById,
+  updateById,
+  updatePaymentById,
+  deleteById,
+  populateIotDevices,
+  populateDeviceImage,
+  populateDeviceStatus,
+  queryDevicesByUser,
+  registerDevice,
+  getAllDevices,
+  createDevice,
+  populateIotDevice,
+  populateIotShadow,
+};

package/src/devices/devices.validation.ts

@@ -0,0 +1,221 @@
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { z } from "zod";
+import { objectId } from "../validations/custom.validation.js";
+import {
+  zGet,
+  zObjectId,
+  zPatchBody,
+  zUpdate,
+  zDelete,
+  zPagination,
+} from "../utils/zValidations.js";
+import { enable } from "agenda/dist/job/enable";
+
+extendZodWithOpenApi(z);
+
+export const createEntrySchema = {
+  body: z
+    .object({
+      name: z.string().optional(),
+      deviceId: z.string().optional(),
+      kind: z.string().optional(),
+      meta: z.record(z.any()).optional(),
+      organization: zObjectId,
+      patient: zObjectId.optional(),
+      paper: zObjectId.optional().nullable(),
+      date: z.string().datetime().optional(),
+    })
+    .openapi({ description: "Create a new device entry" }),
+};
+
+export const getUsersSchema = {
+  query: z
+    .object({
+      name: z.string().optional(),
+      role: z.string().optional(),
+      sortBy: z.string().optional(),
+      limit: z.number().int().optional(),
+      page: z.number().int().optional(),
+    })
+    .openapi({ description: "Query users" }),
+};
+
+export const getEntrySchema = zGet("deviceId");
+
+export const updateEntrySchema = {
+  ...zUpdate("deviceId"),
+  body: zPatchBody({
+    name: z.string().optional(),
+    kind: z.string().optional(),
+    deviceId: z.string().optional(),
+    organization: zObjectId.optional(),
+    patient: zObjectId.optional().nullable(),
+    paper: zObjectId.optional().nullable(),
+    meta: z.record(z.any()).optional(),
+    iotDevice: z.record(z.any()).optional(),
+    shadow: z.union([z.string(), z.number()]).optional(),
+    alarmEnable: z.number().int().optional(),
+    takeOffsetTime: z.number().int().optional(),
+    updatedAt: z.string().datetime().optional(),
+    createdAt: z.string().datetime().optional(),
+    payment: z.record(z.any()).optional(),
+    lut: z.string().optional(),
+    sleepTime: z.string().optional(),
+    clearScreen: z.boolean().optional(),
+  }).openapi({ description: "Fields to update on a device entry" }),
+};
+
+export const getEventsSchema = {
+  query: z
+    .object({
+      DateStart: z.string(),
+      DateEnd: z.string(),
+      TypeFilter: z.string().optional(),
+    })
+    .openapi({ description: "Fetch device events in a time range" }),
+};
+
+export const deleteEntrySchema = zDelete("deviceId");
+
+export const createCheckoutSessionSchema = {};
+export const createCustomerPortalSessionSchema = {
+  params: z.object({
+    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+  }),
+  body: z.object({
+    domain: z.string().url().openapi({
+      description: "Domain for return URL",
+      example: "https://web.wirewire.de",
+    }),
+  }),
+};
+export const createDeviceSchema = {
+  body: z.object({
+    kind: z.string().optional(),
+    patient: zObjectId.optional().nullable(),
+    paper: zObjectId.optional().nullable(),
+    organization: zObjectId.openapi({ description: "Organization ObjectId" }),
+  }),
+};
+export const deleteDeviceSchema = zDelete("deviceId");
+export const getDeviceSchema = zGet("deviceId");
+export const getImageSchema = zGet("deviceId");
+export const ledLightSchema = {
+  params: z.object({
+    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+  }),
+  body: z
+    .object({
+      led: z.array(z.tuple([z.number().int(), z.number().int()])),
+      timeout: z.number().int(),
+    })
+    .openapi({
+      description: "LED light configuration for device",
+      example: {
+        led: [
+          [0, 0],
+          [1, 0],
+          [2, 0],
+          [3, 0],
+          [4, 0],
+          [5, 0],
+          [6, 0],
+          [7, 0],
+          [8, 0],
+          [9, 0],
+          [10, 0],
+          [11, 0],
+          [12, 0],
+          [13, 0],
+          [14, 0],
+          [15, 100],
+          [16, 100],
+          [17, 100],
+          [18, 100],
+          [19, 100],
+          [20, 100],
+          [21, 100],
+          [22, 0],
+          [23, 0],
+          [24, 0],
+          [25, 0],
+          [26, 0],
+          [27, 0],
+          [28, 0],
+        ],
+        timeout: 40,
+      },
+    }),
+};
+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 resetDeviceSchema = {
+  params: z.object({
+    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+  }),
+};
+
+export const rebootDeviceSchema = zGet("deviceId");
+
+export const registerDeviceSchema = {
+  ...zPagination,
+  body: z.object({
+    enable: z.boolean(),
+    organization: zObjectId,
+    patient: zObjectId.optional().nullable(),
+    paper: zObjectId.optional().nullable(),
+  }),
+  params: z.object({
+    deviceId: z.string(),
+  }),
+  query: zPagination.query.extend({
+    patient: zObjectId.optional(),
+    organization: zObjectId.optional(),
+  }),
+};
+
+export const queryDevicesSchema = {
+  ...zPagination,
+  query: zPagination.query.extend({
+    patient: zObjectId.optional(),
+    organization: zObjectId.optional(),
+  }),
+};
+export const subscriptionSchema = {
+  params: z.object({
+    deviceId: zObjectId.openapi({ description: "Device ObjectId" }),
+  }),
+};
+export const uploadSingleImageFromWebsiteSchema = {};
+export const updateDeviceSchema = {
+  ...zUpdate("deviceId"),
+  body: zPatchBody({
+    intake: z.record(z.any()).optional(),
+    meta: z.record(z.any()).optional(),
+    organization: zObjectId.optional(),
+    patient: zObjectId.optional().nullable(),
+    paper: zObjectId.optional().nullable(),
+    kind: z.string().optional(),
+    deviceId: z.string().optional(),
+    alarmEnable: z.number().int().optional(),
+    takeOffsetTime: z.number().int().optional(),
+    iotDevice: z.record(z.any()).optional(),
+    payment: z.record(z.any()).optional(),
+  }),
+};
+
+export const updateSingleImageMetaSchema = {};
+export const uploadSingleImageSchema = {
+  body: z.object({
+    file: z.instanceof(File).openapi({ description: "File to upload" }),
+  }),
+};

package/src/devicesNotifications/devicesNotifications.controller.ts

@@ -0,0 +1,72 @@
+import httpStatus from 'http-status';
+
+import pick from '../../src/utils/pick';
+import ApiError from '../../src/utils/ApiError';
+import catchAsync from '../../src/utils/catchAsync';
+import devicesNotificationsService from './devicesNotifications.service';
+
+import type { Request, Response } from 'express';
+
+export const createEntry = catchAsync(async (req: Request, res: Response) => {
+  const user = await devicesNotificationsService.createNotification({ user: res.req.auth.sub, token: req.body.token });
+  res.status(httpStatus.CREATED).send(user);
+});
+
+export const setDeviceToken = catchAsync(async (req: Request, res: Response) => {
+  const user = await devicesNotificationsService.setDeviceToken({ user: res.req.auth.sub, body: req.body });
+  res.status(httpStatus.CREATED).send(user);
+});
+
+export const removeDeviceToken = catchAsync(async (req: Request, res: Response) => {
+  const user = await devicesNotificationsService.removeDeviceToken({ user: res.req.auth.sub, body: req.body });
+  res.status(httpStatus.CREATED).send(user);
+});
+
+export const getEntries = catchAsync(async (req: Request, res: Response) => {
+  const filter = pick(req.query, ['name', 'role']);
+  const options = pick(req.query, ['sortBy', 'limit', 'page']);
+  const result = await devicesNotificationsService.queryNotifications(filter, options);
+  res.send(result);
+});
+
+export const queryNotificationsByUser = catchAsync(async (req: Request, res: Response) => {
+  const filter = pick({ user: res.req.auth.sub }, ['user']);
+  const options = pick(req.query, ['sortBy', 'limit', 'page']);
+  const result = await devicesNotificationsService.queryNotificationsByUser(filter, options);
+  res.send(result);
+});
+
+export const getEntry = catchAsync(async (req: Request, res: Response) => {
+  const notification = await devicesNotificationsService.getById(req.params.notificationId);
+  if (!notification) {
+    throw new ApiError(httpStatus.NOT_FOUND, 'Notification not found');
+  }
+  res.send(notification);
+});
+
+export const updateEntry = catchAsync(async (req: Request, res: Response) => {
+  const user = await devicesNotificationsService.updateById(req.params.notificationId, req.body);
+  res.send(user);
+});
+
+export const deleteEntry = catchAsync(async (req: Request, res: Response) => {
+  const entry = await devicesNotificationsService.deleteById(req.params.notificationId);
+  res.send(entry);
+});
+
+export const cleanup = catchAsync(async (req: Request, res: Response) => {
+  const entry = await devicesNotificationsService.cleanup();
+  res.send(entry);
+});
+
+export default {
+  createEntry,
+  getEntries,
+  setDeviceToken,
+  removeDeviceToken,
+  cleanup,
+  queryNotificationsByUser,
+  getEntry,
+  updateEntry,
+  deleteEntry,
+};

package/src/devicesNotifications/devicesNotifications.model.ts

@@ -0,0 +1,67 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import type { PaginateModel } from 'mongoose';
+import { toJSON, paginate } from '../../src/models/plugins/index';
+
+interface Token {
+  token: string;
+  deviceId: string;
+  plattform: string;
+  date: Date;
+}
+
+interface Settings {
+  intake: { email: boolean; push: boolean };
+  'intake-reminder': { email: boolean; push: boolean };
+  battery: { email: boolean; push: boolean };
+}
+
+export interface DeviceNotificationDocument extends Document {
+  user: string;
+  tokens: Token[];
+  bounceEmail: string;
+  settings: Settings;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type DeviceNotificationModel = Model<DeviceNotificationDocument> & PaginateModel<DeviceNotificationDocument>;
+
+const deviceNotificationSchema = new Schema<DeviceNotificationDocument>(
+  {
+    user: { type: String, required: true },
+    tokens: [
+      {
+        token: { type: String, required: true },
+        deviceId: { type: String, required: true },
+        plattform: { type: String, required: true },
+        date: {
+          type: Date,
+          default: Date.now,
+        },
+      },
+    ],
+    bounceEmail: { type: String },
+    settings: {
+      intake: { email: { type: Boolean, default: true }, push: { type: Boolean, default: true } },
+      'intake-reminder': {
+        email: { type: Boolean, default: true },
+        push: { type: Boolean, default: true },
+      },
+      battery: { email: { type: Boolean, default: true }, push: { type: Boolean, default: true } },
+    },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+// Add plugins
+deviceNotificationSchema.plugin(toJSON);
+deviceNotificationSchema.plugin(paginate);
+
+const DeviceNotifications = mongoose.model<DeviceNotificationDocument, DeviceNotificationModel>(
+  'DeviceNotification',
+  deviceNotificationSchema,
+);
+
+export default DeviceNotifications;