node-automator 1.0.0

package/commands/mysql_connect.js

@@ -0,0 +1,29 @@
+const { BaseCommand } = require("./base");
+
+class MysqlConnectCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        var mysql = require('mysql');
+        var connection = mysql.createConnection({
+            host     : data.host ?? "localhost",
+            port     : data.port ?? 3306,
+            password : data.password ?? "",
+            user     : data.user,
+            database : data.database,
+        });
+        
+        connection.connect();
+        
+        // connection.query('SELECT * FROM zt_task LIMIT 10', function (error, results, fields) {
+        // if (error) throw error;
+        // console.log('The solution is: ', results[0].solution);
+        // });
+        
+        // connection.end();
+        return connection;
+    }
+}
+
+module.exports = {
+    MysqlConnectCommand,
+};

package/commands/mysql_end.js

@@ -0,0 +1,13 @@
+const { BaseCommand } = require("./base");
+
+class MysqlEndCommand extends BaseCommand {
+    async execute() {
+        let connection = this.selfData.connection;
+        connection.end();
+        return connection;
+    }
+}
+
+module.exports = {
+    MysqlEndCommand,
+};

package/commands/mysql_query.js

@@ -0,0 +1,19 @@
+const {
+    BaseCommand
+} = require("./base");
+
+class MysqlQueryCommand extends BaseCommand {
+    async execute() {
+        let connection = this.selfData.connection;
+        return await new Promise((resolve, reject) => {
+            connection.query(this.selfData.query, function (error, results, fields) {
+                if (error) reject(error);
+                resolve(results);
+            });
+        });
+    }
+}
+
+module.exports = {
+    MysqlQueryCommand,
+};

package/commands/notify.js

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

package/commands/open.js

@@ -0,0 +1,30 @@
+const { get_file_list } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+const { toArray } = require("../utils/transform_tool");
+
+class OpenCommand extends BaseCommand {
+    async execute() {
+        const open = require("open");
+        let data = this.selfData;
+        let urls;
+        switch (data.mode) {
+            case 'web': {
+                urls = toArray(data.src);
+                break;
+            }
+            case 'file':
+            default: {
+               urls = get_file_list(data.src);
+            }
+        }
+        let options = Object.assign({wait: true}, data.options);
+        for (let index = 0; index < urls.length; index++) {
+            const file = urls[index];
+            await open(file, options);
+        }
+    }
+}
+
+module.exports = {
+    OpenCommand,
+};

package/commands/parse.js

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

package/commands/pause.js

@@ -0,0 +1,15 @@
+const { pause } = require("../utils/interaction_tool");
+const { BaseCommand } = require("./base");
+
+class PauseCommand extends BaseCommand {
+    async execute() {
+        if (this.isFullAutomatic()) {
+            return;
+        }
+        await pause(this.selfData && this.selfData.prompt, this.selfData && this.selfData.countdown);
+    }
+}
+
+module.exports = {
+    PauseCommand,
+};

package/commands/print.js

@@ -0,0 +1,47 @@
+const transform_tool = require("../utils/transform_tool");
+const { whisper, info, getPrint, success, log, LogLevel } = require("../utils/log_tool");
+const { pause } = require("../utils/interaction_tool");
+const { BaseCommand } = require("./base");
+const { eval_code } = require("./share_data");
+
+class PrintCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let level = data && data.level || LogLevel.INFO;
+        let ignore = data && data.ignore || [];
+        ignore = transform_tool.toArray(ignore);
+        let content = null;
+        let use_content = false;
+        let useRaw = level === LogLevel.STDOUT;
+        if (data && (data.mode == "content" || Object.prototype.hasOwnProperty.call(data, "content"))) {
+            content = useRaw ? data.content : getPrint(data.content, true);
+            use_content = true;
+        } else if (data && (data.mode == "code" || Object.prototype.hasOwnProperty.call(data, "code"))) {
+            content = useRaw ? data.content : getPrint(eval_code(data.code), true);
+            use_content = true;
+        }
+        if (use_content) {
+            if (content && content.split("\n").length > 1) {
+                log("");    
+            }
+            log(content, undefined, level);
+        } else {
+            log("");
+            let keys = data && data.key ? transform_tool.toArray(data.key) : Object.keys(this.shareData);
+            keys = keys.filter(key => ignore.indexOf(key) == -1);
+            // 仅显示最近的几条
+            const numShowLatest = data && data.count || keys.length;
+            if (numShowLatest > 20) {
+                await pause(`即将打印 ${numShowLatest} 条数据`);
+            }
+            for (let index = keys.length - numShowLatest; index < keys.length; index++) {
+                const key = keys[index];
+                log(useRaw ? this.getDataByKey(key) : `${key} => ${getPrint(this.getDataByKey(key), true)}`, undefined, level);
+            }
+        }
+    }
+}
+
+module.exports = {
+    PrintCommand,
+};

package/commands/read_cache.js

@@ -0,0 +1,12 @@
+const { getCache } = require("../utils/cache_tool");
+const { BaseCommand } = require("./base");
+
+class ReadCacheCommand extends BaseCommand {
+    async execute() {
+        return await getCache(this.selfData.cache_key, this.selfData.cache_type, this.selfData.cache_param);
+    }
+}
+
+module.exports = {
+    ReadCacheCommand,
+};

package/commands/read_cfg.js

@@ -0,0 +1,13 @@
+const { read_cfg } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class ReadCfgCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        return await read_cfg(data.src, data.type, data.options);
+    }
+}
+
+module.exports = {
+    ReadCfgCommand,
+};

package/commands/read_clipboard.js

@@ -0,0 +1,19 @@
+const clipboardy = require('clipboardy');
+const { warn } = require('../utils/log_tool');
+const { BaseCommand } = require('./base');
+
+class ReadClipboard extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        try {
+            return clipboardy.readSync();
+        } catch (err) {
+            warn(err);
+        }
+        return "";
+    }
+}
+
+module.exports = {
+    ReadClipboard,
+};

package/commands/read_excel.js

@@ -0,0 +1,17 @@
+const { get_fst_file } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class ReadExcelCommand extends BaseCommand {
+    async execute() {
+        let filename = get_fst_file(this.selfData.src);
+        const Excel = require("exceljs");
+        // read from a file
+        const workbook = new Excel.Workbook();
+        let ret = await workbook.xlsx.readFile(filename);
+        return ret;
+    }
+}
+
+module.exports = {
+    ReadExcelCommand,
+};

package/commands/read_only_excel.js

@@ -0,0 +1,40 @@
+const { get_fst_file } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class ReadOnlyExcelCommand extends BaseCommand {
+    async execute() {
+        const xlsx = require("xlsx");
+        const SpreadsheetColumn = require('spreadsheet-column');
+        const sc = new SpreadsheetColumn();
+        let filename = get_fst_file(this.selfData.src);
+        let ret = xlsx.readFile(filename, this.selfData.options);
+        if (this.selfData.sheets_array !== false) {
+            ret.SheetsArray = {};
+            for (let sheetName in ret.Sheets) {
+                let sheetData = ret.Sheets[sheetName];
+                let sheetArray = [];
+                // "A1:Y71"
+                /** @type {string[]} */
+                let refs = sheetData['!ref'].split(":");
+                let colBeg = sc.fromStr(/[A-Z]+/.exec(refs[0])[0]);
+                let rowBeg = /[0-9]+/.exec(refs[0])[0];
+                let colEnd = sc.fromStr(/[A-Z]+/.exec(refs[1])[0]);
+                let rowEnd = /[0-9]+/.exec(refs[1])[0];
+                for (let row = rowBeg; row <= rowEnd; ++row) {
+                    let rowData = [];
+                    for (let col = colBeg; col <= colEnd; ++col) {
+                        let cell = sheetData[`${sc.fromInt(col)}${row}`];
+                        rowData.push(cell && cell.v);
+                    }
+                    sheetArray.push(rowData);
+                }
+                ret.SheetsArray[sheetName] = sheetArray;
+            }
+        }
+        return ret;
+    }
+}
+
+module.exports = {
+    ReadOnlyExcelCommand,
+};

package/commands/read_plain.js

@@ -0,0 +1,14 @@
+const { read_plain } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class ReadPlainCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = read_plain(data.src, data.options);
+        return content;
+    }
+}
+
+module.exports = {
+    ReadPlainCommand,
+};

package/commands/remove.js

@@ -0,0 +1,14 @@
+const { remove } = require("../utils/file_tool");
+const { log } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class RemoveCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        await remove(data.src, data.options);
+    }
+}
+
+module.exports = {
+    RemoveCommand,
+};

package/commands/retrieve.js

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

package/commands/reveal.js

@@ -0,0 +1,33 @@
+const { get_file_list } = require("../utils/file_tool");
+const { warn } = require("../utils/log_tool");
+const { exec_shell } = require("../utils/shell_tool");
+const { BaseCommand } = require("./base");
+
+class RevealCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let files = get_file_list(data.src);
+        if (files.length == 0) {
+            warn(`reveal 未匹配到文件 ${data.src}`);
+        }
+        for (let index = 0; index < files.length; index++) {
+            const file = files[index];
+            if (process.platform === 'win32') {
+                await exec_shell({
+                    cmd: ['explorer', "/select,", file.replace(/\//g, "\\")],
+                    // 这条命令的错误码为1
+                    ignore_code: true,
+                });
+            } else {
+                // TODO: 未测验
+                await exec_shell({
+                    cmd: ['start', file]
+                });
+            }
+        }
+    }
+}
+
+module.exports = {
+    RevealCommand,
+};

package/commands/revision_info.js

@@ -0,0 +1,31 @@
+const { parse } = require("../utils/file_tool");
+const { exec_shell } = require("../utils/shell_tool");
+const { BaseCommand } = require("./base");
+
+class RevisionInfoCommand extends BaseCommand {
+    async execute() {
+        let svnInfo = await parse(await exec_shell({
+            cmd: "svn info",
+            cwd: this.selfData.src,
+            capture_stdout: true,
+        }), 'yaml');
+        let svnLogs = await parse(await exec_shell({
+            cmd: `svn log -c${this.selfData.revisions} ${svnInfo.URL} --xml`,
+            capture_stdout: true,
+            encoding: "utf8",
+        }), "xml");
+        let summary = Array.prototype.slice.call(svnLogs.getElementsByTagName("logentry")).map(logentry => {
+                return {
+                    revision: logentry.attributes.getNamedItem('revision').nodeValue,
+                    msg: Array.prototype.slice.call(logentry.getElementsByTagName("msg")).map(v => v.textContent).join(""),
+                    author: Array.prototype.slice.call(logentry.getElementsByTagName("author")).map(v => v.textContent).join(""),
+                };
+            });
+        ;
+        return summary;
+    }
+}
+
+module.exports = {
+    RevisionInfoCommand,
+};

package/commands/schedule.js

@@ -0,0 +1,80 @@
+const { pause } = require('../utils/interaction_tool');
+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 ScheduleCommand extends BaseCommand {
+    async execute() {
+        await new Promise(async (resolve, reject) => {
+            let data = this.selfData;
+            let commandCfgs = data.commands;
+            /** 是否阻塞 */
+            let blocked = data.blocked;
+            // 特殊处理字符的情况
+            if (typeof commandCfgs === "string") {
+                commandCfgs = formatData(commandCfgs);
+            }
+            let now = Date.now();
+            let timeout;
+            let timeout_date = null;
+            switch (data.schedule_type) {
+                case "delay": {
+                    timeout = convert(data.value, "millisecond");
+                    break;
+                }
+                case "date": {
+                    let date = new Date(data.value);
+                    timeout = date - now;
+                    timeout_date = date;
+                    break;
+                }
+                default: {
+                    throw `不支持的计划任务类型 ${data.schedule_type}`;
+                    return;
+                }
+            }
+            let asyncId;
+            if (!timeout_date) {
+                timeout_date = new Date(now + timeout);
+            }
+            if (isNaN(timeout_date)) {
+                throw `日期格式不正确 ${data.value}`;
+                return;
+            }
+            let willConfirm = timeout <= 0 && !data.force;
+            let timer = setTimeout(async () => {
+                if (willConfirm) {
+                    await pause(`需要确认后才可执行任务[${asyncId}]!`);
+                }
+                info("");
+                warn(`开始执行计划任务[${asyncId}]`);
+                await this.exec(commandCfgs, this.depth + 1);
+                if (blocked) {
+                    resolve();
+                }
+            }, timeout);
+            asyncId = timer[Object.getOwnPropertySymbols(timer).find(v => v.description == "asyncId")];
+            info("");
+            if (timeout <= 0) {
+                warn(`将在${formatDate(timeout_date)} 时间已过期${formatTimeInMillisec(-timeout)}, 立刻执行计划任务[${asyncId}]`);
+            } else {
+                warn(`将在${formatDate(timeout_date)} (${formatTimeInMillisec(timeout)}后)执行计划任务[${asyncId}]`);
+            }
+            if (!blocked) {
+                resolve();
+            }
+        });
+    }
+
+    getRequiredParams() {
+        return [
+            "schedule_type",
+            "value",
+        ];
+    }
+}
+
+module.exports = {
+    ScheduleCommand,
+};

package/commands/select.js

@@ -0,0 +1,17 @@
+
+const { BaseCommand } = require("./base");
+const { select } = require('../utils/selection_tool');
+
+class SelectCommand extends BaseCommand {
+    async execute() {
+        return select(this.content, this.selfData);
+    }
+    
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    SelectCommand,
+};

package/commands/send_email.js

@@ -0,0 +1,25 @@
+const { setLastError } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class SendEmailCommand extends BaseCommand {
+    async execute() {
+        const { SMTPClient, Message } = await import('emailjs');
+        const client = new SMTPClient(this.selfData.client);
+        const message = new Message(this.selfData.message);
+
+        return new Promise(resolve => {
+            client.send(message, (err, msg) => {
+                if (err) {
+                    setLastError(err);
+                    resolve();
+                } else {
+                    resolve(msg);
+                }
+            });
+        })
+    }
+}
+
+module.exports = {
+    SendEmailCommand,
+};