pp-robot-module 0.2.14

package/dist/MR/Process.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+var shell = require('shelljs');
+const fkill = require('fkill');
+const nut_js_1 = require("@nut-tree/nut-js");
+const lodash_1 = require("lodash");
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Process {
+        constructor() { }
+        static envs(params = { _type: 'Object' }) {
+            Log_1.default.debug("Process.envs");
+            if (params._type === 'Array')
+                return Object.entries(process.env).map(([key, value]) => ({ name: key, value }));
+            return process.env;
+        }
+        static env(params) {
+            Log_1.default.debug("Process.env", params);
+            return process.env[params._key];
+        }
+        static cwd() {
+            Log_1.default.debug("Process.cwd");
+            return process.cwd();
+        }
+        static echo(params) {
+            Log_1.default.debug("Process.echo", params);
+            if (!params._newline) {
+                return shell.echo(params._content);
+            }
+            else {
+                return shell.echo('-n', params._content);
+            }
+        }
+        static exec(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Process.exec", params);
+                if (params._silent) {
+                    return new Promise((resolve, reject) => {
+                        const data = shell.exec(params._cmd, { silent: true }).stdout;
+                        resolve(data);
+                    });
+                }
+                return new Promise((resolve, reject) => {
+                    const child = shell.exec(params._cmd, { async: true });
+                    child.stdout.on('data', function (data) {
+                        resolve(data);
+                    });
+                });
+            });
+        }
+        static kill(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Process.kill", params);
+                if (params._pid)
+                    yield fkill(params._pid);
+                if (params._name)
+                    yield fkill(params._name);
+                if (params._port)
+                    yield fkill(':' + params._port);
+            });
+        }
+        static capture(params = { _filePath: '.', _fileName: (0, lodash_1.uniqueId)(), _fileType: 'PNG' }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Process.capture", params);
+                if (params._fileType === 'PNG')
+                    return yield nut_js_1.screen.capture(params._fileName, nut_js_1.FileType.PNG, params._filePath);
+                else
+                    return yield nut_js_1.screen.capture(params._fileName, nut_js_1.FileType.JPG, params._filePath);
+            });
+        }
+        static captureRegion(params = { _x: 0, _y: 0, _width: 100, _height: 100, _filePath: '.', _fileName: (0, lodash_1.uniqueId)(), _fileType: 'PNG' }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Process.captureRegion", params);
+                const region = new nut_js_1.Region(params._x, params._x, params._width, params._height);
+                if (params._fileType === 'PNG')
+                    return yield nut_js_1.screen.captureRegion(params._fileName, region, nut_js_1.FileType.PNG, params._filePath);
+                else
+                    return yield nut_js_1.screen.captureRegion(params._fileName, region, nut_js_1.FileType.JPG, params._filePath);
+            });
+        }
+        static test1() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!shell.which('git')) {
+                    shell.echo('Sorry, this script requires git');
+                    shell.exit(1);
+                }
+                else {
+                    shell.echo('oh,git is full');
+                }
+            });
+        }
+    }
+    MR.Process = Process;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Process;

package/dist/MR/QRcode.d.ts

@@ -0,0 +1,13 @@
+export declare namespace MR {
+    class QRCode {
+        private constructor();
+        static generate(params: {
+            _text: string;
+        }): Promise<any>;
+        static identify(params: {
+            _filename: string;
+        }): void;
+    }
+}
+declare const _default: typeof MR.QRCode;
+export default _default;

package/dist/MR/QRcode.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const Log_1 = require("./Log");
+const _qrcode = require('qrcode');
+var MR;
+(function (MR) {
+    class QRCode {
+        constructor() { }
+        static generate(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("QRCode.generate", params);
+                try {
+                    const qrCodeDataURL = yield _qrcode.toDataURL(params._text);
+                    return qrCodeDataURL;
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }
+        static identify(params) {
+            Log_1.default.debug("QRCode.identify", params);
+        }
+    }
+    MR.QRCode = QRCode;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.QRCode;

package/dist/MR/RedisClient.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import Redis from "ioredis";
+export declare namespace MR {
+    class MyRedis {
+        private static myRedis;
+        client: Redis;
+        private static _host;
+        private static _port;
+        private static _password;
+        private static _username;
+        private static _db;
+        private constructor();
+        static get instance(): MyRedis;
+        static create(params: {
+            _host: string;
+            _port: number;
+            _db?: number;
+            _password?: string;
+        }): Redis;
+        config(): Promise<void>;
+        do(params: any): Promise<void>;
+        set(_key: string, _value: string, _ex?: number): Promise<"OK">;
+        get(_key: string): Promise<string>;
+        del(_key: string): Promise<number>;
+        exists(_key: string): Promise<number>;
+        incrby(_key: string): Promise<number>;
+        hmset(_key: string, _value: any): Promise<"OK">;
+        hget(_key: string, _hkey: string): Promise<"OK">;
+        hdel(_key: string, _hkey: string): Promise<number>;
+        hexists(_key: string, _hkey: string): Promise<number>;
+        hincrby(_key: string, _hkey: string): Promise<number>;
+        lpush(_key: string, elements: (string | number | Buffer)[]): Promise<void>;
+        lpop(_key: string): Promise<string>;
+        sadd(_key: string, elements: (string | number | Buffer)[]): Promise<number>;
+        scard(_key: string): Promise<number>;
+        sismember(_key: string, _member: string | Buffer | number): Promise<number>;
+    }
+}
+declare const _default: MR.MyRedis;
+export default _default;

package/dist/MR/RedisClient.js

@@ -0,0 +1,183 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const ioredis_1 = require("ioredis");
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class MyRedis {
+        constructor() {
+            const redisConfig = {
+                host: MyRedis._host,
+                port: MyRedis._port,
+                password: MyRedis._password,
+                username: MyRedis._username,
+                db: MyRedis._db,
+                lazyConnect: true,
+                retryStrategy: function (times) {
+                    return Math.min(times * 50, 5000);
+                },
+                // enableOfflineQueue: false
+            };
+            this.client = new ioredis_1.default(redisConfig);
+        }
+        static get instance() {
+            try {
+                if (!this.myRedis) {
+                    this.myRedis = new MyRedis();
+                }
+            }
+            catch (e) {
+                console.log('----------');
+                console.log(e);
+                Log_1.default.error(e.toString());
+            }
+            return this.myRedis;
+        }
+        static create(params) {
+            const redisConfig = {
+                host: params._host,
+                port: params._port,
+                password: params._password,
+                db: params._db,
+                retryStrategy: function (times) {
+                    return Math.min(times * 50, 5000);
+                },
+                // enableOfflineQueue: false
+            };
+            const _ = new ioredis_1.default(redisConfig);
+            // this.client = _;
+            return _;
+        }
+        /*    public async rawCall(params: {
+               _cmd: string, _key: string, _value: any
+           }) {
+   
+                  if (!params._value || !Array.isArray(params._value)) {
+                     throw new Error('_value argument to rawCall() must be an Array');
+                 }
+               switch (params._cmd.toLowerCase()) {
+                   case 'set':
+                       //redis.set("key_with_ttl", "hey", "EX", 1000);
+                      // this.set(params._value);
+                   case 'get':
+                       this.get(params._key);
+               }
+   
+           }
+    */
+        /*  rawCallAsync(args) {
+             return new Promise((resolve, reject) => {
+               this.rawCall(args, (err, resp) => {
+                 if (err) return reject(err);
+                 resolve(resp);
+               });
+             });
+           } */
+        //nothing
+        config() {
+            return __awaiter(this, void 0, void 0, function* () { });
+        }
+        //nothing
+        do(params) {
+            return __awaiter(this, void 0, void 0, function* () { });
+        }
+        set(_key, _value, _ex) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!_ex) {
+                    return yield this.client.set(_key, _value);
+                }
+                else {
+                    return yield this.client.set(_key, _value, "EX", _ex);
+                }
+            });
+        }
+        get(_key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.get(_key);
+            });
+        }
+        del(_key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.del(_key);
+            });
+        }
+        exists(_key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.exists(_key);
+            });
+        }
+        incrby(_key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.incrby(_key, 1);
+            });
+        }
+        hmset(_key, _value) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.hmset(_key, _value);
+            });
+        }
+        hget(_key, _hkey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.hmset(_key, _hkey);
+            });
+        }
+        hdel(_key, _hkey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.hdel(_key, _hkey);
+            });
+        }
+        hexists(_key, _hkey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.hexists(_key, _hkey);
+            });
+        }
+        hincrby(_key, _hkey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.hincrby(_key, _hkey, 1);
+            });
+        }
+        lpush(_key, elements) {
+            return __awaiter(this, void 0, void 0, function* () {
+                //return await this.client.lpush(_key, elements, null);
+            });
+        }
+        lpop(_key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.lpop(_key);
+            });
+        }
+        sadd(_key, elements) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.sadd(_key, elements);
+            });
+        }
+        scard(_key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.scard(_key);
+            });
+        }
+        sismember(_key, _member) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield this.client.sismember(_key, _member);
+            });
+        }
+    }
+    MyRedis._host = process.env.REDIS_HOST;
+    MyRedis._port = Number(process.env.REDIS_PORT);
+    MyRedis._password = process.env.REDIS_PASSWORD;
+    //redis 6>
+    MyRedis._username = process.env.REDIS_USERNAME;
+    MyRedis._db = Number(process.env.REDIS_DB);
+    MR.MyRedis = MyRedis;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.MyRedis.instance;

package/dist/MR/Regex.d.ts

@@ -0,0 +1,16 @@
+export declare namespace MR {
+    class Regex {
+        private constructor();
+        static match(params: {
+            _exp: string;
+            _msg: string;
+        }): RegExpMatchArray;
+        static replace(params: {
+            _exp: string;
+            _msg: string;
+            _text: string;
+        }): string;
+    }
+}
+declare const _default: typeof MR.Regex;
+export default _default;

package/dist/MR/Regex.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Regex {
+        constructor() { }
+        static match(params) {
+            Log_1.default.debug("Regex.match", params);
+            return params._msg.match(params._exp);
+        }
+        static replace(params) {
+            Log_1.default.debug("Regex.replace", params);
+            return params._msg.replace(params._exp, params._text);
+        }
+    }
+    MR.Regex = Regex;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Regex;

package/dist/MR/Robot.d.ts

@@ -0,0 +1,19 @@
+export declare namespace MR {
+    class Robot {
+        private robotName;
+        private robotDesc;
+        private beanName;
+        private robotTrail;
+        private robotResData;
+        private dataMap;
+        private constructor();
+        addTrail(args: any): void;
+        static create(params?: {
+            _name: string;
+            _desc: string;
+            _beanName: string;
+        }): Robot;
+    }
+}
+declare const _default: typeof MR.Robot;
+export default _default;

package/dist/MR/Robot.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const Log_1 = require("./Log");
+var MR;
+(function (MR) {
+    class Robot {
+        constructor() {
+            this.robotTrail = [];
+            this.robotResData = [];
+            this.dataMap = {};
+        }
+        addTrail(args) {
+            this.robotTrail.push(args);
+        }
+        static create(params = {
+            _name: 'test',
+            _desc: 'no desc',
+            _beanName: '',
+        }) {
+            Log_1.default.debug("Robot.create", params);
+            const robot = new Robot();
+            robot.robotName = params._name;
+            robot.robotDesc = params._desc;
+            robot.beanName = params._beanName;
+            return robot;
+        }
+    }
+    MR.Robot = Robot;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Robot;

package/dist/MR/Screen.d.ts

@@ -0,0 +1,20 @@
+import { Region } from "@nut-tree/nut-js";
+export declare namespace MR {
+    class Screen {
+        private constructor();
+        static highlight(left: number, top: number, width: number, height: number): Promise<Region>;
+        static getSize(): Promise<{
+            width: number;
+            height: number;
+        }>;
+        static width(): Promise<number>;
+        static height(): Promise<number>;
+        static capture(filePath: string, fileName: string): Promise<string>;
+        static colorAt(x: number, y: number): Promise<import("@nut-tree/nut-js").RGBA>;
+        static findImage(path: string, imageFile: string): Promise<Region>;
+        static findImageAndHover(path: string, imageFile: string, timeout: number): Promise<import("@nut-tree/nut-js").MouseClass>;
+        static waitImage(path: string, imageFile: string, timeout: number): Promise<Region>;
+    }
+}
+declare const _default: typeof MR.Screen;
+export default _default;

package/dist/MR/Screen.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const nut_js_1 = require("@nut-tree/nut-js");
+var MR;
+(function (MR) {
+    class Screen {
+        constructor() { }
+        static highlight(left, top, width, height) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.screen.highlight(new nut_js_1.Region(left, top, width, height));
+            });
+        }
+        static getSize() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let h = yield nut_js_1.screen.height();
+                let w = yield nut_js_1.screen.width();
+                return { "width": w, "height": h };
+            });
+        }
+        static width() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.screen.width();
+            });
+        }
+        static height() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.screen.height();
+            });
+        }
+        static capture(filePath, fileName) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.screen.capture(fileName, nut_js_1.FileType.PNG, filePath);
+            });
+        }
+        /*    public static async captureRegion (filePath: string,fileName: string, left: number, top: number, width: number, height: number) {
+              const region = new Region(left, top, width, height)
+              return await screen.capture (fileName,FileType.PNG,region,filePath);
+           } */
+        static colorAt(x, y) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return yield nut_js_1.screen.colorAt(new nut_js_1.Point(x, y));
+            });
+        }
+        static findImage(path, imageFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                nut_js_1.screen.config.resourceDirectory = path;
+                return yield nut_js_1.screen.find((0, nut_js_1.imageResource)(imageFile));
+            });
+        }
+        static findImageAndHover(path, imageFile, timeout) {
+            return __awaiter(this, void 0, void 0, function* () {
+                nut_js_1.screen.config.resourceDirectory = path;
+                return yield nut_js_1.mouse.move((0, nut_js_1.straightTo)((0, nut_js_1.centerOf)(yield nut_js_1.screen.waitFor((0, nut_js_1.imageResource)(imageFile), timeout))));
+            });
+        }
+        /*      public static async findImageAndClick(path:string,imageFile:string,timeout:number) {
+                Screen.findImageAndHover(path,imageFile,timeout)
+                mouse.click()
+             } */
+        static waitImage(path, imageFile, timeout) {
+            return __awaiter(this, void 0, void 0, function* () {
+                nut_js_1.screen.config.resourceDirectory = path;
+                return yield nut_js_1.screen.waitFor((0, nut_js_1.imageResource)(imageFile), timeout);
+            });
+        }
+    }
+    MR.Screen = Screen;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.Screen;

package/dist/MR/Smtp.d.ts

@@ -0,0 +1,21 @@
+export declare namespace MR {
+    class SmtpClass {
+        private constructor();
+        private static _host;
+        private static _port;
+        private static _username;
+        private static _password;
+        private static _netType;
+        private static _service;
+        private static _secure;
+        static send(params: {
+            _from: string;
+            _to: string;
+            _subject: string;
+            _text: string;
+            _filenames?: string | string[];
+        }): Promise<any>;
+    }
+}
+declare const _default: typeof MR.SmtpClass;
+export default _default;

package/dist/MR/Smtp.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MR = void 0;
+const nodemailer = require('nodemailer');
+const path = require('path');
+const Log_1 = require("./Log");
+// 使用内置传输发送邮件 查看支持列表：https://nodemailer.com/smtp/well-known/
+var MR;
+(function (MR) {
+    class SmtpClass {
+        constructor() { }
+        static send(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("SmtpClass.send", params);
+                let transporter = nodemailer.createTransport({
+                    service: SmtpClass._service,
+                    port: SmtpClass._port,
+                    secureConnection: SmtpClass._secure,
+                    auth: {
+                        user: SmtpClass._username,
+                        pass: SmtpClass._password,
+                    }
+                });
+                let mailOptions = {
+                    from: params._from,
+                    to: params._to,
+                    subject: params._subject,
+                    text: params._text
+                };
+                if (params._filenames) {
+                    let attachments = [];
+                    if (Array.isArray(params._filenames)) {
+                        params._filenames.forEach(v => {
+                            const fileName = path.basename(v);
+                            attachments.push({
+                                filename: fileName,
+                                path: v
+                            });
+                        });
+                    }
+                    else {
+                        const fileName = path.basename(params._filenames);
+                        attachments = [
+                            {
+                                filename: fileName,
+                                path: params._filenames
+                            }
+                        ];
+                    }
+                    mailOptions['attachments'] = attachments;
+                }
+                return new Promise((resolve, reject) => {
+                    transporter.sendMail(mailOptions, (error, info) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(info);
+                        }
+                    });
+                });
+            });
+        }
+    }
+    SmtpClass._host = process.env.SMTP_HOST;
+    SmtpClass._port = Number(process.env.SMTP_PORT);
+    SmtpClass._username = process.env.SMTP_USERNAME;
+    SmtpClass._password = process.env.SMTP_PASSWORD;
+    SmtpClass._netType = process.env.SMTP_NETTYPE;
+    SmtpClass._service = process.env.SMTP_SERVICE;
+    SmtpClass._secure = Boolean(process.env.SMTP_SECURE);
+    MR.SmtpClass = SmtpClass;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.SmtpClass;