@internetderdinge/api 1.229.0 → 1.229.1

package/dist/src/i18n/i18n.js

@@ -0,0 +1,38 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { join } from "path";
+import { existsSync, readdirSync } from "fs";
+import i18next from "i18next";
+import Backend, { setLocalesFolder } from "./saveMissingLocalJsonBackend";
+import config from "../config/config";
+// Fix for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function initI18n(options = {}) {
+    const localesFolder = options.generatedPath
+        ? path.resolve(options.generatedPath)
+        : join(__dirname, "./generated");
+    setLocalesFolder(localesFolder);
+    const hasLocalesFolder = existsSync(localesFolder);
+    if (!i18next.isInitialized) {
+        i18next.use(Backend).init({
+            initImmediate: false, // setting initImmediate to false, will load the resources synchronously
+            fallbackLng: "de",
+            preload: hasLocalesFolder
+                ? readdirSync(localesFolder)
+                    .filter((fileName) => path.extname(fileName) === ".json")
+                    .map((fileName) => path.basename(fileName, ".json"))
+                : [],
+            debug: false,
+            saveMissing: config.env !== "production",
+            ns: ["api"],
+            defaultNS: "api",
+            keySeparator: false,
+            interpolation: {
+                escapeValue: false,
+            },
+        });
+    }
+    return i18next;
+}
+export default i18next;

package/dist/src/i18n/saveMissingLocalJsonBackend.js

@@ -0,0 +1,53 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+// Fix for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let localesFolder = path.join(__dirname, "./generated");
+export function setLocalesFolder(nextPath) {
+    localesFolder = nextPath
+        ? path.resolve(nextPath)
+        : path.join(__dirname, "./generated");
+}
+async function createMissingTranslation({ content, namespace, language, key, }) {
+    const response = await fetch(`${process.env.REACT_APP_WEB_BACKEND_URL}/translations/create-missing`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            key,
+            content: content || key,
+            namespace,
+            language,
+            secret: process.env.REACT_APP_TRANSLATION_SECRET,
+        }),
+    });
+    return response;
+}
+const backend = {
+    type: "backend",
+    read(language, namespace, callback) {
+        const filePath = path.join(localesFolder, `${language}.json`);
+        try {
+            const data = fs.readFileSync(filePath, "utf8");
+            const jsonData = JSON.parse(data);
+            /* return resources */
+            callback(null, jsonData);
+        }
+        catch (error) {
+            callback(error, null);
+        }
+    },
+    create(languages, namespace, key, fallbackValue) {
+        console.log("missing translation saved", languages, namespace, key, fallbackValue);
+        createMissingTranslation({
+            key,
+            content: fallbackValue || key,
+            namespace,
+            language: "en",
+        }).catch((error) => console.error("Error creating missing translation:", error));
+    },
+};
+export default backend;

package/dist/src/i18n/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/index.js

@@ -0,0 +1,48 @@
+export { default as config } from "../src/config/config";
+export { default as logger } from "../src/config/logger";
+export { default as morgan } from "../src/config/morgan";
+export { default as auth } from "../src/middlewares/auth";
+export { errorConverter, errorHandler } from "../src/middlewares/error";
+export { default as validate } from "../src/middlewares/validate";
+export { validateDevice, validateDeviceIsInOrganization, validateDeviceOrOrganizationQuery, validateDeviceQuery, } from "../src/middlewares/validateDevice";
+export { initI18n } from "../src/i18n/i18n";
+export { default as usersRoute } from "../src/users/users.route";
+export { default as accountsRoute } from "../src/accounts/accounts.route";
+export { default as accountsService } from "../src/accounts/accounts.service";
+export { default as organizationsRoute } from "../src/organizations/organizations.route";
+export { default as organizationsService } from "../src/organizations/organizations.service";
+export { default as Organization } from "../src/organizations/organizations.model";
+export { default as devicesRoute } from "../src/devices/devices.route";
+export { default as devicesService } from "../src/devices/devices.service";
+export { default as Device } from "../src/devices/devices.model";
+export * from "../src/devices/devices.validation";
+export { default as devicesNotificationsRoute } from "./devicesNotifications/devicesNotifications.route";
+export { default as devicesNotificationsService } from "../src/devicesNotifications/devicesNotifications.service";
+export { default as iotDevicesService } from "../src/iotdevice/iotdevice.service";
+export { SIMILARITY_THRESHOLD } from "../src/iotdevice/iotdevice.service";
+export { default as pdfRoute } from "../src/pdf/pdf.route";
+export { default as tokensRoute } from "../src/tokens/tokens.route";
+export * from "../src/tokens/tokens.service";
+export { default as Token } from "../src/tokens/tokens.model";
+export * as usersService from "../src/users/users.service";
+export { User } from "../src/users/users.model";
+export { isAdmin, validateAdmin } from "../src/middlewares/validateAdmin";
+export { sendEmail } from "../src/email/email.service";
+export { default as catchAsync } from "../src/utils/catchAsync";
+export { default as buildRouterAndDocs } from "../src/utils/buildRouterAndDocs";
+export { default as pick } from "../src/utils/pick";
+export { paginate, toJSON } from "../src/models/plugins/index";
+export { compareImages } from "../src/utils/comparePapers.service";
+export { resolvePossiblyRelativeUrl } from "../src/utils/urlUtils";
+export { getSignedFileUrl } from "../src/files/upload.service";
+export * from "../src/utils/ApiError";
+export * from "../src/utils/buildRouterAndDocs";
+export * from "../src/utils/comparePapers.service";
+export * from "../src/utils/deviceUtils";
+export * from "../src/utils/filterOptions";
+export * from "../src/utils/medicationName";
+export * from "../src/utils/pick";
+export * from "../src/utils/registerOpenApi";
+export * from "../src/utils/urlUtils";
+export * from "../src/utils/userName";
+export * from "../src/utils/zValidations";

package/dist/src/iotdevice/iotdevice.controller.js

@@ -0,0 +1,96 @@
+import catchAsync from "../utils/catchAsync";
+import devicesService from "../devices/devices.service";
+import iotDevicesService from "./iotdevice.service";
+import httpStatus from "http-status";
+import ApiError from "../utils/ApiError";
+export const getIotDevices = catchAsync(async (req, res) => {
+    const iotDevices = await iotDevicesService.getDeviceStatusList();
+    res.send({ results: iotDevices });
+});
+export const getEvents = catchAsync(async (req, res) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const events = await iotDevicesService.getEvents({
+        ...req.query,
+        DeviceId: device.deviceId,
+    });
+    res.send({ ...events, device });
+});
+export const getDevice = catchAsync(async (req, res) => {
+    const events = await iotDevicesService.getDevice(req.body.deviceId);
+    res.send(events);
+});
+export const activateDevice = catchAsync(async (req, res) => {
+    const events = await iotDevicesService.activateDevice(req.body.deviceId);
+    res.send(events);
+});
+export const pingDevice = catchAsync(async (req, res) => {
+    const events = await iotDevicesService.pingDevice(req.body.deviceId);
+    res.send(events);
+});
+export const shadowAlarmUpdate = catchAsync(async (req, res) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const { shadowName, ...others } = req.body;
+    const shadow = await iotDevicesService.shadowAlarmUpdate(device.deviceId, others, shadowName);
+    res.send({ device, shadow });
+});
+export const shadowAlarmGet = catchAsync(async (req, res) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const shadow = await iotDevicesService.shadowAlarmGet(device.deviceId, req.body);
+    res.send({ device, shadow });
+});
+export const shadowAdmin = catchAsync(async (req, res) => {
+    const shadow = await iotDevicesService.shadowAlarmGet(req.params.nrfId, req.params.shadowName);
+    res.send(shadow);
+});
+export const getDeviceStatus = catchAsync(async (req, res) => {
+    const events = await iotDevicesService.getDeviceStatus(req.params.deviceId);
+    res.send(events);
+});
+export const ledLightHint = catchAsync(async (req, res) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const shadow = await iotDevicesService.ledLightHint(device.deviceId, req.body);
+    res.send({ device, shadow });
+});
+export const resetDevice = catchAsync(async (req, res) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const shadow = await iotDevicesService.resetDevice(device.deviceId, req.body);
+    res.send({ device, shadow });
+});
+export const getEntry = catchAsync(async (req, res) => {
+    const iotDevice = await iotDevicesService.getDevice([req.params.deviceId]);
+    if (!iotDevice?.message?.[0]) {
+        throw new ApiError(httpStatus.NOT_FOUND, "IoT Device not found");
+    }
+    res.send(iotDevice.message[0]);
+});
+export const updateEntry = catchAsync(async (req, res) => {
+    const user = await iotDevicesService.updateById(req.params.stockId, req.body);
+    res.send(user);
+});
+export const deleteEntry = catchAsync(async (req, res) => {
+    const entry = await iotDevicesService.deleteById(req.params.stockId);
+    res.send(entry);
+});
+export const getApiStatus = catchAsync(async (req, res) => {
+    const events = await iotDevicesService.getApiStatus(req.params.kind);
+    if (!events) {
+        throw new ApiError(httpStatus.UNAUTHORIZED, "API unavailable");
+    }
+    res.send(events);
+});
+export default {
+    getEvents,
+    getIotDevices,
+    getDevice,
+    shadowAlarmGet,
+    shadowAdmin,
+    pingDevice,
+    getDeviceStatus,
+    ledLightHint,
+    shadowAlarmUpdate,
+    getEntry,
+    getApiStatus,
+    updateEntry,
+    resetDevice,
+    deleteEntry,
+};

package/dist/src/iotdevice/iotdevice.model.js

@@ -0,0 +1,17 @@
+// @ts-nocheck
+import mongoose from "mongoose";
+import { toJSON, paginate } from "../models/plugins/index";
+const iotDeviceSchema = new mongoose.Schema({
+    description: {
+        type: String,
+    },
+    meta: { type: Object },
+    deviceId: { type: String },
+}, {
+    timestamps: true,
+});
+iotDeviceSchema.plugin(toJSON);
+iotDeviceSchema.plugin(paginate);
+export const IotDevices = mongoose.models.IotDevice ||
+    mongoose.model("IotDevice", iotDeviceSchema);
+export default IotDevices;

package/dist/src/iotdevice/iotdevice.route.js

@@ -0,0 +1,143 @@
+import { Router } from "express";
+import buildRouterAndDocs from "../utils/buildRouterAndDocs";
+import auth from "../middlewares/auth";
+import { validateAdmin } from "../middlewares/validateAdmin";
+import { validateDevice } from "../middlewares/validateDevice";
+import { getEventsSchema, getDeviceSchema, getEntrySchema, updateEntrySchema, pingDeviceSchema, iotDevicesSchema, shadowAlarmValidationSchema, apiStatusRequestSchema,
+// add other input schemas as needed
+ } from "./iotdevice.validation";
+import { iotDeviceResponseSchema, eventResponseSchema, deviceResponseSchema, shadowAlarmSchema, pingResponseSchema, deviceStatusSchema, apiStatusSchema, entryResponseSchema, } from "./iotdevice.schemas";
+import { getIotDevices, getEvents, getDevice, shadowAlarmGet, shadowAlarmUpdate, shadowAdmin, pingDevice, getDeviceStatus, getApiStatus, getEntry, updateEntry, } from "./iotdevice.controller";
+export const iotdeviceRouteSpecs = [
+    {
+        method: "get",
+        path: "/",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: iotDevicesSchema,
+        responseSchema: iotDeviceResponseSchema.array(),
+        handler: getIotDevices,
+        summary: "List all IoT devices",
+        description: "Retrieves a list of all registered IoT devices.",
+    },
+    {
+        method: "get",
+        path: "/events/:deviceId",
+        validate: [auth("getUsers"), validateDevice],
+        requestSchema: getEventsSchema,
+        responseSchema: eventResponseSchema.array(),
+        handler: getEvents,
+        summary: "Get events for a device",
+        description: "Fetches event records for the specified device by its ID.",
+    },
+    {
+        method: "post",
+        path: "/devices",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: getDeviceSchema,
+        responseSchema: deviceResponseSchema,
+        handler: getDevice,
+        summary: "Fetch a single device by criteria",
+        description: "Retrieves a single IoT device matching the provided criteria.",
+    },
+    {
+        method: "get",
+        path: "/device/shadowAlarmUpdate/:deviceId",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: getEntrySchema,
+        responseSchema: shadowAlarmSchema,
+        handler: shadowAlarmGet,
+        summary: "Get shadow alarm settings",
+        description: "Fetches the shadow alarm configuration for a specific device.",
+    },
+    {
+        method: "post",
+        path: "/device/shadowAlarmUpdate/:deviceId",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: { body: shadowAlarmSchema },
+        responseSchema: shadowAlarmSchema,
+        handler: shadowAlarmUpdate,
+        summary: "Update shadow alarm settings",
+        description: "Updates the shadow alarm configuration for a specific device.",
+    },
+    {
+        method: "get",
+        path: "/shadow/:nrfId/:shadowName",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: shadowAlarmValidationSchema,
+        responseSchema: shadowAlarmSchema,
+        handler: shadowAdmin,
+        summary: "Administer device shadow by nrfId and name",
+        description: "Performs administrative operations on a device shadow identified by NRF ID and shadow name.",
+    },
+    {
+        method: "post",
+        path: "/ledlight/:deviceId",
+        validate: [auth("getUsers"), validateAdmin],
+        responseSchema: pingResponseSchema,
+        handler: pingDevice,
+        summary: "Ping device LED light",
+        description: "Sends a ping to the device’s LED light to test its connectivity or response.",
+    },
+    {
+        method: "post",
+        path: "/ping/:deviceId",
+        validate: [auth("getUsers"), validateAdmin],
+        requestSchema: pingDeviceSchema,
+        responseSchema: pingResponseSchema,
+        handler: pingDevice,
+        summary: "Ping device",
+        description: "Sends a ping command to the specified device to verify its availability.",
+    },
+    {
+        method: "get",
+        path: "/getDeviceStatus/:deviceId",
+        validate: [auth("getUsers"), validateAdmin],
+        responseSchema: deviceStatusSchema,
+        handler: getDeviceStatus,
+        summary: "Get current status of a device",
+        description: "Retrieves the current operational status of the specified device.",
+    },
+    {
+        method: "get",
+        path: "/status/:kind",
+        validate: [],
+        requestSchema: apiStatusRequestSchema,
+        responseSchema: apiStatusSchema,
+        handler: getApiStatus,
+        summary: "Get API status by kind",
+        description: "Retrieves the API status information for a given status kind.",
+    },
+    {
+        method: "get",
+        path: "/:deviceId",
+        validate: [auth("getUsers"), validateDevice, validateAdmin],
+        requestSchema: getEntrySchema,
+        responseSchema: entryResponseSchema,
+        handler: getEntry,
+        summary: "Get one entry for a device",
+        description: "Fetches a single data entry for the specified device by ID.",
+    },
+    {
+        method: "post",
+        path: "/:deviceId",
+        validate: [auth("manageUsers"), validateDevice, validateAdmin],
+        requestSchema: updateEntrySchema,
+        responseSchema: entryResponseSchema,
+        handler: updateEntry,
+        summary: "Create or replace an entry for a device",
+        description: "Creates or replaces a data entry for the specified device.",
+    },
+    {
+        method: "patch",
+        path: "/:deviceId",
+        validate: [auth("manageUsers"), validateDevice, validateAdmin],
+        requestSchema: updateEntrySchema,
+        responseSchema: entryResponseSchema,
+        handler: updateEntry,
+        summary: "Update an entry for a device",
+        description: "Applies a partial update to an existing data entry for the specified device.",
+    },
+];
+const router = Router();
+buildRouterAndDocs(router, iotdeviceRouteSpecs, "/iotdevice", ["IoTDevice"]);
+export default router;

package/dist/src/iotdevice/iotdevice.schemas.js

@@ -0,0 +1,60 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+extendZodWithOpenApi(z);
+// Represents a device in the system
+export const iotDeviceResponseSchema = z.object({
+    deviceId: z.string(),
+    name: z.string(),
+    model: z.string().optional(),
+    firmwareVersion: z.string().optional(),
+    registeredAt: z.string(), // ISO timestamp
+    lastSeenAt: z.string().optional(), // ISO timestamp
+});
+// An event generated by a device
+export const eventResponseSchema = z.object({
+    eventId: z.string(),
+    deviceId: z.string(),
+    timestamp: z.string(), // ISO timestamp
+    type: z.string(),
+    payload: z.any(),
+});
+// A single device fetched by criteria
+export const deviceResponseSchema = z.object({
+    deviceId: z.string(),
+    serialNumber: z.string(),
+    type: z.string(),
+    owner: z.string(),
+    registeredAt: z.string(),
+});
+// Shadow alarm settings
+export const shadowAlarmSchema = z.object({
+    enabled: z.boolean(),
+    threshold: z.number(),
+    mode: z.enum(['auto', 'manual']).optional(),
+});
+// Ping / LED light response
+export const pingResponseSchema = z.object({
+    success: z.boolean(),
+    message: z.string().optional(),
+    timestamp: z.string(),
+});
+// Current status of a device
+export const deviceStatusSchema = z.object({
+    deviceId: z.string(),
+    online: z.boolean(),
+    batteryLevel: z.number().min(0).max(100).optional(),
+    lastSeenAt: z.string(),
+});
+// API status by kind
+export const apiStatusSchema = z.object({
+    kind: z.string(),
+    status: z.enum(['ok', 'degraded', 'down']),
+    uptimeSeconds: z.number(),
+});
+// Single entry for a device
+export const entryResponseSchema = z.object({
+    entryId: z.string(),
+    deviceId: z.string(),
+    timestamp: z.string(),
+    data: z.any(),
+});