nitor 1.0.0 → 1.2.0

package/services/time-entry/add-task.js

@@ -0,0 +1,50 @@
+const path = require('path');
+const {
+  contentTableHeading,
+  contentTableSeparator,
+  convertToTaskData,
+  readFileSync,
+  accessFileSync,
+  writeFileSync,
+  userHomeDir,
+  appendFileSync,
+} = require('./utils');
+const checkDateEntry = async (date, entryContent) => {
+  const isExists = { file: false, entry: false };
+
+  try {
+    if (accessFileSync(path.join(userHomeDir, `.${date}`))) {
+      const entries = readFileSync(path.join(userHomeDir, `.${date}`));
+
+      isExists.file = entries.includes(`### ${date}`);
+      isExists.entry = entries.includes(entryContent);
+    }
+
+    return isExists;
+  } catch {
+    return isExists;
+  }
+};
+const addNewTask = async (values) => {
+  const { project, sprint, task, date, work, duration, remarks } = await convertToTaskData(values);
+
+  try {
+    const entryHeading = `---\ntags: [Time entry task]\ntitle: ${date}\ncreated: ${new Date().toISOString()}\n---\n\n### ${date}\n${contentTableHeading}\n${contentTableSeparator}`;
+    const entryContent = `\n| ${new Date().getTime()} | ${project} | ${sprint} | ${date} | ${task} | ${work} | ${duration} | ${remarks} | false |`;
+    const isExists = await checkDateEntry(date, entryContent);
+
+    if (isExists.file && isExists.entry) {
+      console.log('Same entry already exists');
+    } else if (isExists.file && !isExists.entry) {
+      console.log('New entry added');
+      appendFileSync(path.join(userHomeDir, `.${date}`), `${entryContent}`);
+    } else {
+      console.log('New entry added');
+      writeFileSync(path.join(userHomeDir, `.${date}`), `${entryHeading}${entryContent}`);
+    }
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+module.exports = { addNewTask };

package/services/time-entry/enums/actions.enum.js

@@ -0,0 +1,16 @@
+module.exports = {
+  ACTIONS: {
+    INIT: 'init',
+    SWITCH: 'switch',
+    ADD: 'add',
+    UPDATE: 'update',
+    DELETE: 'delete',
+    STATUS: 'status',
+    ENTRIES: 'entries',
+    ZOHO: 'zoho',
+    GITLAB: 'gitlab',
+    MERGE: 'merge',
+    VERSION: 'version',
+    HELP: 'help',
+  },
+};

package/services/time-entry/get-gitlab-activities.js

@@ -0,0 +1,137 @@
+const axios = require('axios');
+const cheerio = require('cheerio');
+const { gitlabConfig } = require('../utils');
+
+const getGitlabActivities = async (values) => {
+  const resp = {};
+  const filters = getFilters(values);
+  const startDate = new Date(filters.from);
+
+  while (startDate <= new Date(filters.to)) {
+    const date = startDate.toISOString().split('T')[0];
+    const activities = await getGitlabActivitiesByDate(date);
+
+    if (activities?.length) {
+      resp[date] = arrayToObjectByKey(activities, 'action');
+    }
+
+    startDate.setDate(startDate.getDate() + 1);
+  }
+
+  console.log(resp);
+  return resp;
+};
+const getFilters = (values) => {
+  const filters = {};
+  const keyMap = {
+    f: 'from',
+    from: 'from',
+    t: 'to',
+    to: 'to',
+  };
+
+  if (values?.length) {
+    for (const item of values) {
+      let [key, ...itemValues] = item.split(' ');
+      const itemValue = itemValues.join(' ');
+
+      if (key.charAt(0) === '-') {
+        key = key.substring(1);
+      }
+
+      const dt = new Date(itemValue).toISOString().split('T')[0];
+
+      if (dt) {
+        filters[keyMap[key]] = dt;
+      }
+    }
+  } else {
+    filters.from = new Date(new Date().setDate(new Date().getDate() - 7))
+      .toISOString()
+      .split('T')[0];
+    filters.to = new Date().toISOString().split('T')[0];
+  }
+
+  return filters;
+};
+const getGitlabActivitiesByDate = async (date) => {
+  const { removeEmpty } = require('./utils');
+  const gitlabUrl = `${gitlabConfig.url}/users/${gitlabConfig.userId}/calendar_activities?date=${date}`;
+  const headers = {
+    accept: 'application/json, text/plain, */*',
+    'accept-language': 'en-GB,en-US;q=0.9,en;q=0.8,ml;q=0.7',
+    'cache-control': 'no-cache',
+    cookie: gitlabConfig.cookie,
+    pragma: 'no-cache',
+    referer: `${gitlabConfig.url}/${gitlabConfig.userId}`,
+    'sec-fetch-mode': 'cors',
+    'sec-fetch-site': 'same-origin',
+    'user-agent':
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
+    'x-csrf-token': gitlabConfig.xCsrfToken,
+    'x-requested-with': 'XMLHttpRequest',
+  };
+  // let config = { method: 'get', maxBodyLength: Infinity, url: `${gitlabUrl}2024-5-10`, headers };
+
+  try {
+    const response = await axios.get(gitlabUrl, { headers });
+
+    const $ = cheerio.load(response.data);
+
+    // Initialize an empty array to store the JSON objects
+    let contributions = [];
+
+    // Iterate over each list item
+    $('ul.bordered-list li').each((i, element) => {
+      const $element = $(element);
+      const time = $element.find('span.js-localtime').text().trim();
+      const action = $element
+        .contents()
+        .filter(function () {
+          return this.nodeType === 3; // Text nodes
+        })
+        .text()
+        .trim()
+        .split(/\n/g)[0]
+        .trim();
+      const detailsArray = $element
+        .find('a')
+        .map((i, el) => {
+          return {
+            title: $(el).attr('title'),
+            href: $(el).attr('href').split(/\/-\//g)[1],
+            text: $(el).text().trim().replace(/!/g, ''),
+          };
+        })
+        .get();
+      const details = detailsArray.reduce((acc, item) => {
+        if (item.title === 'medica-portal-client') {
+          acc.repo = item.title;
+        } else {
+          acc = removeEmpty(item);
+        }
+
+        return acc;
+      }, {});
+
+      contributions.push({
+        time,
+        action,
+        ...details,
+      });
+    });
+
+    return contributions;
+  } catch (error) {
+    console.log(error.message);
+  }
+};
+const arrayToObjectByKey = (arr, key) => {
+  return arr.reduce((acc, obj) => {
+    acc[obj[key]] = obj;
+
+    return acc;
+  }, {});
+};
+
+module.exports = { getGitlabActivities };

package/services/time-entry/get-report.js

@@ -0,0 +1,142 @@
+const {
+  contentTableHeading,
+  contentTableSeparator,
+  path,
+  readFileSync,
+  userHomeDir,
+  removeEmpty,
+} = require('./utils');
+const getTasksByDate = async (filters) => {
+  try {
+    if (!(filters?.from || filters?.to)) {
+      filters = getFilters(filters);
+    }
+
+    let data = [];
+    let startDate = new Date(filters.from);
+    const itemHeading = contentTableHeading.split('|').reduce((acc, val) => {
+      const item = val.trim();
+
+      if (item && item !== '--') {
+        acc.push(item);
+      }
+
+      return acc;
+    }, []);
+
+    while (startDate <= new Date(filters.to)) {
+      const stringDate = startDate.toISOString().split('T')[0];
+      const item = readFileSync(path.join(userHomeDir, `.${stringDate}`));
+
+      if (item) {
+        const timeEntries = removeEmpty(item.split(contentTableSeparator)[1].split('\n'));
+
+        data = data.concat(
+          timeEntries.map((entry) =>
+            entry.split('|').reduce((acc, val, i) => {
+              const item = val.trim();
+
+              if (item && item !== '--') {
+                acc[itemHeading[i - 1]] = item;
+              }
+
+              return acc;
+            }, {}),
+          ),
+        );
+      }
+
+      startDate.setDate(startDate.getDate() + 1);
+    }
+
+    return data.filter((item) => item);
+  } catch (error) {
+    console.error(error.message);
+  }
+};
+const getTasksBySynced = async (synced = 'false') => {
+  try {
+    const resp = await getTasksByDate();
+
+    return (resp || []).filter((item) => item.synced === synced);
+  } catch (error) {
+    console.error(error.message);
+  }
+};
+const getReport = async (filters) => {
+  try {
+    const resp = await getTasksByDate(filters);
+    const adhocTasks = ['adhoc', 'internal', 'call', 'calls', 'code', 'review'];
+
+    return (resp || []).reduce((res, { date, work, synced, duration }) => {
+      res[date] = {
+        synced: res[date]?.synced || 0,
+        open: res[date]?.open || 0,
+        task: res[date]?.task || 0,
+        adhoc: res[date]?.adhoc || 0,
+        total: res[date]?.total || 0,
+        pending: res[date]?.pending || 480,
+      };
+
+      if (synced === 'true') {
+        res[date].synced += +duration;
+      } else {
+        res[date].open += +duration;
+      }
+
+      if (adhocTasks.some((adhoc) => work.toLowerCase().includes(adhoc))) {
+        res[date].adhoc += +duration;
+      } else {
+        res[date].task += +duration;
+      }
+
+      res[date].total = res[date].task + res[date].adhoc;
+      res[date].pending = res[date].total - 480;
+
+      return res;
+    }, {});
+  } catch (error) {
+    console.error(error.message);
+  }
+};
+const getStatus = async (values) => {
+  const data = getFilters(values);
+
+  console.table(await getReport(data));
+};
+const getFilters = (values) => {
+  const filters = {};
+  const keyMap = {
+    f: 'from',
+    '-f': 'from',
+    from: 'from',
+    t: 'to',
+    to: 'to',
+  };
+
+  if (values?.length) {
+    for (const item of values) {
+      let [key, ...itemValues] = item.split(' ');
+      const itemValue = itemValues.join(' ');
+
+      if (key.charAt(0) === '-') {
+        key = key.substring(1);
+      }
+
+      const dt = new Date(itemValue).toISOString().split('T')[0];
+
+      if (dt) {
+        filters[keyMap[key]] = dt;
+      }
+    }
+  } else {
+    filters.from = new Date(new Date().setDate(new Date().getDate() - 7))
+      .toISOString()
+      .split('T')[0];
+    filters.to = new Date().toISOString().split('T')[0];
+  }
+
+  return filters;
+};
+
+module.exports = { getReport, getStatus, getTasksByDate, getTasksBySynced };

package/services/time-entry/get-zoho-tasks.js

@@ -0,0 +1,81 @@
+const axios = require('axios');
+const { getHeaders, getSprints, userId } = require('./utils');
+const { zohoConfig } = require('../utils');
+const getZohoTasks = async ({ params }) => {
+  const headers = await getHeaders();
+  let activeSprint;
+
+  if (!params?.sprint) {
+    if (params?.type) {
+      if (typeof params.type === 'string') {
+        params.type = params.type.split(',');
+      }
+    } else {
+      params.type = ['2'];
+    }
+
+    activeSprint = await getSprints({ params });
+
+    params.sprint = activeSprint?.[0]?.value;
+  } else {
+    const isValidSprint = await checkSprintId(params.sprint, { headers, params });
+
+    if (!isValidSprint) {
+      console.error('Invalid sprint ID');
+    }
+  }
+
+  if (activeSprint?.length > 1) {
+    const resp = [];
+
+    for (const sprint of activeSprint) {
+      params.sprint = sprint.value;
+
+      const tasks = await getTasksBySprint({ params, headers });
+
+      resp.push(...(tasks || []));
+    }
+
+    return resp;
+  } else {
+    return getTasksBySprint({ params, headers });
+  }
+};
+const getTasksBySprint = async ({ params, headers }) => {
+  const p = {
+    action: 'data',
+    index: params.index || 1,
+    range: params.range || 300,
+    sprint: params.sprint || null,
+    project: params.project || zohoConfig.defaultProjectId,
+    subitem: params.subitem || false,
+  };
+  const parentUrl = `${zohoConfig.url}/zsapi/team/${zohoConfig.team}/projects/${p.project}/sprints/${p.sprint}/item/?action=${p.action}&range=${p.range}&index=${p.index}&subitem=${p.subitem}&customviewid=${zohoConfig.customViewId}`;
+
+  try {
+    const response = await axios.get(parentUrl, { headers });
+
+    return Object.entries(response.data.itemJObj).reduce((acc, [key, values]) => {
+      if (params.filterUser) {
+        for (const value of values) {
+          if (typeof value === 'object' && value.length && value.includes(userId)) {
+            acc.push({ value: key, label: values[0], taskId: values[1] });
+          }
+        }
+      } else {
+        acc.push({ value: key, label: values[0], taskId: values[1] });
+      }
+
+      return acc.sort((a, b) => a.taskId - b.taskId);
+    }, []);
+  } catch (error) {
+    console.error(error.message);
+  }
+};
+const checkSprintId = async (id, req) => {
+  const sprints = await getSprints(req);
+
+  return sprints.some(({ value }) => value === id);
+};
+
+module.exports = { getZohoTasks };

package/services/time-entry/log-task-hours-and-sync.js

@@ -0,0 +1,81 @@
+const axios = require('axios');
+const FormData = require('form-data');
+const { format, addMinutes, startOfDay } = require('date-fns');
+const { utcToZonedTime } = require('date-fns-tz');
+const { getTasksBySynced } = require('./get-report');
+const { getZohoTasks } = require('./get-zoho-tasks');
+const { updateTaskStatus } = require('./update-delete-task');
+const { getHeaders, getSprints } = require('./utils');
+const { zohoConfig } = require('../utils');
+const logTaskHoursAndSync = async () => {
+  const tasks = await getTasksBySynced();
+  const response = {
+    success: 0,
+    failed: 0,
+    total: tasks.length,
+    pending: tasks.length,
+    erroredTasks: [],
+    successTasks: [],
+  };
+
+  for (const task of tasks) {
+    let status = 'failed';
+    const project = zohoConfig.projects[task.project]?.value || zohoConfig.defaultProjectId;
+    const activeSprint = await getSprints({ params: { type: '2', project } });
+    const sprint = activeSprint.find(
+      ({ label }) => label.toLowerCase() === task.sprint.toLowerCase(),
+    )?.value;
+    const zohoTasks = await getZohoTasks({ params: { project, sprint, subitem: true } });
+    const headers = await getHeaders();
+    const zohoTask = zohoTasks.find(({ taskId }) => taskId === task.task);
+    const newData = new FormData();
+    const taskDate = new Date(task.date);
+    const duration = format(addMinutes(startOfDay(new Date()), task.duration), 'HH:mm');
+
+    if (!zohoTask) {
+      response.failed++;
+      response.erroredTasks.push(task.task);
+      console.log('No tasks found', task.task);
+
+      continue;
+    }
+
+    taskDate.setHours(0, 0, 0, 0);
+
+    const zonedDate = utcToZonedTime(taskDate, 'Asia/Kolkata');
+    const date = format(zonedDate, "yyyy-MM-dd'T'HH:mm:ssXXX");
+    const parentUrl = `${zohoConfig.url}/zsapi/team/${zohoConfig.team}/projects/${project}/sprints/${activeSprint?.[0]?.value}/item/${zohoTask?.value}/timesheet/?action=additemlog`;
+
+    newData.append('users', zohoConfig.userId);
+    newData.append('duration', duration);
+    newData.append('isbillable', 1);
+    newData.append('date', date);
+    newData.append('notes', task.remarks ? `<div>${task.remarks}</div>` : '');
+
+    try {
+      const item = await axios.post(parentUrl, newData, { headers });
+
+      if (item.data.status === 'success') {
+        status = 'success';
+
+        response.success++;
+        response.successTasks.push(task.task);
+        await updateTaskStatus(task.id, task.date);
+      } else {
+        response.failed++;
+        response.erroredTasks.push(task.task);
+      }
+    } catch (error) {
+      response.failed++;
+      response.erroredTasks.push(task.task);
+      console.log(error.message);
+    }
+
+    response.pending--;
+    console.log(`Task ${task.task} is ${status}`);
+  }
+
+  return response;
+};
+
+module.exports = { logTaskHoursAndSync };

package/services/time-entry/update-delete-task.js

@@ -0,0 +1,85 @@
+const { getTasksByDate } = require('./get-report');
+const {
+  contentTableSeparator,
+  readFileSync,
+  path,
+  userHomeDir,
+  writeFileSync,
+  convertToTaskData,
+} = require('./utils');
+const updateTaskStatus = async (taskId, date, taskStatus = true) => {
+  try {
+    const entries = await getTasksByDate([`f ${date}`, `t ${date}`]);
+    const file = readFileSync(path.join(userHomeDir, `.${date}`));
+    let fileHeading = getFileHeading(file.split(contentTableSeparator)[0]);
+
+    for (const entry of entries) {
+      if (entry) {
+        const { id, project, sprint, task, date, work, duration, remarks, synced } = entry;
+
+        fileHeading += `\n| ${id} | ${project} | ${sprint} | ${date} | ${task} | ${work} | ${duration} | ${remarks} | ${taskId === id ? taskStatus : synced} |`;
+      }
+    }
+
+    writeFileSync(path.join(userHomeDir, `.${date}`), fileHeading);
+  } catch (error) {
+    console.log(error.message);
+  }
+};
+const updateTask = async (values) => {
+  try {
+    const item = await convertToTaskData(values);
+    const entries = await getTasksByDate([`f ${item.date}`, `t ${item.date}`]);
+    const file = readFileSync(path.join(userHomeDir, `.${item.date}`));
+    let fileHeading = getFileHeading(file.split(contentTableSeparator)[0]);
+
+    for (const entry of entries) {
+      if (entry) {
+        const { id, project, sprint, task, date, work, duration, remarks, synced } = entry;
+
+        if (id === item.id) {
+          fileHeading += `| ${id} | ${project} | ${sprint} | ${item.date} | ${item.task} | ${item.work} | ${item.duration} | ${item.remarks} | ${synced} |\n`;
+        } else {
+          fileHeading += `| ${id} | ${project} | ${sprint} | ${date} | ${task} | ${work} | ${duration} | ${remarks} | ${synced} |\n`;
+        }
+      }
+    }
+
+    writeFileSync(path.join(userHomeDir, `.${item.date}`), fileHeading);
+  } catch (error) {
+    console.log(error.message);
+  }
+};
+const deleteTask = async (values) => {
+  try {
+    const item = await convertToTaskData(values);
+    const entries = await getTasksByDate(item.date, item.date);
+    const file = readFileSync(path.join(userHomeDir, `.${item.date}`));
+    let fileHeading = getFileHeading(file.split(contentTableSeparator)[0]);
+
+    for (const entry of entries) {
+      if (entry) {
+        const { id, project, sprint, task, date, work, duration, remarks, synced } = entry;
+
+        if (id !== item.id) {
+          fileHeading += `| ${id} | ${project} | ${sprint} | ${date} | ${task} | ${work} | ${duration} | ${remarks} | ${synced} |\n`;
+        }
+      }
+    }
+
+    writeFileSync(path.join(userHomeDir, `.${item.date}`), fileHeading);
+  } catch (error) {
+    console.log(error.message);
+  }
+};
+const getFileHeading = (topHeading) => {
+  const lastIndex = topHeading.lastIndexOf('\n');
+
+  if (lastIndex !== -1) {
+    topHeading = topHeading.substring(0, lastIndex) + topHeading.substring(lastIndex + 1);
+  }
+
+  return `${topHeading}\n${contentTableSeparator}\n`;
+};
+
+module.exports = { updateTaskStatus, updateTask, deleteTask };