pp-robot-module 0.2.14

package/dist/MR/DbClient.js

@@ -0,0 +1,269 @@
+"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 knex_1 = require("knex");
+const Log_1 = require("./Log");
+const dotenv = require("dotenv").config();
+var MR;
+(function (MR) {
+    class DbClient {
+        static get instance() {
+            try {
+                if (!this.dbClient) {
+                    this.dbClient = new DbClient();
+                }
+            }
+            catch (e) {
+                Log_1.default.error("knex->" + e.toString());
+            }
+            return this.dbClient;
+        }
+        constructor() {
+            const dbConfig = {
+                client: DbClient._dbType,
+                debug: DbClient._dbDebug,
+                connection: {
+                    host: DbClient._dbHost,
+                    user: DbClient._dbUser,
+                    port: DbClient._dbPort,
+                    password: DbClient._dbPassword,
+                    database: DbClient._dbName,
+                }
+            };
+            //Logger.debug(dbConfig)
+            const db = (0, knex_1.default)(dbConfig);
+            this._knex = db;
+            this._knex.on('start', (builder) => {
+                Log_1.default.debug(builder.toQuery());
+            });
+        }
+        //nothing
+        config() {
+            return __awaiter(this, void 0, void 0, function* () { });
+        }
+        //test
+        do() {
+            return __awaiter(this, void 0, void 0, function* () {
+                //const data = await this._knex.select() .from('sys_dept')
+                const data = yield this.select({ _table: 'sys_dept', _limit: -1 });
+                //const data = await this.select({ _table: 'sys_dept', _where: 'dept_id > 101 and parent_id >101 and dept_name like "%财%"',_limit:10 })
+                //const data = await this.raw('select * from sys_user_role')
+                //const data = await this._knex.raw('select * from sys_user_role')
+                //const data = await this.insert({ _table: 'sys_dept',_data:{'dept_name':'22333'}})
+                //const data =  await this.update({ _table: 'sys_dept',_data:{'dept_name':'1122'},_where:{'dept_id':'202'}})
+                console.log(data);
+            });
+        }
+        close() {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.close");
+                yield this._knex.destroy();
+            });
+        }
+        select(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.select", params);
+                let limit = params._limit || 10;
+                let offset = params._offset || 0;
+                let column = params._column || '*';
+                if (params._where) {
+                    return yield this._knex.select(column)
+                        .table(params._table).limit(limit, { skipBinding: true }).offset(offset, { skipBinding: true }).whereRaw(params._where);
+                }
+                return yield this._knex.select(column)
+                    .table(params._table).limit(limit, { skipBinding: true }).offset(offset, { skipBinding: true });
+            });
+        }
+        insert(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.insert", params);
+                //[{x: 20}, {y: 30},  {x: 10, y: 20}]
+                return yield this._knex(params._table).insert(params._data);
+            });
+        }
+        update(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.update", params);
+                if (params._where) {
+                    return yield this._knex(params._table).whereRaw(params._where).update(params._data);
+                }
+                return yield this._knex(params._table).update(params._data);
+            });
+        }
+        delete(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.delete", params);
+                if (params._where) {
+                    return yield this._knex(params._table).whereRaw(params._where).del();
+                }
+                return yield this._knex(params._table).del();
+            });
+        }
+        raw(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.raw", params);
+                if (typeof params == 'string') {
+                    let result = yield this._knex.raw(params);
+                    return result[0];
+                }
+                else {
+                    let result = yield this._knex.raw(params._sql);
+                    return result[0];
+                }
+            });
+        }
+        avg(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.avg", params);
+                let result;
+                if (params._where) {
+                    result = yield this._knex(params._table).avg(params._column).whereRaw(params._where);
+                }
+                else {
+                    result = yield this._knex(params._table).avg(params._column);
+                }
+                let values = Object.values(result[0]);
+                return values[0];
+            });
+        }
+        count(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.count", params);
+                let result;
+                if (params._where) {
+                    result = yield this._knex(params._table).count(params._column).whereRaw(params._where);
+                }
+                else {
+                    result = yield this._knex(params._table).count(params._column);
+                }
+                let values = Object.values(result[0]);
+                return values[0];
+            });
+        }
+        sum(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.sum", params);
+                let result;
+                if (params._where) {
+                    result = yield this._knex(params._table).sum(params._column).whereRaw(params._where);
+                }
+                else {
+                    result = yield this._knex(params._table).sum(params._column);
+                }
+                let values = Object.values(result[0]);
+                return values[0];
+            });
+        }
+        min(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.min", params);
+                let result;
+                if (params._where) {
+                    result = yield this._knex(params._table).min(params._column).whereRaw(params._where);
+                }
+                else {
+                    result = yield this._knex(params._table).min(params._column);
+                }
+                let values = Object.values(result[0]);
+                return values[0];
+            });
+        }
+        max(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.max", params);
+                let result;
+                if (params._where) {
+                    result = yield this._knex(params._table).max(params._column).whereRaw(params._where);
+                }
+                else {
+                    result = yield this._knex(params._table).max(params._column);
+                }
+                let values = Object.values(result[0]);
+                return values[0];
+            });
+        }
+        trx(params = {}) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.trx", params);
+            });
+        }
+        join(params = {}) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.join", params);
+            });
+        }
+        alterTable(params, _callback) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.alterTable", params);
+                return this._knex.schema.alterTable(params._table, _callback);
+            });
+        }
+        createTable(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.createTable", params);
+                /***
+                 * function (table) {
+                    table.increments();
+                    table.string('name');
+                    table.timestamps();
+                  }
+                 */
+                return this._knex.schema.createTable(params._table, params._callback);
+            });
+        }
+        schema(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.schema", params);
+                return yield this._knex.table(params._table).columnInfo();
+            });
+        }
+        truncate(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.truncate", params);
+                return yield this._knex.truncate(params._table);
+            });
+        }
+        hasTable(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.hasTable", params);
+                return yield this._knex.hasTable(params._table);
+            });
+        }
+        dropTable(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.dropTable", params);
+                return yield this._knex.schema.dropTableIfExists(params._table);
+            });
+        }
+        createTableLike(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.createTableLike", params);
+                return yield this._knex.schema.createTableLike(params._newTable, params._oldTable);
+            });
+        }
+        renameTable(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                Log_1.default.debug("Db.renameTable", params);
+                return yield this._knex.schema.renameTable(params._oldTable, params._newTable);
+            });
+        }
+    }
+    DbClient._dbType = process.env.DB_TYPE || 'mysql';
+    DbClient._dbHost = process.env.DB_HOST;
+    DbClient._dbPort = Number(process.env.DB_PORT);
+    DbClient._dbUser = process.env.DB_USER;
+    DbClient._dbPassword = process.env.DB_PASSWORD;
+    DbClient._dbName = process.env.DB_NAME;
+    DbClient._dbDebug = Boolean(process.env.DB_DEBUG) || false;
+    MR.DbClient = DbClient;
+})(MR = exports.MR || (exports.MR = {}));
+exports.default = MR.DbClient.instance;

package/dist/MR/Dialog.js

@@ -0,0 +1,40 @@
+//var dialog = require('dialog-node');
+/* export namespace MR {
+    export class Dialog {
+
+        private constructor() { }
+
+        public static async do(params: {
+            _type: string,
+            _msg: string,
+            _title: string,
+            _timeout: number,
+            _callback?: Function
+        }) {
+            switch (params._type.toLowerCase()) {
+                case 'info':
+                    dialog.info(params._msg,params._title,params._timeout,params._callback)
+                    break;
+                case 'warn':
+                    dialog.warn(params._msg,params._title,params._timeout,params._callback)
+                    break;
+                case 'error':
+                    dialog.error(params._msg,params._title,params._timeout,params._callback)
+                    break;
+                case 'question':
+                    dialog.question(params._msg,params._title,params._timeout,params._callback)
+                    break;
+                case 'entry':
+                    dialog.entry(params._msg,params._title,params._timeout,params._callback)
+                    break;
+                case 'calendar':
+                    dialog.calendar(params._msg,params._title,params._timeout,params._callback)
+                    break;
+                case 'fileselect':
+                    dialog.fileselect(params._msg,params._title,params._timeout,params._callback)
+                    break;
+            }
+        }
+    }
+}
+export default MR.Dialog; */ 

package/dist/MR/Excel.d.ts

@@ -0,0 +1,110 @@
+import * as xlsx from "xlsx";
+export declare namespace MR {
+    class Excel {
+        private static excel;
+        private _workbook;
+        private _filename;
+        private _sheet;
+        private constructor();
+        static get instance(): Excel;
+        private load;
+        open(params: {
+            _filename: string;
+            _sheetname?: string;
+        }): xlsx.WorkBook;
+        sheetNames(): string[];
+        getData(params: {
+            _sheetname?: string;
+            _type?: 'json' | 'csv' | 'txt' | 'html' | 'formulae';
+        }): any;
+        private ec;
+        buildStyle(params?: {
+            _fontname: string;
+            _fontsize: number;
+            _fontbold: boolean;
+            _fontrgb: string;
+        }): {
+            font: {
+                name: number;
+                sz: number;
+                bold: boolean;
+                color: {
+                    rgb: string;
+                };
+            };
+        };
+        clearColumn(params: {
+            _column: string;
+        }): void;
+        deleteColumn(params: {
+            _column: string;
+        }): void;
+        clearRow(params: {
+            _row: number;
+        }): void;
+        deleteRow(params: {
+            _row: number;
+        }): void;
+        size(params?: {
+            _sheetname?: string;
+        }): string;
+        formula(params: {
+            _sheetname?: string;
+            _range: string;
+            _formula: string;
+        }): void;
+        range(params?: {
+            _sheetname?: string;
+        }): xlsx.Range;
+        row(params: {
+            _row: number;
+        }): any[];
+        column(params: {
+            _column: string;
+        }): any[];
+        cell(params: {
+            _pos: string;
+            _value?: any;
+        }): any;
+        /**
+         * Convert to CSV/other and export file.
+         */
+        convert(params: {
+            _type: 'json' | 'csv' | 'txt' | 'html' | 'formulae';
+            _filename?: string;
+            _sheetname?: string;
+        }): string;
+        posSheet(params: {
+            _sheetname: string;
+        }): void;
+        addSheet(params: {
+            _sheetname: string;
+            _data: any;
+            _type: 'aoa' | 'json';
+        }): void;
+        put(params: {
+            _data: any;
+            _sheetname?: string;
+            _type: 'json' | 'aoa';
+        }): void;
+        cover(params: {
+            _data: any;
+            _type: 'aoa' | 'json';
+            _sheetname?: string;
+        }): void;
+        write(params: {
+            _filename: string;
+            _data: any;
+            _type: 'json';
+        }): void;
+        /**
+         * Convert to CSV and export file.
+         */
+        toCSV(params: {
+            _filename: string;
+            _sheetname?: string;
+        }): string | string[];
+    }
+}
+declare const _default: MR.Excel;
+export default _default;