cgserver 8.9.2 → 8.9.4

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

@@ -1,466 +1,467 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMongoMgr = 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;
-exports.GMongoMgr = null;
-class MongoManager {
-    _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));
-        let client = new mongo.MongoClient("mongodb://" + this._mongocfg.host + ":" + this._mongocfg.port, this._mongocfg.options);
-        await Core_1.core.safeCall(client.connect, client);
-        this.onConnect();
-        this._mongoDb = client.db(this._mongocfg.database);
-        for (let i = 0; i < this._init_cbs.length; ++i) {
-            this._init_cbs[i]();
-        }
-        return true;
-    }
-    registerInitCb(cb) {
-        this._init_cbs.push(cb);
-    }
-    onConnect() {
-        this._mongo_init_succ = true;
-        Log_1.GLog.info("mongo has connected!");
-    }
-    onEnd() {
-        this._mongo_init_succ = false;
-        Log_1.GLog.error("mongo has ended!");
-        Log_1.GLog.info("mongo try reconnect");
-        this.init(this._mongocfg);
-    }
-    onError(err) {
-        Log_1.GLog.error("Error " + err);
-        Log_1.GLog.info("mongo try reconnect");
-        this.init(this._mongocfg);
-    }
-    /**
-     * 获取自增长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 = new mongo.ObjectId(_id);
-            }
-            catch (e) {
-                where._id = _id;
-            }
-        }
-        return where;
-    }
-    /**
-     * 获取单条消息
-     * @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.GMongoMgr = new MongoManager();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoManager = exports.GMongoMgr = 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;
+exports.GMongoMgr = null;
+class MongoManager {
+    _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));
+        let client = new mongo.MongoClient("mongodb://" + this._mongocfg.host + ":" + this._mongocfg.port, this._mongocfg.options);
+        await Core_1.core.safeCall(client.connect, client);
+        this.onConnect();
+        this._mongoDb = client.db(this._mongocfg.database);
+        for (let i = 0; i < this._init_cbs.length; ++i) {
+            this._init_cbs[i]();
+        }
+        return true;
+    }
+    registerInitCb(cb) {
+        this._init_cbs.push(cb);
+    }
+    onConnect() {
+        this._mongo_init_succ = true;
+        Log_1.GLog.info("mongo has connected!");
+    }
+    onEnd() {
+        this._mongo_init_succ = false;
+        Log_1.GLog.error("mongo has ended!");
+        Log_1.GLog.info("mongo try reconnect");
+        this.init(this._mongocfg);
+    }
+    onError(err) {
+        Log_1.GLog.error("Error " + err);
+        Log_1.GLog.info("mongo try reconnect");
+        this.init(this._mongocfg);
+    }
+    /**
+     * 获取自增长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 = new mongo.ObjectId(_id);
+            }
+            catch (e) {
+                where._id = _id;
+            }
+        }
+        return where;
+    }
+    /**
+     * 获取单条消息
+     * @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.MongoManager = MongoManager;
+exports.GMongoMgr = new MongoManager();