cgserver 6.2.2 → 6.2.7

package/dist/lib/Core/Core.js

@@ -32,6 +32,12 @@ class core {
     static isString(param) {
         return typeof (param) === "string";
     }
+    static isAsyncFunc(fun) {
+        if (!this.isFunction(fun)) {
+            return;
+        }
+        return fun[Symbol.toStringTag] === "AsyncFunction";
+    }
     /**
      * 深度拷贝
      * @param obj

package/dist/lib/Database/MongoBaseService.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoBaseService = void 0;
+const MongoManager_1 = require("./MongoManager");
+class MongoBaseService {
+    _table = "";
+    get table() {
+        return this._table;
+    }
+    _inited = false;
+    get isInited() {
+        return this._inited;
+    }
+    get mongo() {
+        return MongoManager_1.GMongoMgr.mongo;
+    }
+    _t_type = null;
+    constructor(table, type) {
+        this._t_type = type;
+        this._table = table;
+    }
+    async getNextId() {
+        let id = await MongoManager_1.GMongoMgr.getAutoIds(this._table);
+        return id;
+    }
+    /**
+     * 没有id(非_id)的表不能使用该函数
+     * @param id
+     */
+    async getById(id) {
+        let rs = await MongoManager_1.GMongoMgr.findOne(this._table, null, { id: id });
+        return rs.one;
+    }
+    async get(proterty, where, sort) {
+        let rs = await MongoManager_1.GMongoMgr.findOne(this._table, proterty, where, sort);
+        return rs.one;
+    }
+    async countDocuments(where, options) {
+        let rs = await MongoManager_1.GMongoMgr.countDocuments(this._table, where);
+        return rs.count;
+    }
+    async gets(property, where, sort, skip = 0, limit = 0) {
+        let rs = await MongoManager_1.GMongoMgr.findMany(this._table, property, where, sort, skip, limit);
+        return rs.list;
+    }
+    async getRandoms(num, proterty, where) {
+        let rs = await MongoManager_1.GMongoMgr.simpleAggregate(this._table, proterty, where, null, num);
+        return rs.list;
+    }
+    async updateOne(model, where, upsert = false) {
+        let rs = await MongoManager_1.GMongoMgr.updateOne(this._table, model, where, upsert);
+        return rs;
+    }
+    async updateMany(models, where) {
+        let rs = await MongoManager_1.GMongoMgr.updateMany(this._table, models, where);
+        return rs;
+    }
+    async insert(model) {
+        let rs = await MongoManager_1.GMongoMgr.insertOne(this._table, model);
+        return rs;
+    }
+    async deleteOne(where) {
+        let rs = await MongoManager_1.GMongoMgr.deleteOne(this._table, where);
+        return rs;
+    }
+    async deleteMany(where) {
+        let rs = await MongoManager_1.GMongoMgr.deleteMany(this._table, where);
+        return rs;
+    }
+    async createIndex(index, options) {
+        let rs = await MongoManager_1.GMongoMgr.createIndex(this._table, index, options);
+        return rs;
+    }
+    aggregate(pipeline, options) {
+        let ret = MongoManager_1.GMongoMgr.aggregate(this._table, pipeline, options);
+        return ret;
+    }
+}
+exports.MongoBaseService = MongoBaseService;

package/dist/lib/Database/MongoManager.js

@@ -133,12 +133,7 @@ class MongoManager {
         let one = null;
         try {
             let col = this._mongo.collection(collection);
-            if (!sort) {
-                one = await col.findOne(where, property);
-            }
-            else {
-                one = await (col.find(where, property).sort(sort).limit(1).next());
-            }
+            one = await col.findOne(where, { projection: property });
         }
         catch (e) {
             Log_1.GLog.error(e.stack);

package/dist/lib/Database/MysqlBaseService.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlBaseService = exports.BaseModel = void 0;
+const Property_1 = require("./Decorator/Property");
+const MysqlManager_1 = require("./MysqlManager");
+const Log_1 = require("../Logic/Log");
+const DBCache_1 = require("./Decorator/DBCache");
+const FrameworkConfig_1 = require("../Config/FrameworkConfig");
+class BaseModel {
+}
+exports.BaseModel = BaseModel;
+class MysqlBaseService {
+    _table = "";
+    get table() {
+        return this._table;
+    }
+    get version() {
+        let table = this._t_type.prototype[Property_1.TableProperty.key];
+        return table.version;
+    }
+    _inited = false;
+    get isInited() {
+        return this._inited;
+    }
+    _t_type = null;
+    constructor(type) {
+        this._t_type = type;
+        if (MysqlManager_1.GMysqlMgr.isValid) {
+            this._init();
+        }
+        else {
+            MysqlManager_1.GMysqlMgr.registerInitCb(this._init.bind(this));
+        }
+    }
+    async _init() {
+        if (this._inited) {
+            return;
+        }
+        this._inited = true;
+        let table = this._t_type.prototype[Property_1.TableProperty.key];
+        if (!table || !table.table) {
+            throw new Error("数据表的类必须要具有Table装饰器");
+        }
+        this._table = "`" + table.table + "`";
+        if (!FrameworkConfig_1.GFCfg.db.mysql.auto) {
+            //未开启自动创建数据表
+            return;
+        }
+        let droped = await this._checkDropTable(table.version);
+        if (!droped) {
+            Log_1.GLog.info("table(" + this._table + ")无需升级...", true);
+            //既然版本号没变，就快速返回
+            return;
+        }
+        let primary_key = null;
+        let sql = "create table if not exists " + this._table + " (";
+        for (let key in table.items) {
+            let item = table.items[key];
+            sql += "`" + key + "`" + " " + item.type;
+            if (item.type == Property_1.EPropertyType.Varchar
+                || item.type == Property_1.EPropertyType.Char
+                || item.type == Property_1.EPropertyType.NVarchar) {
+                sql += "(" + item.type_len + ")";
+            }
+            if (item.is_notnull) {
+                sql += " not null";
+            }
+            if (item.default != undefined && !item.is_primary) {
+                sql += " default \'" + item.default + "\'";
+            }
+            if (item.auto_increment) {
+                sql += " auto_increment";
+            }
+            if (item.is_primary) {
+                primary_key = key;
+            }
+            sql += ",";
+        }
+        if (primary_key) {
+            sql += "primary key (`" + primary_key + "`),";
+            sql += "unique key `" + primary_key + "_unique` (`" + primary_key + "`)";
+        }
+        else {
+            //去掉最后一个逗号
+            sql = sql.substr(0, sql.length - 1);
+        }
+        sql += ")";
+        sql += " engine=" + table.engine;
+        if (table.auto_increment != null) {
+            sql += " auto_increment=" + table.auto_increment;
+        }
+        sql += " default charset=" + table.charset;
+        if (table.comment) {
+            sql += " comment=\'" + table.comment + "\';";
+        }
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql);
+        if (sr.error) {
+            Log_1.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 + ")初始化成功...", true);
+            await this._onReCreated();
+        }
+    }
+    async _onReCreated() {
+    }
+    async _onDroped() {
+    }
+    async _checkDropTable(cur_version) {
+        let local_version = DBCache_1.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);
+        if (sr.error) {
+            Log_1.GLog.error(sr.error);
+            throw Error(sr.error);
+        }
+        else {
+            Log_1.GLog.info("table(" + this._table + ")删除成功...", true);
+            await this._onDroped();
+        }
+        return true;
+    }
+    /**
+     * 没有id的表不能使用该函数
+     * @param id
+     */
+    async getById(id) {
+        let tm = null;
+        let sr = await MysqlManager_1.GMysqlMgr.query("select * from " + this._table + " where id=? limit 1", [id]);
+        if (sr.error || sr.results.length <= 0) {
+            return tm;
+        }
+        tm = sr.results[0];
+        return tm;
+    }
+    async get(proterty, where, args) {
+        let sql = "select ";
+        sql += proterty || "*";
+        sql += " from " + this._table;
+        if (where) {
+            sql += " where " + where;
+        }
+        sql += " limit 1";
+        let tm = null;
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        if (sr.list && sr.list.length > 0) {
+            tm = sr.list[0];
+        }
+        return tm;
+    }
+    async getTotal(where, args) {
+        let sql = "select ";
+        sql += "count(*) as num";
+        sql += " from " + this._table;
+        if (where) {
+            sql += " where " + where;
+        }
+        let total = 0;
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        if (sr.list && sr.list.length > 0) {
+            total = sr.list[0].num || 0;
+        }
+        return total;
+    }
+    async gets(proterty, where, args) {
+        let sql = "select ";
+        sql += proterty || "*";
+        sql += " from " + this._table;
+        if (where) {
+            sql += " where " + where;
+        }
+        let tms = null;
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        tms = sr.list;
+        return tms;
+    }
+    async getCount(where, args) {
+        let sql = "select count(*) as num from " + this._table;
+        if (where) {
+            sql += " where " + where;
+        }
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        if (sr.error || sr.results.length <= 0) {
+            return 0;
+        }
+        return sr.results[0]["num"] || 0;
+    }
+    async getRandoms(num, proterty, where, args) {
+        num = num || 5;
+        let sql = "select ";
+        sql += proterty || "*";
+        sql += " from " + this._table;
+        if (where) {
+            sql += " where " + where;
+        }
+        sql += " order by rand() limit ?";
+        args = args || [];
+        args.push(num);
+        let tms = null;
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        tms = sr.list;
+        return tms;
+    }
+    async updateProperty(set, where, args, limit) {
+        let sql = "update " + this._table + " set ";
+        if (set) {
+            sql += set;
+        }
+        else {
+            sql += "?";
+        }
+        if (where) {
+            sql += " where " + where;
+        }
+        if (limit) {
+            sql += " limit " + limit;
+        }
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        return sr;
+    }
+    async update(model, where, args, limit) {
+        let sql = "update " + this._table + " set ?";
+        if (!where) {
+            where = " id=?";
+        }
+        sql += " where " + where;
+        let id = model["id"];
+        delete model["id"];
+        let u_m = JSON.parse(JSON.stringify(model));
+        if (!args) {
+            args = [u_m, id];
+        }
+        else {
+            args.unshift(u_m);
+        }
+        if (limit) {
+            sql += " limit " + limit;
+        }
+        let sr = await MysqlManager_1.GMysqlMgr.query(sql, args);
+        if (id) {
+            model["id"] = id;
+        }
+        return sr;
+    }
+    async insert(model, ip) {
+        let table = model[Property_1.TableProperty.key];
+        let id_property = table.items["id"];
+        if (id_property) {
+            if (id_property.auto_increment) {
+                delete model["id"];
+            }
+        }
+        if (table.items["create_time"] && model["create_time"] <= 0) {
+            model["create_time"] = Date.now();
+        }
+        if (table.items["create_ip"] && ip) {
+            model["create_ip"] = ip;
+        }
+        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]);
+        return sr;
+    }
+    async removeById(id) {
+        let sql = "delete from " + this._table + " where id=?";
+        let sr = await MysqlManager_1.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);
+        return sr;
+    }
+}
+exports.MysqlBaseService = MysqlBaseService;

package/dist/lib/Service/AccountService.js

@@ -8,7 +8,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountService = exports.GAccountSer = exports.AccountModel = void 0;
 const Property_1 = require("./../Database/Decorator/Property");
-const BaseService_1 = require("./../Database/BaseService");
+const MysqlBaseService_1 = require("../Database/MysqlBaseService");
 const CacheTool_1 = require("../Logic/CacheTool");
 const _error_1 = require("../Config/_error_");
 const OpenSocial_1 = require("../ThirdParty/OpenSocial");
@@ -21,7 +21,7 @@ const NotNull_1 = require("../Database/Decorator/NotNull");
 const Type_1 = require("../Database/Decorator/Type");
 const AutoIncrement_1 = require("../Database/Decorator/AutoIncrement");
 const ini_1 = require("./ini");
-let AccountModel = class AccountModel extends BaseService_1.BaseModel {
+let AccountModel = class AccountModel extends MysqlBaseService_1.BaseModel {
     id = -1;
     phone = "";
     email = "";
@@ -96,7 +96,7 @@ AccountModel = __decorate([
 exports.AccountModel = AccountModel;
 //暂时不实例化，方便重写
 exports.GAccountSer = null;
-class AccountService extends BaseService_1.BaseService {
+class AccountService extends MysqlBaseService_1.MysqlBaseService {
     _account_cache_key_pre = "table_account_";
     _account_cache_time_sec = 1 * 60 * 60 * 1000;
     constructor() {

package/dist/lib/Service/MongoAccountService.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountService = exports.GAccountSer = exports.AccountModel = void 0;
 const _error_1 = require("../Config/_error_");
-const BaseMongoService_1 = require("../Database/BaseMongoService");
+const MongoBaseService_1 = require("../Database/MongoBaseService");
 const MongoManager_1 = require("../Database/MongoManager");
 const CacheTool_1 = require("../Logic/CacheTool");
 const OpenSocial_1 = require("../ThirdParty/OpenSocial");
@@ -28,7 +28,7 @@ class AccountModel extends MongoManager_1.MongoBaseModel {
 exports.AccountModel = AccountModel;
 //暂时不实例化，方便重写
 exports.GAccountSer = null;
-class AccountService extends BaseMongoService_1.BaseService {
+class AccountService extends MongoBaseService_1.MongoBaseService {
     _account_cache_key_pre = "table_account_";
     _account_cache_time_sec = 1 * 60 * 60 * 1000;
     constructor() {

package/dist/lib/Service/MongoCacheService.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GMongoCacheSer = exports.MongoCacheModel = void 0;
-const BaseMongoService_1 = require("../Database/BaseMongoService");
+const MongoBaseService_1 = require("../Database/MongoBaseService");
 const MongoManager_1 = require("../Database/MongoManager");
 //暂时就用这个了，反正没啥用户
 class MongoCacheModel extends MongoManager_1.MongoBaseModel {
@@ -11,7 +11,7 @@ class MongoCacheModel extends MongoManager_1.MongoBaseModel {
 }
 exports.MongoCacheModel = MongoCacheModel;
 exports.GMongoCacheSer = null;
-class MongoCacheService extends BaseMongoService_1.BaseService {
+class MongoCacheService extends MongoBaseService_1.MongoBaseService {
     constructor() {
         super("cache", MongoCacheModel);
         this.createIndex({ "expireAt": 1 }, { expireAfterSeconds: 0 });

package/dist/lib/Service/MongoUserService.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserService = exports.GUserSer = exports.UserModel = void 0;
 const _ = require("underscore");
-const BaseMongoService_1 = require("../Database/BaseMongoService");
+const MongoBaseService_1 = require("../Database/MongoBaseService");
 const MongoManager_1 = require("../Database/MongoManager");
 const ini_1 = require("./ini");
 class UserModel extends MongoManager_1.MongoBaseModel {
@@ -30,7 +30,7 @@ class UserModel extends MongoManager_1.MongoBaseModel {
 exports.UserModel = UserModel;
 //暂时不实例化，方便重写
 exports.GUserSer = null;
-class UserService extends BaseMongoService_1.BaseService {
+class UserService extends MongoBaseService_1.MongoBaseService {
     constructor(type) {
         super("user", type);
         exports.GUserSer = this;

package/dist/lib/Service/UserService.js

@@ -8,13 +8,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserService = exports.GUserSer = exports.UserModel = void 0;
 const _ = require("underscore");
-const BaseService_1 = require("../Database/BaseService");
+const MysqlBaseService_1 = require("../Database/MysqlBaseService");
 const PrimaryKey_1 = require("../Database/Decorator/PrimaryKey");
 const NotNull_1 = require("../Database/Decorator/NotNull");
 const Property_1 = require("../Database/Decorator/Property");
 const Type_1 = require("../Database/Decorator/Type");
 const ini_1 = require("./ini");
-class UserModel extends BaseService_1.BaseModel {
+class UserModel extends MysqlBaseService_1.BaseModel {
     id = -1;
     account_id = -1;
     nickname = "";
@@ -120,7 +120,7 @@ __decorate([
 exports.UserModel = UserModel;
 //暂时不实例化，方便重写
 exports.GUserSer = null;
-class UserService extends BaseService_1.BaseService {
+class UserService extends MysqlBaseService_1.MysqlBaseService {
     constructor(type) {
         super(type);
         exports.GUserSer = this;

package/dist/lib/SocketServer/IWebSocket.js

@@ -99,7 +99,7 @@ class IWebSocket {
             }
         }
         catch (e) {
-            Log_1.GLog.error('Received Message Handle Error: ' + e);
+            Log_1.GLog.error(this.tipKey + ' Received Message Handle Error: ' + e);
         }
     }
     _onDecode(message, ...params) {
@@ -135,73 +135,81 @@ class IWebSocket {
             && jsonData
             && jsonData.cmd != "heartbeat") {
             Log_1.GLog.info(this.tipKey + "  receive:--------", true);
-            Log_1.GLog.info(jsonData, true);
+            Log_1.GLog.info({ tipKey: this.tipKey, jsonData }, true);
         }
         if (!jsonData.cmd || jsonData.cmd == "") {
-            Log_1.GLog.error('Received Message warning: no cmd param,data=');
-            Log_1.GLog.error(jsonData);
+            Log_1.GLog.error(this.tipKey + ' Received Message warning: no cmd param,data=');
+            Log_1.GLog.error({ tipKey: this.tipKey, jsonData });
             return false;
         }
         return true;
     }
     async _onMessage(data) {
         let jsonData = data;
+        let func = this["receive_" + jsonData.cmd];
         let ret = this.filterMsg(jsonData);
         if (!ret) {
             return;
         }
-        else if (!this["receive_" + jsonData.cmd]) {
-            if (this["receive_other_all"]) {
+        else if (!func) {
+            let otherfunc = this["receive_other_all"];
+            if (otherfunc) {
                 try {
-                    await this["receive_other_all"](jsonData); //默认支持其他所有处理消息
-                }
-                catch (e) {
-                    if (e && e.stack) {
-                        Log_1.GLog.error(e.stack);
+                    if (Core_1.core.isAsyncFunc(otherfunc)) {
+                        //默认支持其他所有处理消息
+                        await otherfunc(jsonData).catch((reason) => {
+                            Log_1.GLog.error(reason);
+                        });
                     }
                     else {
-                        Log_1.GLog.error(e + "  msg:data=" + JSON.stringify(jsonData));
+                        otherfunc(jsonData);
                     }
                 }
+                catch (e) {
+                    Log_1.GLog.error(this.tipKey + e.stack);
+                }
             }
             else {
-                Log_1.GLog.error('Received Message warning: no cmd handle,cmd=' + jsonData.cmd);
+                Log_1.GLog.error(this.tipKey + ' Received Message warning: no cmd handle,cmd=' + jsonData.cmd);
             }
         }
         else {
             try {
-                await this["receive_" + jsonData.cmd](jsonData);
-            }
-            catch (e) {
-                if (e && e.stack) {
-                    Log_1.GLog.error("error msg:data=" + JSON.stringify(jsonData) + "\n" + e.stack);
+                if (Core_1.core.isAsyncFunc(func)) {
+                    //默认支持其他所有处理消息
+                    await func(jsonData).catch((reason) => {
+                        Log_1.GLog.error(reason);
+                    });
                 }
                 else {
-                    Log_1.GLog.error(e + "  msg:data=" + JSON.stringify(jsonData));
+                    func(jsonData);
                 }
             }
+            catch (e) {
+                Log_1.GLog.error(this.tipKey + " error msg:data=" + JSON.stringify(jsonData) + "\n" + e.stack);
+            }
         }
     }
     onOpen(e) {
     }
     onError(e) {
-        Log_1.GLog.info("onError:" + e.message);
+        Log_1.GLog.error(this.tipKey + " onError:" + e.message);
     }
     onClose(reasonCode, description) {
-        Log_1.GLog.info("onClose resonCode=" + reasonCode + "  des=" + description);
+        Log_1.GLog.info(this.tipKey + " onClose resonCode=" + reasonCode + "  des=" + description);
     }
     send(data) {
         if (!this.connected) {
             return;
         }
         if (!data) {
-            Log_1.GLog.error("Send Message warning:null data!");
+            Log_1.GLog.error(this.tipKey + " Send Message warning:null data!");
             return;
         }
         if (this._debug_msg
             && data.cmd != "heartbeat") {
             Log_1.GLog.info(this.tipKey + "  send:-----------------------------------", true);
-            Log_1.GLog.info(data, true);
+            Log_1.GLog.info({ tipKey: this.tipKey, data }, true);
         }
         let msg = this._onEncode(data);
         this._ws.send(msg);

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

@@ -60,7 +60,19 @@ class Engine {
                 credentials: this._cfg.cors.credentials || false
             }));
         }
-        this._app.all("/*", this._all.bind(this));
+        this._app.all("/*", (_req, _res) => {
+            this._all(_req, _res).catch((reason) => {
+                Log_1.GLog.error(reason);
+                let res = new Response_1.Response(_res, this._cfg);
+                let method = _req.method.toLowerCase();
+                if (method == "post") {
+                    res.renderJson500();
+                }
+                else if (method == "get") {
+                    res.render500();
+                }
+            });
+        });
     }
     async _all(_req, _res) {
         let req = new Request_1.Request(_req, this._cfg);

package/dist/lib/WebServer/Engine/Response.js

@@ -53,7 +53,10 @@ class Response {
         this._res.send(html || "");
     }
     render404(html) {
-        this._res.status(404).send("没找到该页面");
+        this._res.status(404).send(html || "没找到该页面");
+    }
+    render500(html) {
+        this._res.status(500).send(html || "服务器内部错误500");
     }
     renderOptions(method, origin) {
         this._res.sendStatus(204);

package/dist/lib/cgserver.js

@@ -47,18 +47,18 @@ var Type_1 = require("./Database/Decorator/Type");
 Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return Type_1.Type; } });
 var Property_2 = require("./Database/Decorator/Property");
 Object.defineProperty(exports, "EPropertyType", { enumerable: true, get: function () { return Property_2.EPropertyType; } });
-var BaseMongoService_1 = require("./Database/BaseMongoService");
-Object.defineProperty(exports, "MongoBaseService", { enumerable: true, get: function () { return BaseMongoService_1.BaseService; } });
-var BaseService_1 = require("./Database/BaseService");
-Object.defineProperty(exports, "MysqlBaseModel", { enumerable: true, get: function () { return BaseService_1.BaseModel; } });
+var MongoBaseService_1 = require("./Database/MongoBaseService");
+Object.defineProperty(exports, "MongoBaseService", { enumerable: true, get: function () { return MongoBaseService_1.MongoBaseService; } });
+var MysqlBaseService_1 = require("./Database/MysqlBaseService");
+Object.defineProperty(exports, "MysqlBaseModel", { enumerable: true, get: function () { return MysqlBaseService_1.BaseModel; } });
 var MongoManager_1 = require("./Database/MongoManager");
 Object.defineProperty(exports, "MongoBaseModel", { enumerable: true, get: function () { return MongoManager_1.MongoBaseModel; } });
 var MongoManager_2 = require("./Database/MongoManager");
 Object.defineProperty(exports, "GMongoMgr", { enumerable: true, get: function () { return MongoManager_2.GMongoMgr; } });
 var MSSqlManager_1 = require("./Database/MSSqlManager");
 Object.defineProperty(exports, "GMSSqlMgr", { enumerable: true, get: function () { return MSSqlManager_1.GMSSqlMgr; } });
-var BaseService_2 = require("./Database/BaseService");
-Object.defineProperty(exports, "MysqlBaseService", { enumerable: true, get: function () { return BaseService_2.BaseService; } });
+var MysqlBaseService_2 = require("./Database/MysqlBaseService");
+Object.defineProperty(exports, "MysqlBaseService", { enumerable: true, get: function () { return MysqlBaseService_2.MysqlBaseService; } });
 var MysqlManager_1 = require("./Database/MysqlManager");
 Object.defineProperty(exports, "GMysqlMgr", { enumerable: true, get: function () { return MysqlManager_1.GMysqlMgr; } });
 var RedisManager_1 = require("./Database/RedisManager");
@@ -157,3 +157,4 @@ var Response_1 = require("./WebServer/Engine/Response");
 Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return Response_1.Response; } });
 var FrameworkConfig_2 = require("./Config/FrameworkConfig");
 Object.defineProperty(exports, "WebServerConfig", { enumerable: true, get: function () { return FrameworkConfig_2.WebServerConfig; } });
+process.env.TZ = "Asia/Shanghai";

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

@@ -13,6 +13,7 @@ export declare class core {
     static isNaN(param: any): boolean;
     static isFunction(param: any): boolean;
     static isString(param: any): boolean;
+    static isAsyncFunc(fun: any): boolean;
     /**
      * 深度拷贝
      * @param obj

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

@@ -0,0 +1,67 @@
+import * as mongo from 'mongodb';
+export declare class MongoBaseService<T> {
+    protected _table: string;
+    get table(): string;
+    protected _inited: boolean;
+    get isInited(): boolean;
+    get mongo(): mongo.Db;
+    protected _t_type: {
+        new (): T;
+    };
+    constructor(table: string, type: {
+        new (): T;
+    });
+    getNextId(): Promise<any>;
+    /**
+     * 没有id(非_id)的表不能使用该函数
+     * @param id
+     */
+    getById(id: any): Promise<any>;
+    get(proterty?: {}, where?: {}, sort?: {}): Promise<any>;
+    countDocuments(where?: {}, options?: mongo.CountDocumentsOptions): Promise<number>;
+    gets(property?: {}, where?: {}, sort?: {}, skip?: number, limit?: number): Promise<any[]>;
+    getRandoms(num: number, proterty?: {}, where?: {}): Promise<any[]>;
+    updateOne(model: any, where?: {}, upsert?: boolean): Promise<{
+        errcode: {
+            id: number;
+            des: string;
+        };
+        rs: mongo.UpdateResult;
+    }>;
+    updateMany(models: [], where?: {}): Promise<{
+        errcode: {
+            id: number;
+            des: string;
+        };
+        rs: mongo.Document | mongo.UpdateResult;
+    }>;
+    insert(model: T): Promise<{
+        errcode: {
+            id: number;
+            des: string;
+        };
+        rs: mongo.InsertOneResult<any>;
+    }>;
+    deleteOne(where: any): Promise<{
+        errcode: {
+            id: number;
+            des: string;
+        };
+        count: number;
+    }>;
+    deleteMany(where: any): Promise<{
+        errcode: {
+            id: number;
+            des: string;
+        };
+        count: number;
+    }>;
+    createIndex(index: any, options?: mongo.CreateIndexesOptions): Promise<{
+        errcode: {
+            id: number;
+            des: string;
+        };
+        rs: string;
+    }>;
+    aggregate(pipeline?: Document[], options?: mongo.AggregateOptions): mongo.AggregationCursor<mongo.Document>;
+}

package/dist/types/Database/MysqlBaseService.d.ts

@@ -0,0 +1,34 @@
+export declare class BaseModel {
+}
+export declare class MysqlBaseService<T extends BaseModel> {
+    protected _table: string;
+    get table(): string;
+    get version(): number;
+    protected _inited: boolean;
+    get isInited(): boolean;
+    protected _t_type: {
+        new (): T;
+    };
+    constructor(type: {
+        new (): T;
+    });
+    protected _init(): Promise<void>;
+    protected _onReCreated(): Promise<void>;
+    protected _onDroped(): Promise<void>;
+    protected _checkDropTable(cur_version: number): Promise<boolean>;
+    /**
+     * 没有id的表不能使用该函数
+     * @param id
+     */
+    getById(id: any): Promise<T>;
+    get(proterty?: string, where?: string, args?: Array<any>): Promise<any>;
+    getTotal(where?: string, args?: Array<any>): Promise<number>;
+    gets(proterty?: string, where?: string, args?: Array<any>): Promise<any[]>;
+    getCount(where?: string, args?: Array<any>): Promise<any>;
+    getRandoms(num: number, proterty?: string, where?: string, args?: Array<any>): Promise<any[]>;
+    updateProperty(set: string, where?: string, args?: Array<any>, limit?: number): Promise<import("./MysqlManager").SqlReturn>;
+    update(model: T, where?: string, args?: Array<any>, limit?: number): Promise<import("./MysqlManager").SqlReturn>;
+    insert(model: T, ip?: string): Promise<import("./MysqlManager").SqlReturn>;
+    removeById(id: any): Promise<import("./MysqlManager").SqlReturn>;
+    remove(where: string, args?: Array<any>): Promise<import("./MysqlManager").SqlReturn>;
+}

package/dist/types/Service/AccountService.d.ts

@@ -1,4 +1,4 @@
-import { BaseModel, BaseService } from './../Database/BaseService';
+import { BaseModel, MysqlBaseService } from '../Database/MysqlBaseService';
 import { UserModel } from './UserService';
 import { EAccountFrom } from './ini';
 export declare class AccountModel extends BaseModel {
@@ -17,7 +17,7 @@ export declare class AccountModel extends BaseModel {
     state: number;
 }
 export declare let GAccountSer: AccountService;
-export declare class AccountService extends BaseService<AccountModel> {
+export declare class AccountService extends MysqlBaseService<AccountModel> {
     protected _account_cache_key_pre: string;
     protected _account_cache_time_sec: number;
     constructor();

package/dist/types/Service/MongoAccountService.d.ts

@@ -1,4 +1,4 @@
-import { BaseService } from '../Database/BaseMongoService';
+import { MongoBaseService } from '../Database/MongoBaseService';
 import { MongoBaseModel } from '../Database/MongoManager';
 import { EAccountFrom } from './ini';
 import { UserModel } from './MongoUserService';
@@ -18,7 +18,7 @@ export declare class AccountModel extends MongoBaseModel {
     state: number;
 }
 export declare let GAccountSer: AccountService;
-export declare class AccountService extends BaseService<AccountModel> {
+export declare class AccountService extends MongoBaseService<AccountModel> {
     protected _account_cache_key_pre: string;
     protected _account_cache_time_sec: number;
     constructor();

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

@@ -1,4 +1,4 @@
-import { BaseService } from "../Database/BaseMongoService";
+import { MongoBaseService } from "../Database/MongoBaseService";
 import { MongoBaseModel } from "../Database/MongoManager";
 export declare class MongoCacheModel extends MongoBaseModel {
     key: string;
@@ -6,7 +6,7 @@ export declare class MongoCacheModel extends MongoBaseModel {
     expireAt: number;
 }
 export declare let GMongoCacheSer: MongoCacheService;
-declare class MongoCacheService extends BaseService<MongoCacheModel> {
+declare class MongoCacheService extends MongoBaseService<MongoCacheModel> {
     constructor();
     getData(key: string): Promise<any>;
 }

package/dist/types/Service/MongoUserService.d.ts

@@ -1,4 +1,4 @@
-import { BaseService } from "../Database/BaseMongoService";
+import { MongoBaseService } from "../Database/MongoBaseService";
 import { MongoBaseModel } from "../Database/MongoManager";
 import { ERoleGroup } from "./ini";
 export declare class UserModel extends MongoBaseModel {
@@ -24,7 +24,7 @@ export declare class UserModel extends MongoBaseModel {
     create_time: number;
 }
 export declare let GUserSer: UserService<UserModel>;
-export declare class UserService<T extends UserModel> extends BaseService<T> {
+export declare class UserService<T extends UserModel> extends MongoBaseService<T> {
     constructor(type: {
         new (): T;
     });

package/dist/types/Service/UserService.d.ts

@@ -1,4 +1,4 @@
-import { BaseService, BaseModel } from "../Database/BaseService";
+import { MysqlBaseService, BaseModel } from "../Database/MysqlBaseService";
 import { ERoleGroup } from "./ini";
 export declare class UserModel extends BaseModel {
     id: number;
@@ -23,7 +23,7 @@ export declare class UserModel extends BaseModel {
     create_time: number;
 }
 export declare let GUserSer: UserService<UserModel>;
-export declare class UserService<T extends UserModel> extends BaseService<T> {
+export declare class UserService<T extends UserModel> extends MysqlBaseService<T> {
     constructor(type: {
         new (): T;
     });

package/dist/types/WebServer/Engine/Response.d.ts

@@ -20,6 +20,7 @@ export declare class Response {
     renderJson500(origin?: string | string[] | undefined): void;
     renderHtml(html: string): void;
     render404(html?: string): void;
+    render500(html?: string): void;
     renderOptions(method: any, origin: any): void;
     renderFile(fullPath: string): void;
     downloadFile(fullPath: string): void;

package/dist/types/cgserver.d.ts

@@ -19,12 +19,12 @@ export { Property } from './Database/Decorator/Property';
 export { Table } from './Database/Decorator/Table';
 export { Type } from './Database/Decorator/Type';
 export { EPropertyType } from './Database/Decorator/Property';
-export { BaseService as MongoBaseService } from './Database/BaseMongoService';
-export { BaseModel as MysqlBaseModel } from './Database/BaseService';
+export { MongoBaseService } from './Database/MongoBaseService';
+export { BaseModel as MysqlBaseModel } from './Database/MysqlBaseService';
 export { MongoBaseModel } from './Database/MongoManager';
 export { GMongoMgr } from './Database/MongoManager';
 export { GMSSqlMgr } from './Database/MSSqlManager';
-export { BaseService as MysqlBaseService } from './Database/BaseService';
+export { MysqlBaseService } from './Database/MysqlBaseService';
 export { GMysqlMgr } from './Database/MysqlManager';
 export { GRedisMgr, RedisManager } from './Database/RedisManager';
 export { GCacheTool } from './Logic/CacheTool';

package/package.json

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