Initial commit

controllers/AuthController.js

@@ -0,0 +1,167 @@
+const moment = require('moment');
+const Validator = require('validatorjs');
+const Helper = require('../library/LibHelper');
+const UsersModels = require('../models/UsersModels');
+const LibPassword = require('../library/LibPassword');
+const LibJwt = require('../library/LibJwt');
+const response = require('../config/response');
+
+Validator.useLang('en');
+
+class AuthController {
+
+  async register(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      // input validation
+      const input = {
+        first_name: req.body.first_name,
+        last_name: req.body.last_name,
+        email: req.body.email,
+        password: req.body.password,
+        crt_at: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
+        updt_at: moment.unix(now).format('YYYY-MM-DD HH:mm:ss'),
+      };
+      const rulesInput = {
+        first_name: 'required|string|max:45',
+        last_name: 'required|string|max:45',
+        email: 'required|email|max:45',
+        password: 'required|string|min:6|max:16',
+      };
+      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);
+      }
+
+      // check email unique
+      const getUsers = await UsersModels.findEmail(input.email);
+      if (getUsers.length > 0) {
+        apiRes.meta = response['email_unique'].meta;
+        return res.status(200).json(apiRes);
+      }
+
+      // create account
+      input.password = await LibPassword.hashPw(input.password); // hash password
+      const respCreateUser = await UsersModels.create(input);
+
+      // success response
+      apiRes.meta = response[201].meta;
+      apiRes.data = (await UsersModels.find(respCreateUser.insertId))[0];
+      return res.status(201).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 login(req, res) {
+    let apiRes = {}
+    try {
+      const now = moment().unix()
+
+      // input validation
+      const input = {
+        email: req.body.email,
+        password: req.body.password,
+      };
+      const rulesInput = {
+        email: 'required|email',
+        password: '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);
+      }
+
+      // login
+      const getUsers = await UsersModels.findEmail(input.email);
+      if (getUsers.length < 1) {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+      const isPwValid = await LibPassword.checkPw(getUsers[0].password, input.password);
+      if (!isPwValid) {
+        apiRes.meta = response['wrong_password'].meta;
+        return res.status(200).json(apiRes);
+      }
+
+      await UsersModels.update({is_login: 1}, getUsers[0].id);
+
+      // success response
+      const jwt = await LibJwt.createToken({
+        uid: getUsers[0].id
+      });
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success login';
+      apiRes.data = getUsers[0];
+      apiRes.token = jwt.token;
+      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 profile(req, res) {
+    let apiRes = {}
+    try {
+      const now = moment().unix();
+      const { uid } = req.jwt;
+      
+      const getUsers = await UsersModels.find(uid);
+      if (getUsers.length < 1) {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      delete getUsers[0].password;
+
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.data = getUsers[0];
+      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 logout(req, res) {
+    let apiRes = {}
+    try {
+      const now = moment().unix();
+      const { uid } = req.jwt;
+      
+      const getUsers = await UsersModels.find(uid);
+      if (getUsers.length < 1) {
+        apiRes = JSON.parse(JSON.stringify(response[404]));
+        return res.status(200).json(apiRes);
+      }
+
+      await UsersModels.update({is_login: 0}, uid);
+
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success logout';
+      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);
+    }
+  }
+
+}
+
+const object = new AuthController();
+
+module.exports = object;

controllers/DummyController.js

@@ -0,0 +1,165 @@
+const moment = require('moment');
+const Validator = require('validatorjs');
+const Helper = require('../library/LibHelper');
+const DummyModels = require('../models/DummyModels');
+const response = require('../config/response');
+const LibMail = require('../library/LibMail');
+
+Validator.useLang('en');
+
+class DummyController {
+
+	async logging(req, res) {
+		let apiRes = {}
+		const now = moment().unix();
+		try {
+			apiRes.meta = response[201].meta;
+
+			const insLog = {
+				ip: req.ip,
+				ips: JSON.stringify([...req.ips]),
+				// protocol: req.protocol || null,
+				method: req.method,
+				path: req.path,
+				headers: JSON.stringify({ ...req.headers }),
+				params: JSON.stringify({ ...req.params }),
+				request: JSON.stringify({ ...req.query, ...req.body }),
+				cookies: JSON.stringify({ ...req.cookies }),
+				xhr: req.xhr,
+				response: JSON.stringify(apiRes),
+				crt: now,
+			};
+			await DummyModels.create(insLog);
+
+			return res.status(201).json(apiRes);
+		} catch (e) {
+			apiRes = JSON.parse(JSON.stringify(response[500]));
+			apiRes.meta.message += Helper.setErrMsg(': ' + e.message);
+
+			const insLog = {
+				method: req.method,
+				response: JSON.stringify(apiRes),
+				crt: now,
+			};
+			await DummyModels.create(insLog);
+
+			return res.status(500).json(apiRes);
+		}
+	}
+
+	async distance(req, res) {
+		let apiRes = {};
+		try {
+			const now = moment().unix();
+
+			const { latFrom, lngFrom, latTo, lngTo } = req.query;
+
+			// input validation
+			const input = {
+				latFrom: latFrom,
+				lngFrom: lngFrom,
+				latTo: latTo,
+				lngTo: lngTo,
+			};
+			const rulesInput = {
+				latFrom: 'required|string|max:25',
+				lngFrom: 'required|string|max:25',
+				latTo: 'required|string|max:25',
+				lngTo: 'required|string|max:25',
+			};
+			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);
+			}
+
+			const respData = {};
+			// round up with precisions digits => 4 == (10000)
+			// reference: https://stackoverflow.com/questions/11832914/how-to-round-to-at-most-2-decimal-places-if-necessary
+			// const precisionDigits = 10000;
+
+			// distance == miles
+			// const distance = Helper.haversineGreatCircleDistance(latFrom, lngFrom, latTo, lngTo, Helper.EARTH_RADIUS_MILES);
+			// respData.distance_km = Helper.milesToKm(distance);
+			// respData.distance_miles = Helper.milesToMiles(distance);
+			// respData.distance_meters = Helper.milesToMeters(distance);
+
+			// distance == km
+			const distance = Helper.haversineGreatCircleDistance(latFrom, lngFrom, latTo, lngTo, Helper.EARTH_RADIUS_KM);
+			respData.distance_km = Helper.kmToKm(distance);
+			respData.distance_miles = Helper.kmToMiles(distance);
+			respData.distance_meters = Helper.kmToMeters(distance);
+
+			// distance == meters
+			// const distance = Helper.haversineGreatCircleDistance(latFrom, lngFrom, latTo, lngTo, Helper.EARTH_RADIUS_M);
+			// respData.distance_km = Helper.metersToKm(distance);
+			// respData.distance_miles = Helper.metersToMiles(distance);
+			// respData.distance_meters = Helper.metersToMeters(distance);
+
+			// success response
+			apiRes = JSON.parse(JSON.stringify(response[200]));
+			apiRes.meta.message = 'success get distance';
+			apiRes.data = respData;
+			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 sendEmail(req, res) {
+		let apiRes = {};
+		try {
+			const now = moment().unix();
+
+			const { subject, to } = req.body;
+
+			// input validation
+			const input = {
+				subject,
+				to
+			};
+			const rulesInput = {
+				subject: 'required|string|max:125',
+				to: 'required|string|max:255',
+			};
+			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);
+			}
+
+			const mailData = {
+				pic_name: 'Rafif Mulia',
+				pic_mail: 'rafifrest@gmail.com',
+				z_name: 'REST-01',
+				z_type_name: 'Warehousing',
+				z_workflow_name: 'Parking',
+				shiptocode: '12330',
+				z_fulladdress: 'Jl. Perdagangan No.101, RT.4/RW.7, Bintaro, Kec. Pesanggrahan, Kota Jakarta Selatan, Daerah Khusus Ibukota Jakarta 12330',
+				v_nopol: 'B 3633 EVV',
+				da_name: 'Chienghou Zou',
+				da_phone: '+62 8128 8789 878',
+			};
+			const resp = await LibMail.sendVhcSpawnZoneMail(subject, to, mailData);
+
+			// success response
+			apiRes = JSON.parse(JSON.stringify(response[200]));
+			apiRes.meta.message = 'success send email';
+			apiRes.data = resp;
+			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);
+		}
+	}
+
+}
+
+const object = new DummyController();
+
+module.exports = object;

controllers/OrderController.js

@@ -0,0 +1,821 @@
+const moment = require('moment');
+const Validator = require('validatorjs');
+const Helper = require('../library/LibHelper');
+const response = require('../config/response');
+const LibMail = require('../library/LibMail');
+const DanaModels = require('../models/DanaModels');
+// const LibQueueBlastOrder = require('../library/LibQueueBlastOrder');
+
+Validator.useLang('en');
+
+class OrderController {
+
+  async createOrder(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        trx_code,
+        trx_at,
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        client_addr,
+        client_prefer_type_truck,
+        // weight,
+        // cbm,
+        // koli,
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at,
+        drop_zone_title,
+        drop_zone_addr,
+        vendors,
+        admins,
+      } = req.body;
+
+      // input validation
+      const input = {
+        trx_code,
+        trx_at,
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck,
+        // weight,
+        // cbm,
+        // koli,
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at,
+        drop_zone_title,
+        drop_zone_addr,
+        vendors,
+        admins,
+      };
+      const rulesInput = {
+        trx_code: 'required|string',
+        trx_at: 'required|numeric',
+        client_id: 'required|integer',
+        client_name: 'required|string|max:255',
+        client_phone: 'required|string',
+        client_mail: 'required|email',
+        // client_addr: 'required|string',
+        client_prefer_type_truck: 'present|string',
+        // weight: 'required|numeric',
+        // cbm: 'required|numeric',
+        // koli: 'required|numeric',
+        pickup_zone_title: 'required|string',
+        pickup_zone_addr: 'required|string',
+        pickup_at: 'required|numeric',
+        drop_zone_title: 'required|string',
+        drop_zone_addr: 'required|string',
+        // vendors: 'required|array',
+        // 'vendors.*.vendor_id': 'required|integer',
+        // 'vendors.*.vendor_name': 'required|string|max:255',
+        // 'vendors.*.vendor_phone': 'required|string',
+        // 'vendors.*.vendor_mail': 'required|email',
+        // 'vendors.*.vendor_addr': 'present|string',
+        // 'vendors.*.vendor_acc_link': 'required|string',
+        // 'vendors.*.vendor_reject_link': 'required|string',
+        admins: 'required|array',
+        'admins.*.admin_id': 'required|integer',
+        'admins.*.admin_name': 'required|string|max:255',
+        'admins.*.admin_phone': 'required|string',
+        'admins.*.admin_mail': 'required|email',
+        // 'admins.*.admin_addr': 'present|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 resp = {};
+      // for (let vendor of vendors) {
+      //   let bidOrderMailData = {
+      //     client_id,
+      //     client_name,
+      //     client_phone,
+      //     client_mail,
+      //     client_addr,
+      //     client_prefer_type_truck: client_prefer_type_truck,
+      //     weight: Number(weight),
+      //     cbm: Number(cbm),
+      //     koli: Number(koli),
+      //     pickup_zone_title,
+      //     pickup_zone_addr,
+      //     pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+      //     drop_zone_title,
+      //     drop_zone_addr,
+      //     vendor_id: vendor.vendor_id,
+      //     vendor_name: vendor.vendor_name,
+      //     vendor_phone: vendor.vendor_phone,
+      //     vendor_mail: vendor.vendor_mail,
+      //     vendor_addr: vendor.vendor_addr,
+      //   };
+      //   LibMail.sendBidOrderMail('Ada Order Masuk', vendor.vendor_mail, bidOrderMailData);
+      // }
+
+      for (let admin of admins) {
+        let infoOrderMailData = {
+          trx_code,
+          trx_at: moment.unix(trx_at).format('DD MMM YYYY HH:mm') + ' WIB',
+          client_id,
+          client_name,
+          client_phone,
+          client_mail,
+          // client_addr,
+          client_prefer_type_truck: client_prefer_type_truck,
+          // weight: Number(weight),
+          // cbm: Number(cbm),
+          // koli: Number(koli),
+          pickup_zone_title,
+          pickup_zone_addr,
+          pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+          drop_zone_title,
+          drop_zone_addr,
+          admin_id: admin.admin_id,
+          admin_name: admin.admin_name,
+          admin_phone: admin.admin_phone,
+          admin_mail: admin.admin_mail,
+          // admin_addr: admin.admin_addr,
+        };
+        LibMail.sendAdminInfoOrdMail('Ada Order Masuk', admin.admin_mail, infoOrderMailData);
+      }
+
+      let clientCreateOrdMailData = {
+        trx_code,
+        trx_at: moment.unix(trx_at).format('DD MMM YYYY HH:mm') + ' WIB',
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck: client_prefer_type_truck,
+        // weight: Number(weight),
+        // cbm: Number(cbm),
+        // koli: Number(koli),
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+        drop_zone_title,
+        drop_zone_addr,
+      };
+      LibMail.sendClientCreateOrdMail('Kamu Telah Membuat Order ' + trx_code, client_mail, clientCreateOrdMailData);
+
+      // success response
+     apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success create new order';
+      apiRes.data = resp;
+      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 emailToVendor(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        trx_code,
+        trx_at,
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck,
+        // weight,
+        // cbm,
+        // koli,
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at,
+        drop_zone_title,
+        drop_zone_addr,
+        vendors,
+      } = req.body;
+
+      // input validation
+      const input = {
+        trx_code,
+        trx_at,
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck,
+        // weight,
+        // cbm,
+        // koli,
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at,
+        drop_zone_title,
+        drop_zone_addr,
+        vendors,
+      };
+
+      const rulesInput = {
+        trx_code: 'required|string',
+        trx_at: 'required|numeric',
+        client_id: 'required|integer',
+        client_name: 'required|string|max:255',
+        client_phone: 'required|string',
+        client_mail: 'required|email',
+        // client_addr: 'required|string',
+        client_prefer_type_truck: 'present|string',
+        // weight: 'required|numeric',
+        // cbm: 'required|numeric',
+        // koli: 'required|numeric',
+        pickup_zone_title: 'required|string',
+        pickup_zone_addr: 'required|string',
+        pickup_at: 'required|numeric',
+        drop_zone_title: 'required|string',
+        drop_zone_addr: 'required|string',
+        vendors: 'required|array',
+        'vendors.*.vendor_id': 'required|integer',
+        'vendors.*.vendor_name': 'required|string|max:255',
+        'vendors.*.vendor_phone': 'required|string',
+        'vendors.*.vendor_mail': 'required|email',
+        // 'vendors.*.vendor_addr': 'present|string',
+        'vendors.*.vendor_acc_link': 'required|string',
+        // 'vendors.*.vendor_reject_link': '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 resp = {};
+      for (let vendor of vendors) {
+        let bidOrderMailData = {
+          trx_code,
+          // client_id,
+          client_name,
+          client_phone,
+          client_mail,
+          // client_addr,
+          client_prefer_type_truck: client_prefer_type_truck,
+          // weight: Number(weight),
+          // cbm: Number(cbm),
+          // koli: Number(koli),
+          pickup_zone_title,
+          pickup_zone_addr,
+          pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+          drop_zone_title,
+          drop_zone_addr,
+          // vendor_id: vendor.vendor_id,
+          vendor_name: vendor.vendor_name,
+          vendor_phone: vendor.vendor_phone,
+          vendor_mail: vendor.vendor_mail,
+          vendor_addr: vendor.vendor_addr,
+          vendor_acc_link: vendor.vendor_acc_link,
+        };
+        LibMail.sendBidOrderMail('Ada Order Masuk', vendor.vendor_mail, bidOrderMailData);
+      }
+
+      // success response
+     apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success send email';
+      apiRes.data = resp;
+      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 emailVdrAccOrder(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        trx_code,
+        trx_at,
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck,
+        // weight,
+        // cbm,
+        // koli,
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at,
+        drop_zone_title,
+        drop_zone_addr,
+        vendors,
+        drivers,
+      } = req.body;
+
+      // input validation
+      const input = {
+        trx_code,
+        trx_at,
+        client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck,
+        // weight,
+        // cbm,
+        // koli,
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at,
+        drop_zone_title,
+        drop_zone_addr,
+        vendors,
+        drivers,
+      };
+      const rulesInput = {
+        trx_code: 'required|string',
+        trx_at: 'required|numeric',
+        client_id: 'required|integer',
+        client_name: 'required|string|max:255',
+        client_phone: 'required|string',
+        client_mail: 'required|email',
+        // client_addr: 'required|string',
+        client_prefer_type_truck: 'present|string',
+        // weight: 'required|numeric',
+        // cbm: 'required|numeric',
+        // koli: 'required|numeric',
+        pickup_zone_title: 'required|string',
+        pickup_zone_addr: 'required|string',
+        pickup_at: 'required|numeric',
+        drop_zone_title: 'required|string',
+        drop_zone_addr: 'required|string',
+        vendors: 'required|array',
+        'vendors.*.vendor_id': 'required|integer',
+        'vendors.*.vendor_name': 'required|string|max:255',
+        'vendors.*.vendor_phone': 'required|string',
+        'vendors.*.vendor_mail': 'required|email',
+        // 'vendors.*.vendor_addr': 'present|string',
+        'vendors.*.vendor_acc_at': 'required|numeric',
+        drivers: 'required|array',
+        'drivers.*.driver_id': 'required|integer',
+        'drivers.*.driver_name': 'required|string|max:255',
+        'drivers.*.driver_phone': 'required|string',
+        'drivers.*.driver_mail': 'required|email',
+        // 'drivers.*.driver_addr': 'present|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 resp = {};
+      for (let vendor of vendors) {
+        let vdrAccOrderMailData = {
+          trx_code,
+          // client_id,
+          client_name,
+          client_phone,
+          client_mail,
+          // client_addr,
+          client_prefer_type_truck: client_prefer_type_truck,
+          // weight: Number(weight),
+          // cbm: Number(cbm),
+          // koli: Number(koli),
+          pickup_zone_title,
+          pickup_zone_addr,
+          pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+          drop_zone_title,
+          drop_zone_addr,
+          // vendor_id: vendor.vendor_id,
+          vendor_name: vendor.vendor_name,
+          vendor_phone: vendor.vendor_phone,
+          vendor_mail: vendor.vendor_mail,
+          vendor_addr: vendor.vendor_addr,
+          acc_at: moment.unix(vendor.vendor_acc_at).format('DD MMM YYYY HH:mm') + ' WIB',
+        };
+        LibMail.sendVdrAccOrderMail('Kamu Telah Menerima Order', vendor.vendor_mail, vdrAccOrderMailData);
+      }
+
+      for (let driver of drivers) {
+        let driverGetOrderMailData = {
+          trx_code,
+          // client_id,
+          client_name,
+          client_phone,
+          client_mail,
+          // client_addr,
+          client_prefer_type_truck: client_prefer_type_truck,
+          // weight: Number(weight),
+          // cbm: Number(cbm),
+          // koli: Number(koli),
+          pickup_zone_title,
+          pickup_zone_addr,
+          pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+          drop_zone_title,
+          drop_zone_addr,
+          // driver_id: driver.driver_id,
+          driver_name: driver.driver_name,
+          driver_phone: driver.driver_phone,
+          driver_mail: driver.driver_mail,
+          driver_addr: driver.driver_addr,
+          acc_at: moment.unix(vendors[0].vendor_acc_at).format('DD MMM YYYY HH:mm') + ' WIB',
+        };
+        LibMail.sendDrvGetOrderMail('Kamu Mendapatkan Order', driver.driver_mail, driverGetOrderMailData);
+      }
+
+      let sendClientOrderHaveBeenAccMailData = {
+        trx_code,
+        // client_id,
+        client_name,
+        client_phone,
+        client_mail,
+        // client_addr,
+        client_prefer_type_truck: client_prefer_type_truck,
+        // weight: Number(weight),
+        // cbm: Number(cbm),
+        // koli: Number(koli),
+        pickup_zone_title,
+        pickup_zone_addr,
+        pickup_at: moment.unix(pickup_at).format('DD MMM YYYY HH:mm') + ' WIB',
+        drop_zone_title,
+        drop_zone_addr,
+        // vendor_id: vendors[0].vendor_id,
+        vendor_name: vendors[0].vendor_name,
+        vendor_phone: vendors[0].vendor_phone,
+        vendor_mail: vendors[0].vendor_mail,
+        vendor_addr: vendors[0].vendor_addr,
+        // driver_id: drivers[0].driver_id,
+        driver_name: drivers[0].driver_name,
+        driver_phone: drivers[0].driver_phone,
+        driver_mail: drivers[0].driver_mail,
+        driver_addr: drivers[0].driver_addr,
+        acc_at: moment.unix(vendors[0].vendor_acc_at).format('DD MMM YYYY HH:mm') + ' WIB',
+      };
+      LibMail.sendClientOrderHaveBeenAccMail('Order Kamu Telah Diambil Driver', client_mail, sendClientOrderHaveBeenAccMailData);
+
+      // success response
+     apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success send email';
+      apiRes.data = resp;
+      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 delayBlastOrderBAK(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        ord_id,
+        ord_code,
+        current_ord_vdr_id,
+        next_ord_vdr_id,
+        next_vdr_bid_token,
+        next_vdr_acc_link,
+      } = req.body;
+
+      // input validation
+      const input = {
+        ord_id,
+        ord_code,
+        current_ord_vdr_id,
+        next_ord_vdr_id,
+        next_vdr_bid_token,
+        next_vdr_acc_link,
+      };
+
+      const rulesInput = {
+        ord_id: 'required|integer|min:1',
+        ord_code: 'required|string',
+        current_ord_vdr_id: 'required|integer|min:1',
+        next_ord_vdr_id: 'present|array',
+        next_vdr_bid_token: 'present|array',
+        next_vdr_acc_link: 'present|array',
+      };
+      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);
+      }
+
+      LibQueueBlastOrder.addQueue({
+        ord_id,
+        ord_code,
+        current_ord_vdr_id,
+        next_ord_vdr_id,
+        next_vdr_bid_token,
+        next_vdr_acc_link,
+        label: 'Delay Blast Order to Another Vendor',
+        delay: 10 * (60 * 1000), // 600000 || 10 minute || 10 * (60 * 1000)
+      });
+
+      // success response
+     apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success blast order';
+      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 delayBlastOrder(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        ord_id,
+        ord_code,
+        base_link,
+      } = req.body;
+
+      // input validation
+      const input = {
+        ord_id,
+        ord_code,
+        base_link,
+      };
+
+      const rulesInput = {
+        ord_id: 'required|integer|min:1',
+        ord_code: 'required|string',
+        base_link: '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);
+      }
+
+      LibQueueBlastOrder.addQueue({
+        ord_id,
+        ord_code,
+        base_link,
+        delay: 10 * (60 * 1000), // 600000 || 10 minute || 10 * (60 * 1000)
+      });
+      LibQueueBlastOrder.addQueue({
+        ord_id,
+        ord_code,
+        base_link,
+        delay: 20 * (60 * 1000), // 600000 || 20 minute || 20 * (60 * 1000)
+      });
+      LibQueueBlastOrder.addQueue({
+        ord_id,
+        ord_code,
+        base_link,
+        delay: 30 * (60 * 1000), // 600000 || 30 minute || 30 * (60 * 1000)
+      });
+
+      // success response
+     apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success blast order';
+      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 sendFinanceInfoTfPocket(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        trx_code,
+        drv_name,
+        pickup_zone_title,
+        pickup_zone_addr,
+        drop_zone_title,
+        drop_zone_addr,
+        pocket_total,
+        bank_name,
+        bank_code,
+        bank_branch_name,
+        bank_acc_name,
+        bank_acc_no,
+        admins,
+      } = req.body;
+
+      // input validation
+      const input = {
+        trx_code,
+        drv_name,
+        pickup_zone_title,
+        pickup_zone_addr,
+        drop_zone_title,
+        drop_zone_addr,
+        pocket_total,
+        bank_name,
+        bank_code,
+        bank_branch_name,
+        bank_acc_name,
+        bank_acc_no,
+        admins,
+      };
+      const rulesInput = {
+        trx_code: 'required|string|max:255',
+        drv_name: 'required|string|max:255',
+        pickup_zone_title: 'required|string|max:255',
+        pickup_zone_addr: 'required|string',
+        drop_zone_title: 'required|string|max:255',
+        drop_zone_addr: 'required|string',
+        pocket_total: 'required|string|max:255',
+        bank_name: 'required|string',
+        bank_code: 'required|string|max:255',
+        bank_branch_name: 'string',
+        bank_acc_name: 'required|string',
+        bank_acc_no: 'required|string',
+        admins: 'required|array',
+        // 'admins.*.admin_id': 'required|integer',
+        'admins.*.admin_name': 'required|string|max:255',
+        'admins.*.admin_phone': 'required|string',
+        'admins.*.admin_mail': 'required|email',
+      };
+      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 resp = {};
+
+      let mailData = {
+        trx_code,
+        drv_name,
+        pickup_zone_title,
+        pickup_zone_addr,
+        drop_zone_title,
+        drop_zone_addr,
+        pocket_total,
+        bank_name,
+        bank_code,
+        bank_branch_name,
+        bank_acc_name,
+        bank_acc_no,
+      };
+
+      for (let admin of admins) {
+        mailData.admin_name = admin.admin_name;
+        LibMail.sendFinanceInfoTfPocket('Transfer uang saku order ' + trx_code, admin.admin_mail, mailData);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success send mail';
+      apiRes.data = resp;
+      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 sendFinanceInfoDanaAmount(req, res) {
+    let apiRes = {};
+    try {
+      const now = moment().unix();
+
+      const {
+        trx_code,
+        drv_name,
+        pickup_zone_title,
+        pickup_zone_addr,
+        drop_zone_title,
+        drop_zone_addr,
+        pocket_total,
+        bank_name,
+        bank_code,
+        bank_branch_name,
+        bank_acc_name,
+        bank_acc_no,
+        admins,
+      } = req.body;
+
+      // input validation
+      const input = {
+        trx_code,
+        drv_name,
+        pickup_zone_title,
+        pickup_zone_addr,
+        drop_zone_title,
+        drop_zone_addr,
+        pocket_total,
+        bank_name,
+        bank_code,
+        bank_branch_name,
+        bank_acc_name,
+        bank_acc_no,
+        admins,
+      };
+      const rulesInput = {
+        trx_code: 'required|string|max:255',
+        drv_name: 'required|string|max:255',
+        pickup_zone_title: 'required|string|max:255',
+        pickup_zone_addr: 'required|string',
+        drop_zone_title: 'string|max:255',
+        drop_zone_addr: 'string',
+        pocket_total: 'required|string|max:255',
+        bank_name: 'required|string',
+        bank_code: 'required|string|max:255',
+        bank_branch_name: 'string',
+        bank_acc_name: 'required|string',
+        bank_acc_no: 'required|string',
+        admins: 'required|array',
+        // 'admins.*.admin_id': 'required|integer',
+        'admins.*.admin_name': 'required|string|max:255',
+        'admins.*.admin_phone': 'required|string',
+        'admins.*.admin_mail': 'required|email',
+      };
+      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);
+      }
+
+      const danas = await DanaModels.list({'id': DanaModels.PK_ID, 'limit': 1});
+      if (danas.length < 1) {
+        apiRes = JSON.parse(JSON.stringify(response[400]));
+        apiRes.meta.message = 'dana error';
+        return res.status(200).json(apiRes); 
+      }
+      const dana = danas[0];
+
+      let resp = {};
+
+      let mailData = {
+        trx_code,
+        drv_name,
+        pickup_zone_title,
+        pickup_zone_addr,
+        drop_zone_title,
+        drop_zone_addr,
+        pocket_total,
+        bank_name,
+        bank_code,
+        bank_branch_name,
+        bank_acc_name,
+        bank_acc_no,
+        dana_current: 'Rp'+((new Intl.NumberFormat('id-ID')).format(dana.amt)).split('.').join('-').split(',').join('.').split('-').join(','), // yang . => - || , => . || - => ,,
+        dana_minimum: 'Rp'+((new Intl.NumberFormat('id-ID')).format(DanaModels.MINIMUM_AMT)).split('.').join('-').split(',').join('.').split('-').join(','), // yang . => - || , => . || - => ,,
+      };
+
+      for (let admin of admins) {
+        mailData.admin_name = admin.admin_name;
+        LibMail.sendFinanceInfoDanaAmount('Saldo Dana Tidak Mencukupi', admin.admin_mail, mailData);
+      }
+
+      // success response
+      apiRes = JSON.parse(JSON.stringify(response[200]));
+      apiRes.meta.message = 'success send mail';
+      apiRes.data = resp;
+      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);
+    }
+  }
+
+}
+
+const object = new OrderController();
+
+module.exports = object;

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;

controllers/ZoneController.js

@@ -0,0 +1,134 @@
+const moment = require('moment');
+const Validator = require('validatorjs');
+const Helper = require('../library/LibHelper');
+const ZoneModels = require('../models/ZoneModels');
+const response = require('../config/response');
+const axios = require('axios').default;
+const url = require('url');
+const request = require('../config/request');
+
+Validator.useLang('en');
+
+class ZoneController {
+
+	async nearest(req, res) {
+		let apiRes = {};
+		try {
+			const now = moment().unix();
+			const { lat, lng, meters } = req.query;
+
+			// input validation
+			const input = {
+				lat: lat,
+				lng: lng,
+				meters: meters,
+			};
+			const rulesInput = {
+				lat: 'required|string|max:25',
+				lng: 'required|string|max:25',
+				meters: 'required|numeric',
+			};
+			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);
+			}
+
+			const nearest = await ZoneModels.getNearest(lat, lng, meters);
+
+			// success response
+			apiRes = JSON.parse(JSON.stringify(response[200]));
+			apiRes.meta.message = 'success get nearest zone in meters: ' + meters;
+			apiRes.count = nearest.length;
+			apiRes.data = nearest;
+
+			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 inCircle(req, res) {
+		let apiRes = {};
+		try {
+			const now = moment().unix();
+			const { lat, lng } = req.query;
+
+			// input validation
+			const input = {
+				lat: lat,
+				lng: lng,
+			};
+			const rulesInput = {
+				lat: 'required|string|max:25',
+				lng: 'required|string|max:25',
+			};
+			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);
+			}
+
+			const inCircle = await ZoneModels.getInCircle(lat, lng);
+
+			// success response
+			apiRes = JSON.parse(JSON.stringify(response[200]));
+			apiRes.meta.message = 'success get in circle zone';
+			apiRes.count = inCircle.length;
+			apiRes.data = inCircle;
+
+			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 inShape(req, res) {
+		let apiRes = {};
+		try {
+			const now = moment().unix();
+			const { lat, lng } = req.query;
+
+			// input validation
+			const input = {
+				lat: lat,
+				lng: lng,
+			};
+			const rulesInput = {
+				lat: 'required|string|max:25',
+				lng: 'required|string|max:25',
+			};
+			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);
+			}
+
+			const inShape = await ZoneModels.getInShape(lat, lng);
+
+			// success response
+			apiRes = JSON.parse(JSON.stringify(response[200]));
+			apiRes.meta.message = 'success get in shape zone';
+			apiRes.count = inShape.length;
+			apiRes.data = inShape;
+
+			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);
+		}
+	}
+
+}
+
+const object = new ZoneController();
+
+module.exports = object;