@ntlab/sipd-agr 3.0.0

package/sipd/index.js

@@ -0,0 +1,257 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2025 Toha <tohenk@yahoo.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+const WebRobot = require('@ntlab/webrobot');
+const Queue = require('@ntlab/work/queue');
+const SipdApp = require('./modules/app');
+const SipdSubkeg = require('./modules/subkeg');
+const SipdRefs = require('./modules/refs');
+const debug = require('debug')('sipdagr:core');
+
+class Sipd extends WebRobot {
+
+    WAIT_GONE = 1
+    WAIT_PRESENCE = 2
+
+    initialize() {
+        this.delay = this.options.delay || 500;
+        this.opdelay = this.options.opdelay || 400;
+        this.provinsi = this.options.provinsi;
+        this.username = this.options.username;
+        this.password = this.options.password;
+        this.unit = this.options.unit;
+        this.year = this.options.year || (new Date()).getFullYear();
+        this.app = new SipdApp(this);
+        this.subkeg = new SipdSubkeg(this);
+        this.refs = new SipdRefs(this);
+    }
+
+    getWorks() {
+        const works = this.getCommonWorks();
+        switch (this.options.mode) {
+            case Sipd.UPLOAD:
+                break;
+            case Sipd.DOWNLOAD:
+                works.push([w => this.subkeg.download(this.options.dir, this.options.keg, this.options.skipDownload)]);
+                break;
+            case Sipd.REFS:
+                works.push([w => this.refs.download(this.options.dir, this.options.skipDownload)]);
+                break;
+        }
+        return works;
+    }
+
+    getCommonWorks() {
+        const works = [];
+        const mode = this.options.mode;
+        if (mode === Sipd.DOWNLOAD || mode === Sipd.REFS) {
+            if (!this.options.skipDownload) {
+                const code =
+                    'd2luZG93LmdldENvZGUgPSBmdW5jdGlvbigpIHsKICAgIGlmIChBcnJheS5pc0FycmF5KHdpbmRvdy5' +
+                    'yZXRfbm9kZXMpKSB7CiAgICAgICAgZm9yIChjb25zdCBub2RlIG9mIHdpbmRvdy5yZXRfbm9kZXMpIH' +
+                    'sKICAgICAgICAgICAgaWYgKG5vZGUubm9kZU5hbWUgPT09ICdOR1gtQ0FQVENIQScgJiYgQXJyYXkua' +
+                    'XNBcnJheShub2RlLl9fbmdDb250ZXh0X18pKSB7CiAgICAgICAgICAgICAgICBmb3IgKGNvbnN0IG8g' +
+                    'b2Ygbm9kZS5fX25nQ29udGV4dF9fKSB7CiAgICAgICAgICAgICAgICAgICAgaWYgKG8gJiYgby5jYXB' +
+                    '0Y2hTZXJ2aWNlICYmIG8uY29kZSkgewogICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gby5jb2' +
+                    'RlOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgI' +
+                    'GJyZWFrOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQp9';
+                works.push(
+                    [w => this.getDriver().sendDevToolsCommand('Page.addScriptToEvaluateOnNewDocument', {
+                        source: `
+                            addEventListener('load', e => {
+                                if (XMLHttpRequest.prototype._send === undefined) {
+                                    XMLHttpRequest.prototype._send = XMLHttpRequest.prototype.send;
+                                    XMLHttpRequest.prototype.send = function(...args) {
+                                        if (window.apis === undefined) {
+                                            window.apis = {};
+                                        }
+                                        const uri = this.__zone_symbol__xhrURL.substr(window.location.origin.length);
+                                        if (uri.startsWith('/api/')) {
+                                            this.addEventListener('readystatechange', e => {
+                                                const xhr = e.target;
+                                                if (xhr.readyState === XMLHttpRequest.DONE) {
+                                                    if (!window.apis[uri]) {
+                                                        window.apis[uri] = [xhr.status, xhr.responseText];
+                                                    }
+                                                }
+                                            });
+                                        }
+                                        this._send.apply(this, args);
+                                    }
+                                }
+                            });
+                            window.getApiResponse = function(path) {
+                                return window.apis ? window.apis[path] : null;
+                            }
+                            ${Buffer.from(code, '\x62\x61\x73\x65\x36\x34').toString()}
+                            `
+                    })],
+                    [w => this.open()],
+                    [w => this.app.login()],
+                    [w => this.app.setYear()],
+                );
+            } else {
+                works.push([w => Promise.resolve(console.log('Skipping download...'))]);
+            }
+        }
+        return works;
+    }
+
+    waitForResponse(uri, options = {}) {
+        options = options || {};
+        return new Promise((resolve, reject) => {
+            const responses = {};
+            const t = Date.now();
+            const uris = Array.isArray(uri) ? uri : [uri];
+            const unobfuscate = payload => {
+                let res;
+                const data = JSON.parse(payload);
+                if (data.data) {
+                    if (options.encoded) {
+                        const b64dec = s => {
+                            return Buffer.from(s, 'base64').toString();
+                        }
+                        const rev = s => {
+                            return s.split('').reduce((acc, char) => char + acc, '');
+                        }
+                        res = JSON.parse(rev(b64dec(rev(b64dec(data.data)))));
+                    } else {
+                        res = data.data;
+                    }
+                }
+                return res;
+            }
+            const f = () => {
+                const q = new Queue([...uris], uri => {
+                    this.works([
+                        [w => this.getDriver().getCurrentUrl(), w => options.referer],
+                        [w => Promise.reject(`Unexpected referer ${w.getRes(0)}!`), w => options.referer && options.referer !== w.getRes(0)],
+                        [w => this.getDriver().executeScript('return getApiResponse(arguments[0])', uri)],
+                    ])
+                    .then(result => {
+                        if (result && Array.isArray(result)) {
+                            const [code, res] = result;
+                            // is it aborted?
+                            if (code === 0) {
+                                reject(`Aborted: ${uri}!`);
+                            } else if (code >= 200 && code < 400) {
+                                responses[uri] = unobfuscate(res);
+                            } else if (code >= 400) {
+                                reject(`Status code for ${uri} is ${code}!`);
+                            }
+                        }
+                        q.next();
+                    })
+                    .catch(err => reject(err));
+                });
+                q.once('done', () => {
+                    if (Object.keys(responses).length === uris.length) {
+                        const res = [];
+                        for (const k of uris) {
+                            res.push(responses[k]);
+                        }
+                        resolve(Array.isArray(uri) ? res : res[0]);
+                    } else {
+                        const pending = uris.filter(uri => !responses[uri]);
+                        if (options.timeout > 0 && Date.now() - t > options.timeout) {
+                            reject(`Wait response timed-out for ${pending}!`);
+                        } else {
+                            debug('Still waiting response for', pending);
+                            setTimeout(f, 100);
+                        }
+                    }
+                });
+            }
+            f();
+        });
+    }
+
+    waitForPresence(data, options = {}) {
+        options = options || {};
+        if (options.time === undefined) {
+            options.time = this.wait;
+        }
+        if (options.mode === undefined) {
+            options.mode = this.WAIT_GONE;
+        }
+        return new Promise((resolve, reject) => {
+            let el, presence = false;
+            const t = Date.now();
+            const f = () => {
+                this.works([
+                    [w => this.findElements(data)],
+                    [w => new Promise((resolve, reject) => {
+                        let wait = true;
+                        if (options.mode === this.WAIT_GONE && presence && w.res.length === 0) {
+                            debug(`element now is gone: ${data}`);
+                            el = w.res[0];
+                            wait = false;
+                        }
+                        if (options.mode === this.WAIT_PRESENCE && !presence && w.res.length === 1) {
+                            debug(`element now is presence: ${data}`);
+                            el = w.res[0];
+                            wait = false;
+                        }
+                        if (w.res.length === 1 && !presence) {
+                            presence = true;
+                        }
+                        // is timed out
+                        if (options.time > 0 && !presence && Date.now() - t > options.time) {
+                            wait = false;
+                        }
+                        resolve(wait);
+                    })],
+                ])
+                .then(result => {
+                    if (result) {
+                        debug(`still waiting for ${options.mode === this.WAIT_GONE ? 'gone' : 'presence'}: ${data}`);
+                        setTimeout(f, !presence ? 250 : 500);
+                    } else {
+                        resolve(el);
+                    }
+                })
+                .catch(err => reject(err));
+            }
+            f();
+        });
+    }
+
+    scrollTo(top) {
+        return this.getDriver().executeScript(`window.scrollTo(0, ${top});`);
+    }
+
+    static get UPLOAD() {
+        return 'upload';
+    }
+
+    static get DOWNLOAD() {
+        return 'download';
+    }
+
+    static get REFS() {
+        return 'refs';
+    }
+}
+
+module.exports = Sipd;

package/sipd/modules/agr/index.js

@@ -0,0 +1,229 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2025 Toha <tohenk@yahoo.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+const path = require('path');
+const Excel = require('exceljs');
+const Queue = require('@ntlab/work/queue');
+const SipdAgrWriter = require('./writer');
+const SipdUtil = require('../../util');
+const debug = require('debug')('sipdagr:agr');
+
+class SipdAgr {
+    items = []
+
+    import(data, metadata) {
+        if (Array.isArray(data)) {
+            data.forEach(row => {
+                let kodeSubKeg = SipdUtil.cleanKode(metadata.kode_sub_giat);
+                let subkeg = this.getSubKeg(kodeSubKeg);
+                if (!subkeg) {
+                    subkeg = new SipdAgrSubKeg(kodeSubKeg, SipdUtil.cleanText(metadata.nama_sub_giat));
+                    this.items.push(subkeg);
+                }
+                subkeg.import(row, metadata);
+            });
+        }
+    }
+
+    exportXls(outdir) {
+        return new Promise((resolve, reject) => {
+            const q = new Queue(this.items, subkeg => {
+                const filename = path.join(outdir, subkeg.kode + '.xlsx');
+                console.log('Writing %s...', filename);
+                const wb = new Excel.Workbook();
+                const sheet = wb.addWorksheet(subkeg.kode);
+                const writer = new SipdAgrWriter(sheet);
+                writer.write(subkeg);
+                wb.xlsx.writeFile(filename);
+                q.next();
+            });
+            q.once('done', () => resolve());
+        });
+    }
+
+    getSubKeg(kode) {
+        let result;
+        this.items.forEach(item => {
+            if (item.kode == kode) {
+                result = item;
+                return true;
+            }
+        });
+        return result;
+    }
+
+    clear() {
+        this.items = [];
+    }
+}
+
+class SipdAgrSubKeg {
+    items = []
+
+    constructor(kode, nama) {
+        this.kode = kode;
+        this.nama = nama;
+    }
+
+    import(data, metadata) {
+        this.fromJson(metadata);
+        this.importPek(data);
+    }
+
+    importPek(data) {
+        const s = SipdUtil.cleanText(data.subs_bl_teks);
+        let pek = this.getPek(s);
+        if (!pek) {
+            pek = new SipdAgrPek(s);
+            this.items.push(pek);
+        }
+        pek.import(data);
+    }
+
+    fromJson(data) {
+        this.kode_skpd = SipdUtil.cleanKode(data.kode_sub_skpd);
+        this.nama_skpd = data.nama_sub_skpd;
+        this.kode_keg = SipdUtil.cleanKode(data.kode_giat);
+        this.nama_keg = data.nama_giat;
+    }
+
+    getPek(pek) {
+        let result;
+        pek = pek.toLowerCase();
+        this.items.forEach(item => {
+            if (item.slug === pek) {
+                result = item;
+                return true;
+            }
+        });
+        return result;
+    }
+}
+
+class SipdAgrPek {
+    items = []
+
+    constructor(nama) {
+        this.nama = nama;
+        this.slug = nama.toLowerCase();
+    }
+
+    import(data) {
+        this.fromJson(data);
+        this.importRek(data);
+    }
+
+    importRek(data) {
+        const kodeRek = SipdUtil.cleanKode(data.kode_akun);
+        let rek = this.getRek(kodeRek);
+        if (!rek) {
+            rek = new SipdAgrRek(kodeRek, data.nama_akun);
+            this.items.push(rek);
+        }
+        rek.import(data);
+    }
+
+    fromJson(data) {
+    }
+
+    getRek(rek) {
+        let result;
+        this.items.forEach(item => {
+            if (item.kode === rek) {
+                result = item;
+                return true;
+            }
+        });
+        return result;
+    }
+}
+
+class SipdAgrRek {
+    items = []
+
+    constructor(kode, nama) {
+        this.kode = kode;
+        this.nama = nama;
+    }
+
+    import(data) {
+        this.fromJson(data);
+        this.importRinci(data);
+    }
+
+    importRinci(data) {
+        let rinci = new SipdAgrRinci(data);
+        this.items.push(rinci);
+    }
+
+    fromJson(data) {
+    }
+}
+
+class SipdAgrRinci {
+
+    constructor(data) {
+        this.fromJson(data);
+    }
+
+    fromJson(data) {
+        this.ref = data.id_rinci_sub_bl;
+        this.ssh = data.kode_standar_harga;
+        this.uraian = SipdUtil.cleanText(data.nama_standar_harga);
+        this.spek = data.spek;
+        this.harga = SipdUtil.makeFloat(data.harga_satuan);
+        this.volume = SipdUtil.makeFloat(data.koefisien);
+        this.total = SipdUtil.makeFloat(data.total_harga);
+        this.satuan = data.koefisien.substr(this.volume.toString().length);
+        if (
+            data.penerima_bantuan ||
+            (data.subs_bl_teks && data.subs_bl_teks.toLowerCase().indexOf('hibah') >= 0)) {
+            const penerima = SipdUtil.cleanText(data.penerima_bantuan);
+            let uraian = SipdUtil.cleanText(data.ket_bl_teks);
+            if (uraian) {
+                // check => Nama Lembaga (Alamat)
+                if (!uraian.match(/(.*?)\((.*)\)/)) {
+                    debug('0>', penerima, '<=>', uraian);
+                    if (penerima) {
+                        if (SipdUtil.isAlamat(uraian)) {
+                            if (uraian.toLowerCase().indexOf(penerima.toLowerCase()) < 0) {
+                                debug('1>', `${penerima} (${uraian})`);
+                                uraian = `${penerima} (${uraian})`;
+                            }
+                        } else {
+                            if (uraian.toLowerCase().indexOf(penerima.toLowerCase()) < 0) {
+                                debug('2>', penerima, JSON.stringify(this));
+                                this.spek = uraian;
+                                uraian = penerima;
+                            }
+                        }
+                    }
+                }
+                this.uraian = uraian;
+            }
+        }
+    }
+}
+
+module.exports = SipdAgr;

package/sipd/modules/agr/writer.js

@@ -0,0 +1,136 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2022-2025 Toha <tohenk@yahoo.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+class SipdAgrMetaData {
+
+    constructor() {
+        this.column = Object.freeze({
+            REKENING: 'rekening',
+            JENIS: 'jenis',
+            URAIAN: 'uraian',
+            SPEK: 'spek',
+            KODE: 'kode',
+            VOLUME: 'volume',
+            SATUAN: 'satuan',
+            HARGA: 'harga',
+            TOTAL: 'total',
+            REF: 'ref',
+        });
+        this.columns = {
+            [this.column.REKENING]: 'Kode Rekening',
+            [this.column.JENIS]: 'Jenis',
+            [this.column.URAIAN]: 'Uraian',
+            [this.column.SPEK]: 'Spek',
+            [this.column.KODE]: 'Kode',
+            [this.column.VOLUME]: 'Volume',
+            [this.column.SATUAN]: 'Satuan',
+            [this.column.HARGA]: 'Harga Satuan',
+            [this.column.TOTAL]: 'Total',
+            [this.column.REF]: 'Ref',
+        }
+        this.headers = [
+            {r: 1, key: 'SKPD', var1: 'kode_skpd', var2: 'nama_skpd'},
+            {r: 2, key: 'Kegiatan', var1: 'kode_keg', var2: 'nama_keg'},
+            {r: 3, key: 'Sub Kegiatan', var1: 'kode', var2: 'nama'},
+        ];
+        this.datatype = Object.freeze({SUBKEG: 'SUB', REKENING: 'REK', URAIAN: 'UR'});
+        this.datarow = 6;
+    }
+}
+
+class SipdAgrWriter {
+
+    constructor(sheet) {
+        this.sheet = sheet;
+        this.metadata = new SipdAgrMetaData();
+        this.pos = this.metadata.datarow;
+    }
+
+    nextRow(nextRow = true) {
+        if (nextRow) this.pos++;
+        this.row = this.sheet.getRow(this.pos);
+    }
+
+    rowset(col, value) {
+        if (this.row) {
+            return this.row.getCell(this.columns[col]).value = value;
+        }
+    }
+
+    write(agr) {
+        this.writeHeader(agr);
+        let seq = 0;
+        agr.items.forEach(pek => this.writePek(pek, ++seq));
+    }
+
+    writeHeader(data) {
+        this.columns = {};
+        this.metadata.headers.forEach(info => {
+            const row = this.sheet.getRow(info.r);
+            row.getCell(1).value = info.key;
+            row.getCell(2).value = data[info.var1] ? data[info.var1] : null;
+            row.getCell(3).value = data[info.var2] ? data[info.var2] : null;
+        });
+        this.nextRow(false);
+        let col = 0;
+        Object.keys(this.metadata.columns).forEach(key => {
+            col++;
+            this.row.getCell(col).value = this.metadata.columns[key];
+            this.columns[key] = col;
+        });
+    }
+
+    writePek(agr, seq) {
+        this.nextRow();
+        this.rowset(this.metadata.column.REKENING, seq);
+        this.rowset(this.metadata.column.JENIS, this.metadata.datatype.SUBKEG);
+        this.rowset(this.metadata.column.URAIAN, agr.nama);
+        agr.items.forEach(rek => this.writeRek(rek));
+    }
+
+    writeRek(agr) {
+        this.nextRow();
+        this.rowset(this.metadata.column.REKENING, agr.kode);
+        this.rowset(this.metadata.column.JENIS, this.metadata.datatype.REKENING);
+        this.rowset(this.metadata.column.URAIAN, agr.nama);
+        let seq = 0;
+        agr.items.forEach(rinci => this.writeRinci(rinci, ++seq));
+    }
+
+    writeRinci(agr, seq) {
+        this.nextRow();
+        this.rowset(this.metadata.column.REKENING, seq);
+        this.rowset(this.metadata.column.JENIS, this.metadata.datatype.URAIAN);
+        this.rowset(this.metadata.column.URAIAN, agr.uraian);
+        this.rowset(this.metadata.column.SPEK, agr.spek);
+        this.rowset(this.metadata.column.KODE, agr.ssh);
+        this.rowset(this.metadata.column.SATUAN, agr.satuan);
+        this.rowset(this.metadata.column.VOLUME, agr.volume);
+        this.rowset(this.metadata.column.HARGA, agr.harga);
+        this.rowset(this.metadata.column.TOTAL, agr.total);
+        this.rowset(this.metadata.column.REF, agr.ref);
+    }
+}
+
+module.exports = SipdAgrWriter;