async function runAutomation(req, res) {
try {
const mongoose = require('mongoose');
const { auth, id, } = req.params;
const automationScript = await periodic.datas.get('standard_cron').load({
query:getIdQuery(req.params.id),
});
utilities = utilities || periodic.locals.container.get(CONTAINER_NAME);
if (!automationScript) return res.send(getError({ error: 'Invalid Automation', }));
const cronAuth = automationScript.runtime_options.req_body.cron_properties.auth;
if (cronAuth !== authMap[ auth ]) return res.send(getError({ error: 'Invalid Automation Authentication', }));
const runAutomation = utilities.crons.runScript.bind({
stop: () => {
periodic.logger.debug('Automation ran to completion');
},
});
const data = await runAutomation({ req, script: automationScript.runtime_options.script, });
return res.send(routeUtils.formatResponse({
result: 'success',
data,
}));
} catch (e) {
periodic.logger.error(e);
return res.send(getError({ error: 'Invalid Automation Process', status:500, }));
}
}
function getDataCoreController() {
try {
const dataCoreControllers = new Map();
for (let [dataName, datum, ] of periodic.datas) {
if (dataName === 'dblog_logger') {
const CoreController = new CoreControllerModule(periodic, {
compatibility: false,
skip_responder: true,
skip_db: true,
skip_protocol: true,
});
CoreController.initialize_responder({
adapter: 'json',
});
CoreController.initialize_protocol({
adapter: 'http',
api: 'rest',
});
CoreController.db[dataName] = datum;
dataCoreControllers.set(dataName, {
controller: CoreController,
router: CoreController.protocol.api.implement({
model_name: dataName,
// override,
dirname: path.join(periodic.config.app_root, '/node_modules/periodicjs.ext.dblogger/views'),
}).router,
});
}
}
return (dataCoreControllers);
} catch (e) {
periodic.logger.error(e);
}
}
computeQueue.push({ task, }, function computeQueuePush(err) {
tasks--;
if (err) periodic.logger.error(err);
else {
process.send({
event: 'compute-log',
payload: {
message: 'Completed task computation',
meta: {
task,
clientlog: true,
},
status:getQueueStatus(),
},
});
}
});
async function runScript({ script, req, }) {
const cronJobThisContext = this;
try {
const sandbox = {
asyncMethod: async () => { },
datasets,
helpers:functionprops,
periodic,
request,
Promisie,
$,
randomUA,
$p:periodic,
puppeteer,
rebulma,
rjx,
crons,
req,
importHelpers:helpers,
logger:periodic.logger,
console,
scripts,
};
vm.createContext(sandbox);
vm.runInContext(`asyncMethod = async function _asyncMethod(){
${script}
}`, sandbox);
const scriptStatus = await sandbox.asyncMethod();
cronJobThisContext.stop();
return scriptStatus;
} catch (e) {
cronJobThisContext.stop();
periodic.logger.error(e);
throw e;
}
}
async function authenticateAutomation(req, res, next) {
try {
const { auth, id, } = req.params;
req.query.format = 'json';
if (!auth || ['go', 'process', 'run', ].includes(auth)===false) {
res.status(401);
return res.send(getError({ error: 'Invalid Authentication', }));
} else {
switch (auth) {
case 'go':
return next();
case 'process':
req.url = `/automation/authenticate/client/${auth}/${id}`;
return periodic.app._router.handle(req, res, next);
case 'run':
req.url = `/automation/authenticate/bearer/${auth}/${id}`;
return periodic.app._router.handle(req, res, next);
}
}
} catch (e) {
periodic.logger.error(e);
return res.send(getError({ error: 'Invalid Authentication Process', status:500, }));
}
}
stop: () => {
periodic.logger.debug('Automation ran to completion');
},
periodic.status.on('configuration-complete', (status) => {
const dbloggerExtSettings = periodic.settings.extensions[ 'periodicjs.ext.dblogger' ];
periodic.logger.add(utilities.winston.coreDataWinstonLogger, dbloggerExtSettings);
utilities.reactapphelper.setReactAppTable();
});
userAuth(mockUserAuthReq, mockUserAuthRes, () => {
if (periodic.config.debug) {
periodic.logger.silly(`Configured ${service_name}, OAuth2 Bearer Authentication for (${capitalize(oauth2client_settings.user_entity_type || 'user')})${oauth2client_settings.user_email}`);
}
});