564 lines
20 KiB
JavaScript
564 lines
20 KiB
JavaScript
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; |