21603407728

Committed 02 Feb 2026 06:59PM UTC coverage: 78.0% (-4.0%) from 82.0%

Build # 21603407728

Build Type

Pull #71

github

Committed by

web-flow

Commit Message

Merge ff5d27caa into 3dc1e9c82

Pull Request Pull Request #71: chore(deps): update dependency eslint to v9.26.0 [security]

Run Details

37 of 65 branches covered (56.92%)

Branch coverage included in aggregate %.

236 of 285 relevant lines covered (82.81%)

5.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.0

/controllers/taskExecutor/index.js

const filemanager = require('../filemanager');
// const { v4: uuidv4 } = require('uuid');
const requireFromString = require('require-from-string');
const governify = require('governify-commons');
const logger = governify.getLogger().tag('task-executor');

const programmedTasks = {};

module.exports.runTask = runTask;
module.exports.runScript = runScript;

module.exports.startExecutor = async function () {
  setInterval(programNextTasks, 3000);
};

module.exports.getProgrammedTasks = function () {
  return programmedTasks;
};

async function programNextTasks () {
  const currentTime = new Date().getTime();
  const maxTimeProgram = currentTime + 10000;

  const files = await filemanager.readFiles();

  // Programmed Task Object cleanup
  const taskListId = files.map(x => x.id);
  const programmedListId = Object.keys(programmedTasks);
  const toDelete = programmedListId.filter(id => { return !taskListId.includes(id); });
  const toCreate = taskListId.filter(id => { return !programmedListId.includes(id); });
  toDelete.forEach(id => delete programmedTasks[id]);
  toCreate.forEach(id => { programmedTasks[id] = {}; });

  // Iteration for all task files
  files.filter(task => { return task.running; }).forEach(task => {
    const initTime = new Date(task.init).getTime();
    const endTime = new Date(task.end).getTime();

    if (currentTime > endTime) {
      filemanager.deleteTaskFile(task.id);
    } else {
      let realInitTime = initTime;
      // Remove old period if time init is past for optimization
      if (initTime < currentTime) {
        realInitTime = currentTime - (currentTime - initTime) % task.interval;
      }
      const nextTaskDates = [];
      let currentTimeCalculation = realInitTime;
      while (maxTimeProgram > currentTimeCalculation && endTime > currentTimeCalculation) {
        if (currentTimeCalculation > currentTime && !programmedTasks[task.id][currentTimeCalculation]) {
          nextTaskDates.push(currentTimeCalculation);
        }
        currentTimeCalculation += task.interval;
      }

      nextTaskDates.forEach(time => {
        const scheduledFunction = function () {
          if (task) {
            delete programmedTasks[task.id]?.[time];
            runTask(task);
          } else {
            logger.info('Task canceled because it was deleted.');
          }
        };

        setTimeout(scheduledFunction, time - currentTime);
        programmedTasks[task.id][time] = { timer: 'id' };
      });
    }
  });
  if(Object.keys(programmedTasks).length > 0){
    logger.info(`Tasks: \n${JSON.stringify(programmedTasks)}`);
  };
}

// Run a specific tasktask
async function runTask (task) {
  try {
    const scriptFile = await governify.httpClient({
      url: task.script,
      method: 'GET',
      headers: { 'User-Agent': 'request' },
      transformResponse: function (response) {
        // do not convert the response to JSON or object
        return response;
      }
    });
    return await runScript(scriptFile.data, task.config, task.id);
  } catch (err) {
    console.error(err);
    throw Error('Error obtaining: ' + URL);
  }
}

// Run raw JS file with a specific configuration.
async function runScript (scriptText, config, scriptInfo) {
  let scriptResponse;
  try {
    const module = requireFromString(scriptText);

    scriptResponse = await module.main(config);
  } catch (error) {
    scriptResponse = 'Error running script: ' + JSON.stringify(scriptInfo) + '\n' + 'Script config: ' + JSON.stringify(config);
    throw Error(scriptResponse);
  }
  return scriptResponse;
}

1	const filemanager = require('../filemanager');	1✔
2	// const { v4: uuidv4 } = require('uuid');
3	const requireFromString = require('require-from-string');	1✔
4	const governify = require('governify-commons');	1✔
5	const logger = governify.getLogger().tag('task-executor');	1✔
6
7	const programmedTasks = {};	1✔
8
9	module.exports.runTask = runTask;	1✔
10	module.exports.runScript = runScript;	1✔
11
12	module.exports.startExecutor = async function () {	1✔
13	setInterval(programNextTasks, 3000);	1✔
14	};
15
16	module.exports.getProgrammedTasks = function () {	1✔
17	return programmedTasks;	1✔
18	};
19
20	async function programNextTasks () {
21	const currentTime = new Date().getTime();	7✔
22	const maxTimeProgram = currentTime + 10000;	7✔
23
24	const files = await filemanager.readFiles();	7✔
25
26	// Programmed Task Object cleanup
27	const taskListId = files.map(x => x.id);	7✔
28	const programmedListId = Object.keys(programmedTasks);	7✔
29	const toDelete = programmedListId.filter(id => { return !taskListId.includes(id); });	7✔
30	const toCreate = taskListId.filter(id => { return !programmedListId.includes(id); });	7✔
31	toDelete.forEach(id => delete programmedTasks[id]);	7✔
32	toCreate.forEach(id => { programmedTasks[id] = {}; });	7✔
33
34	// Iteration for all task files
35	files.filter(task => { return task.running; }).forEach(task => {	7✔
36	const initTime = new Date(task.init).getTime();	×
37	const endTime = new Date(task.end).getTime();	×
38
39	if (currentTime > endTime) {	×
40	filemanager.deleteTaskFile(task.id);	×
41	} else {
42	let realInitTime = initTime;	×
43	// Remove old period if time init is past for optimization
44	if (initTime < currentTime) {	×
45	realInitTime = currentTime - (currentTime - initTime) % task.interval;	×
46	}
47	const nextTaskDates = [];	×
48	let currentTimeCalculation = realInitTime;	×
49	while (maxTimeProgram > currentTimeCalculation && endTime > currentTimeCalculation) {	×
50	if (currentTimeCalculation > currentTime && !programmedTasks[task.id][currentTimeCalculation]) {	×
51	nextTaskDates.push(currentTimeCalculation);	×
52	}
53	currentTimeCalculation += task.interval;	×
54	}
55
56	nextTaskDates.forEach(time => {	×
57	const scheduledFunction = function () {	×
58	if (task) {	×
59	delete programmedTasks[task.id]?.[time];	×
60	runTask(task);	×
61	} else {
62	logger.info('Task canceled because it was deleted.');	×
63	}
64	};
65
66	setTimeout(scheduledFunction, time - currentTime);	×
67	programmedTasks[task.id][time] = { timer: 'id' };	×
68	});
69	}
70	});
71	if(Object.keys(programmedTasks).length > 0){	7!
72	logger.info(`Tasks: \n${JSON.stringify(programmedTasks)}`);	×
73	};
74	}
75
76	// Run a specific tasktask
77	async function runTask (task) {
78	try {	2✔
79	const scriptFile = await governify.httpClient({	2✔
80	url: task.script,
81	method: 'GET',
82	headers: { 'User-Agent': 'request' },
83	transformResponse: function (response) {
84	// do not convert the response to JSON or object
85	return response;	2✔
86	}
87	});
88	return await runScript(scriptFile.data, task.config, task.id);	2✔
89	} catch (err) {
90	console.error(err);	1✔
91	throw Error('Error obtaining: ' + URL);	1✔
92	}
93	}
94
95	// Run raw JS file with a specific configuration.
96	async function runScript (scriptText, config, scriptInfo) {
97	let scriptResponse;
98	try {	4✔
99	const module = requireFromString(scriptText);	4✔
100
101	scriptResponse = await module.main(config);	2✔
102	} catch (error) {
103	scriptResponse = 'Error running script: ' + JSON.stringify(scriptInfo) + '\n' + 'Script config: ' + JSON.stringify(config);	2✔
104	throw Error(scriptResponse);	2✔
105	}
106	return scriptResponse;	2✔
107	}

governify / director / 21603407728

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous