node-automator 1.0.0

package/commands/date.js

@@ -0,0 +1,25 @@
+const { formatDate } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class DateCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let date = (data && data.date) || new Date();
+        if (typeof date === "string") {
+            date = new Date(date);
+        }
+        if (data) {
+            if (data.offset) {
+                date.setTime(date.getTime() + data.offset);
+            }
+            if (data.format) {
+                date = formatDate(date, data.format);
+            }
+        }
+        return date;
+    }
+}
+
+module.exports = {
+    DateCommand,
+};

package/commands/debugger.js

@@ -0,0 +1,11 @@
+const { BaseCommand } = require("./base");
+
+class DebuggerCommand extends BaseCommand {
+    async execute() {
+        debugger;
+    }
+}
+
+module.exports = {
+    DebuggerCommand,
+};

package/commands/dingtalk.js

@@ -0,0 +1,110 @@
+const {
+    doRequest
+} = require("../utils/request_tool");
+const {
+    BaseCommand
+} = require("./base");
+
+class DingtalkCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let body = {};
+        // 要@的目标
+        body.at = {
+            "atMobiles": data.atMobiles || [],
+            "atUserIds": data.atUserIds || [],
+            "isAtAll": data.isAtAll || false,
+        };
+        let atUserSuffix = "";
+        atUserSuffix += body.at.atMobiles.map(v => `@${v}`).join(" ");
+        // atUserSuffix += body.at.atUserIds.map(v => `@${v}`).join(" ");
+        if (atUserSuffix) {
+            if (data.msgtype && data.msgtype != "text") {
+                atUserSuffix = "\n<font color=#007fff>" + atUserSuffix + "</font>";
+            } else {
+                atUserSuffix = "\n" + atUserSuffix;
+            }
+        }
+        body.msgtype = data.msgtype;
+        switch (data.msgtype) {
+            case "markdown": {
+                body.markdown = {
+                    title: data.title || "",
+                    text: data.content + atUserSuffix,
+                };
+                break;
+            }
+            case "actionCard": {
+                body.actionCard = {
+                    title: data.title || "",
+                    text: data.content + atUserSuffix,
+                };
+                let btns = data.btns || [];
+                if (btns.length) {
+                    if (btns.length == 1) {
+                        body.actionCard.singleTitle = btns[0].title;
+                        body.actionCard.singleURL = btns[0].url;
+                    } else {
+                        body.actionCard.btnOrientation = "1";
+                        body.actionCard.btns = btns.map(v => {
+                            return {
+                                title: v.title,
+                                actionURL: v.url
+                            };
+                        });
+                    }
+                }
+                break;
+            }
+            case 'feedCard': {
+                body.feedCard = {};
+                let btns = data.btns || [];
+                if (btns.length) {
+                    body.feedCard.links = btns.map(v => {
+                        return {
+                            title: v.title,
+                            messageURL: v.url,
+                            picURL: v.image,
+                        };
+                    });
+                }
+                break;
+            }
+            case "text":
+            default: {
+                // content 中必须要有关键词
+                body.text = { content: data.content };
+                break;
+            }
+        }
+        let webhook = data.webhook;
+        // 使用 加签
+        if (data.secret) {
+            let timestamp = Date.now();
+            let str2sign = timestamp + '\n' + data.secret;
+            const sign = encodeURIComponent(require("crypto").createHmac('sha256', data.secret).update(str2sign).digest('base64'));
+            webhook += `&timestamp=${timestamp}&sign=${sign}`;
+        }
+        let ret = await doRequest({
+            target: {
+                url: webhook,
+            },
+            options: {
+                method: 'POST',
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                json: body,
+            },
+        });
+        return ret;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    DingtalkCommand,
+};

package/commands/disassemble.js

@@ -0,0 +1,36 @@
+const {
+    BaseCommand
+} = require("./base");
+
+class DisassembleCommand extends BaseCommand {
+    async execute() {
+        let delimiter = this.selfData.delimiter;
+        if (delimiter) {
+            delimiter = new RegExp(delimiter);
+        }
+        let props = this.selfData.props;
+        if (delimiter && typeof props === "string") {
+            props = props.split(delimiter);
+        }
+        let num_item = this.content.length;
+        return props.map((prop, prop_index) => {
+            return this.content.map(v => {
+                return v[prop];
+            });
+        });
+    }
+
+    getRequiredParams() {
+        return [
+            'props'
+        ];
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    DisassembleCommand,
+};

package/commands/divination.js

@@ -0,0 +1,15 @@
+const { generateAndParseDiagram, searchDiagram } = require("../utils/divination_util");
+const { BaseCommand } = require("./base");
+
+class DivinationCommand extends BaseCommand {
+    async execute() {
+        if (this.selfData?.name) {
+            return searchDiagram(this.selfData?.name);
+        }
+        return generateAndParseDiagram(this.selfData?.raw);
+    }
+}
+
+module.exports = {
+    DivinationCommand,
+};

package/commands/download.js

@@ -0,0 +1,12 @@
+const { doRequest } = require("../utils/request_tool");
+const { BaseCommand } = require("./base");
+
+class DownloadCommand extends BaseCommand {
+    async execute() {
+        return await doRequest(this.selfData);
+    }
+}
+
+module.exports = {
+    DownloadCommand,
+};

package/commands/edit.js

@@ -0,0 +1,83 @@
+const { warn } = require("../utils/log_tool");
+const { format, toArray } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class EditCommand extends BaseCommand {
+    async execute() {
+        let content = this.content;
+        /**
+         * @type { {type: string, data: any}[] }
+         */
+        let actions = this.selfData.actions;
+        if (typeof actions === "string") {
+            // delete group,update group 6599,update ios_pay true,delete ios_pay
+            actions = actions.split(",").filter(Boolean).map(action => {
+                let hashIdx = action.indexOf("#");
+                let desc = "";
+                if (hashIdx >= 0) {
+                    desc = action.substring(hashIdx + 1);
+                    action = action.substring(0, hashIdx);
+                } else {
+                    desc = action;
+                }
+                let [type, prop, val] = action.split(" ");
+                switch(type) {
+                    case "delete": {
+                        return  { type, desc, data: { [prop]: true } };
+                    }
+                    case "update": { 
+                        return { type, desc, data: { [prop]: eval(val) } }; 
+                    }
+                }
+            }).filter(v => v);
+        }
+        actions.forEach(action => {
+            let actionType = action.type;
+            let actionData = action.data;
+            let actionDesc = action.desc;
+            switch (actionType) {
+                case "delete": {
+                    if (actionData instanceof Array) {
+                        actionData.forEach(key => {
+                            delete content[key];
+                        });
+                    } else if (typeof actionData === "object") {
+                        Object.keys(actionData).forEach(key => {
+                            if (actionData[key]) {
+                                delete content[key];
+                            }
+                        });
+                    } else {
+                        warn(`未支持的 edit - delete 参数`);
+                    }
+                    break;
+                }
+                case "update": {
+                    for (let key in actionData) {
+                        content[key] = actionData[key];
+                    }
+                    break;
+                }
+                default: {
+                    warn(`未支持的 edit 类型 ${actionType}`);
+                    break;
+                }
+            }
+        });
+        return actions;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+
+    getRequiredParams() {
+        return [
+            "actions",
+        ];
+    }
+}
+
+module.exports = {
+    EditCommand,
+};

package/commands/edit_excel.js

@@ -0,0 +1,57 @@
+const { warn } = require("../utils/log_tool");
+const { format, toArray } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class EditExcelCommand extends BaseCommand {
+    async execute() {
+        const Excel = require("exceljs");
+        /**
+         * @type {Excel.Workbook}
+         */
+        let workbook = this.content;
+        /**
+         * @type { {type: string, data: any}[] }
+         */
+        let actions = this.selfData.actions;
+        actions.forEach(action => {
+            let data = action.data;
+            switch (action.type) {
+                case "insert_row": {
+                    let sheet = workbook.getWorksheet(data.sheet ?? 1);
+                    let row = data.row ?? 0;
+                    if (row < 1) {
+                        row = sheet.rowCount + 1 + row;
+                    }
+                    sheet.insertRow(row, data.value);
+                    break;
+                }
+                case "modify": {
+                    let sheet = workbook.getWorksheet(data.sheet ?? 1);
+                    let cell = sheet.getCell(data.cell);
+                    if (cell) {
+                        cell.value = data.value;
+                    }
+                    break;
+                }
+                default: {
+                    warn(`未支持的 edit_excel 类型 ${action.type}`);
+                    break;
+                }
+            }
+        });
+    }
+
+    getRequireContent() {
+        return true;
+    }
+
+    getRequiredParams() {
+        return [
+            "actions",
+        ];
+    }
+}
+
+module.exports = {
+    EditExcelCommand,
+};

package/commands/env_optional.js

@@ -0,0 +1,57 @@
+const { decode } = require('../utils/base64_tool');
+const { info } = require('../utils/log_tool');
+const { parse } = require('../utils/parse_tool');
+const { BaseCommand } = require("./base");
+
+class EnvOptionalCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let updatedData = {};
+        for (let k in data) {
+            const envVal = this.shareData.ENV[k];
+            let defValue = data[k];
+            if (defValue == null) {
+                defValue = "";
+            }
+            if (envVal == null) {
+                updatedData[k] = defValue;
+            } else {
+                let toType = typeof defValue;
+                switch(toType) {
+                    case 'string': {
+                        updatedData[k] = envVal;
+                        break;
+                    }
+                    case 'number': {
+                        updatedData[k] = parseFloat(envVal);
+                        break;
+                    }
+                    case 'boolean': {
+                        if (envVal && envVal !== "false" && envVal !== "0") {
+                            updatedData[k] = true;
+                        } else {
+                            updatedData[k] = false;
+                        }
+                        break;
+                    }
+                    case 'object': {
+                        updatedData[k] = await parse(envVal, "yaml");
+                        break;
+                    }
+                    default: {
+                        throw `unsupport type ${toType}`;
+                        break;
+                    }
+                }
+            }
+        }
+        for (let k in updatedData) {
+            this.shareData[k] = updatedData[k];
+        }
+        return updatedData;
+    }
+}
+
+module.exports = {
+    EnvOptionalCommand,
+};

package/commands/eval.js

@@ -0,0 +1,27 @@
+const { eval_code } = require("./share_data");
+const { whisper, vital, getPrint, warn, error } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class EvalCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let code = data && data.code;
+        try {
+            let result = eval_code(code);
+            return result;
+        } catch (err) {
+            // warn(getPrint(data, true));
+            throw err;
+        }
+    }
+
+    getRequiredParams() {
+        return [
+            'code',
+        ];
+    }
+}
+
+module.exports = {
+    EvalCommand,
+};

package/commands/exec_from_file.js

@@ -0,0 +1,31 @@
+const { get_file_list, read_cfg, get_fst_file } = require("../utils/file_tool");
+const { whisper, info, warn, success, vital } = require("../utils/log_tool");
+const { toArray } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class ExecFromFileCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = this.content;
+        let srcs = toArray(data.src);
+        for (let i = 0; i < srcs.length; i++) {
+            let src = srcs[i];
+            src = get_fst_file(src);
+            if (!src) {
+                throw (`配置文件未找到 ${srcs[i]}`);
+            }
+            if (!data.force && this.globalData.executed_cfg.includes(src)) {
+                info(`不执行重复配置 ${src}`);
+                continue;
+            }
+            info(`执行配置文件 ${src}`);
+            this.globalData.executed_cfg.push(src);
+            let cfg = await read_cfg(src, data.type);
+            await this.exec(cfg, this.depth + 1);
+        }
+    }
+}
+
+module.exports = {
+    ExecFromFileCommand,
+};

package/commands/export_diff_head.js

@@ -0,0 +1,31 @@
+const { vital } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class ExportDiffHeadCommand extends BaseCommand {
+    async execute() {
+        switch (this.selfData.type) {
+            case 'svn': {
+                return await this.forward('svn_export_diff_head');
+                break;
+            }
+            case 'git': {
+                return await this.forward('git_export_diff_head');
+                break;
+            }
+            default: {
+                throw (`不支持的类型 ${this.selfData.type}`);
+                break;
+            }
+        }
+    }
+
+    getRequiredParams() {
+        return [
+            "type",
+        ];
+    }
+}
+
+module.exports = {
+    ExportDiffHeadCommand,
+};

package/commands/file_info.js

@@ -0,0 +1,41 @@
+const { get_fst_file } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+const path = require("path");
+const fs = require("fs");
+const sizeOf = require('image-size');
+
+class FileInfoCommand extends BaseCommand {
+    async execute() {
+        let file = get_fst_file(this.selfData.src);
+        if (!file) {
+            return null;
+        }
+        let dimensions;
+        try {
+           dimensions = sizeOf(file);
+        } catch (err) {
+            
+        }
+        let stat = fs.statSync(file);
+        let ret = {
+            fullpath: file,
+            extname: path.extname(file),
+            basename: path.basename(file),
+            basename_noext: path.basename(file, path.extname(file)),
+            dirname: path.dirname(file),
+            isDirectory: stat.isDirectory(),
+            isFile: stat.isFile(),
+            atime: stat.atime,
+            mtime: stat.mtime,
+            ctime: stat.ctime,
+            size: stat.size,
+            size_kb: +(stat.size / 1024).toFixed(2),
+            dimensions: dimensions,
+        };
+        return ret;
+    }
+}
+
+module.exports = {
+    FileInfoCommand,
+};

package/commands/file_size.js

@@ -0,0 +1,12 @@
+const { get_file_size } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class FileSizeCommand extends BaseCommand {
+    async execute() {
+        return get_file_size(this.selfData.src);
+    }
+}
+
+module.exports = {
+    FileSizeCommand,
+};

package/commands/files.js

@@ -0,0 +1,14 @@
+const { get_file_list } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class FilesCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let ret = get_file_list(data.src, data.no_glob, data.only_file, data.real);
+        return ret;
+    }
+}
+
+module.exports = {
+    FilesCommand,
+};

package/commands/first_exist.js

@@ -0,0 +1,18 @@
+const { get_fst_file } = require("../utils/file_tool");
+const { error, warn, setLastError } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class FirstExistCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let ret = get_fst_file(data.src, data.real, data.noGlob);
+        if (!ret) {
+            setLastError(`未找到文件 ${data.src}`);
+        }
+        return ret;
+    }
+}
+
+module.exports = {
+    FirstExistCommand,
+};

package/commands/flatten.js

@@ -0,0 +1,18 @@
+const { flatten } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class FlattenCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = this.content;
+        return flatten(content);
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    FlattenCommand,
+};