Block unchanged equipment request

src/container.ts

@@ -1,100 +1,126 @@
-import * as controllers from './controllers/'
-import * as middlewares from './middleware/'
-import { routes } from './routes'
-import express from 'express'
-import { ApiError } from './middleware/ApiError'
+import * as controllers from "./controllers/";
+import * as middlewares from "./middleware/";
+import { routes } from "./routes";
+import express from "express";
+import { ApiError } from "./middleware/ApiError";
 
 interface ControllerCollection {
-  [key: string]: any
+  [key: string]: any;
 }
 
-const controllerInstances: ControllerCollection = {}
-const router = express.Router()
+const controllerInstances: ControllerCollection = {};
+const router = express.Router();
 
 export function loadRoute(): express.Router {
   for (const route of routes) {
-    const [controllerName, controllerAction] = route.action.split('@')
-    let middlewareList: Array<express.RequestHandler> = []
+    const [controllerName, controllerAction] = route.action.split("@");
+    let middlewareList: Array<express.RequestHandler> = [];
 
     // Check whether controller exists
     if (!isControllerInitialized(controllerName)) {
       if (isControllerExisted(controllerName)) {
-        controllerInstances[controllerName] = new controllers[controllerName]()
+        controllerInstances[controllerName] = new controllers[controllerName]();
       } else {
-        throw new Error(`Controller ${controllerName} not exist.`)
+        throw new Error(`Controller ${controllerName} not exist.`);
       }
     }
 
     if (route.middlewares) {
-      middlewareList = getMiddlewareList(route.middlewares)
+      middlewareList = getMiddlewareList(route.middlewares);
     }
 
     if (route.validator) {
-      middlewareList.push(...route.validator, ApiError)
+      middlewareList.push(...route.validator, ApiError);
     }
 
     switch (route.method) {
-      case 'get':
-        router.get(route.url, middlewareList, controllerInstances[controllerName][controllerAction])
-        break
-
-      case 'post':
-        router.post(route.url, middlewareList, controllerInstances[controllerName][controllerAction])
-        break
-
-      case 'delete':
-        router.delete(route.url, middlewareList, controllerInstances[controllerName][controllerAction])
-        break
-
-      case 'patch':
-        router.patch(route.url, middlewareList, controllerInstances[controllerName][controllerAction])
-        break
-
-      case 'put':
-        router.put(route.url, middlewareList, controllerInstances[controllerName][controllerAction])
-        break
+      case "get":
+        router.get(
+          route.url,
+          middlewareList,
+          controllerInstances[controllerName][controllerAction]
+        );
+        break;
+
+      case "post":
+        router.post(
+          route.url,
+          middlewareList,
+          controllerInstances[controllerName][controllerAction]
+        );
+        break;
+
+      case "delete":
+        router.delete(
+          route.url,
+          middlewareList,
+          controllerInstances[controllerName][controllerAction]
+        );
+        break;
+
+      case "patch":
+        router.patch(
+          route.url,
+          middlewareList,
+          controllerInstances[controllerName][controllerAction]
+        );
+        break;
+
+      case "put":
+        router.put(
+          route.url,
+          middlewareList,
+          controllerInstances[controllerName][controllerAction]
+        );
+        break;
     }
   }
 
-  return router
+  return router;
 }
 
-function getMiddlewareList(middlewareNames: Array<string>): Array<express.RequestHandler> {
-  const middlewareList = []
+function getMiddlewareList(
+  middlewareNames: Array<string>
+): Array<express.RequestHandler> {
+  const middlewareList = [];
 
   for (const middlewareName of middlewareNames) {
     if (!isMiddlewareExists(middlewareName)) {
-      throw new Error(`Middleware ${middlewareName} not exist.`)
+      throw new Error(`Middleware ${middlewareName} not exist.`);
     }
 
-    middlewareList.push(middlewares[middlewareName])
+    middlewareList.push(middlewares[middlewareName]);
   }
 
-  return middlewareList
+  return middlewareList;
 }
 
 function isControllerInitialized(controller: string): boolean {
-  return controller in controllerInstances
+  return controller in controllerInstances;
 }
 
-function isControllerExisted(controller: string): controller is keyof typeof controllers {
-  return controller in controllers
+function isControllerExisted(
+  controller: string
+): controller is keyof typeof controllers {
+  return controller in controllers;
 }
 
 function isActionExisted(controller: object, action: string) {
-  return action in controller
+  return action in controller;
 }
 
-function isMiddlewareExists(middlewareName: string): middlewareName is keyof typeof middlewares {
-  return middlewareName in middlewares
+function isMiddlewareExists(
+  middlewareName: string
+): middlewareName is keyof typeof middlewares {
+  return middlewareName in middlewares;
 }
 
 function isMethodExisted(method: string): method is keyof typeof router {
-  const httpMethods = ['get', 'post', 'delete', 'put', 'patch']
+  const httpMethods = ["get", "post", "delete", "put", "patch"];
 
   if (!httpMethods.includes(method)) {
-    return false
+    return false;
   }
 
-  return method in router
+  return method in router;
 }

src/controllers/EquipmentController.ts

@@ -36,14 +36,14 @@ class EquipmentController {
 
       if (!user) {
         res.status(404).json({
-          message: "User not found"
+          message: "User not found",
         });
         return;
       }
 
       if (!equipment) {
         res.status(400).json({
-          message: "Equipment not found"
+          message: "Equipment not found",
         });
         return;
       }
@@ -61,11 +61,9 @@ class EquipmentController {
       Normal: 1,
       Rest: 2,
       Alarm: 3,
-      SOS: 4
+      SOS: 4,
     };
-
     var statusId = Status[req.body.Status] ? Status[req.body.Status] : 1;
-
     const equipment = await Equipment.findByPk(Number(req.body.AidID));
 
     if (!equipment) {
@@ -83,7 +81,7 @@ class EquipmentController {
       longitude: req.body.GPS_Lon,
       hook_battery_1: req.body.BattHook1,
       hook_battery_2: req.body.BattHook2,
-      alarm: JSON.stringify(req.body.Alarm)
+      alarm: JSON.stringify(req.body.Alarm),
     });
 
     if (
@@ -96,7 +94,7 @@ class EquipmentController {
     }
 
     equipment.update({
-      current_alarm_type: req.body.Alarm.length > 0 ? req.body.Alarm[0] : null
+      current_alarm_type: req.body.Alarm.length > 0 ? req.body.Alarm[0] : null,
     });
     res.json({ message: "ok" });
   }

src/controllers/Error.ts

@@ -1,8 +1,8 @@
-import { Response } from 'express'
+import { Response } from "express";
 
 export function networkError(res: Response, error: string) {
   res.status(500).json({
-    msg: 'Internal network error',
-    reason: JSON.stringify(error)
-  })
+    msg: "Internal network error",
+    reason: JSON.stringify(error),
+  });
 }

src/database/models/Equipment.ts

@@ -1,16 +1,24 @@
-import { Model, Table, Column, Unique, Default, CreatedAt, UpdatedAt } from 'sequelize-typescript'
+import {
+  Model,
+  Table,
+  Column,
+  Unique,
+  Default,
+  CreatedAt,
+  UpdatedAt,
+} from "sequelize-typescript";
 
-@Table({ tableName: 'equipments', timestamps: false })
+@Table({ tableName: "equipments", timestamps: false })
 export class Equipment extends Model<Equipment> {
   @Column
-  name: string
+  name: string;
 
   @Column
-  current_user_id: Number
+  current_user_id: Number;
 
   @Column
-  site_id: Number
+  site_id: Number;
 
   @Column
-  current_alarm_type: Number
+  current_alarm_type: Number;
 }

src/firebase.ts

@@ -1,31 +1,31 @@
-const config = require('../maa-client-firebase-adminsdk-4dont-9a7175f84c.json')
+const config = require("../maa-client-firebase-adminsdk-4dont-9a7175f84c.json");
 // const admin = require('firebase-admin')
-import admin from 'firebase-admin'
+import admin from "firebase-admin";
 
 export function initializeFirebase() {
   admin.initializeApp({
     credential: admin.credential.cert(config),
-    databaseURL: 'https://maa-client.firebaseio.com'
-  })
+    databaseURL: "https://maa-client.firebaseio.com"
+  });
 }
 
 export function sendUpdateRequest() {
   var message: admin.messaging.Message = {
     data: {
-      type: 'update request'
+      type: "update request"
     },
-    topic: 'maa'
-  }
+    topic: "maa"
+  };
 
   admin
     .messaging()
     .send(message)
     .then(response => {
-      console.log('Message sent', response)
+      console.log("Message sent", response);
     })
     .catch(error => {
-      console.log('Message error ', error)
-    })
+      console.log("Message error ", error);
+    });
 }
 
 export function sendAlarm(equipmentName: string, alarmType: string) {
@@ -35,19 +35,19 @@ export function sendAlarm(equipmentName: string, alarmType: string) {
       type: alarmType
     },
     android: {
-      priority: 'high',
+      priority: "high",
       ttl: 0
     },
-    topic: 'maa'
-  }
+    topic: "maa"
+  };
 
   admin
     .messaging()
     .send(message)
     .then(response => {
-      console.log('Message sent', response)
+      console.log("Message sent", response);
     })
     .catch(error => {
-      console.log('Message error ', error)
-    })
+      console.log("Message error ", error);
+    });
 }

src/middleware/BlockDuplicatedEquipmentData.ts

@@ -0,0 +1,25 @@
+import { Request, Response, NextFunction } from "express";
+import { EquipmentData } from "../database/models/EquipmentData";
+
+async function BlockDuplicatedEquipmentData(
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  const lastReceivedData = await EquipmentData.findOne({
+    where: { aid_id: req.body.AidID },
+    order: [["id", "DESC"]],
+  });
+
+  if (
+    !lastReceivedData ||
+    lastReceivedData.battery != Number(req.body.Battery) ||
+    lastReceivedData.alarm != JSON.stringify(req.body.Alarm)
+  ) {
+    return next();
+  }
+
+  return res.json({ message: "data unchanged." });
+}
+
+export default BlockDuplicatedEquipmentData;

src/middleware/index.ts

@@ -1 +1,2 @@
-export { default as AuthMiddleware } from './AuthMiddleware'
+export { default as AuthMiddleware } from "./AuthMiddleware";
+export { default as BlockDuplicatedEquipmentData } from "./BlockDuplicatedEquipmentData";

src/requests/EquipmentDataRequest.ts

@@ -12,7 +12,7 @@ const EquipmentDataRequest = [
   check("BattHook1").exists(),
   check("BattHook2").exists(),
   check("Alarm").exists(),
-  check("Alarm").isArray()
+  check("Alarm").isArray(),
 ];
 
 export default EquipmentDataRequest;

src/routes.ts

@@ -1,39 +1,40 @@
-import LoginRequest from './requests/LoginRequest'
-import AssignEquipmentRequest from './requests/AssignEquipmentRequest'
-import EquipmentDataRequest from './requests/EquipmentDataRequest'
-import { ValidationChain } from 'express-validator'
+import LoginRequest from "./requests/LoginRequest";
+import AssignEquipmentRequest from "./requests/AssignEquipmentRequest";
+import EquipmentDataRequest from "./requests/EquipmentDataRequest";
+import { ValidationChain } from "express-validator";
 
 interface route {
-  url: string
-  method: string
-  action: string
-  middlewares?: Array<string>
-  validator?: Array<ValidationChain>
+  url: string;
+  method: string;
+  action: string;
+  middlewares?: Array<string>;
+  validator?: Array<ValidationChain>;
 }
 
 export const routes: Array<route> = [
   {
-    url: '/login',
-    method: 'post',
-    action: 'AuthController@login',
-    validator: LoginRequest
+    url: "/login",
+    method: "post",
+    action: "AuthController@login",
+    validator: LoginRequest,
   },
   {
-    url: '/equipments',
-    method: 'get',
-    action: 'EquipmentController@getEquipments'
+    url: "/equipments",
+    method: "get",
+    action: "EquipmentController@getEquipments",
   },
   {
-    url: '/assignEquipment',
-    method: 'post',
-    action: 'EquipmentController@assignUserToEquipment',
-    validator: AssignEquipmentRequest
+    url: "/assignEquipment",
+    method: "post",
+    action: "EquipmentController@assignUserToEquipment",
+    validator: AssignEquipmentRequest,
   },
-  { url: '/users', method: 'get', action: 'AuthController@getUsers' },
+  { url: "/users", method: "get", action: "AuthController@getUsers" },
   {
-    url: '/equipments',
-    method: 'post',
-    action: 'EquipmentController@receiveEquipmentData',
-    validator: EquipmentDataRequest
-  }
-]
+    url: "/equipments",
+    method: "post",
+    action: "EquipmentController@receiveEquipmentData",
+    validator: EquipmentDataRequest,
+    middlewares: ["BlockDuplicatedEquipmentData"],
+  },
+];