Merge pull request #81 from coronasafe/develop

Production Release

src/Validators/cameraValidators.js

@@ -46,6 +46,30 @@ export const baseGetCameraParamsValidators = [
     .withMessage("port must be integer."),
 ];
 
+export const camerasStatusBodyValidators = [
+  body().isArray().withMessage("body must be a valid array."),
+  body("*.hostname")
+    .exists({ checkFalsy: true })
+    .withMessage("hostname is required.")
+    .isString()
+    .withMessage("hostname must be string."),
+  body("*.username")
+    .exists({ checkFalsy: true })
+    .withMessage("username is required.")
+    .isString()
+    .withMessage("username must be string."),
+  body("*.password")
+    .exists({ checkFalsy: true })
+    .withMessage("password is required.")
+    .isString()
+    .withMessage("password must be string."),
+  body("*.port")
+    .exists({ checkFalsy: true })
+    .withMessage("port is required.")
+    .isInt()
+    .withMessage("port must be integer."),
+];
+
 export const gotoPresetValidator = [
   ...baseCameraParamsValidators,
   body("preset")

src/controller/CameraController.js

@@ -1,6 +1,50 @@
 import { CameraUtils } from "../utils/CameraUtils.js";
 import { catchAsync } from "../utils/catchAsync.js";
 
+var assets = [];
+var statuses = [];
+var fetchStatusesInterval = null;
+
+const filterStatus = () => {
+  const MIN_IN_MS = 60000;
+  statuses = statuses.filter(
+    (status) => new Date() - new Date(status.time) <= 30 * MIN_IN_MS
+  );
+};
+
+const fetchCameraStatuses = async () => {
+  filterStatus();
+
+  const cameraStatuses = await Promise.all(
+    assets.map(async (camera) => {
+      try {
+        const camParams = CameraController._getCamParams(camera);
+        const status = await CameraUtils.getStatus({ camParams });
+
+        return {
+          deviceId: camera.hostname,
+          status: status?.error === "NO error" ? "up" : "down",
+        };
+      } catch (error) {
+        console.error(error);
+
+        return {
+          deviceId: camera.hostname,
+          status: "down",
+        };
+      }
+    })
+  );
+
+  statuses.push({
+    time: new Date().toISOString(),
+    status: cameraStatuses.reduce((acc, curr) => {
+      acc[curr.deviceId] = curr.status;
+      return acc;
+    }, {}),
+  });
+};
+
 export class CameraController {
   static _getCamParams = (body) => {
     const { hostname, username, password, port } = body;
@@ -140,6 +184,59 @@ export class CameraController {
     res.send(status);
   });
 
+  /**
+   * @swagger
+   * /cameras/status:
+   *   post:
+   *     summary: "Get status of cameras"
+   *     tags:
+   *       - status
+   *     requestBody:
+   *       content:
+   *         application/json:
+   *           schema:
+   *             type: array
+   *             items:
+   *               type: object
+   *               properties:
+   *                 hostname:
+   *                   type: string
+   *                   description: Device Id or device IP address
+   *                 port:
+   *                   type: number
+   *                   enum: [80, 443]
+   *                 username:
+   *                   type: string
+   *                 password:
+   *                   type: string
+   *     responses:
+   *       "200":
+   *         description: Return camera statuses
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 time:
+   *                   type: string
+   *                   format: date-time
+   *                 status:
+   *                   type: object
+   *                   properties:
+   *                     device_id:
+   *                       type: string
+   *                       enum: [up, down]
+   */
+  static getCameraStatuses = catchAsync(async (req, res) => {
+    assets = req.body;
+    await fetchCameraStatuses();
+
+    clearInterval(fetchStatusesInterval);
+    fetchStatusesInterval = setInterval(fetchCameraStatuses, 60 * 1000);
+
+    return res.json(statuses);
+  });
+
   /**
    * @swagger
    * /absoluteMove:

src/controller/ObservationController.js

@@ -373,13 +373,13 @@ const updateObservationsToCare = async () => {
 const filterStatusData = () => {
   const MIN_IN_MS = 60000;
   statusData = statusData.filter(
-    (status) => new Date() - status.time <= 30 * MIN_IN_MS
+    (status) => new Date() - new Date(status.time) <= 30 * MIN_IN_MS
   );
 };
 
 const parseDataAsStatus = (data) => {
   return {
-    time: new Date(),
+    time: new Date(new Date().setSeconds(0, 0)).toISOString(),
 
     status: data.reduce((acc, device_observations) => {
       device_observations.forEach((observation) => {
@@ -396,7 +396,24 @@ const parseDataAsStatus = (data) => {
 const addStatusData = (data) => {
   filterStatusData();
 
-  statusData.push(parseDataAsStatus(data));
+  const newStatus = parseDataAsStatus(data);
+
+  const index = statusData.findIndex(
+    (status) => status.time === newStatus.time
+  );
+
+  if (index === -1) {
+    statusData.push(newStatus);
+    return;
+  }
+
+  statusData[index] = {
+    time: newStatus.time,
+    status: {
+      ...statusData[index].status,
+      ...newStatus.status,
+    },
+  };
 };
 
 export class ObservationController {

src/router/cameraRouter.js

@@ -5,6 +5,7 @@ import { CameraController } from "../controller/CameraController.js";
 import { validate } from "../middleware/validate.js";
 import {
   baseCameraParamsValidators,
+  camerasStatusBodyValidators,
   setPresetValidators,
   baseGetCameraParamsValidators,
   camMoveValidator,
@@ -31,6 +32,12 @@ router.get(
   CameraController.getStatus
 );
 
+router.post(
+  "/cameras/status",
+  validate(camerasStatusBodyValidators),
+  CameraController.getCameraStatuses
+);
+
 router.post(
   "/gotoPreset",
   validate(gotoPresetValidator),