cgserver 9.2.6 → 10.0.0

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

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoExt = exports.MongoManager = exports.MgReturn = exports.MrResult = exports.MongoBaseModel = exports.MongoConfig = void 0;
+const mongo = require("mongodb");
+const _error_1 = require("../../Config/_error_");
+const Core_1 = require("../../Core/Core");
+const global_1 = require("../../global");
+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]) {
+            global_1.global.gLog.error("数据库配置得database不能相同!database=" + cfg.database);
+            return false;
+        }
+        let mongoext = new MongoExt();
+        let ret = await mongoext.init(cfg);
+        if (!ret) {
+            global_1.global.gLog.error("数据库初始化失败!cfg=" + JSON.stringify(cfg));
+            return false;
+        }
+        this._dbs[cfg.database] = mongoext;
+        if (!this._defdbname) {
+            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;
+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;
+        global_1.global.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;
+        global_1.global.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) {
+            global_1.global.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, where = {}, property = {}) {
+        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) {
+            global_1.global.gLog.error({ collection, property, where });
+            global_1.global.gLog.error(e.stack);
+            rs.errcode = _error_1.EErrorCode.Mongo_Error;
+        }
+        rs.one = one;
+        return rs;
+    }
+    async findMany(collection, where = {}, property = {}, 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) {
+            global_1.global.gLog.error({ collection, property, where, sort, skip, limit });
+            global_1.global.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) {
+            global_1.global.gLog.error({ collection, where });
+            global_1.global.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) {
+            global_1.global.gLog.error({ collection, where });
+            global_1.global.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) {
+            global_1.global.gLog.error({ collection, where });
+            global_1.global.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) {
+            global_1.global.gLog.error({ collection, data });
+            global_1.global.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) {
+            global_1.global.gLog.error({ collection, data });
+            global_1.global.gLog.error(e.stack);
+            rs.errcode = _error_1.EErrorCode.Mongo_Error;
+        }
+        rs.rs = in_rs;
+        return rs;
+    }
+    async updateOne(collection, where, model, 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) {
+            global_1.global.gLog.error({ collection, model, where, upsert });
+            global_1.global.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, where, model, 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) {
+            global_1.global.gLog.error({ collection, model, where, upsert });
+            global_1.global.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) {
+            global_1.global.gLog.error({ collection, index });
+            global_1.global.gLog.error(e.stack);
+            rs.errcode = _error_1.EErrorCode.Mongo_Error;
+        }
+        rs.rs = i_rs;
+        return rs;
+    }
+    async simpleAggregate(collection, where, property, 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) {
+            global_1.global.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();
+            global_1.global.gLog.error(e.stack);
+        }
+        finally {
+            await session.endSession();
+        }
+        return false;
+    }
+}
+exports.MongoExt = MongoExt;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoServiceManager = void 0;
+const MongoBaseService_1 = require("./MongoBaseService");
+class MongoServiceManager {
+    _services = {};
+    addService(table, type, dbname = "") {
+        if (!this._services[dbname]) {
+            this._services[dbname] = {};
+        }
+        if (!this._services[dbname][table]) {
+            this._services[dbname][table] = new MongoBaseService_1.MongoBaseService(table, type, dbname);
+        }
+        return this._services[dbname][table];
+    }
+    getService(table, dbname = "") {
+        if (!this._services[dbname]) {
+            this._services[dbname] = {};
+        }
+        if (!this._services[dbname][table]) {
+            return null;
+        }
+        return this._services[dbname][table];
+    }
+}
+exports.MongoServiceManager = MongoServiceManager;

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

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlBaseService = exports.BaseModel = void 0;
+const global_1 = require("../global");
 const Property_1 = require("./Decorator/Property");
-const MysqlManager_1 = require("./MysqlManager");
-const Log_1 = require("../Logic/Log");
-const DBCache_1 = require("./Decorator/DBCache");
 class BaseModel {
 }
 exports.BaseModel = BaseModel;
@@ -24,11 +22,11 @@ class MysqlBaseService {
     _t_type = null;
     constructor(type) {
         this._t_type = type;
-        if (MysqlManager_1.GMysqlMgr.isValid) {
+        if (global_1.global.gMysqlMgr.isValid) {
             this._init();
         }
         else {
-            MysqlManager_1.GMysqlMgr.registerInitCb(this._init.bind(this));
+            global_1.global.gMysqlMgr.registerInitCb(this._init.bind(this));
         }
     }
     async _init() {
@@ -41,13 +39,13 @@ class MysqlBaseService {
             throw new Error("数据表的类必须要具有Table装饰器");
         }
         this._table = "`" + table.table + "`";
-        if (!MysqlManager_1.GMysqlMgr.cfg.auto) {
+        if (!global_1.global.gMysqlMgr.cfg.auto) {
             //未开启自动创建数据表
             return;
         }
         let droped = await this._checkDropTable(table.version);
         if (!droped) {
-            Log_1.GLog.info("table(" + this._table + ")无需升级...");
+            global_1.global.gLog.info("table(" + this._table + ")无需升级...");
             //既然版本号没变，就快速返回
             return;
         }
@@ -92,14 +90,14 @@ class MysqlBaseService {
         if (table.comment) {
             sql += " comment=\'" + table.comment + "\';";
         }
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql);
+        let sr = await global_1.global.gMysqlMgr.query(sql);
         if (sr.error) {
-            Log_1.GLog.error(sr.error);
+            global_1.global.gLog.error(sr.error);
             throw Error("table(" + this._table + ")创建失败...");
         }
         else {
-            DBCache_1.GDBCache.setVersion(this.table, table.version);
-            Log_1.GLog.info("table(" + this._table + ")初始化成功...");
+            global_1.global.gDbCache.setVersion(this.table, table.version);
+            global_1.global.gLog.info("table(" + this._table + ")初始化成功...");
             await this._onReCreated();
         }
     }
@@ -108,18 +106,18 @@ class MysqlBaseService {
     async _onDroped() {
     }
     async _checkDropTable(cur_version) {
-        let local_version = DBCache_1.GDBCache.getVersion(this._table);
+        let local_version = global_1.global.gDbCache.getVersion(this._table);
         if (local_version == cur_version) {
             return false;
         }
         let sql = "drop table if exists " + this._table;
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql);
+        let sr = await global_1.global.gMysqlMgr.query(sql);
         if (sr.error) {
-            Log_1.GLog.error(sr.error);
+            global_1.global.gLog.error(sr.error);
             throw Error(sr.error);
         }
         else {
-            Log_1.GLog.info("table(" + this._table + ")删除成功...");
+            global_1.global.gLog.info("table(" + this._table + ")删除成功...");
             await this._onDroped();
         }
         return true;
@@ -130,7 +128,7 @@ class MysqlBaseService {
      */
     async getById(id) {
         let tm = null;
-        let sr = await MysqlManager_1.GMysqlMgr.query("select * from " + this._table + " where id=? limit 1", [id]);
+        let sr = await global_1.global.gMysqlMgr.query("select * from " + this._table + " where id=? limit 1", [id]);
         if (sr.error || sr.queryResult.length <= 0) {
             return tm;
         }
@@ -146,7 +144,7 @@ class MysqlBaseService {
         }
         sql += " limit 1";
         let tm = null;
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         if (sr.queryResult && sr.queryResult.length > 0) {
             tm = sr.queryResult[0];
         }
@@ -160,7 +158,7 @@ class MysqlBaseService {
             sql += " where " + where;
         }
         let total = 0;
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         if (sr.queryResult && sr.queryResult.length > 0) {
             total = sr.queryResult[0].num || 0;
         }
@@ -174,7 +172,7 @@ class MysqlBaseService {
             sql += " where " + where;
         }
         let tms = null;
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         tms = sr.queryResult;
         return tms;
     }
@@ -183,7 +181,7 @@ class MysqlBaseService {
         if (where) {
             sql += " where " + where;
         }
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         if (sr.error || sr.queryResult.length <= 0) {
             return 0;
         }
@@ -201,7 +199,7 @@ class MysqlBaseService {
         args = args || [];
         args.push(num);
         let tms = null;
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         tms = sr.queryResult;
         return tms;
     }
@@ -219,7 +217,7 @@ class MysqlBaseService {
         if (limit) {
             sql += " limit " + limit;
         }
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         return sr;
     }
     async update(model, where, args, limit) {
@@ -240,7 +238,7 @@ class MysqlBaseService {
         if (limit) {
             sql += " limit " + limit;
         }
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         if (id) {
             model["id"] = id;
         }
@@ -263,17 +261,17 @@ class MysqlBaseService {
         let sql = "insert into " + this._table + " set ?";
         //这步的做法是为了去掉model种的TableProperty.key(___table___)
         model = JSON.parse(JSON.stringify(model));
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, [model]);
+        let sr = await global_1.global.gMysqlMgr.query(sql, [model]);
         return sr;
     }
     async removeById(id) {
         let sql = "delete from " + this._table + " where id=?";
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, [id]);
+        let sr = await global_1.global.gMysqlMgr.query(sql, [id]);
         return sr;
     }
     async remove(where, args) {
         let sql = "delete from " + this._table + " where " + where;
-        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        let sr = await global_1.global.gMysqlMgr.query(sql, args);
         return sr;
     }
 }