Initial commit

controllers/WorkerController.js

@@ -0,0 +1,564 @@
+const moment = require('moment');
+const Validator = require('validatorjs');
+const Helper = require('../library/LibHelper');
+const GpsTracksModels = require('../models/GpsTracksModels');
+const response = require('../config/response');
+const LibSchedulerReverseGeocode = require('../library/LibSchedulerReverseGeocode');
+const LibQueueBlastOrder = require('../library/LibQueueBlastOrder');
+const LibSchedulerDrvUpLoc = require('../library/LibSchedulerDrvUpLoc');
+const LibSchedulerDrvUpPhoto = require('../library/LibSchedulerDrvUpPhoto');
+const LibSchedulerDrvUpLocIdle = require('../library/LibSchedulerDrvUpLocIdle');
+const LibSchedulerDrvBlastNotif = require('../library/LibSchedulerDrvBlastNotif');
+const LibSchedulerGpsTrackerWakeUp = require('../library/LibSchedulerGpsTrackerWakeUp');
+// START TESTING
+const axios = require('axios').default;
+const url = require('url');
+const request = require('../config/request');
+// END TESTING
+
+Validator.useLang('en');
+
+class WorkerController {
+
+  /**
+   * QUEUE
+   */
+
+  async add(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name, data } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.runQueueScheduler({
+          label: 'Reverse geocoding from gps tracker latlng',
+        });
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.addQueue({
+          ...data,
+          label: 'Blast Order to Another Vendor',
+          delay: 5000, // 600000 || 10 minute
+        });
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.runQueueScheduler({
+          label: 'Scheduler driver up location',
+        });
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.runQueueScheduler({
+          label: 'Scheduler driver up photo',
+        });
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.runQueueScheduler({
+          label: 'Scheduler driver up location idle',
+        });
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.runQueueScheduler({
+          label: 'Scheduler driver blast notif',
+        });
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.runQueueScheduler({
+          label: 'Scheduler gps tracker wakeup',
+        });
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success add queue';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async getJobs(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      let gets = undefined;
+      if (name === LibSchedulerReverseGeocode.name) {
+        gets = await LibSchedulerReverseGeocode.getJobs();
+      } else if (name === LibQueueBlastOrder.name) {
+        gets = await LibQueueBlastOrder.getJobs();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        gets = await LibSchedulerDrvUpLoc.getJobs();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.getJobs();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        gets = await LibSchedulerDrvUpLocIdle.getJobs();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        gets = await LibSchedulerDrvBlastNotif.getJobs();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        gets = await LibSchedulerGpsTrackerWakeUp.getJobs();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success get jobs';
+      apiRes.data = gets;
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async getRepeatableJobs(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      let gets = undefined;
+      if (name === LibSchedulerReverseGeocode.name) {
+        gets = await LibSchedulerReverseGeocode.getRepeatableJobs();
+      } else if (name === LibQueueBlastOrder.name) {
+        gets = await LibQueueBlastOrder.getRepeatableJobs();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        gets = await LibSchedulerDrvUpLoc.getRepeatableJobs();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.getRepetableJobs();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        gets = await LibSchedulerDrvUpLocIdle.getRepeatableJobs();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        gets = await LibSchedulerDrvBlastNotif.getRepeatableJobs();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        gets = await LibSchedulerGpsTrackerWakeUp.getRepeatableJobs();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success get repeatable jobs';
+      apiRes.data = gets;
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async resume(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.resumeQueue();
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.resumeQueue();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.resumeQueue();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.resumeQueue();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.resumeQueue();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.resumeQueue();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.resumeQueue();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success resume';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async pause(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.pauseQueue();
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.pauseQueue();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.pauseQueue();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.pauseQueue();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.pauseQueue();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.pauseQueue();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.pauseQueue();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success pause job';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async drain(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.drainQueue();
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.drainQueue();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.drainQueue()
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.drainQueue();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.drainQueue()
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.drainQueue()
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.drainQueue()
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success drain queue';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async obliterate(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.obliterateQueue();
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.obliterateQueue();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.obliterateQueue();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.obliterateQueue();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.obliterateQueue();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.obliterateQueue();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.obliterateQueue();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success obliterateQueue queue';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  /**
+   * WORKERS
+   */
+
+  async start(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+ 
+        return res.status(200).json(apiRes);
+      }
+
+      // just work if before this set have waiting list, so new queue will not be processed
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.setWorker();
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.setWorker();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.setWorker();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.setWorker();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.setWorker();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.setWorker();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.setWorker();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success start worker';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  async shutdown(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+      const { name } = req.body;
+
+      // input validation
+      const input = {
+        name,
+      };
+      const rulesInput = {
+        name: 'required|string',
+      };
+      const isInputValid = new Validator(input, rulesInput);
+      if (isInputValid.fails()) {
+        apiRes = JSON.parse(JSON.stringify(response[422]));
+        apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+        return res.status(200).json(apiRes);
+      }
+
+      if (name === LibSchedulerReverseGeocode.name) {
+        LibSchedulerReverseGeocode.workerShutDown();
+      } else if (name === LibQueueBlastOrder.name) {
+        LibQueueBlastOrder.workerShutDown();
+      } else if (name === LibSchedulerDrvUpLoc.name) {
+        LibSchedulerDrvUpLoc.workerShutDown();
+      } else if (name === LibSchedulerDrvUpPhoto.name) {
+        LibSchedulerDrvUpPhoto.workerShutDown();
+      } else if (name === LibSchedulerDrvUpLocIdle.name) {
+        LibSchedulerDrvUpLocIdle.workerShutDown();
+      } else if (name === LibSchedulerDrvBlastNotif.name) {
+        LibSchedulerDrvBlastNotif.workerShutDown();
+      } else if (name === LibSchedulerGpsTrackerWakeUp.name) {
+        LibSchedulerGpsTrackerWakeUp.workerShutDown();
+      } else {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success shutdown worker';
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      return res.status(500).json(apiRes);
+    }
+  }
+
+  /**
+   * DO THE PROCESS VIA REQUEST
+   */
+
+  async revgeo(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      // input validation
+      // const input = { };
+      // const rulesInput = { };
+      // const isInputValid = new Validator(input, rulesInput);
+      // if (isInputValid.fails()) {
+      //   apiRes = JSON.parse(JSON.stringify(response[422]));
+      //   apiRes.meta.message += Helper.setErrMsg(': ' + Object.values(isInputValid.errors.all())[0][0]); // get first message
+      //   return res.status(200).json(apiRes);
+      // }
+
+      let params = new url.URLSearchParams({
+        lat: req.body.lat,
+        lon: req.body.lon,
+        format: 'geojson',
+      });
+      const axInstance = axios.create();
+      axios.defaults.timeout = 3000;
+      axios.defaults.crossDomain = true;
+      // respReverseGeo = await axios({
+      //   url: request.osm_reverse_geo.urlFull,
+      //   method: request.osm_reverse_geo.method,
+      //   params: params,
+      //   timeout: 3000,
+      //   responseType: 'json',
+      // });
+      let respReverseGeo = await axInstance.get(request.osm_reverse_geo.urlFull + '?' + params.toString(), {
+        timeout: 3000,
+      });
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success reverse geocode';
+      apiRes.meta.data = respReverseGeo.data;
+      return res.status(200).json(apiRes);
+    } catch (e) {
+      apiRes = JSON.parse(JSON.stringify(response[500]));
+      apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+      // apiRes.debug = e.response.data;
+      return res.status(500).json(apiRes);
+    }
+  }
+
+}
+
+const object = new WorkerController();
+
+module.exports = object;