cgserver 10.0.0 → 10.0.1

package/dist/lib/Framework/Core/Core.js

@@ -10,7 +10,9 @@ const ec_key_1 = require("ec-key");
 const uuid_1 = require("uuid");
 const global_1 = require("../global");
 /**
- * 常用的工具函数类
+ * 一些通用的常用函数，
+ * 比如格式化字符串，常用加解密，
+ * 时间计算，类型判断等
  */
 class core {
     /**

package/dist/lib/Framework/Service/MongoCacheService.js

@@ -10,6 +10,10 @@ class MongoCacheModel extends MongoManager_1.MongoBaseModel {
     expireAt = Date.now() + 365 * 24 * 60 * 60 * 1000;
 }
 exports.MongoCacheModel = MongoCacheModel;
+/**
+ * mongo版本的缓存服务
+ * 可以用来缓存kv数据
+ */
 class MongoCacheService extends MongoBaseService_1.MongoBaseService {
     constructor() {
         super("cache", MongoCacheModel);

package/dist/lib/Framework/WebServer/Engine/ControllerManager.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerManager = void 0;
+/**
+ * web服务中mvc的控制器管理器
+ */
 class ControllerManager {
     _static_ctr = {};
     _ctr_cls = {};

package/dist/lib/Framework/global.js

@@ -25,6 +25,10 @@ const QiniuTool_1 = require("./ThirdParty/QiniuTool");
 const WechatTool_1 = require("./ThirdParty/WechatTool");
 const ControllerManager_1 = require("./WebServer/Engine/ControllerManager");
 const cgserver_1 = require("./cgserver");
+const Core_1 = require("./Core/Core");
+/**
+ * cg引擎的，全局对象
+ */
 class global {
     static gMongoServiceMgr = new MongoServiceManager_1.MongoServiceManager();
     static gCgServer = new cgserver_1.CgServer();
@@ -50,7 +54,20 @@ class global {
     static gAlipayTool = new AlipayTool_1.AlipayTool();
     static gAppleTool = new AppleTool_1.AppleTool();
     static gProtoFactory = new ProtoFactory_1.ProtoFactory();
+    /**
+     * web服务中mvc的控制器管理器
+     */
     static gCtrMgr = new ControllerManager_1.ControllerManager();
+    /**
+     * mongo版本的缓存服务
+     * 可以用来缓存kv数据
+     */
     static gMongoCacheSer = new MongoCacheService_1.MongoCacheService();
+    /**
+     * 一些通用的常用函数，
+     * 比如格式化字符串，常用加解密，
+     * 时间计算，类型判断等
+     */
+    static core = Core_1.core;
 }
 exports.global = global;

package/dist/types/Framework/Core/Core.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
 import * as crypto from "crypto";
 /**
- * 常用的工具函数类
+ * 一些通用的常用函数，
+ * 比如格式化字符串，常用加解密，
+ * 时间计算，类型判断等
  */
 export declare class core {
     /**

package/dist/types/Framework/Service/MongoCacheService.d.ts

@@ -5,6 +5,10 @@ export declare class MongoCacheModel extends MongoBaseModel {
     data: any;
     expireAt: number;
 }
+/**
+ * mongo版本的缓存服务
+ * 可以用来缓存kv数据
+ */
 export declare class MongoCacheService extends MongoBaseService<MongoCacheModel> {
     constructor();
     getData(key: string): Promise<any>;

package/dist/types/Framework/WebServer/Engine/ControllerManager.d.ts

@@ -1,4 +1,7 @@
 import { BaseController } from "../Controller/BaseController";
+/**
+ * web服务中mvc的控制器管理器
+ */
 export declare class ControllerManager {
     protected _static_ctr: {
         [module_name: string]: {

package/dist/types/Framework/global.d.ts

@@ -23,6 +23,10 @@ import { QiniuTool } from './ThirdParty/QiniuTool';
 import { WechatTool } from './ThirdParty/WechatTool';
 import { ControllerManager } from './WebServer/Engine/ControllerManager';
 import { CgServer } from './cgserver';
+import { core } from './Core/Core';
+/**
+ * cg引擎的，全局对象
+ */
 export declare class global {
     static gMongoServiceMgr: MongoServiceManager;
     static gCgServer: CgServer;
@@ -48,6 +52,19 @@ export declare class global {
     static gAlipayTool: AlipayTool;
     static gAppleTool: AppleTool;
     static gProtoFactory: ProtoFactory;
+    /**
+     * web服务中mvc的控制器管理器
+     */
     static gCtrMgr: ControllerManager;
+    /**
+     * mongo版本的缓存服务
+     * 可以用来缓存kv数据
+     */
     static gMongoCacheSer: MongoCacheService;
+    /**
+     * 一些通用的常用函数，
+     * 比如格式化字符串，常用加解密，
+     * 时间计算，类型判断等
+     */
+    static core: typeof core;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cgserver",
-  "version": "10.0.0",
+  "version": "10.0.1",
   "author": "trojan",
   "type": "commonjs",
   "description": "free for all.Websocket or Http",

package/dist/lib/Framework/Database/MongoBaseService.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoBaseService = void 0;
-const MongoManager_1 = require("./MongoManager");
-class MongoBaseService {
-    _table = "";
-    get table() {
-        return this._table;
-    }
-    _inited = false;
-    get isInited() {
-        return this._inited;
-    }
-    get mongoDb() {
-        return MongoManager_1.GMongoMgr.getMongo(this._dbname);
-    }
-    _dbname = "";
-    get dbname() {
-        if (!this._dbname) {
-            this._dbname = MongoManager_1.GMongoMgr.defdbname;
-        }
-        return this._dbname;
-    }
-    _t_type = null;
-    constructor(table, type, dbname = "") {
-        this._t_type = type;
-        this._table = table;
-        this._dbname = dbname;
-    }
-    async getNextId(key = "") {
-        if (!key) {
-            key = this._table;
-        }
-        let id = await this.mongoDb.getAutoIds(this._table);
-        return id;
-    }
-    toObjectId(id) {
-        return this.mongoDb.toObjectId(id);
-    }
-    /**
-     * 没有id(非_id)的表不能使用该函数
-     * @param id
-     */
-    async getById(id) {
-        let rs = await this.mongoDb.findOne(this._table, null, { id: id });
-        return rs.one;
-    }
-    async get(property = null, where = null) {
-        let rs = await this.mongoDb.findOne(this._table, property, where);
-        return rs.one;
-    }
-    async countDocuments(where = null, options) {
-        let rs = await this.mongoDb.countDocuments(this._table, where);
-        return rs.count;
-    }
-    async gets(property = null, where = null, sort = null, skip = 0, limit = 0) {
-        let rs = await this.mongoDb.findMany(this._table, property, where, sort, skip, limit);
-        return rs.list;
-    }
-    async getRandoms(num, property, where = null) {
-        let rs = await this.mongoDb.simpleAggregate(this._table, property, where, null, num);
-        return rs.list;
-    }
-    async updateOne(model, where, upsert = false) {
-        let rs = await this.mongoDb.updateOne(this._table, model, where, upsert);
-        return rs;
-    }
-    async updateMany(model, where = null) {
-        let rs = await this.mongoDb.updateMany(this._table, model, where);
-        return rs;
-    }
-    async insert(model) {
-        let rs = await this.mongoDb.insertOne(this._table, model);
-        return rs;
-    }
-    async deleteOne(where) {
-        let rs = await this.mongoDb.deleteOne(this._table, where);
-        return rs;
-    }
-    async deleteMany(where) {
-        let rs = await this.mongoDb.deleteMany(this._table, where);
-        return rs;
-    }
-    async createIndex(index, options) {
-        let rs = await this.mongoDb.createIndex(this._table, index, options);
-        return rs;
-    }
-    aggregate(pipeline, options) {
-        let ret = this.mongoDb.aggregate(this._table, pipeline, options);
-        return ret;
-    }
-    /**
-     * 仅仅支持一级
-     * @param array 数据名称 比如 items
-     * @param where 数组内赛选条件 比如 "items.id":1
-     * @param pre_match 数组上一级赛选条件 比如 "user_id":1
-     */
-    async getsInArray(array, where, pre_match) {
-        let agg = this.aggregate();
-        if (pre_match) {
-            agg = agg.match(pre_match);
-        }
-        agg = agg.unwind("$" + array);
-        if (where) {
-            agg = agg.match(where);
-        }
-        let all = await agg.toArray();
-        let items = [];
-        for (let i = 0; i < all.length; ++i) {
-            items.push(all[i][array]);
-        }
-        return items;
-    }
-    /**
-     * 仅仅支持一级
-     * @param array 数据名称 比如 items
-     * @param where 数组内赛选条件 比如 "items.id":1
-     * @param pre_match 数组上一级赛选条件 比如 "user_id":1
-     */
-    async getInArray(array, where, pre_match) {
-        let items = await this.getsInArray(array, where, pre_match);
-        if (items.length <= 0) {
-            return null;
-        }
-        return items[0];
-    }
-}
-exports.MongoBaseService = MongoBaseService;

package/dist/lib/Framework/Database/MongoManager.js

@@ -1,508 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoExt = exports.GMongoMgr = exports.MongoManager = exports.MgReturn = exports.MrResult = exports.MongoBaseModel = exports.MongoConfig = void 0;
-const Log_1 = require("../Logic/Log");
-const mongo = require("mongodb");
-const _error_1 = require("../Config/_error_");
-const Core_1 = require("../Core/Core");
-class MongoConfig {
-    open = false;
-    host = "127.0.0.1";
-    port = 27017;
-    options = null;
-    database = 'mongodb';
-}
-exports.MongoConfig = MongoConfig;
-class MongoBaseModel {
-    _id;
-}
-exports.MongoBaseModel = MongoBaseModel;
-class MrResult {
-    /**
-     * select 的数据量
-     */
-    length = 0;
-    /**
-     * 插入数据的自增id
-     */
-    insertId = null;
-    insertIds = null;
-    /**
-     * update 更新数据的影响条数
-     */
-    changedRows = null;
-    /**
-     * 插入或删除数据的影响条数
-     */
-    affectedRows = null;
-}
-exports.MrResult = MrResult;
-class MgReturn {
-    error = null;
-    result = new MrResult();
-    list = [];
-}
-exports.MgReturn = MgReturn;
-class MongoManager {
-    _dbs = {};
-    _defdbname = "";
-    get defdbname() {
-        return this._defdbname;
-    }
-    //初始化多个数据库，第一个open数据库为默认数据库
-    async init(cfgs) {
-        for (let i = 0; i < cfgs.length; ++i) {
-            let cfg = cfgs[i];
-            let ret = await this.addMongo(cfg);
-            if (!ret) {
-                return false;
-            }
-        }
-        return true;
-    }
-    async addMongo(cfg) {
-        if (this._dbs[cfg.database]) {
-            Log_1.GLog.error("数据库配置得database不能相同!database=" + cfg.database);
-            return false;
-        }
-        let mongoext = new MongoExt();
-        let ret = await mongoext.init(cfg);
-        if (!ret) {
-            Log_1.GLog.error("数据库初始化失败!cfg=" + JSON.stringify(cfg));
-            return false;
-        }
-        this._dbs[cfg.database] = mongoext;
-        this._defdbname = cfg.database;
-        return true;
-    }
-    async removeMongo(dbname, force = false) {
-        let mongo = this.getMongo(dbname);
-        if (!mongo) {
-            return false;
-        }
-        mongo.close(force);
-    }
-    getMongo(dbname = "") {
-        if (!dbname) {
-            dbname = this._defdbname;
-        }
-        return this._dbs[dbname];
-    }
-}
-exports.MongoManager = MongoManager;
-exports.GMongoMgr = new MongoManager();
-class MongoExt {
-    _mongocfg = null;
-    _init_cbs = [];
-    _mongoDb = null;
-    get mongoDb() {
-        return this._mongoDb;
-    }
-    _mongoClient = null;
-    get mongoClient() {
-        return this._mongoClient;
-    }
-    _mongo_init_succ = false;
-    _inited = false;
-    get isValid() {
-        return this._inited;
-    }
-    constructor() {
-    }
-    async init(cfg) {
-        if (!cfg || !cfg.open) {
-            return false;
-        }
-        if (this._inited) {
-            return false;
-        }
-        if (this._mongoDb) {
-            return true;
-        }
-        this._mongocfg = cfg;
-        this._inited = true;
-        Log_1.GLog.info("mongo config=" + JSON.stringify(this._mongocfg));
-        this._mongoClient = new mongo.MongoClient("mongodb://" + this._mongocfg.host + ":" + this._mongocfg.port, this._mongocfg.options);
-        await Core_1.core.safeCall(this._mongoClient.connect, this._mongoClient);
-        this.onConnect();
-        this._mongoDb = this._mongoClient.db(this._mongocfg.database);
-        for (let i = 0; i < this._init_cbs.length; ++i) {
-            this._init_cbs[i]();
-        }
-        return true;
-    }
-    close(force = false) {
-        this._mongoClient.close(force);
-    }
-    registerInitCb(cb) {
-        this._init_cbs.push(cb);
-    }
-    onConnect() {
-        this._mongo_init_succ = true;
-        Log_1.GLog.info("mongo has connected!");
-    }
-    /**
-     * 获取自增长id
-     * @param key
-     * @returns 小于等于0为异常
-     */
-    async getAutoIds(key) {
-        if (!this._mongoDb) {
-            return -1;
-        }
-        let collection = "auto_ids";
-        let col = this._mongoDb.collection(collection);
-        try {
-            let where = this._convertWhere({ _id: key });
-            let rs = await Core_1.core.safeCall(col.findOneAndUpdate, col, where, { $inc: { id: 1 } }, { upsert: true });
-            if (rs.id) {
-                return rs.id + 1;
-            }
-            return 1;
-        }
-        catch (e) {
-            Log_1.GLog.error(e.stack);
-        }
-        return -2;
-    }
-    _convertWhere(where) {
-        if (!where || !where._id) {
-            return;
-        }
-        if (Core_1.core.isString(where._id) && where._id.length == 24) {
-            let _id = where._id;
-            try {
-                where._id = this.toObjectId(_id);
-            }
-            catch (e) {
-                where._id = _id;
-            }
-        }
-        return where;
-    }
-    toObjectId(id) {
-        return new mongo.ObjectId(id);
-    }
-    /**
-     * 获取单条消息
-     * @param collection
-     */
-    async findOne(collection, property = {}, where = {}) {
-        this._convertWhere(where);
-        let rs = { errcode: null, one: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let one = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            one = await col.findOne(where, { projection: property });
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, property, where });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.one = one;
-        return rs;
-    }
-    async findMany(collection, property = {}, where = {}, sort, skip = 0, limit = 0) {
-        this._convertWhere(where);
-        let rs = { errcode: null, list: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let list = [];
-        try {
-            let col = this._mongoDb.collection(collection);
-            let cursor = col.find(where, { projection: property });
-            if (sort) {
-                cursor = cursor.sort(sort);
-            }
-            if (skip) {
-                cursor = cursor.skip(skip);
-            }
-            if (limit) {
-                cursor = cursor.limit(limit);
-            }
-            list = await cursor.toArray();
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, property, where, sort, skip, limit });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.list = list;
-        return rs;
-    }
-    async countDocuments(collection, where, options) {
-        this._convertWhere(where);
-        let rs = { errcode: null, count: -1 };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let count = -1;
-        try {
-            let col = this._mongoDb.collection(collection);
-            count = await col.countDocuments(where || {}, options);
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, where });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.count = count;
-        return rs;
-    }
-    async deleteOne(collection, where) {
-        this._convertWhere(where);
-        let rs = { errcode: null, count: -1 };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let del_rs = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            del_rs = await col.deleteOne(where || {});
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, where });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        if (del_rs) {
-            rs.count = del_rs.deletedCount;
-        }
-        return rs;
-    }
-    async deleteMany(collection, where) {
-        this._convertWhere(where);
-        let rs = { errcode: null, count: -1 };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let del_rs = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            del_rs = await col.deleteMany(where || {});
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, where });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        if (del_rs) {
-            rs.count = del_rs.deletedCount;
-        }
-        return rs;
-    }
-    /**
-     * 插入数据
-     * @param collection
-     * @param data
-     */
-    async insertOne(collection, data) {
-        let rs = { errcode: null, rs: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let in_rs = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            in_rs = await col.insertOne(data);
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, data });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.rs = in_rs;
-        return rs;
-    }
-    async insertManay(collection, data) {
-        let rs = { errcode: null, rs: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let in_rs = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            in_rs = await col.insertMany(data);
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, data });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.rs = in_rs;
-        return rs;
-    }
-    async updateOne(collection, model, where, upsert = false) {
-        let _id = model["_id"];
-        delete model["_id"];
-        if (!where && _id) {
-            where["_id"] = _id;
-        }
-        this._convertWhere(where);
-        let rs = { errcode: null, rs: null };
-        if (!this._mongoDb) {
-            if (_id) {
-                model["_id"] = _id;
-            }
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let up_rs = null;
-        try {
-            let updatemodel = null;
-            let money = false;
-            for (let key in model) {
-                if (key.startsWith("$")) {
-                    money = true;
-                }
-            }
-            if (!money) {
-                updatemodel = { "$set": model };
-            }
-            else {
-                updatemodel = model;
-            }
-            let col = this._mongoDb.collection(collection);
-            up_rs = await col.updateOne(where, updatemodel, { upsert: upsert });
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, model, where, upsert });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.rs = up_rs;
-        if (up_rs?.upsertedId || _id) {
-            model["_id"] = up_rs?.upsertedId || _id;
-        }
-        return rs;
-    }
-    async updateMany(collection, model, where, upsert = false) {
-        this._convertWhere(where);
-        let rs = { errcode: null, rs: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let up_rs = null;
-        try {
-            let updateModel = null;
-            let firstKey = Object.keys(model)[0];
-            if (!firstKey.startsWith("$")) {
-                updateModel = { $set: model };
-            }
-            else {
-                updateModel = model;
-            }
-            let col = this._mongoDb.collection(collection);
-            up_rs = await col.updateMany(where, updateModel, { upsert: upsert });
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, model, where, upsert });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.rs = up_rs;
-        return rs;
-    }
-    async createIndex(collection, index, options) {
-        let rs = { errcode: null, rs: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let i_rs = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            i_rs = await col.createIndex(index, options);
-        }
-        catch (e) {
-            Log_1.GLog.error({ collection, index });
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.rs = i_rs;
-        return rs;
-    }
-    async simpleAggregate(collection, property, where, size, random_size) {
-        this._convertWhere(where);
-        let rs = { errcode: null, list: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let list = [];
-        try {
-            let col = this._mongoDb.collection(collection);
-            let params = [];
-            if (where) {
-                params.push({ '$match': where });
-            }
-            if (property) {
-                params.push({ '$project': property });
-            }
-            if (random_size) {
-                params.push({ '$sample': { 'size': random_size } });
-            }
-            let agg = col.aggregate(params);
-            if (size) {
-                list = await agg.limit(size).toArray();
-            }
-            else {
-                list = await agg.toArray();
-            }
-        }
-        catch (e) {
-            Log_1.GLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.list = list;
-        return rs;
-    }
-    aggregate(collection, pipeline, options) {
-        if (!this._mongoDb) {
-            return;
-        }
-        let col = this._mongoDb.collection(collection);
-        let agg = col.aggregate(pipeline, options);
-        return agg;
-    }
-    /**
-     * 快速事务
-     * @param collection
-     * @param cb
-     */
-    async quickTransaction(cb, options) {
-        if (!this._mongoDb) {
-            return false;
-        }
-        let session = this._mongoClient.startSession();
-        session.startTransaction(options);
-        try {
-            let rs = await cb(session);
-            await session.commitTransaction();
-            session.endSession();
-            return rs;
-        }
-        catch (e) {
-            await session.abortTransaction();
-            Log_1.GLog.error(e.stack);
-        }
-        finally {
-            await session.endSession();
-        }
-        return false;
-    }
-}
-exports.MongoExt = MongoExt;

package/dist/lib/Framework/Database/MongoServiceManager.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMongoSerMgr = void 0;
-const Log_1 = require("../Logic/Log");
-const MongoManager_1 = require("./MongoManager");
-class MongoServiceManager {
-    _dbservicess = {};
-    add(ser) {
-        let dbname = ser.dbname;
-        if (!this._dbservicess[dbname]) {
-            this._dbservicess[dbname] = {};
-        }
-        let classname = ser.constructor.name;
-        if (this._dbservicess[dbname][classname]) {
-            Log_1.GLog.error("same db created duplicated service:" + classname);
-            return;
-        }
-        this._dbservicess[dbname][classname] = ser;
-    }
-    getService(type, dbname = "") {
-        if (!dbname) {
-            dbname = MongoManager_1.GMongoMgr.defdbname;
-        }
-        //后有defdbname，所以检测一下，把之前的空转换为defname
-        if (dbname && this._dbservicess[""]) {
-            if (!this._dbservicess[dbname]) {
-                this._dbservicess[dbname] = {};
-            }
-            for (let key in this._dbservicess[""]) {
-                let ser = this._dbservicess[""][key];
-                this._dbservicess[dbname][key] = ser;
-            }
-            this._dbservicess[""] = undefined;
-            delete this._dbservicess[""];
-        }
-        //正式逻辑
-        let dbservices = this._dbservicess[dbname];
-        let classname = type.name;
-        if (!dbservices) {
-            this._dbservicess[dbname] = {};
-        }
-        if (!dbservices[classname]) {
-            //mongobaseservice 会掉add
-            new type();
-        }
-        return dbservices[classname];
-    }
-}
-exports.GMongoSerMgr = new MongoServiceManager();

package/dist/lib/Framework/ThirdParty/OpenSocial.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GOpenSocial = void 0;
-const IServerConfig_1 = require("../Config/IServerConfig");
-const HttpTool_1 = require("../Logic/HttpTool");
-exports.GOpenSocial = null;
-class OpenSocial {
-    _getNewMsg() {
-        return {
-            app_id: IServerConfig_1.GServerCfg.third_cfg.open_social.app_id,
-            app_secret: IServerConfig_1.GServerCfg.third_cfg.open_social.app_secret
-        };
-    }
-    async getUser(unionid, openid) {
-        let msg = {
-            unionid: unionid,
-            openid: openid
-        };
-        let rs = await HttpTool_1.GHttpTool.post({ url: IServerConfig_1.GServerCfg.third_cfg.open_social.user_url, json: msg });
-        return rs.body;
-    }
-    async updatePwd(unionid, openid, new_pwd) {
-        let msg = {
-            unionid: unionid,
-            openid: openid,
-            password: new_pwd
-        };
-        let jsonData = await HttpTool_1.GHttpTool.post({ url: IServerConfig_1.GServerCfg.third_cfg.open_social.update_pwd_url, json: msg });
-        return jsonData.body || jsonData.error;
-    }
-}
-exports.GOpenSocial = new OpenSocial();

package/dist/lib/Framework/ThirdParty/WechatOATool.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WechatOATool = exports.GWechatOATool = exports.WechatOAMsg = void 0;
-//OA=offical account公众号
-class WechatOAMsg {
-    // <xml>
-    // <ToUserName><![CDATA[toUser]]></ToUserName>
-    // <FromUserName><![CDATA[fromUser]]></FromUserName>
-    // <CreateTime>1348831860</CreateTime>
-    // <MsgType><![CDATA[text]]></MsgType>
-    // <Content><![CDATA[this is a test]]></Content>
-    // <MsgId>1234567890123456</MsgId>
-    // </xml>
-    toUserName = "";
-    fromUserName = ""; //其实是一个userid
-    createTime = -1;
-    msgType = ""; //text文本
-    content = "";
-    msgId = -1; //只有收到消息才会有
-}
-exports.WechatOAMsg = WechatOAMsg;
-exports.GWechatOATool = null;
-class WechatOATool {
-    convertMsg(xmlStr) {
-        if (!xmlStr) {
-            return null;
-        }
-        let msg = new WechatOAMsg();
-        let pre = "<ToUserName><![CDATA[";
-        xmlStr = xmlStr.substr(xmlStr.indexOf(pre) + pre.length);
-        msg.toUserName = xmlStr.substr(0, xmlStr.indexOf("]"));
-        pre = "<FromUserName><![CDATA[";
-        xmlStr = xmlStr.substr(xmlStr.indexOf(pre) + pre.length);
-        msg.fromUserName = xmlStr.substr(0, xmlStr.indexOf("]"));
-        pre = "<CreateTime>";
-        xmlStr = xmlStr.substr(xmlStr.indexOf(pre) + pre.length);
-        msg.createTime = parseInt(xmlStr.substr(0, xmlStr.indexOf("<")));
-        pre = "<MsgType><![CDATA[";
-        xmlStr = xmlStr.substr(xmlStr.indexOf(pre) + pre.length);
-        msg.msgType = xmlStr.substr(0, xmlStr.indexOf("]"));
-        pre = "<Content><![CDATA[";
-        xmlStr = xmlStr.substr(xmlStr.indexOf(pre) + pre.length);
-        msg.content = xmlStr.substr(0, xmlStr.indexOf("]"));
-        pre = "<MsgId>";
-        xmlStr = xmlStr.substr(xmlStr.indexOf(pre) + pre.length);
-        msg.msgId = parseInt(xmlStr.substr(0, xmlStr.indexOf("<")));
-        return msg;
-    }
-    toReplyXmlStr(msg) {
-        let xmlStr = "<xml>";
-        xmlStr += "<ToUserName><![CDATA[" + msg.toUserName + "]]></ToUserName>";
-        xmlStr += "<FromUserName><![CDATA[" + msg.fromUserName + "]]></FromUserName>";
-        xmlStr += "<CreateTime>" + msg.createTime + "</CreateTime>";
-        xmlStr += "<MsgType><![CDATA[" + msg.msgType + "]]></MsgType>";
-        xmlStr += "<Content><![CDATA[" + msg.content + "]]></Content>";
-        xmlStr += "</xml>";
-        return xmlStr;
-    }
-}
-exports.WechatOATool = WechatOATool;
-exports.GWechatOATool = new WechatOATool();

package/dist/types/Framework/Database/MongoBaseService.d.ts

@@ -1,85 +0,0 @@
-import { MongoBaseModel } from "./MongoManager";
-import * as mongo from 'mongodb';
-export declare class MongoBaseService<T extends MongoBaseModel> {
-    protected _table: string;
-    get table(): string;
-    protected _inited: boolean;
-    get isInited(): boolean;
-    get mongoDb(): import("./MongoManager").MongoExt;
-    protected _dbname: string;
-    get dbname(): string;
-    protected _t_type: {
-        new (): T;
-    };
-    constructor(table: string, type: {
-        new (): T;
-    }, dbname?: string);
-    getNextId(key?: string): Promise<number>;
-    toObjectId(id: string): mongo.BSON.ObjectId;
-    /**
-     * 没有id(非_id)的表不能使用该函数
-     * @param id
-     */
-    getById(id: any): Promise<T>;
-    get(property?: any, where?: any): Promise<T>;
-    countDocuments(where?: any, options?: mongo.CountDocumentsOptions): Promise<number>;
-    gets(property?: any, where?: any, sort?: any, skip?: number, limit?: number): Promise<T[]>;
-    getRandoms(num: number, property: any, where?: any): Promise<T[]>;
-    updateOne(model: any, where?: any, upsert?: boolean): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.UpdateResult<mongo.BSON.Document>;
-    }>;
-    updateMany(model: any, where?: any): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.BSON.Document | mongo.UpdateResult<mongo.BSON.Document>;
-    }>;
-    insert(model: T): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.InsertOneResult<any>;
-    }>;
-    deleteOne(where: any): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        count: number;
-    }>;
-    deleteMany(where: any): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        count: number;
-    }>;
-    createIndex(index: any, options?: mongo.CreateIndexesOptions): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: string;
-    }>;
-    aggregate(pipeline?: Document[], options?: mongo.AggregateOptions): mongo.AggregationCursor<mongo.BSON.Document>;
-    /**
-     * 仅仅支持一级
-     * @param array 数据名称 比如 items
-     * @param where 数组内赛选条件 比如 "items.id":1
-     * @param pre_match 数组上一级赛选条件 比如 "user_id":1
-     */
-    getsInArray<T>(array: string, where?: any, pre_match?: any): Promise<T[]>;
-    /**
-     * 仅仅支持一级
-     * @param array 数据名称 比如 items
-     * @param where 数组内赛选条件 比如 "items.id":1
-     * @param pre_match 数组上一级赛选条件 比如 "user_id":1
-     */
-    getInArray<T>(array: string, where?: any, pre_match?: any): Promise<T>;
-}

package/dist/types/Framework/Database/MongoManager.d.ts

@@ -1,166 +0,0 @@
-import * as mongo from 'mongodb';
-export declare class MongoConfig {
-    open: boolean;
-    host: string;
-    port: number;
-    options: mongo.MongoClientOptions;
-    database: string;
-}
-export declare class MongoBaseModel {
-    _id: mongo.ObjectId;
-}
-export declare class MrResult {
-    /**
-     * select 的数据量
-     */
-    length: number;
-    /**
-     * 插入数据的自增id
-     */
-    insertId: number;
-    insertIds: {
-        [key: number]: number;
-    };
-    /**
-     * update 更新数据的影响条数
-     */
-    changedRows: number;
-    /**
-     * 插入或删除数据的影响条数
-     */
-    affectedRows: number;
-}
-export declare class MgReturn {
-    error: any;
-    result: MrResult;
-    list: any[];
-}
-export declare class MongoManager {
-    protected _dbs: {
-        [key: string]: MongoExt;
-    };
-    protected _defdbname: string;
-    get defdbname(): string;
-    init(cfgs: MongoConfig[]): Promise<boolean>;
-    addMongo(cfg: MongoConfig): Promise<boolean>;
-    removeMongo(dbname: string, force?: boolean): Promise<boolean>;
-    getMongo(dbname?: string): MongoExt;
-}
-export declare let GMongoMgr: MongoManager;
-export declare class MongoExt {
-    protected _mongocfg: MongoConfig;
-    protected _init_cbs: any[];
-    protected _mongoDb: mongo.Db;
-    get mongoDb(): mongo.Db;
-    protected _mongoClient: mongo.MongoClient;
-    get mongoClient(): mongo.MongoClient;
-    protected _mongo_init_succ: boolean;
-    protected _inited: boolean;
-    get isValid(): boolean;
-    constructor();
-    init(cfg: MongoConfig): Promise<boolean>;
-    close(force?: boolean): void;
-    registerInitCb(cb: Function): void;
-    onConnect(): void;
-    /**
-     * 获取自增长id
-     * @param key
-     * @returns 小于等于0为异常
-     */
-    getAutoIds(key: string): Promise<number>;
-    protected _convertWhere(where?: any): any;
-    toObjectId(id: string): mongo.BSON.ObjectId;
-    /**
-     * 获取单条消息
-     * @param collection
-     */
-    findOne(collection: string, property?: {}, where?: {}): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        one: any;
-    }>;
-    findMany(collection: string, property?: {}, where?: {}, sort?: {}, skip?: number, limit?: number): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        list: any[];
-    }>;
-    countDocuments(collection: string, where?: {}, options?: mongo.CountDocumentsOptions): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        count: number;
-    }>;
-    deleteOne(collection: any, where: any): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        count: number;
-    }>;
-    deleteMany(collection: any, where: any): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        count: number;
-    }>;
-    /**
-     * 插入数据
-     * @param collection
-     * @param data
-     */
-    insertOne(collection: string, data: any): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.InsertOneResult<any>;
-    }>;
-    insertManay(collection: string, data: []): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.InsertManyResult<any>;
-    }>;
-    updateOne(collection: string, model?: {}, where?: {}, upsert?: boolean): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.UpdateResult<mongo.BSON.Document>;
-    }>;
-    updateMany(collection: string, model: any, where?: {}, upsert?: boolean): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: mongo.BSON.Document | mongo.UpdateResult<mongo.BSON.Document>;
-    }>;
-    createIndex(collection: string, index: any, options?: mongo.CreateIndexesOptions): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        rs: string;
-    }>;
-    simpleAggregate(collection: string, property?: {}, where?: {}, size?: number, random_size?: number): Promise<{
-        errcode: {
-            id: number;
-            des: string;
-        };
-        list: any[];
-    }>;
-    aggregate(collection: string, pipeline?: Document[], options?: mongo.AggregateOptions): mongo.AggregationCursor<mongo.BSON.Document>;
-    /**
-     * 快速事务
-     * @param collection
-     * @param cb
-     */
-    quickTransaction(cb: Function, options?: mongo.TransactionOptions): Promise<false | any>;
-}

package/dist/types/Framework/Database/MongoServiceManager.d.ts

@@ -1,15 +0,0 @@
-import { MongoBaseService } from "./MongoBaseService";
-import { MongoBaseModel } from "./MongoManager";
-declare class MongoServiceManager {
-    protected _dbservicess: {
-        [dbname: string]: {
-            [classname: string]: MongoBaseService<MongoBaseModel>;
-        };
-    };
-    add(ser: MongoBaseService<MongoBaseModel>): void;
-    getService<T extends MongoBaseService<MongoBaseModel>>(type: {
-        new (): T;
-    }, dbname?: string): T;
-}
-export declare let GMongoSerMgr: MongoServiceManager;
-export {};

package/dist/types/Framework/ThirdParty/OpenSocial.d.ts

@@ -1,7 +0,0 @@
-export declare let GOpenSocial: OpenSocial;
-declare class OpenSocial {
-    protected _getNewMsg(): any;
-    getUser(unionid: string, openid: string): Promise<any>;
-    updatePwd(unionid: string, openid: string, new_pwd: string): Promise<any>;
-}
-export {};

package/dist/types/Framework/ThirdParty/WechatOATool.d.ts

@@ -1,13 +0,0 @@
-export declare class WechatOAMsg {
-    toUserName: string;
-    fromUserName: string;
-    createTime: number;
-    msgType: string;
-    content: string;
-    msgId: number;
-}
-export declare let GWechatOATool: WechatOATool;
-export declare class WechatOATool {
-    convertMsg(xmlStr: string): WechatOAMsg;
-    toReplyXmlStr(msg: WechatOAMsg): string;
-}