biz-a-cli 2.3.1 → 2.3.3

package/proxyController.js

@@ -0,0 +1,83 @@
+import * as https from 'https';
+import * as http from 'http';
+
+export function proxy(clientRequest, clientResponse) {
+    try {
+        const isHttps = url => url.startsWith('https://');
+        const hasPort = url => url.indexOf(':') > -1;
+
+        const targetUrl = clientRequest.query.target ?
+            clientRequest.query.target
+            : clientRequest.get('target');
+        const target = targetUrl.split('/')[2];
+
+        let parsedHost = targetUrl.split('/').splice(2).splice(0, 1).join('/');
+        if (hasPort(target)) parsedHost = parsedHost.split(':')[0];
+        let targetPort = hasPort(target) ? target.split(':')[1] : null;
+
+        const parsedSSL = isHttps(targetUrl) ? https : http;
+
+        // console.log(clientRequest.headers)
+        let svrReqHeader = {};
+        if (clientRequest.headers["content-type"]) {
+            svrReqHeader["content-type"] = clientRequest.headers["content-type"];
+        }
+
+        const options = {
+            hostname: parsedHost,
+            port: isHttps(targetUrl) ?
+                // (targetPort ? targetPort : 443) :
+                // (targetPort ? targetPort : 80),
+                (targetPort || 443) :
+                (targetPort || 80),
+            path: clientRequest.url,
+            method: clientRequest.method,
+            headers: svrReqHeader
+        };
+        if (clientRequest.headers['user-agent']) {
+            options['User-Agent'] = clientRequest.headers['user-agent'];
+        }
+
+        const serverRequest = parsedSSL.request(options, function (serverResponse) {
+            try {
+                let body = '';
+                if (serverResponse.headers['content-type'] && String(serverResponse.headers['content-type']).indexOf('text/html') !== -1) {
+                    serverResponse.on('data', function (chunk) {
+                        body += chunk;
+                    });
+
+                    serverResponse.on('end', function () {
+                        clientResponse.writeHead(serverResponse.statusCode, serverResponse.headers);
+                        clientResponse.end(body);
+                    });
+                } else {
+                    serverResponse.pipe(clientResponse, {
+                        end: true,
+                    });
+                    clientResponse.contentType(serverResponse.headers['content-type']);
+                }
+            } catch (error) {
+                console.log('exception')
+                console.log(error);
+            }
+        });
+
+        serverRequest.on('error', function (err) {
+            // clientResponse.writeHead(503, {Error: err.message});
+            console.log('On Error serverRequest Proxy: ', err);
+        })
+
+        // console.log(clientRequest.body)
+        if (clientRequest.body) {
+            serverRequest.write(JSON.stringify(clientRequest.body));
+        }
+        serverRequest.end();
+    } catch (err) {
+        console.log(err);
+
+        // serverRequest.end();
+        // clientResponse.end();
+        serverRequest.destroy();
+        // clientResponse.destroy();
+    }
+};

package/scheduler/configController.js

@@ -0,0 +1,106 @@
+import { MongoClient, ObjectId } from 'mongodb';
+import { envDev } from '../envs/env.dev.js';
+import { env } from '../envs/env.js';
+
+let BIZA_MONGO_LINK;
+let CDM_MONGO_LINK;
+let COMPANY_REGISTER;
+
+// if ((process.env.NODE_ENV == undefined) || (process.env.NODE_ENV == 'development')) {
+    // BIZA_MONGO_LINK = envDev.BIZA_MONGO_LINK;
+    // CDM_MONGO_LINK = envDev.CDM_MONGO_LINK;
+    // COMPANY_REGISTER = envDev.COMPANY_REGISTER;
+
+    // console.log('BIZA_MONGO_LINK =>', BIZA_MONGO_LINK);
+    // console.log('CDM_MONGO_LINK =>', CDM_MONGO_LINK);
+    // console.log('COMPANY_REGISTER =>', COMPANY_REGISTER);
+// } else {
+    BIZA_MONGO_LINK = env.BIZA_MONGO_LINK;
+    CDM_MONGO_LINK = env.CDM_MONGO_LINK;
+    COMPANY_REGISTER = env.COMPANY_REGISTER;
+// }
+
+async function fetchSelectedConfig(aggregateField) {
+    const client = new MongoClient(BIZA_MONGO_LINK);
+    try {
+        await client.connect();
+        const db = client.db('biz-a');
+        const config = db.collection('configuration');
+
+        return await config.aggregate(aggregateField).toArray();
+    } catch (error) {
+        console.error(error);
+        throw new Error(error);
+    } finally {
+        client.close()
+    }
+}
+
+function getSelectedConfigAggregateField(companyObjectId) {
+    let configAggregate = [];
+    if (companyObjectId) {
+        configAggregate.push({ "$match": { companyObjectId: new ObjectId(companyObjectId) } });
+    };
+    configAggregate.push({
+        $lookup: {
+            from: 'smtp',
+            localField: '_id',
+            foreignField: 'configObjectId',
+            as: 'smtp'
+        }
+    });
+    configAggregate.push({ $unwind: { path: "$smtp" } });
+
+    return configAggregate;
+}
+
+async function getSelectedConfig(companyObjectId) {
+    return await fetchSelectedConfig(getSelectedConfigAggregateField(companyObjectId));
+}
+
+function getCompanyObjectIdFindOneField(companyName) {
+    return [
+        { companyID: { $regex: new RegExp(`^${companyName}$`, 'i') } },
+        {
+            projection: {
+                _id: 1,
+                companyID: 1
+            }
+        }
+    ]
+}
+
+async function fetchCompanyObjectId(findOneField) {
+    const client = new MongoClient(CDM_MONGO_LINK);
+    try {
+        await client.connect();
+        const db = client.db(COMPANY_REGISTER);
+        const company = db.collection('companies');
+
+        return await company.findOne(findOneField[0], findOneField[1]);
+    } catch (error) {
+        console.error(error);
+        throw new Error(error);
+    } finally {
+        client.close()
+    }
+}
+
+function validateCompanyObjectId(companyObjectId) {
+    if (companyObjectId?._id) {
+        return companyObjectId;
+    } else {
+        throw { code: 'ENOENT' };
+    }
+};
+
+async function getCompanyObjectId(companyName) {
+    const companyObjectId = await fetchCompanyObjectId(getCompanyObjectIdFindOneField(companyName));
+    return validateCompanyObjectId(companyObjectId);
+};
+
+export {
+    BIZA_MONGO_LINK,
+    getSelectedConfig,
+    getCompanyObjectId
+};

package/scheduler/converter.js

@@ -0,0 +1,84 @@
+export function historyRecordToJson(data) {
+    let dataJson = [];
+    data.map(history => {
+        dataJson.push({
+            _id: parseInt(history.history_id),
+            timerObjectId: parseInt(history.timer_id),
+            latestRun: new Date(history.latest_run)
+        })
+    })
+
+    return dataJson;
+}
+
+function addTimer(timer, timerData) {
+    let timerIdx = (timerData) ? timerData.findIndex(value => value._id == timer.timer_id) : -1;
+    if (timerIdx > -1) {
+        if (timer.hourly_hours) {
+            timerData[timerIdx].hourly = timer.hourly_hours.split(',').map(String);
+        }
+    } else {
+        let timerObj = {
+            _id: parseInt(timer.timer_id),
+            watcherObjectId: parseInt(timer.timer_watcher_id),
+            name: timer.name,
+            active: (timer.active == 1),
+            timezone: timer.timezone,
+            templateName: timer.templateName,
+            seq: parseInt(timer.seq),
+            scriptId: parseInt(timer.scriptId),
+            script: (timer.cli_script) ? JSON.stringify(timer.cli_script) : ''
+        };
+        if ((timer.daily_days)) {
+            timerObj.daily = timer.daily_days.split(',').map(Number);
+        }
+        if (timer.weekly_ordinal && timer.weekly_days) {
+            timerObj.weekly = {
+                ordinal: timer.weekly_ordinal.split(',').map(Number),
+                days: timer.weekly_days.split(',').map(Number)
+            }
+        }
+        if ((timer.monthly_days)) {
+            timerObj.monthly = timer.monthly_days.split(',')
+                .map(value => (!isNaN(value)) ? Number(value) : value);
+        }
+        if (timer.minutely_everymin &&
+            timer.minutely_time_from && timer.minutely_time_to) {
+            timerObj.minutely = {
+                everyMin: parseInt(timer.minutely_everymin),
+                from: timer.minutely_time_from,
+                to: timer.minutely_time_to,
+            }
+        }
+        timerData.push(timerObj);
+
+        timerIdx = timerData.length - 1;
+
+        if (timer.hourly_hours) {
+            timerData[timerIdx].hourly = timer.hourly_hours.split(',').map(String);
+        }
+    }
+    return timerData;
+}
+
+export function watcherRecordToJson(data) {
+    let dataJson = [];
+    data.map(timer => {
+        let watcherIdx = (dataJson) ? dataJson.findIndex(value => value._id == timer.watcher_id) : -1;
+
+        if (watcherIdx > -1) {
+            addTimer(timer, dataJson[watcherIdx].timer);
+        } else {
+            dataJson.push({
+                _id: parseInt(timer.watcher_id),
+                companyObjectId: timer.company_id,
+                timer: []
+            })
+
+            watcherIdx = dataJson.length - 1;
+            addTimer(timer, dataJson[watcherIdx].timer);
+        }
+    })
+
+    return dataJson;
+}

package/scheduler/datalib.js

@@ -0,0 +1,200 @@
+import { map, throttleTime, of, timeout } from "rxjs";
+import { Axios } from 'axios-observable';
+import { insertHistory } from "./watcherController.js";
+
+// let BIZA_SERVER_LINK;
+
+// // if ((process.env.NODE_ENV == undefined) || (process.env.NODE_ENV == 'development')) {
+// if ((MODE == undefined) || (MODE == 'development')) {
+//     BIZA_SERVER_LINK = envDev.BIZA_SERVER_LINK;
+// } else {
+//     BIZA_SERVER_LINK = env.BIZA_SERVER_LINK;
+// };
+
+function mapData2Key(res, cols) {
+    return res.map(e => {
+        return cols.reduce((o, k) => {
+            o[k.key ? k.key : k.data] = e[k.data]
+            return o;
+        }, {})
+    })
+}
+
+function hex2a(hexx) {
+    let hex = hexx.toString();//force conversion
+    let str = '';
+    for (let i = 0; i < hex.length; i += 2)
+        str += String.fromCharCode(parseInt(hex.slice(i, i + 2), 16));
+    return str;
+}
+
+function deserialise(key, data) {
+    if (data instanceof Array && data[0] == 'window.Function') {
+        let f = Function(data[1], data[2].join("\r\n"));
+        return f;
+    } else {
+        return data;
+    }
+};
+
+function getUrlApi(config, methodName, isPost = true) {
+    return `${config.API_URL}/fina/rest/TOrmMethod/` +
+        `${isPost ? '%22' : ''}${methodName}${isPost ? '%22' : ''}`
+}
+
+function json2Parameters(obj) {
+    return JSON.stringify(
+        {
+            _parameters: obj.map((el) => JSON.stringify(el))
+        }
+    );
+}
+
+function getUrlAndParam(config, method, obj, path) {
+    return {
+        url: getUrlApi(config, path),
+        params: json2Parameters([
+            {
+                dbIndex: config.dbindex,
+                method: method,
+                object: obj
+            }
+        ])
+    }
+}
+
+// export function getSelectedCompConfig(companyName) {
+//     const url = `${BIZA_SERVER_LINK}/config/%22getSelectedCompConfig%22`;
+//     const param = { companyName };
+
+//     return Axios.post(url, param).pipe(
+//         map(res => res.data?.data ? JSON.parse(res.data.data) : res.data)
+//     )
+// }
+
+export function queryData(param, apiConfig, mapField) {
+    const defaultParam = {
+        start: 0, length: -1, order: [], filter: [], columns: []
+    };
+
+    const { url, params } = getUrlAndParam(
+        apiConfig,
+        'list',
+        { ...defaultParam, ...param },
+        'list'
+    );
+
+    const options = {
+        headers: { 'content-type': 'text/plain' },
+        params: { subdomain: apiConfig.subdomain }
+    }
+
+    return Axios.post(url, params, options).pipe(
+        // tap(res=>console.log(res, 'res')),
+        map(res => res.data?.data ? JSON.parse(res.data.data) : res.data),
+        map(res => {
+            if (!mapField || res.error) return res;
+            return mapData2Key(res, param.columns)
+        })
+    )
+}
+
+export function crudData(param, apiConfig, method, path) {
+    const { url, params } = getUrlAndParam(
+        apiConfig,
+        method,
+        { ...param },
+        path
+    );
+
+    const options = {
+        headers: { 'content-type': 'text/plain' },
+        params: { subdomain: apiConfig.subdomain }
+    }
+
+    return Axios.post(url, params, options).pipe(
+        map(res => res.data?.data ? JSON.parse(res.data.data) : res.data),
+    )
+}
+
+export function genId(apiConfig, genName) {
+    const url = `${getUrlApi(apiConfig, 'genId', false)}/${genName}/${apiConfig.dbindex}`;
+    const options = {
+        headers: { 'content-type': 'text/plain' },
+        params: { subdomain: apiConfig.subdomain }
+    }
+    return Axios.get(url, options).pipe(
+        map(res => res.data?.data ? JSON.parse(res.data.data) : res.data),
+    )
+}
+
+export function extractFunctionScript(data) {
+    if (data.error) {
+        console.log(data.error, 'error')
+        return
+    }
+    if (data.length == 0) return
+    let hex = JSON.parse(hex2a(data[0].template))
+    //sementara ke template dahulu
+    // let hex = JSON.parse(hex2a(data[0].script))
+
+    if (!hex.functions) return
+    return JSON.parse(JSON.stringify(hex.functions), deserialise)
+}
+
+export function getQueryDataObsParameters(trigger) {
+    return {
+        length: 1,
+        // filter: [{ junction: '', column: 'FILENAME', operator: '=', value1: `'${trigger.filename}'` }],
+        filter: [{ junction: '', column: 'FILENAME', operator: '=', value1: `'cekUser.js'` }],
+        columns: [{ data: "TEMPLATE.TEMPLATE", key: 'template' }]
+
+        //sementara ke template dahulu
+        // filter: [{ junction: '', column: 'ID', operator: '=', value1: `${trigger.scriptId}` }],
+        // columns: [{ data: "SYS$CLI_SCRIPT.SCRIPT", key: 'script' }]
+    }
+}
+
+export function queryDataObservable(config, trigger) {
+    let param = getQueryDataObsParameters(trigger);
+
+    return queryData(param, config, true);
+}
+
+export function getConfig(config) {
+    return (Array.isArray(config)) ? config[0] : config;
+}
+
+export function loadCliScript(selectedConfig, trigger) {
+    const config = getConfig(selectedConfig);
+
+    return queryDataObservable(config, trigger).pipe(
+        // throttleTime(100)
+    )
+}
+
+export function scheduleSubscription(config, data, trigger, needSetHistory, isTest = false) {
+    try {
+        let functions = extractFunctionScript(data);
+        if (!isTest) {  // next, change isTest to test better
+            functions.onInit(config, trigger.data);
+        }
+
+        if (needSetHistory) {
+            insertHistory(config, trigger._id, new Date());
+            console.log(`Run Recent Schedule : ${trigger.name}`);
+        } else {
+            console.log(`Run Schedule : ${trigger.name}`);
+        }
+    } catch (error) {
+        console.error(error);
+        throw new Error(error);
+    }
+}
+
+export function checkSchedule(selectedConfig, trigger, needSetHistory) {
+    loadCliScript(selectedConfig, trigger).subscribe({
+        next: data => scheduleSubscription(selectedConfig, data, trigger, needSetHistory),
+        error: error => console.log(error.response.data || error)
+    })
+}

package/scheduler/timer.js

@@ -0,0 +1,83 @@
+import { checkSchedule } from "./datalib.js"
+import { getWatchers, getHistories } from "./watcherController.js";
+import { isItTime, loopTimer } from "./watcherlib.js"
+import { setInterval } from 'timers/promises';
+import { getCompanyObjectId, getSelectedConfig } from "../scheduler/configController.js";
+import { forkJoin } from 'rxjs';
+import { historyRecordToJson, watcherRecordToJson } from "./converter.js";
+
+
+export const delay = ms => new Promise(res => setTimeout(res, ms));
+export const SCHEDULE_INTERVAL = 60000;
+
+export function increaseInterval(latestRun) {
+    const addInterval = new Date(latestRun).getMilliseconds() + SCHEDULE_INTERVAL;
+    return new Date(latestRun).setMilliseconds(addInterval);
+}
+
+export function getSelectedData(data, field, compareData) {
+    return data.find(element => {
+        return element[field].toString() == compareData.toString();
+    })
+}
+
+async function executeHistory(config, timer, history, currentTime) {
+    let latestRun = new Date(history.latestRun);
+
+    while ((latestRun < currentTime) &&
+        ((currentTime - latestRun) >= SCHEDULE_INTERVAL)) {
+        if (isItTime(timer, latestRun)) {
+            checkSchedule(config, timer, false);
+            await delay(1000);
+        }
+
+        latestRun = increaseInterval(latestRun);
+    }
+}
+
+export async function runHistory(histories, config, watchers, now) {
+    const currentTime = new Date(now);
+
+    for (const watcher of watchers) {
+        for (const timer of watcher.timer) {
+            const history = getSelectedData(histories, 'timerObjectId', timer._id);
+            if (history) {
+                await executeHistory(config, timer, history, currentTime)
+            }
+        }
+    }
+}
+
+
+export const runScheduler = async (companyName) => {
+    await delay(30000);
+
+    const company = await getCompanyObjectId(companyName);
+    const config = await getSelectedConfig(company._id);
+
+    forkJoin([getHistories(config[0]), getWatchers(config[0])]).subscribe({
+        next: ([historyResult, watcherResult]) => {
+            
+            const histories = historyRecordToJson(historyResult);
+            const watchers = watcherRecordToJson(watcherResult);
+            runHistory(histories, config[0], watchers, new Date());
+        }
+    });
+
+
+    for await (const startTime of setInterval(SCHEDULE_INTERVAL, Date.now())) {
+        // if ((now - startTime) > 1000)
+        //     break;
+
+        getWatchers(config[0]).subscribe({
+            next: result => {
+                const watchers = watcherRecordToJson(result);
+                for (const watcher of watchers) {
+                    loopTimer(watcher.timer, Date.now(), config[0], true);
+                }
+            }
+        });
+
+        // // reload == true ?
+    }
+}

package/scheduler/watcherController.js

@@ -0,0 +1,105 @@
+import { from, tap } from 'rxjs';
+import { concatMap, map, catchError } from 'rxjs/operators';
+
+import { crudData, genId, queryData } from '../scheduler/datalib.js';
+
+//LIST
+export function getWatcherParameters(watcherFilter) {
+    return {
+        // filter: [{ junction: '', column: 'COMPANY_OBJ_ID', operator: '=', value1: `'${watcherFilter?.companyObjectId}'` }],
+        columns: [
+            { data: "SYS$WATCHER.ID", key: 'watcher_id' },
+            { data: "SYS$WATCHER.COMPANY_OBJ_ID", key: 'company_id' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.ID", key: 'timer_id' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.WATCHER_ID", key: 'timer_watcher_id' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.NAME", key: 'name' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.ACTIVE", key: 'active' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.TIME_ZONE", key: 'timezone' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.SCRIPT_NAME", key: 'templateName' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.SEQ", key: 'seq' },
+            { data: "SYS$WATCHER.ID.WATCHER_ID.SYS$TIMER.SCRIPT_ID", key: 'scriptId' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$DAILY.DAYS", key: 'daily_days' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$WEEKLY.ORDINAL", key: 'weekly_ordinal' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$WEEKLY.DAYS", key: 'weekly_days' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$MONTHLY.DAYS", key: 'monthly_days' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$MINUTELY.EVERYMIN", key: 'minutely_everymin' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$MINUTELY.TIME_FROM", key: 'minutely_time_from' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$MINUTELY.TIME_TO", key: 'minutely_time_to' },
+            { data: "SYS$TIMER.ID.TIMER_ID.SYS$HOURLY.HOURS", key: 'hourly_hours' },
+            { data: "SYS$TIMER.SCRIPT_ID.ID.SYS$CLI_SCRIPT.SCRIPT", key: 'cli_script' }
+        ]
+    }
+}
+
+export function getWatchers(config, watcherFilter) {
+    let param = getWatcherParameters(watcherFilter);
+    return queryData(param, config, true, 'list', 'list');
+}
+
+
+//HISTORY
+export function getInsertHistoryParameters(timerObjectId) {
+    return {
+        filter: [{
+            junction: '',
+            column: 'TIMER_ID',
+            operator: '=',
+            value1: `'${timerObjectId}'`
+        }],
+        columns: [
+            { data: "HISTORY.ID", key: 'history_id' },
+        ]
+    }
+}
+
+export function formatDate2API(oriDate) {
+    return oriDate.replace('T', ' ').replace('Z', '');
+}
+
+export function getHistoryField(timerObjectId, historyId, currentDate) {
+    return {
+        SYS$HISTORY: {
+            ID: historyId,
+            TIMER_ID: parseInt(timerObjectId),
+            LATEST_RUN: formatDate2API(new Date(currentDate).toISOString())
+        }
+    }
+}
+
+export function insertHistory(config, timerObjectId, currentDate) {
+    const listData = getInsertHistoryParameters(timerObjectId);
+
+    queryData(listData, config, true, 'list', 'list')
+    // return queryData(listData, config, true, 'list', 'list')
+        .pipe(
+            concatMap(historyResponse => {
+                const history = historyResponse[0];
+
+                return history ? from([parseInt(history.history_id)]) : genId(config, 'SYS$HISTORY_ID_GEN');
+            }),
+            map(historyId => {
+                return getHistoryField(timerObjectId, historyId, currentDate);
+            }),
+            concatMap(param => crudData(param, config, 'put', 'orm')),
+            catchError(error => {
+                console.error(error);
+                return new Error(error);
+            })
+        // )
+        ).subscribe();
+}
+
+export function getHistoryParameters(timerObjectId) {
+    return {
+        columns: [
+            { data: "SYS$HISTORY.ID", key: 'history_id' },
+            { data: "SYS$HISTORY.TIMER_ID", key: 'timer_id' },
+            { data: "SYS$HISTORY.LATEST_RUN", key: 'latest_run' }
+        ]
+    }
+}
+
+export function getHistories(config, timerObjectId) {
+    let param = getHistoryParameters(timerObjectId);
+    return queryData(param, config, true, 'list', 'list');
+}