node-automator 1.0.0

package/commands/ftp.js

@@ -0,0 +1,161 @@
+const {
+    BaseCommand
+} = require("./base");
+
+const fs = require("fs");
+const path = require("path");
+const {
+    get_full_path,
+    get_file_list
+} = require("../utils/file_tool");
+const {
+    info
+} = require("../utils/log_tool");
+const {
+    progress
+} = require("../utils/display_tool");
+
+class FtpCommand extends BaseCommand {
+    async execute() {
+        let config = this.selfData.config;
+        let mode = this.selfData.mode;
+        return await new Promise((resolve, reject) => {
+            var Client = require('ftp');
+            var c = new Client();
+            c.on('ready', () => {
+                switch (mode) {
+                    case "VIEW": {
+                        let src = this.selfData.src || "/";
+                        c.list(src, function (err, list) {
+                            if (err) {
+                                throw err;
+                            }
+                            resolve(list);
+                            c.end();
+                        });
+                        break;
+                    }
+                    case "DOWNLOAD": {
+                        let src = this.selfData.src;
+                        let dst = get_full_path(this.selfData.dst);
+                        let remote_dirname = path.dirname(src);
+                        let remote_basename = path.basename(src);
+                        c.list(remote_dirname, function (err, list) {
+                            if (err) {
+                                throw err;
+                            }
+                            const element = list.find((element) => element.name == remote_basename);
+                            if (element) {
+                                let cur = 0,
+                                    total = element.size;
+                                c.get(src, function (err, stream) {
+                                    if (err) {
+                                        throw err;
+                                    }
+                                    stream.on('data', function (d) {
+                                        cur += d.length;
+                                        progress(cur, total, {
+                                            desc: `Downloading from ${src}`,
+                                            depth: 0,
+                                            color: "green",
+                                            align: true,
+                                            format_bytes: true,
+                                        }, true);
+                                    });
+                                    stream.once('close', function () {
+                                        c.end();
+                                        resolve(true);
+                                    });
+                                    stream.pipe(fs.createWriteStream(dst));
+                                });
+                            } else {
+                                reject(`Not found ${src}`);
+                            }
+                        });
+                        break;
+                    }
+                    case "UPLOAD_FILE":
+                    case "UPLOAD": {
+                        let dst = this.selfData.dst;
+                        let src = get_full_path(this.selfData.src);
+                        let readStream = fs.createReadStream(src),
+                            cur = 0,
+                            total = fs.statSync(src).size;
+                        readStream.on('data', function (d) {
+                            cur += d.length;
+                            progress(cur, total, {
+                                desc: `Uploading to ${dst}`,
+                                depth: 0,
+                                color: "green",
+                                align: true,
+                                format_bytes: true,
+                            }, true);
+                        });
+                        c.put(readStream, dst, function (err) {
+                            if (err) {
+                                throw err;
+                            }
+                            c.end();
+                            resolve(true);
+                        });
+                        break;
+                    }
+                    case "UPLOAD_FILES": {
+                        let dst_folder = this.selfData.dst_folder;
+                        let srcs = get_file_list(this.selfData.src, undefined, true);
+                        let base = this.selfData.base;
+                        let numFiles = srcs.length;
+                        if (numFiles) {
+                            let numComplete = 0;
+
+                            function completeOne() {
+                                ++numComplete;
+                                if (numComplete == numFiles) {
+                                    c.end();
+                                    resolve(true);
+                                }
+                            }
+
+                            for (let i = 0; i < numFiles; i++) {
+                                const src = srcs[i];
+                                const dst = path.join(dst_folder, path.relative(base, src));
+                                let readStream = fs.createReadStream(src),
+                                    cur = 0,
+                                    total = fs.statSync(src).size;
+                                readStream.on('data', function (d) {
+                                    cur += d.length;
+                                    let percentageComplete = ((cur / total) * 100).toFixed(1);
+                                    progress(i + (cur / total), numFiles, {
+                                        desc: `Uploading to ${dst} [${percentageComplete}%]`,
+                                        depth: 0,
+                                        color: "green",
+                                        align: true,
+                                    }, true);
+                                });
+                                c.put(readStream, dst, function (err) {
+                                    if (err) {
+                                        throw err;
+                                    }
+                                    completeOne();
+                                });
+                            }
+                        } else {
+                            resolve(true);
+                        }
+                        break;
+                    }
+                    default: {
+                        resolve(false);
+                        break;
+                    }
+                }
+            });
+            // connect to localhost:21 as anonymous
+            c.connect(config);
+        });
+    }
+}
+
+module.exports = {
+    FtpCommand,
+};

package/commands/git_commit.js

@@ -0,0 +1,31 @@
+const { whisper, warn, info } = require("../utils/log_tool");
+const { git_is_dirty, git_commit, git_push } = require("../utils/scm_tool");
+const { toArray } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class GitCommitCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        if (!data.force) {
+            let is_dirty = await git_is_dirty(data.cwd);
+            if (!is_dirty) {
+                whisper(`没有要git提交的更改 ${data.cwd} ${data.msg}`, undefined, true);
+            } else {
+                info(`准备git提交 ${data.cwd} ${data.msg}`);
+                await git_commit(data.cwd, data.msg);
+            }
+        }
+        let pushCfgs = data.push;
+        if (pushCfgs) {
+            pushCfgs = toArray(pushCfgs);
+            for (let i = 0; i < pushCfgs.length; i++) {
+                const pushCfg = pushCfgs[i];
+                await git_push(data.cwd, pushCfg);
+            }
+        }
+    }
+}
+
+module.exports = {
+    GitCommitCommand,
+};

package/commands/git_export_diff_head.js

@@ -0,0 +1,13 @@
+const { git_export_diff_head } = require("../utils/scm_tool");
+const { BaseCommand } = require("./base");
+
+class GitExportDiffHeadCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        await git_export_diff_head(data.cwd, data.dst, data.base, data.options);
+    }
+}
+
+module.exports = {
+    GitExportDiffHeadCommand,
+};

package/commands/git_is_dirty.js

@@ -0,0 +1,13 @@
+const { git_is_dirty } = require("../utils/scm_tool");
+const { BaseCommand } = require("./base");
+
+class GitIsDirtyCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        return await git_is_dirty(data.cwd);
+    }
+}
+
+module.exports = {
+    GitIsDirtyCommand,
+};

package/commands/hash.js

@@ -0,0 +1,21 @@
+const { BaseCommand } = require("./base");
+const fs = require("fs");
+const { get_fst_file } = require("../utils/file_tool");
+const { hash } = require('../utils/hash_tool');
+
+class HashCommand extends BaseCommand {
+    async execute() {
+        let target;
+        if (this.selfData.content) {
+            target = "" + this.selfData.content;
+        } else if (this.selfData.src) {
+            let file = get_fst_file(this.selfData.src);
+            target = fs.readFileSync(file);
+        }
+        return hash(target, this.selfData.algorithm, this.selfData.digestEncoding);
+    }
+}
+
+module.exports = {
+    HashCommand,
+};

package/commands/http_request.js

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

package/commands/image_crop.js

@@ -0,0 +1,19 @@
+const { get_fst_file, get_full_path } = require('../utils/file_tool');
+const { BaseCommand } = require("./base");
+const Jimp = require("jimp");
+
+class ImageCropCommand extends BaseCommand {
+    async execute() {
+        const data = this.selfData;
+        const src = get_fst_file(data.src);
+        const image = await Jimp.read(src);
+        const {x, y, w, h} = data.region;
+        const croped = image.crop(x, y, w, h);
+        const dst = get_full_path(data.dst);
+        await croped.writeAsync(dst);
+    }
+}
+
+module.exports = {
+    ImageCropCommand,
+};

package/commands/input.js

@@ -0,0 +1,37 @@
+const { BaseCommand } = require("./base");
+const { moveCursorLineUp } = require("../utils/interaction_tool");
+const { info, log } = require("../utils/log_tool");
+
+class InputCommand extends BaseCommand {
+    async execute() {
+        const readline = require("readline");
+        let data = this.selfData;
+        const prompt = data && (data.prompt || this.selfCfg.title);
+        const default_value = data && data.default;
+        if (prompt) {
+            info(prompt);
+        }
+        const input = await new Promise(resolve => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: null,
+            });
+            rl.question("", function(input) {
+                info("");
+                resolve(input);
+                rl.close();
+            });
+            
+            rl.on("close", function() {
+
+            });
+        });
+        // 往上移一行
+        moveCursorLineUp(1);
+        return input || default_value || "";
+    }
+}
+
+module.exports = {
+    InputCommand,
+};

package/commands/interval.js

@@ -0,0 +1,60 @@
+const { warn, error, info, success, getPrint } = require('../utils/log_tool');
+const { formatTimeInMillisec, formatDate, convert } = require('../utils/transform_tool');
+const { BaseCommand } = require('./base');
+const { formatData } = require('./share_data');
+
+class IntervalCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let commandCfgs = data.commands;
+        // 特殊处理字符的情况
+        if (typeof commandCfgs === "string") {
+            commandCfgs = formatData(commandCfgs);
+        }
+        let now = Date.now();
+        let asyncId;
+        let delay = convert(data.delay, "millisecond");
+        let repeat = data.repeat || 0;
+        let times = 0;
+        if (data.run_immediately) {
+            warn(`立即执行一次任务`);
+            await this.exec(commandCfgs, this.depth + 1);
+        }
+        // 正在执行任务。（执行中，不能再次发起）
+        let isRunningTask = 0;
+        let timer = setInterval( async () => {
+            if (isRunningTask && !data.concurrent) return;
+            info("");
+            times += 1;
+            if (repeat) {
+                if (times >= repeat) {
+                    clearInterval(timer);
+                }
+            }
+            if (data.repeat_mapping) {
+                this.shareData[data.repeat_mapping] = repeat;
+            }
+            if (data.times_mapping) {
+                this.shareData[data.times_mapping] = times;
+            }
+            warn(`开始执行间隔任务[${asyncId}] (${times}/${repeat || "∞"})`, undefined, undefined, true);
+            isRunningTask++;
+            await this.exec(commandCfgs, this.depth + 1);
+            isRunningTask--;
+        }, delay);
+        asyncId = timer[Object.getOwnPropertySymbols(timer).find(v => v.description == "asyncId")];
+        info("");
+        warn(`将每间隔 ${formatTimeInMillisec(delay, true)} 执行定时任务[${asyncId}] (${times}/${repeat || "∞"})`, undefined, undefined, true);
+    }
+
+    getRequiredParams() {
+        return [
+            "commands",
+            "delay",
+        ];
+    }
+}
+
+module.exports = {
+    IntervalCommand,
+};

package/commands/is_dirty.js

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

package/commands/jwt_decode.js

@@ -0,0 +1,22 @@
+const { BaseCommand } = require("./base");
+
+class JwtDecodeCommand extends BaseCommand {
+    async execute() {
+        // eyJraWQiOiIxYnh2cE80cGI5TGs1b09HMTZLMlJCIiwiYWxnIjoiRVMyNTYifQ.eyJzdWIiOiJHMUE0Q0VQUkciLCJhdWQiOiJzZWlyZWkiLCJjb3VudHJ5IjoiSlAiLCJjcmVhdGVkIjoxNjY1MzEzMjkwLCJpc3MiOiJnMTIzLWF1dGgiLCJjdXJyZW5jeSI6IkpQWSIsImV4cCI6MTY3Nzk1ODM4NywicmVnaW9uIjoiSlAiLCJsYW5nIjoiamEiLCJpYXQiOjE2Nzc3ODU1ODcsImp0aSI6IjFMbE00UEtuR2VaWWthR0V6YjBhd2wifQ.HXC6wkb7D57I2bdu0Ds_gQp_ZngvjvniP62wJZB5V7pawyVPvnOZT7s_Hkhg9G1hSpoHlAtZKIW5tndlydRBZQ
+        let ret = require("jwt-js").decodeToken(this.content);
+        // ret = {
+        //     "header": {"kid": "1bxvpO4pb9Lk5oOG16K2RB", "alg": "ES256"},
+        //     "payload": {"sub": "G1A4CEPRG", "aud": "seirei", "country": "JP", "created": 1665313290, "iss": "g123-auth", "currency": "JPY", "exp": 1677958387, "region": "JP", "lang": "ja", "iat": 1677785587, "jti": "1LlM4PKnGeZYkaGEzb0awl"},
+        //     "signature": "HXC6wkb7D57I2bdu0Ds_gQp_ZngvjvniP62wJZB5V7pawyVPvnOZT7s_Hkhg9G1hSpoHlAtZKIW5tndlydRBZQ"
+        // };
+        return ret;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    JwtDecodeCommand,
+};

package/commands/list2dict.js

@@ -0,0 +1,32 @@
+const { BaseCommand } = require("./base");
+const { getDataByKey } = require("./share_data");
+
+class List2DictCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = this.content;
+        let keyIndex = data.key_index == undefined ? 0 : data.key_index;
+        let valueIndex = data.value_index == undefined ? 1 : data.value_index;
+        let value_self = data.value_self;
+        let result = {};
+        for (let i = 0; i < content.length; i++) {
+            const v = content[i];
+            if (value_self) {
+                result[getDataByKey("" + keyIndex, v)] = v;
+            } else if (valueIndex instanceof Array) {
+                result[getDataByKey("" + keyIndex, v)] = valueIndex.map(i => getDataByKey("" + v[i], v));
+            } else {
+                result[getDataByKey("" + keyIndex, v)] = getDataByKey("" + valueIndex, v);
+            }
+        }
+        return result;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    List2DictCommand,
+};

package/commands/log.js

@@ -0,0 +1,72 @@
+const { BaseCommand } = require("./base");
+const { shareData } = require("./share_data");
+let logger;
+
+class LogCommand extends BaseCommand {
+    async execute() {
+        if (!logger) {
+            const log4js = require('log4js');
+            log4js.configure({
+                appenders: {
+                    automator: {
+                        type: 'file',
+                        filename: shareData.AUTOMATOR_ROOT + '/log/automator.log',
+                    },
+                    console: {
+                        type: "console"
+                    },
+                },
+                categories: {
+                    default: {
+                        appenders: ['automator'],
+                        level: 'debug'
+                    }
+                }
+            });
+            logger = log4js.getLogger();
+        }
+
+        switch (this.selfData && this.selfData.level) {
+            case "trace": {
+                logger.trace(this.content);
+                break;
+            }
+            case "debug": {
+                logger.debug(this.content);
+                break;
+            }
+            case "info": {
+                logger.info(this.content);
+                break;
+            }
+            case "warn": {
+                logger.warn(this.content);
+                break;
+            }
+            case "error": {
+                logger.error(this.content);
+                break;
+            }
+            case "fatal": {
+                logger.fatal(this.content);
+                break;
+            }
+            case "mark": {
+                logger.mark(this.content);
+                break;
+            }
+            default: {
+                logger.info(this.content);
+                break;
+            }
+        }
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    LogCommand,
+};

package/commands/loop.js

@@ -0,0 +1,115 @@
+const transform_tool = require("../utils/transform_tool");
+const { progress } = require("../utils/display_tool");
+const { getLastError, resetError, log } = require("../utils/log_tool");
+const { BaseCommand, PROCESS_STATE } = require("./base");
+
+class LoopCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = this.content;
+        if (data.delimiter) {
+            content = content.split(new RegExp(data.delimiter));
+        }
+        let keys = Object.keys(content);
+        let show_progress = this.selfCfg.show_progress;
+        for (let loop_index = 0; loop_index < keys.length; loop_index++) {
+            if (this.globalData.process_state === PROCESS_STATE.BREAK) {
+                this.resetProcessState();
+                break;
+            } else if (this.globalData.process_state === PROCESS_STATE.CONTINUE) {
+                this.resetProcessState();
+            }
+            let loop_key = keys[loop_index];
+            let loop_data = content[loop_key];
+            // 键索引值映射
+            if (data.index_mapping) {
+                this.shareData[data.index_mapping] = loop_index;
+            } else {
+                this.shareData['loop_index'] = loop_index;
+            }
+            // 键映射
+            if (data.key_mapping) {
+                this.shareData[data.key_mapping] = loop_key;
+            } else {
+                this.shareData['loop_key'] = loop_key;
+            }
+            // 值映射
+            let value_mapping = data.value_mapping;
+            if (value_mapping) {
+                if (typeof value_mapping === "string") {
+                    this.shareData[value_mapping] = loop_data;
+                } else if (value_mapping instanceof Array) {
+                    for (let i = 0; i < value_mapping.length; i++) {
+                        const k = value_mapping[i];
+                        this.shareData[k] = loop_data[i];
+                    }
+                } else if (typeof value_mapping === "object") {
+                    for (const key in value_mapping) {
+                        if (Object.hasOwnProperty.call(value_mapping, key)) {
+                            const element = value_mapping[key];
+                            this.shareData[element] = loop_data[key];
+                        }
+                    }
+                } else if (typeof value_mapping === "boolean") {
+                    for (const key in loop_data) {
+                        if (Object.hasOwnProperty.call(loop_data, key)) {
+                            this.shareData[key] = loop_data[key];
+                        }
+                    }
+                }
+            } else {
+                this.shareData['loop_data'] = loop_data;
+            }
+            let tip = "";
+            if (data.tip_key != undefined) {
+                if (typeof data.tip_key === "boolean") {
+                    tip = `[${loop_data}]`;
+                } else {
+                    tip = `[${this.getDataByKey(data.tip_key)}]`;
+                }
+            }
+            if (show_progress) {
+                ++this.shareData.$COMPRESS_PROGERSS;
+                // log("");
+                progress(loop_index, keys.length, { desc: `> ${this.selfCfg.title || this.selfCfg.type}${tip}`, color: "cyan"});
+                // log("");
+            }
+            let commandCfgs = data.commands;
+            // 特殊处理字符的情况
+            if (typeof commandCfgs === "string") {
+                commandCfgs = this.formatData(commandCfgs);
+            }
+            // 默认从循环开始执行，增加深度
+            await this.exec(commandCfgs, this.depth + 1);
+            if (show_progress) {
+                --this.shareData.$COMPRESS_PROGERSS;
+                if (!getLastError()) {
+                    progress(loop_index + 1, keys.length, {desc: `> ${this.selfCfg.title || this.selfCfg.type}${tip}`, color: "cyan"});
+                } else {
+                    progress(loop_index + 1, keys.length, {desc: `> ${this.selfCfg.title || this.selfCfg.type}${tip}`, color: "cyan"});
+                }
+                // log("");
+            }
+            if (getLastError()) {
+                if (this.selfCfg.ignore_error) {
+                    resetError(this.selfCfg.ignore_error);
+                } else {
+                    throw getLastError();
+                }
+            }
+        }
+        if (show_progress) {
+            log("");
+        }
+        // 最后一个循环结束后，需要重置掉执行状态
+        this.resetProcessState();
+    }
+    
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    LoopCommand,
+};