cgserver 12.3.6 → 13.0.1

package/dist/lib/Framework/Config/_error_.js

@@ -1,34 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FrameworkErrorCode = exports.EErrorCode = void 0;
+exports.FrameworkErrorCode = exports.Errcode = exports.EErrorCode = void 0;
 exports.EErrorCode = null;
+class Errcode {
+    id;
+    des;
+    constructor(id, des) {
+        this.id = id;
+        this.des = des;
+    }
+}
+exports.Errcode = Errcode;
 /**
  * 1-100
  */
 class FrameworkErrorCode {
-    Wrong_Params = { id: 1, des: "参数错误" };
-    Verify_failed = { id: 2, des: "验证失败" };
-    Account_Create_Failed = { id: 3, des: "账号创建失败" };
-    User_Create_Failed = { id: 4, des: "角色创建失败" };
-    Server_Error = { id: 5, des: "服务器内部错误" };
-    No_Account = { id: 6, des: "账户不存在" };
-    Mysql_Error = { id: 7, des: "数据库异常" };
-    No_Mysql = { id: 8, des: "未开通Mysql数据库" };
-    No_Mssql = { id: 8, des: "未开通Mssql数据库" };
-    No_User = { id: 9, des: "用户不存在" };
-    Account_Phone_Exist = { id: 10, des: "电话已存在" };
-    Account_Email_Exist = { id: 11, des: "邮箱已存在" };
-    Account_Name_Exist = { id: 12, des: "账户名已存在" };
-    Account_Type_Error = { id: 13, des: "账户类型错误" };
-    Email_Send_Failed = { id: 14, des: "邮件发送失败" };
-    Login_Failed = { id: 15, des: "登陆验证失败" };
-    Password_Too_Short = { id: 16, des: "密码太短" };
-    Wrong_Phone = { id: 17, des: "电话号码不正确" };
-    PhoneCode_Too_Quick = { id: 18, des: "验证码获取过快，请稍后再试" };
-    PhoneCode_GetFailed = { id: 19, des: "验证码获取失败" };
-    Wrong_Phone_Code = { id: 20, des: "验证码不正确" };
-    No_Mongo = { id: 21, des: "未开通Mongo数据库" };
-    Mongo_Error = { id: 22, des: "Mongo数据库异常" };
+    Wrong_Params = new Errcode(1, "参数错误");
+    Verify_failed = new Errcode(2, "验证失败");
+    Account_Create_Failed = new Errcode(3, "账号创建失败");
+    User_Create_Failed = new Errcode(4, "角色创建失败");
+    Server_Error = new Errcode(5, "服务器内部错误");
+    No_Account = new Errcode(6, "账户不存在");
+    Mysql_Error = new Errcode(7, "数据库异常");
+    No_Mysql = new Errcode(8, "未开通Mysql数据库");
+    No_Mssql = new Errcode(8, "未开通Mssql数据库");
+    No_User = new Errcode(9, "用户不存在");
+    Account_Phone_Exist = new Errcode(10, "电话已存在");
+    Account_Email_Exist = new Errcode(11, "邮箱已存在");
+    Account_Name_Exist = new Errcode(12, "账户名已存在");
+    Account_Type_Error = new Errcode(13, "账户类型错误");
+    Email_Send_Failed = new Errcode(14, "邮件发送失败");
+    Login_Failed = new Errcode(15, "登陆验证失败");
+    Password_Too_Short = new Errcode(16, "密码太短");
+    Wrong_Phone = new Errcode(17, "电话号码不正确");
+    PhoneCode_Too_Quick = new Errcode(18, "验证码获取过快，请稍后再试");
+    PhoneCode_GetFailed = new Errcode(19, "验证码获取失败");
+    Wrong_Phone_Code = new Errcode(20, "验证码不正确");
+    No_Mongo = new Errcode(21, "未开通Mongo数据库");
+    Mongo_Error = new Errcode(22, "Mongo数据库异常");
     constructor() { }
 }
 exports.FrameworkErrorCode = FrameworkErrorCode;

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

@@ -1,145 +1,169 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoBaseService = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const _error_1 = require("../../Config/_error_");
+const Log_1 = require("../../Logic/Log");
 const MongoManager_1 = require("./MongoManager");
-const MongoServiceManager_1 = require("./MongoServiceManager");
 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;
+    _model;
+    _schema;
+    _collection_name;
+    get model() {
+        if (this._model) {
+            return this._model;
         }
-        return this._dbname;
-    }
-    set dbname(db) {
-        this._dbname = db;
-    }
-    _t_type = null;
-    constructor(table, type, dbname = "") {
-        this._t_type = type;
-        this._table = table;
-        this._dbname = dbname;
-        MongoServiceManager_1.gMongoServiceMgr.addService(this);
-    }
-    async getNextId(key = "") {
-        if (!key) {
-            key = this._table;
+        if (mongoose_1.default.connection.readyState !== 1) {
+            Log_1.gLog.error("MongoDB connection is not ready, please check the connection settings. Current state: " + mongoose_1.default.connection.readyState);
+            throw new Error("MongoDB connection is not ready");
         }
-        let id = await this.mongoDb.getAutoIds(this._table);
-        return id;
+        let db = mongoose_1.default.connection.db;
+        if (!db || db.databaseName == "test") {
+            Log_1.gLog.error("MongoDB connection is not valid, please check the connection settings.");
+            throw new Error("MongoDB connection is not valid");
+        }
+        this._model = mongoose_1.default.model(this._collection_name, this._schema);
+        return this._model;
     }
-    toObjectId(id) {
-        return this.mongoDb.toObjectId(id);
+    constructor(collection_name, schema) {
+        this._collection_name = collection_name;
+        schema.set('collection', collection_name);
+        this._schema = schema;
     }
-    /**
-     * 没有id(非_id)的表不能使用该函数
-     * @param id
-     */
-    async getById(id) {
-        let rs = await this.mongoDb.findOne(this._table, { id: id });
-        return rs.one;
+    async findOne(filter, projection, options) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        return await this.model.findOne(filter, projection, options);
     }
-    async findOne(where = null, property = null) {
-        let rs = await this.mongoDb.findOne(this._table, where, property);
-        return rs.one;
+    async find(filter, projection, options) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        return await this.model.find(filter, projection, options);
     }
-    async findOneAndUpdate(where = null, update, options) {
-        let rs = await this.mongoDb.findOneAndUpdate(this._table, where, update, options);
-        return rs;
+    async findMany(filter, projection, options, skip, limit) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        let query = this.model.find(filter, projection, options);
+        if (skip !== undefined) {
+            query = query.skip(skip);
+        }
+        if (limit !== undefined) {
+            query = query.limit(limit);
+        }
+        return await query.exec();
     }
-    async countDocuments(where = null, options) {
-        let rs = await this.mongoDb.countDocuments(this._table, where);
-        return rs.count;
+    async findById(id, projection, options) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        return await this.model.findById(id, projection, options);
     }
-    async findMany(where = null, property = null, sort = null, skip = 0, limit = 0) {
-        let rs = await this.mongoDb.findMany(this._table, where, property, sort, skip, limit);
-        return rs.list;
+    async create(doc) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        const newDoc = new this.model(doc);
+        return await newDoc.save();
+    }
+    async insert(doc) {
+        try {
+            if (!this.model) {
+                throw new Error("Model is not defined");
+            }
+            const newDoc = await this.model.insertOne(doc);
+            return { errcode: null, model: newDoc };
+        }
+        catch (error) {
+            Log_1.gLog.error(arguments);
+            Log_1.gLog.error("MongoDB insert error:", error.stack);
+            return { errcode: _error_1.EErrorCode.Mongo_Error, model: null };
+        }
     }
-    async getRandoms(num, where, property = null) {
-        let rs = await this.mongoDb.simpleAggregate(this._table, where, property, null, num);
-        return rs.list;
+    async updateOne(filter, update, options) {
+        try {
+            if (!this.model) {
+                throw new Error("Model is not defined");
+            }
+            let rs = await this.model.updateOne(filter, update, options);
+            return { errcode: null, rs: rs };
+        }
+        catch (error) {
+            return { errcode: _error_1.EErrorCode.Mongo_Error, rs: null };
+        }
     }
-    async updateOne(where, model, options) {
-        let rs = await this.mongoDb.updateOne(this._table, where, model, options);
-        return rs;
+    async updateMany(filter, update, options) {
+        try {
+            if (!this.model) {
+                throw new Error("Model is not defined");
+            }
+            await this.model.updateMany(filter, update, options);
+            return { errcode: null };
+        }
+        catch (error) {
+            return { errcode: error };
+        }
     }
-    async updateMany(where, model = null, options) {
-        let rs = await this.mongoDb.updateMany(this._table, where, model, options);
-        return rs;
+    async deleteOne(filter) {
+        try {
+            if (!this.model) {
+                throw new Error("Model is not defined");
+            }
+            let rs = await this.model.deleteOne(filter);
+            return { errcode: null, rs: rs };
+        }
+        catch (error) {
+            return { errcode: _error_1.EErrorCode.Mongo_Error, rs: null };
+        }
     }
-    async insert(model) {
-        let rs = await this.mongoDb.insertOne(this._table, model);
-        return rs;
+    async deleteMany(filter) {
+        try {
+            if (!this.model) {
+                throw new Error("Model is not defined");
+            }
+            await this.model.deleteMany(filter);
+            return { errcode: null };
+        }
+        catch (error) {
+            return { errcode: error };
+        }
     }
-    async deleteOne(where) {
-        let rs = await this.mongoDb.deleteOne(this._table, where);
-        return rs;
+    async exists(filter) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        const doc = await this.model.findOne(filter, { _id: 1 });
+        return !!doc;
     }
-    async deleteMany(where) {
-        let rs = await this.mongoDb.deleteMany(this._table, where);
-        return rs;
+    // 用于聚合查询
+    aggregate(pipeline) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        return this.model.aggregate(pipeline);
     }
-    async createIndex(index, options) {
-        let rs = await this.mongoDb.createIndex(this._table, index, options);
+    // findOneAndUpdate method for MongoDB operations
+    async findOneAndUpdate(filter, update, options) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        let rs = await this.model.findOneAndUpdate(filter, update, 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];
-    }
-    async distinct(key, where = {}) {
-        let rs = await this.mongoDb.distinct(this._table, key, where);
-        return rs;
+    async countDocuments(filter) {
+        if (!this.model) {
+            throw new Error("Model is not defined");
+        }
+        return await this.model.countDocuments(filter);
     }
-    async bulkWrite(operations, options) {
-        let bwr = await this.mongoDb.bulkWrite(this._table, operations, options);
-        return bwr;
+    async getAutoIds() {
+        let id = await MongoManager_1.gMongoMgr.getMongo().getAutoIds(this.model.collection.name);
+        return id;
     }
 }
 exports.MongoBaseService = MongoBaseService;