    /**
     * 加密数据
     *
     * @param {string} text 需要加密的字符串
     * @param {crypto.BinaryToTextEncoding} [encoding] 加密方式 默认为hex
     * @param {string} [algorithm] 加密模式，默认为aes-128-ecb
     * @param {crypto.CipherKey} [password] 加密密钥，不传使用默认值
     * @param {string} [iv] 加密偏移量
     * @returns {string}
     * @memberof Crypto
     */
    encrypt(text: string, encoding?: crypto.BinaryToTextEncoding, algorithm?: string, password?: crypto.CipherKey, iv?: string): string

解密数据

/**
     * 解密数据
     *
     * @param {string} text 需要解密的字符串
     * @param {crypto.BinaryToTextEncoding} [encoding] 加密方式 默认为hex
     * @param {string} [algorithm] 加密模式 默认为aes-128-ecb
     * @param {crypto.CipherKey} [password] 加密密钥，不传使用默认值
     * @param {string} [iv] 加密偏移量
     * @returns {string}
     * @memberof Crypto
     */
    decrypt(text: string, encoding?: crypto.BinaryToTextEncoding, algorithm?: string, password?: crypto.CipherKey, iv?: string): string

签名数据

/**
     * 签名数据
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput)} privateKey 签名私钥
     * @param {string} data 签名数据
     * @param {string} algorithm 验签模式 默认为SHA1
     * @param {crypto.BinaryToTextEncoding} output_format 签名输出类型 默认为base64
     * @returns {string}
     * @memberof Crypto
     */
    sign(privateKey: string | crypto.KeyObject | Buffer | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput, data: string, algorithm?: string, output_format?: crypto.BinaryToTextEncoding): string

验证签名

/**
     * 验证签名
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.VerifyKeyObjectInput | crypto.VerifyPublicKeyInput)} publicKey 验签公钥
     * @param {string} data 签名数据
     * @param {BufferEncoding} input_encoding 输入的签名数据类型 默认为base64
     * @param {string} signStr 签名数据
     * @param {string} algorithm 验签模式 默认为SHA1
     * @param {("base64" | "hex" | undefined)} [signature_format]  签名数据类型 默认为base64
     * @returns {boolean}
     * @memberof Crypto
     */
    verify(publicKey: string | crypto.KeyObject | Buffer | crypto.VerifyKeyObjectInput | crypto.VerifyPublicKeyInput, data: string, signStr: string, input_encoding?: BufferEncoding, algorithm?: string, signature_format?: "base64" | "hex" | undefined): boolean

将16进制转换成二进制，主要用于需要将加密解密密钥进行转换来用的情况。比如云闪付的解密手机号就需要用到

/**
     * 将16进制转换成二进制，主要用于需要将加密解密密钥进行转换来用的情况。比如云闪付的解密手机号就需要用到
     *
     * @param {string} str 传入的16进制数据
     * @returns {any[]}
     * @memberof Crypto
     */
    Hexstring2btye(str: string): any[]

HMAC 加密方式（带加密密钥）

  /**
     * HMAC 加密方式 （带加密密钥）
     *
     * @param {string} data 需要加密的字符串
     * @param {string} key 加密的密钥
     * @param {string} algorithm 签名模式  默认为SHA1
     * @param {crypto.BinaryToTextEncoding} encoding 加密后生成的类型 默认为base64
     * @returns {string}
     * @memberof Crypto
     */
    createHmac(data: string, key: string, algorithm?: string, encoding?: crypto.BinaryToTextEncoding): string

公钥加密

/**
     * 公钥加密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey)} publicKey 公钥
     * @param {NodeJS.ArrayBufferView} buffer 需要加密的数据
     * @returns {string}
     * @memberof Crypto
     */
    publicEncrypt(publicKey: string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey, data: any): string

私钥解密

 /**
     * 私钥解密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey)} private_key 私钥
     * @param {NodeJS.ArrayBufferView} buffer 需要解密的私钥
     * @returns {string}
     * @memberof Crypto
     */
    privateDecrypt(private_key: string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey, data: any): string

私钥加密

/**
     * 私钥加密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey)} private_key 私钥
     * @param {NodeJS.ArrayBufferView} buffer 需要加密的数据
     * @returns {string}
     * @memberof Crypto
     */
    privateEncrypt(private_key: string | crypto.KeyObject | Buffer | crypto.RsaPrivateKey, data: any): string

公钥解密

/**
     * 公钥解密
     *
     * @param {(string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey)} publicKey 公钥
     * @param {NodeJS.ArrayBufferView} buffer 需要解密的数据
     * @returns {string}
     * @memberof Crypto
     */
    publicDecrypt(publicKey: string | crypto.KeyObject | Buffer | crypto.RsaPublicKey | crypto.RsaPrivateKey, data: any): string

hash加密（不带加密密钥）

/**
     * hash加密 （不带加密密钥）
     *
     * @param {string} data 加密的数据
     * @param {string} algorithm 加密类型 默认为sha256
     * @param {crypto.BinaryToTextEncoding} encoding 加密后转换的字符串类型  默认为base64
     * @returns {string}
     * @memberof Crypto
     */
    createHash(data: string, algorithm?: string, encoding?: crypto.BinaryToTextEncoding): string

ascii排序通过spliter方式连接

 /**
     * ascii排序 通过spliter方式连接 
     *
     * @param {*} dataObject 排序对象
     * @param {string} spliter 分割符号
     * @returns {string}
     * @memberof Crypto
     */
    sortASCII(dataObject: any, spliter: string):string

jsrsa 签名方法

    /**
     * jsrsa 签名方法 
     *
     * @param {string} data 签名数据
     * @param {*} privateKey 私钥文件数据
     * @param {string} [alg] 签名类型 默认为 SHA256withRSA
     * @returns {string} 字符串为base64
     * @memberof Crypto
     */
    JSRSASign(data: string, privateKey: any, alg?: string): string

mail类相关方法使用说明

引用import { mail } from "mitch-tool"

创建邮件发送对象

 /**
     * 创建邮件发送对象
     *
     * @param {string} name 邮件对象名称
     * @param {MailConfig} config 创建邮件对象参数 {host: string; port: number; secure?: boolean; auth: { user: string, pass: string } }
     * @returns {Mail}
     * @memberof NodeMail
     */
    createMailTransport(name: string, config: MailConfig): Mail

发送邮件

/**
     * 发送邮件
     *
     * @param {Mail} mail 创建的邮件对象
     * @param {mailOption} option 发送邮件对应的操作参数 
     * {from: 发送者邮箱，多个用‘，’隔开; to: 收件人邮箱，多个用‘，’隔开; subject: 邮件标题; html: 邮件内容 html格式的字符串; attachments: 附件 [{filename: 'test.md',path: './test.md'}, {filename: 'content', content: '发送内容'}] }}
     * @returns {Promise<any>}
     * @memberof NodeMail
     */
    sendEmail(mail: Mail, option: mailOption): Promise<any>

mysql类相关方法使用说明

引用import { mysql } from "mitch-tool"

创建数据库对象单列方法

/**
     * 创建数据库对象单列方法
     *
     * @param {string} DBName 创建的单列名称
     * @param {dbConfig[]} config 创建数据库连接的config配置
     * @returns {mysqlDB}
     * @memberof Mysql
     */
    createSqlPool(DBName:string, config: dbConfig[]): mysqlDB

创建数据库公用方法对象

 /**
     * 创建数据库公用方法对象
     *
    * @param {string} modelName 创建单列名称
    * @param {modelConfig} model 创建数据库公用方法表配置文件
    * @param {mysqlDB} db 引用的数据库对象
     * @returns {mysqlModel}
     * @memberof Mysql
     */
    createSqlModel(modelName:string, model: modelConfig,db: mysqlDB): mysqlModel

自定义mysql方法类,获取到类对象后即可使用类中方法

新增或更新数据，根据传入的字段中是否有主键来决定，没有主键则新增，有主键则更新

/**
    * 新增或更新数据，根据传入的字段中是否有主键来决定，没有主键则新增，有主键则更新
    *
    * @param {*} data
    * @returns
    * @memberof mysqlModel
    */
    createOrUpdate(data: any): Promise<any[]> {
        if (data[this.pk]) {
            let idObj = this.createPkObj(data[this.pk]);
            delete data[this.pk];
            const params = [this.name, data, idObj];
            const strSql = "update ?? set ? where ? ";
            return this.mysqlMainDB.execWP(strSql, params);
        } else {
            const params = [this.name, data];
            delete data[this.pk];
            const strSql = "insert into ?? set ?";
            return this.mysqlMainDB.execWP(strSql, params);
        }
    }

根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用replace 参数中必须包含主键

 /**
     * 根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用replace 参数中必须包含主键
     *
     * @param {*} data 数据对象中必须包含主键ID
     * @memberof mysqlModel
     */
    createOrUpdateByReplace(data: any): Promise<any[]> {
        let keyAll = '';
        let valueAll = '';
        for (const k in data) {
            keyAll += `${k},`;
            valueAll += `'${data[k]}',`;
        }
        keyAll = keyAll.substr(0, keyAll.length - 1);
        valueAll = valueAll.substr(0, valueAll.length - 1);
        const params = [this.name];
        const strSql = `REPLACE INTO ?? (${keyAll}) VALUES(${valueAll});`;

        return this.mysqlMainDB.execWP(strSql, params);
    }

根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用Duplicate 参数中必须包含主键

/**
     * 根据key参数来决定，如果表中存在对应的key则更新，不存在则插入,使用Duplicate 参数中必须包含主键
     *
     * @param {*} data 数据对象中必须包含主键ID
     * @memberof mysqlModel
     */
    createOrUpdateByDuplicate(data: any): Promise<any[]> {
        let keyAll = '';
        let valueAll = '';
        for (const k in data) {
            keyAll += `${k},`;
            valueAll += `'${data[k]}',`;
        }
        keyAll = keyAll.substr(0, keyAll.length - 1);
        valueAll = valueAll.substr(0, valueAll.length - 1);
        const params = [this.name, data];
        const strSql = `INSERT INTO ?? (${keyAll}) VALUES(${valueAll}) ON DUPLICATE KEY UPDATE ?;`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

根据指定的主键字段来更新对应数据

/**
     * 根据指定的主键字段来更新对应数据
     *
     * @param {*} data
     * @param {string} upPk 指定的主键字段
     * @returns
     * @memberof mysqlModel
     */
    upDateByPkData(data: any, upPk: string): Promise<any[]> {
        let idObj = this.createMyPkObj(data[upPk], upPk);
        delete data[upPk];
        const params = [this.name, data, idObj];
        const strSql = "update ?? set ? where ? ";
        return this.mysqlMainDB.execWP(strSql, params);
    }

通过主键来查询数据

/**
    * 通过主键来查询数据
    *
    * @param {*} id
    * @returns
    * @memberof mysqlModel
    */
    get(id: any): Promise<any[]> {
        const params = [this.column, this.name, this.createPkObj(id)];
        const strSql = "select ?? from ?? where ? ";
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过字段key和对应的value值来查询数据

/**
    * 通过字段key和对应的value值来查询数据
    *
    * @param {*} key
    * @param {*} value
    * @returns
    * @memberof mysqlModel
    */
    getKeyValue(key: any, value: any): Promise<any[]> {
        const params = [this.column, this.name, value];
        const strSql = `select ?? from ?? where ${key} = ? `;
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过主键ID来删除column数据

/**
     * 通过主键ID来删除column数据
     *
     * @param {*} id
     * @returns
     * @memberof mysqlModel
     */
    deleteById(id: any): Promise<any[]> {
        const params = [this.name, this.createPkObj(id)];
        const strSql = "delete from ?? where ? ";
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过自定义where条件对象来查询数据

/**
    * 通过自定义where条件对象来查询数据
    *
    * @param {*} where
    * @param {*} order
    * @memberof mysqlModel
    */
    getWhere(where: any, order = ''): Promise<any[]> {
        const params = [this.column, this.name, ...where.params];
        const strSql = `select ?? from ?? ${where.strSql} ${order}`;
        return this.mysqlMainDB.execWP(strSql, params);
    };

通过参入自定义where对象，排序和分页来查询数据

/**
     * 通过参入自定义where对象，排序和分页来查询数据
     *
     * @memberof mysqlModel
     */
    getWhereAndPage(where: any, order: any, page: any): Promise<any[]>{
        const params = [this.column, this.name, ...where.params, ...page.params];
        const strSql = `select ?? from ?? ${where.strSql} ${order} ${page.strSql}`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

通过参入自定义where对象，排序和分页来查询数据，并查询出最大数据数量。

/**
     * 通过参入自定义where对象，排序和分页来查询数据，并查询出最大数据数量。
     *
     * @memberof mysqlModel
     */
    getWhereAndPageTotal(where: any, order: any, page: any): Promise<any[]> {
        const params = [this.column, this.name, ...where.params, ...page.params];
        const strSql = `select SQL_CALC_FOUND_ROWS ?? from ?? ${where.strSql} ${order} ${page.strSql};select found_rows() as total;`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

自定义输入sql语句和参数来查询

/**
     * 自定义输入sql语句和参数来查询
     *
     * @memberof mysqlModel
     */
    dealMySqlDIY(sql: string, _params: any[]): Promise<any[]> {
        const params = [..._params];
        const strSql = sql;
        return this.mysqlMainDB.execWPTRAN(strSql, params);
    };

自定义输入sql语句和参数来查询未开启事务

/**
     * 自定义输入sql语句和参数来查询 未开启事务
     *
     * @memberof mysqlModel
     */
    dealMySqlDIY2(sql: string, _params: any[]): Promise<any[]> {
        const params = [..._params];
        const strSql = sql;
        return this.mysqlMainDB.execWP(strSql, params);
    };

根据join表对象数据来链接

/**
 * 
 *
 * @param {*} data 需要join 的数据对象数组  {name:表名,type:join方式（left join,right join ....）,on:join的on链接参数}
 * @param {*} where
 * @param {*} order
 * @memberof mysqlModel
 */
    getJoin(data: joinObj[], searchData: any[], where: any, order = ''): Promise<any[]> {
        let joinSql = "";
        let _searchData = "";
        for (let d of data) {
            joinSql += ` ${d.type} ${d.name} on ${d.on} `
        }
        if (searchData.length > 0) {
            for (let s of searchData) {
                _searchData += `${s},`;
            }
            _searchData = _searchData.substring(0, _searchData.length - 1);
        } else {
            _searchData = '*';
        }

        const params = [this.name, ...where.params];
        const strSql = `select ${_searchData} from ?? ${joinSql} ${where.strSql} ${order}`;

        return this.mysqlMainDB.execWP(strSql, params);

    }

通过指定key来删除column数据

 /**
    * 通过指定key来删除column数据
    *
    * @param {*} key
    * @param {*} value
    * @returns
    * @memberof mysqlModel
    */
    deleteByKeyValue(key: any, value: any): Promise<any[]> {
        const params = [this.name, value];
        const strSql = `delete from ?? where ${key} = ?`;
        return this.mysqlMainDB.execWP(strSql, params);
    }

多表关联查询

/**
    *多表关联查询
    *
    * 
    * @param {Obj} sqlObj  
    * {
    * colunums:<string>'', // 要查询的字段
    * joinTbales:<string>'', //相关表连接查询
    * params: <any>[], //where条件参数
    * strSql: <string>"", // where条件sql语句
    * group:<string>"" //分组条件
    * };
    * @param {string} order 排序字符串
    * @param {obj} page 分页对象  { params: [ 0, 10 ], strSql: ' limit ?,?' }
    * @returns
    */
    selJoinTable(sqlObj: any, order: any, page: any): Promise<any[]> {
        let params = [...sqlObj.params, ...page.params];
        let strSQL = `select SQL_CALC_FOUND_ROWS ${sqlObj.colunums} from ${sqlObj.joinTbales}
         ${sqlObj.whereStrSql} ${sqlObj.whereGroup} ${order} ${page.strSql};select found_rows() as total;`
        return this.mysqlMainDB.execWP(strSQL, params);
    }

redis类相关方法使用说明

1.引用 import { redis } from "mitch-tool"

创建redisDB单列对象

 /**
     * 创建redisDB单列对象
     *
     * @param {string} name 创建单例名称
     * @param {redisConfig[]} dbConfig 创建redis对象的参数配置
     * @returns {(ioRedis.Redis | ioRedis.Cluster)}
     * @memberof Redis
     */
    createRedisDB(name:string,dbConfig: redisConfig[]): ioRedis.Redis | ioRedis.Cluster

创建redis公用模块对象

 /**
     * 创建redis公用模块对象
     *
     * @param {string} name 创建公用模块名称
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 用到的redisDB对象
     * @returns {redisModel}
     * @memberof Redis
     */
    createRedisModel(name:string, redisDB: ioRedis.Redis | ioRedis.Cluster): redisModel

发送redisMQ队列数据

/**
     * 发送redisMQ队列数据
     *
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 创建的redisDB对象
     * @param {string} MQStreamName 队列名称
     * @param {object} data 发送的数据对象 为 {} 结构
     * @param {number} [maxLen] 此队列中最大保存的数据条数
     * @returns {Promise<boolean>} 返回true为成功  false为失败
     * @memberof Redis
     */
    sendMQData(redisDB:ioRedis.Redis | ioRedis.Cluster, MQStreamName: string, data: object,maxLen?: number): Promise<boolean>

启动redisMQ队列

   /**
     * 启动redisMQ队列 默认会创建一个默认的{}数据对象，option中操作函数需要对{}对象数据进行处理，遇见{}对象数据直接返回成功并ack，非{}数据再进行其他操作
     *
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 创建的redisDB对象
     * @param {RedisMQConfig} option 相关的队列对象参数
     * @returns {Promise<void>}
     * @memberof Redis
     */
    redisMQStart(redisDB:ioRedis.Redis | ioRedis.Cluster, option:RedisMQConfig): Promise<void>

自定义redis方法类,获取到类对象后即可使用类中方法

获取字符串指定 key 的值。

 /**
     *获取字符串指定 key 的值。
     *
     * @param {string} keyName key值
     * @returns {Promise<any>} 返回一个promise
     * @memberof redisModel
     */
    public get(keyName: string): Promise<any> {
        return new Promise((resolve, reject) => {
            this.redisClient.get(keyName, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

设置字符串指定 key 的值

/**
     *设置字符串指定 key 的值
     *
     * @param {string} keyName key值
     * @param {string} data 字符串value
     * @returns {Promise<any>}
     * @memberof redisModel
     */
    public set(keyName: string, data: string): Promise<any> {
        return new Promise((resolve, reject) => {
            this.redisClient.set(keyName, data, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

检查指定字符串 key 是否存在。

  /**
     *检查指定字符串 key 是否存在。
     *
     * @param {string} keyName 给定key值
     * @returns {Promise<any>}
     * @memberof redisModel
     */
    public exists(keyName: string): Promise<any> {
        return new Promise((resolve, reject) => {
            this.redisClient.exists(keyName, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

将哈希表 key 中的字段 field 的值设为 value 。

    /**
     *将哈希表 key 中的字段 field 的值设为 value 。
     *
     * @param {string} keyName key值
     * @param {string} filed 指定的字段
     * @param {string} data value 
     * @returns 成功返回1，如果字段存在，成功则返回0
     * @memberof redisModel
     */
    public setHash(keyName: string, filed: string, data: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hset(keyName, filed, data, (err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            })
        })
    }

获取存储在哈希表中指定字段的值

 /**
     *
     *获取存储在哈希表中指定字段的值
     * @param {string} keyName key值
     * @param {string} filed 指定的字段
     * @returns
     * @memberof redisModel
     */
    public getHash(keyName: string, filed: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hget(keyName, filed, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

删除一个或多个哈希表字段

 /**
     * 删除一个或多个哈希表字段
     *
     * @param {string} keyName 指定key值
     * @param {(string | string[])} field 除的字段，单个：string,多个：array,数组里面存放field字段
     * @returns 删除成功返回1
     * @memberof redisModel
     */
    public delHash(keyName: string, field: string | string[]) {
        return new Promise((resolve, reject) => {
            this.redisClient.hdel(keyName, field, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

获取在哈希表中指定 key 的所有字段和值

 /**
     * 获取在哈希表中指定 key 的所有字段和值
     *
     * @param {string} keyName 指定的key值
     * @memberof redisModel
     * @returns 返回一个对象，object
     */
    public getAllHash(keyName: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hgetall(keyName, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

查看哈希表 key 中，指定的字段是否存在。

   /**
     *查看哈希表 key 中，指定的字段是否存在。
     *
     * @param {string} keyName key值
     * @param {string} field 指定字段
     * @memberof redisModel 如果哈希表含有给定字段，返回 1 。 如果哈希表不含有给定字段，或 key 不存在，返回 0 。
     */
    public hexists(keyName: string, field: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.hexists(keyName, field, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

将一个或多个值插入到列表头部

/**
     *将一个或多个值插入到列表头部
     *
     * @param {string} keyName
     * @param {string} data
     * @memberof redisModel
     */
    public lpush(keyName: string, data: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.lpush(keyName, data, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

获取列表指定范围内的元素,默认取全部元素

/**
     *获取列表指定范围内的元素,默认取全部元素
     *
     * @param {string} keyName key值
     * @param {number} start 区间偏移量，0表示第一个元素，以此类推
     * @param {number} end 区间偏移量，-1标识最后一个元素，以此类推
     * @memberof redisModel
     */
    public lrange(keyName: string, start?: number, end?: number) {
        let _start = start || 0
        let _end = end || -1
        return new Promise((resolve, reject) => {
            this.redisClient.lrange(keyName, _start, _end, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

移除列表元素

/**
     *移除列表元素
     *
     * @param {string} keyName key值
     * @param {number} count
     *  count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     * count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     * count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param {string} value value值
     * @memberof redisModel
     */
    public Lrem(keyName: string, count: number, value: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.lrem(keyName, count, value, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

删除整个key值

    /**
     *删除整个key值
     *
     * @param {string} keyName
     * @memberof redisModel
     */
    public delAll(keyName: string) {
        return new Promise((resolve, reject) => {
            this.redisClient.del(keyName, (err, data) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(data)
                }
            })
        })
    }

schedule类方法使用说明

引入 import { schedule } from "mitch-tool"

初始化设置定时器设置

 /**
     * 初始化设置定时器设置  
     * 程序中启动定时任务, pm2 启动会默认自带一个 'NODE_APP_INSTANCE' 的环境变量,  它从 0 开始自增, 
     * 永远不能能重复, 每一个worker拥有一个值，或者执行方法的时候判断下 if(process.env.NODE_APP_INSTANCE === '0'){// TO DO ...}  这样就可以在某个worker里执行一次
     *
     * @param {string} time 定时器时间   * * * * * *
     *                                  ┬ ┬ ┬ ┬ ┬ ┬
     *                                  │ │ │ │ │  |
     *                                  │ │ │ │ │ └ day of week (0 - 7) (0 or 7 is Sun)
     *                                  │ │ │ │ └───── month (1 - 12)
     *                                  │ │ │ └────────── day of month (1 - 31)
     *                                  │ │ └─────────────── hour (0 - 23)
     *                                  │ └──────────────────── minute (0 - 59)
     *                                  └───────────────────────── second (0 - 59, OPTIONAL)
     * @param {() => any} fuc 定时执行的方法 
     * @returns {schedule.Job} 返回定时器任务对象
     * @memberof nodeSchedule
     */
    setSchedule(time: string, fuc: () => any): schedule.Job

取消定时器

   /**
     * 取消定时器
     *
     * @param {schedule.Job} job 定时器任务对象
     * @memberof nodeSchedule
     */
    stopSchedule(job: schedule.Job): void

根据规则来设置定时器

/**
     * 根据规则来设置定时器
     *
     * @param {schedule.RecurrenceRule} scheduleRuler 定时器规则
     * 程序中启动定时任务, pm2 启动会默认自带一个 'NODE_APP_INSTANCE' 的环境变量,  它从 0 开始自增, 
     * 永远不能能重复, 每一个worker拥有一个值，或者执行方法的时候判断下 if(process.env.NODE_APP_INSTANCE === '0'){// TO DO ...}  这样就可以在某个worker里执行一次
     * 
     * Examples:
     * 
     *     let rule = new schedule.RecurrenceRule();
     *     rule.dayOfWeek = 2;
     *     rule.month = 3;
     *     rule.dayOfMonth = 1;
     *     rule.hour = 1;
     *     rule.minute = 42; 或者数组 [0, 15, 45]
     *     rule.second = 0;
     * @param {() => any} fuc 定时器执行的方法
     * @returns {schedule.Job} 返回定时器对象
     * @memberof nodeSchedule
     */
    rulerSetSchedule(scheduleRuler: schedule.RecurrenceRule, fuc: () => any): schedule.Job
}

ipBlock类相关方法说明

引用import { ipBlock } from "mitch-tool"

创建ipBlock对象创建对象后，可使用对象中的addIp removeIp 方法来操作redis中的数据

/**
     * 创建ipBlock对象  创建对象后，可使用对象中的addIp  removeIp 方法来操作redis中的数据
     *
     * @param {string} name 对象单列名称
     * @param {(ioRedis.Redis | ioRedis.Cluster)} redisDB 使用到的redisDB对象
     * @param {IpBlockOption} option 操作参数   block: boolean 是否禁用IP;  maxCount: number 检测周期时间内访问最大次数;  blockCount: number 禁用IP访问最大次数 一般大于maxCount; 
     * expireIn: number 检测周期时间; key: string 保存次数的key名称;  blockKeyName:string 保存禁用IP Hash表的名称; whileKeyName:string 保存白名单IP Hash表的名称；
     * @returns {IpBlock}
     * @memberof IPBlock
     */
    createIpBlock(name:string, redisDB: ioRedis.Redis | ioRedis.Cluster, option: IpBlockOption): IpBlock

express框架对ip进行检测阻拦的中间件

 /**
     * express框架对ip进行检测阻拦的中间件
     *
     * @param {IpBlock} ipBlock 创建的IpBlock对象
     * @returns {(req: any, res: any, next:any) => void}
     * @memberof IPBlock
     */
    ipBlockMiddleware(ipBlock: IpBlock): (req: any, res: any, next:any) => void

snowFlakeID类方法使用说明

引入 import { snowFlakeID } from "mitch-tool"

创建雪花算法对象

 /**
     * 创建雪花算法对象 对象中调用generate方法来获取ID
     *
     * @param {string} name 单列对象名称
     * @param {*} [mid] 机器id或任何随机数。如果您是在分布式系统中生成id，强烈建议您提供一个适合不同机器的mid
     * @param {number} [offset] 这是一个时间偏移量，它将从当前时间中减去以获得id的前42位。这将有助于生成更小的id
     * @returns {string} 返回ID
     * @memberof snowFlakeID
     */
    createSnowFlake(name: string, mid?: any, offset?: number): string

Keywords

FAQs

What is mitch-tool?

Is mitch-tool well maintained?

Package last updated on 22 Jul 2024

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

mitch-tool

安装

异步方法使用说明

crypto类加解密方法使用说明

加密数据