@internetderdinge/api 1.224.2

package/src/files/upload.service.ts

@@ -0,0 +1,145 @@
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import multer from 'multer';
+import multerS3 from 'multer-s3';
+import fs from 'fs';
+import request from 'request';
+
+type GetSignedFileUrlParams = {
+  fileName: string;
+  bucket?: string;
+  expiresIn?: number;
+};
+
+type UploadImageParams = {
+  key: string;
+  blob: Buffer | Uint8Array | Blob | string | ReadableStream;
+};
+
+const s3 = new S3Client({
+  region: 'eu-central-1',
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
+  },
+});
+
+export const getSignedFileUrl = async ({
+  fileName,
+  bucket = process.env.AWS_S3_BUCKET_NAME!,
+  expiresIn = 7200,
+}: GetSignedFileUrlParams): Promise<string> => {
+  const command = new GetObjectCommand({
+    Bucket: bucket,
+    Key: fileName,
+  });
+
+  const result = await getSignedUrl(s3, command, { expiresIn });
+  return result;
+};
+
+export const uploadImage = async ({ key, blob }: UploadImageParams): Promise<{ hello: string }> => {
+  const target = {
+    Bucket: process.env.AWS_S3_BUCKET_NAME!,
+    Key: key,
+    Body: blob,
+  };
+
+  try {
+    const parallelUploads3 = new Upload({
+      client: s3,
+      queueSize: 4,
+      leavePartsOnError: false,
+      params: target,
+    });
+
+    parallelUploads3.on('httpUploadProgress', (progress) => {
+      // console.log(progress);
+    });
+
+    await parallelUploads3.done();
+  } catch (e) {
+    console.error(e);
+  }
+
+  return { hello: 'xx' };
+};
+
+export const fileFilter = (req: Express.Request, file: Express.Multer.File, cb: multer.FileFilterCallback): void => {
+  if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png') {
+    cb(null, true);
+  } else {
+    cb(new Error('Invalid file type, only JPEG and PNG is allowed!'), false);
+  }
+};
+
+export const uploadFile = multer({
+  storage: multerS3({
+    s3: s3,
+    bucket: process.env.AWS_S3_BUCKET_NAME!,
+    contentType: multerS3.AUTO_CONTENT_TYPE,
+    acl: 'public-read',
+    metadata(req, file, cb) {
+      cb(null, { fieldName: file.fieldname });
+    },
+    key(req, file, cb) {
+      cb(null, `${Date.now().toString()}-${file.originalname}`);
+    },
+  }),
+});
+
+const getPhoto = async (photoId: string, res: Express.Response): Promise<void> => {
+  try {
+    const params = {
+      Bucket: process.env.AWS_S3_BUCKET_NAME!,
+      Key: photoId,
+    };
+
+    await s3
+      .getObject(params)
+      .on('httpHeaders', function (statusCode, headers) {
+        res.set('Content-Length', headers['content-length']);
+        res.set('Content-Type', headers['content-type']);
+        this.response.httpResponse.createUnbufferedStream().pipe(res);
+      })
+      .send();
+  } catch (e) {
+    throw new Error(`Could not retrieve file from S3: ${e.message}`);
+  }
+};
+
+const download = (uri: string, filename: string, callback: () => void): void => {
+  request.head(uri, (err, res, body) => {
+    if (err) {
+      console.error(err);
+      return;
+    }
+    console.log('content-type:', res.headers['content-type']);
+    console.log('content-length:', res.headers['content-length']);
+
+    request(uri).pipe(fs.createWriteStream(filename)).on('close', callback);
+  });
+};
+
+const getPhotoFromUserImage = async (photoId: string, res: Express.Response): Promise<void> => {
+  try {
+    const params = {
+      Bucket: process.env.AWS_S3_BUCKET_NAME!,
+      Key: photoId,
+    };
+
+    await s3
+      .getObject(params)
+      .on('httpHeaders', function (statusCode, headers) {
+        res.set('Content-Length', headers['content-length']);
+        res.set('Content-Type', headers['content-type']);
+        this.response.httpResponse.createUnbufferedStream().pipe(res);
+      })
+      .send();
+  } catch (e) {
+    throw new Error(`Could not retrieve file from S3: ${e.message}`);
+  }
+};
+
+export default { uploadFile, uploadImage, getPhoto, getPhotoFromUserImage, getSignedFileUrl };

package/src/i18n/i18n.ts

@@ -0,0 +1,51 @@
+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 "@wirewire/openiot-api/src/config/config";
+
+// Fix for __dirname in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface InitI18nOptions {
+  generatedPath?: string;
+}
+
+export function initI18n(options: InitI18nOptions = {}): typeof i18next {
+  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/src/i18n/saveMissingLocalJsonBackend.ts

@@ -0,0 +1,92 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { Callback } from "./types"; // Assuming a `types.ts` file exists for type definitions
+
+// 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?: string): void {
+  localesFolder = nextPath
+    ? path.resolve(nextPath)
+    : path.join(__dirname, "./generated");
+}
+
+interface CreateMissingTranslationParams {
+  content?: string;
+  namespace: string;
+  language: string;
+  key: string;
+}
+
+async function createMissingTranslation({
+  content,
+  namespace,
+  language,
+  key,
+}: CreateMissingTranslationParams): Promise<Response> {
+  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: string, namespace: string, callback: Callback): void {
+    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: string[],
+    namespace: string,
+    key: string,
+    fallbackValue?: string,
+  ): void {
+    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/src/index.ts

@@ -0,0 +1,7 @@
+export { default as usersRoute } from "../src/users/users.route";
+export { default as accountsRoute } from "../src/accounts/accounts.route";
+export { default as organizationsRoute } from "../src/organizations/organizations.route";
+export { default as devicesRoute } from "../src/devices/devices.route";
+export { default as devicesNotificationsRoute } from "./devicesNotifications/devicesNotifications.route";
+export { default as pdfRoute } from "../src/pdf/pdf.route";
+export { default as tokensRoute } from "../src/tokens/tokens.route";

package/src/iotdevice/iotdevice.controller.ts

@@ -0,0 +1,136 @@
+import type { Request, Response } from "express";
+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";
+
+import type { Device, ShadowUpdatePayload } from "./iotdevice.types"; // Example type imports
+
+export const getIotDevices = catchAsync(async (req: Request, res: Response) => {
+  const iotDevices = await iotDevicesService.getDeviceStatusList();
+  res.send({ results: iotDevices });
+});
+
+export const getEvents = catchAsync(async (req: Request, res: Response) => {
+  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: Request, res: Response) => {
+  const events = await iotDevicesService.getDevice(req.body.deviceId);
+  res.send(events);
+});
+
+export const activateDevice = catchAsync(
+  async (req: Request, res: Response) => {
+    const events = await iotDevicesService.activateDevice(req.body.deviceId);
+    res.send(events);
+  },
+);
+
+export const pingDevice = catchAsync(async (req: Request, res: Response) => {
+  const events = await iotDevicesService.pingDevice(req.body.deviceId);
+  res.send(events);
+});
+
+export const shadowAlarmUpdate = catchAsync(
+  async (req: Request, res: Response) => {
+    const device = await devicesService.getById(req.params.deviceId);
+    const { shadowName, ...others } = req.body as ShadowUpdatePayload;
+    const shadow = await iotDevicesService.shadowAlarmUpdate(
+      device.deviceId,
+      others,
+      shadowName,
+    );
+    res.send({ device, shadow });
+  },
+);
+
+export const shadowAlarmGet = catchAsync(
+  async (req: Request, res: Response) => {
+    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: Request, res: Response) => {
+  const shadow = await iotDevicesService.shadowAlarmGet(
+    req.params.nrfId,
+    req.params.shadowName,
+  );
+  res.send(shadow);
+});
+
+export const getDeviceStatus = catchAsync(
+  async (req: Request, res: Response) => {
+    const events = await iotDevicesService.getDeviceStatus(req.params.deviceId);
+    res.send(events);
+  },
+);
+
+export const ledLightHint = catchAsync(async (req: Request, res: Response) => {
+  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: Request, res: Response) => {
+  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: Request, res: Response) => {
+  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: Request, res: Response) => {
+  const user = await iotDevicesService.updateById(req.params.stockId, req.body);
+  res.send(user);
+});
+
+export const deleteEntry = catchAsync(async (req: Request, res: Response) => {
+  const entry = await iotDevicesService.deleteById(req.params.stockId);
+  res.send(entry);
+});
+
+export const getApiStatus = catchAsync(async (req: Request, res: Response) => {
+  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/src/iotdevice/iotdevice.model.ts

@@ -0,0 +1,32 @@
+import mongoose, { Schema, Document, Model } from 'mongoose';
+import { toJSON, paginate } from '../models/plugins/index';
+
+interface IotDeviceMeta {
+  [key: string]: any;
+}
+
+export interface IotDevice extends Document {
+  description?: string;
+  meta?: IotDeviceMeta;
+  deviceId?: string;
+}
+
+const iotDeviceSchema: Schema<IotDevice> = new mongoose.Schema(
+  {
+    description: {
+      type: String,
+    },
+    meta: { type: Object },
+    deviceId: { type: String },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+iotDeviceSchema.plugin(toJSON);
+iotDeviceSchema.plugin(paginate);
+
+export const IotDevices: Model<IotDevice> = mongoose.model<IotDevice>('IotDevice', iotDeviceSchema);
+
+export default IotDevices;

package/src/iotdevice/iotdevice.route.ts

@@ -0,0 +1,181 @@
+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 type { RouteSpec } from '../types/routeSpec';
+
+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';
+import { request } from 'https';
+
+export const iotdeviceRouteSpecs: RouteSpec[] = [
+  {
+    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: 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 = Router();
+
+buildRouterAndDocs(router, iotdeviceRouteSpecs, '/iotdevice', ['IoTDevice']);
+
+export default router;