cgserver 12.0.8 → 12.2.0

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

@@ -1,547 +1,595 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gMongoMgr = 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 Log_1 = require("../../Logic/Log");
-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;
-        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;
-        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 && 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, where = {}, property = {}) {
-        if (!where) {
-            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 distinct(collection, key, where = {}) {
-        if (!where) {
-            where = {};
-        }
-        this._convertWhere(where);
-        let rs = { errcode: null, lst: null };
-        if (!this._mongoDb) {
-            rs.errcode = _error_1.EErrorCode.No_Mongo;
-            return rs;
-        }
-        let lst = null;
-        try {
-            let col = this._mongoDb.collection(collection);
-            lst = await col.distinct(key, where);
-        }
-        catch (e) {
-            Log_1.gLog.error({ collection, key, where });
-            Log_1.gLog.error(e.stack);
-            rs.errcode = _error_1.EErrorCode.Mongo_Error;
-        }
-        rs.lst = lst;
-        return rs;
-    }
-    async findMany(collection, where = {}, property = {}, sort, skip = 0, limit = 0) {
-        if (!where) {
-            where = {};
-        }
-        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, where, model, options) {
-        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, options);
-        }
-        catch (e) {
-            Log_1.gLog.error({ collection, model, where, options });
-            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, where, model, options) {
-        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, options);
-        }
-        catch (e) {
-            Log_1.gLog.error({ collection, model, where, options });
-            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, 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) {
-            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;
-    }
-    async bulkWrite(collection, operations, options) {
-        if (!this._mongoDb) {
-            return;
-        }
-        let bulk = this._mongoDb.collection(collection);
-        let bwr = bulk.bulkWrite(operations, options);
-        return bwr;
-    }
-}
-exports.MongoExt = MongoExt;
-exports.gMongoMgr = new MongoManager();
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gMongoMgr = exports.MongoExt = exports.MongoManager = exports.MgReturn = exports.MrResult = exports.MongoBaseModel = exports.MongoConfig = void 0;
+const mongo = __importStar(require("mongodb"));
+const _error_1 = require("../../Config/_error_");
+const Core_1 = require("../../Core/Core");
+const Log_1 = require("../../Logic/Log");
+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;
+        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;
+        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);
+        this._mongoClient.on("connectionCreated", this.onConnectionCreated.bind(this));
+        this._mongoClient.on("connectionReady", this.onConnectionReady.bind(this));
+        this._mongoClient.on("connectionClosed", this.onConnectionClosed.bind(this));
+        this._mongoClient.connect();
+        return true;
+    }
+    onConnectionCreated(event) {
+        Log_1.gLog.info({ key: "mongo onConnectionCreated", event });
+    }
+    onConnectionReady(event) {
+        Log_1.gLog.info({ key: "mongo onConnectionReady", event });
+        this.onConnect();
+        this._mongoDb = this._mongoClient.db(this._mongocfg.database);
+        for (let i = 0; i < this._init_cbs.length; ++i) {
+            this._init_cbs[i]();
+        }
+        this._init_cbs = [];
+    }
+    onConnectionClosed(event) {
+        Log_1.gLog.info({ key: "mongo onConnectionClosed", event });
+        this._inited = false;
+        this.init(this._mongocfg);
+    }
+    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 && 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.BSON.ObjectId(id);
+    }
+    /**
+     * 获取单条消息
+     * @param collection
+     */
+    async findOne(collection, where = {}, property = {}) {
+        if (!where) {
+            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 distinct(collection, key, where = {}) {
+        if (!where) {
+            where = {};
+        }
+        this._convertWhere(where);
+        let rs = { errcode: null, lst: null };
+        if (!this._mongoDb) {
+            rs.errcode = _error_1.EErrorCode.No_Mongo;
+            return rs;
+        }
+        let lst = null;
+        try {
+            let col = this._mongoDb.collection(collection);
+            lst = await col.distinct(key, where);
+        }
+        catch (e) {
+            Log_1.gLog.error({ collection, key, where });
+            Log_1.gLog.error(e.stack);
+            rs.errcode = _error_1.EErrorCode.Mongo_Error;
+        }
+        rs.lst = lst;
+        return rs;
+    }
+    async findMany(collection, where = {}, property = {}, sort, skip = 0, limit = 0) {
+        if (!where) {
+            where = {};
+        }
+        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, where, model, options) {
+        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, options);
+        }
+        catch (e) {
+            Log_1.gLog.error({ collection, model, where, options });
+            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, where, model, options) {
+        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, options);
+        }
+        catch (e) {
+            Log_1.gLog.error({ collection, model, where, options });
+            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, 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) {
+            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;
+    }
+    async bulkWrite(collection, operations, options) {
+        if (!this._mongoDb) {
+            return;
+        }
+        let bulk = this._mongoDb.collection(collection);
+        let bwr = bulk.bulkWrite(operations, options);
+        return bwr;
+    }
+}
+exports.MongoExt = MongoExt;
+exports.gMongoMgr = new MongoManager();