cgserver 6.0.6 → 6.0.9

package/dist/lib/Database/BaseMongoService.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const MongoManager_1 = require("./MongoManager");
+class BaseService {
+    _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 getTotal(where) {
+        let rs = await MongoManager_1.GMongoMgr.findCount(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);
+        return ret;
+    }
+}
+exports.BaseService = BaseService;

package/dist/lib/Database/BaseService.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = 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 BaseService {
+    _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.BaseService = BaseService;

package/dist/lib/Database/Decorator/AutoIncrement.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoIncrement = void 0;
+const Property_1 = require("./Property");
+function AutoIncrement(target, propertyName) {
+    let table = target[Property_1.TableProperty.key] = target[Property_1.TableProperty.key] || new Property_1.TableProperty();
+    table.items[propertyName] = table.items[propertyName] || new Property_1.Property();
+    let pt = table.items[propertyName];
+    pt.auto_increment = true;
+}
+exports.AutoIncrement = AutoIncrement;

package/dist/lib/Database/Decorator/DBCache.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GDBCache = exports.VersionModel = void 0;
+const Log_1 = require("./../../Logic/Log");
+const fs = require("fs");
+class VersionModel {
+    table = "";
+    version = 0;
+    /**
+     * 创建时间
+     */
+    create_time = 0;
+    /**
+     * 创建时间
+     */
+    update_time = 0;
+}
+exports.VersionModel = VersionModel;
+exports.GDBCache = null;
+class DBCache {
+    _versions = new Map();
+    _path = __dirname + "/tmp_table_version.json";
+    async init() {
+        if (fs.existsSync(this._path)) {
+            try {
+                let table = fs.readFileSync(this._path);
+                this._versions = JSON.parse(table.toString());
+            }
+            catch (e) {
+                Log_1.GLog.info("error:" + this._path);
+                process.exit();
+            }
+        }
+        else {
+            this._versions = new Map();
+            fs.writeFileSync(this._path, JSON.stringify(this._versions));
+        }
+    }
+    async setVersion(table, version) {
+        let vm = this._versions[table];
+        if (!vm) {
+            vm = new VersionModel();
+            vm.table = table;
+            vm.version = version;
+            vm.create_time = Date.now();
+            vm.update_time = Date.now();
+            this._versions[table] = vm;
+            fs.writeFileSync(this._path, JSON.stringify(this._versions));
+        }
+        else if (vm.version != version) {
+            vm.version = version;
+            vm.update_time = Date.now();
+            fs.writeFileSync(this._path, JSON.stringify(this._versions));
+        }
+    }
+    getVersion(table) {
+        let vm = this._versions[table];
+        if (!vm) {
+            return -1;
+        }
+        return vm.version;
+    }
+}
+exports.GDBCache = new DBCache();

package/dist/lib/Database/Decorator/NotNull.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotNull = void 0;
+const Property_1 = require("./Property");
+function NotNull(target, propertyName) {
+    let table = target[Property_1.TableProperty.key] = target[Property_1.TableProperty.key] || new Property_1.TableProperty();
+    table.items[propertyName] = table.items[propertyName] || new Property_1.Property();
+    let pt = table.items[propertyName];
+    pt.is_notnull = true;
+}
+exports.NotNull = NotNull;

package/dist/lib/Database/Decorator/PrimaryKey.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryKey = void 0;
+const Property_1 = require("./Property");
+function PrimaryKey(target, propertyName) {
+    let table = target[Property_1.TableProperty.key] = target[Property_1.TableProperty.key] || new Property_1.TableProperty();
+    table.items[propertyName] = table.items[propertyName] || new Property_1.Property();
+    let pt = table.items[propertyName];
+    pt.is_primary = true;
+}
+exports.PrimaryKey = PrimaryKey;

package/dist/lib/Database/Decorator/Property.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableProperty = exports.Property = exports.EPropertyType = void 0;
+class EPropertyType {
+    static Char = "char";
+    static NVarchar = "nvarchar";
+    static Varchar = "varchar";
+    static BigInt = "bigint";
+    static Decimal = "decimal";
+    static Double = "double";
+    static Float = "float";
+    static Int = "int";
+    static MediumInt = "Mediumint";
+    static Real = "real";
+    static SmallInt = "smallint";
+    static TinyInt = "tinyint";
+    static LongText = "longtext";
+    static MediumText = "mediumtext";
+    static Text = "text";
+    static TinyText = "tinytext";
+    static defs = {
+        "char": "",
+        "nvarchar": "",
+        "varchar": "",
+        "bigint": 0,
+        "decimal": 0,
+        "double": 0,
+        "float": 0,
+        "int": 0,
+        "Mediumint": 0,
+        "real": 0,
+        "smallint": 0,
+        "tinyint": 0,
+        "longtext": "",
+        "mediumtext": "",
+        "text": undefined,
+        "tinytext": ""
+    };
+}
+exports.EPropertyType = EPropertyType;
+class Property {
+    is_primary = false;
+    is_notnull = false;
+    auto_increment = false;
+    auto_start = 1; //包含
+    type = EPropertyType.Varchar;
+    type_len = 45;
+    default = null;
+}
+exports.Property = Property;
+class TableProperty {
+    static key = "___table___";
+    table = null;
+    version = 1;
+    engine = "InnoDB";
+    auto_increment = null;
+    charset = "utf8mb4";
+    comment = null;
+    items = new Map();
+}
+exports.TableProperty = TableProperty;

package/dist/lib/Database/Decorator/Table.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+const Property_1 = require("./Property");
+function Table(table_name, version, comment, charset, auto_increment) {
+    return function (constructor) {
+        let table = constructor.prototype[Property_1.TableProperty.key] = constructor.prototype[Property_1.TableProperty.key] || new Property_1.TableProperty();
+        table.table = table_name;
+        table.version = version;
+        table.comment = comment || table.comment;
+        table.charset = charset || table.charset;
+        table.auto_increment = auto_increment || table.auto_increment;
+    };
+}
+exports.Table = Table;

package/dist/lib/Database/Decorator/Type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+const Property_1 = require("./Property");
+function Type(type, def, len) {
+    return function (target, propertyName) {
+        let table = target[Property_1.TableProperty.key] = target[Property_1.TableProperty.key] || new Property_1.TableProperty();
+        table.items[propertyName] = table.items[propertyName] || new Property_1.Property();
+        let pt = table.items[propertyName];
+        pt.type = type;
+        if (def != undefined) {
+            pt.default = def;
+        }
+        else {
+            pt.default = Property_1.EPropertyType.defs[type];
+        }
+        pt.type_len = len || pt.type_len;
+    };
+}
+exports.Type = Type;

package/dist/lib/Database/MSSqlManager.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GMSSqlMgr = exports.MssqlReturn = void 0;
+const mssql = require("mssql");
+const FrameworkConfig_1 = require("../Config/FrameworkConfig");
+const DBCache_1 = require("./Decorator/DBCache");
+class MssqlReturn {
+    error = null;
+    fields = null;
+    list = null;
+}
+exports.MssqlReturn = MssqlReturn;
+exports.GMSSqlMgr = null;
+class MSSqlManager {
+    _init_cbs = [];
+    _pool = null;
+    get pool() {
+        return this._pool;
+    }
+    get isValid() {
+        return !!this._pool;
+    }
+    constructor() {
+    }
+    async init() {
+        if (this._pool
+            || !FrameworkConfig_1.GFCfg.db.mssql
+            || !FrameworkConfig_1.GFCfg.db.mssql.open) {
+            return;
+        }
+        this._pool = await mssql.connect(FrameworkConfig_1.GFCfg.db.mssql);
+        console.log("mssql config=" + JSON.stringify(FrameworkConfig_1.GFCfg.db.mssql));
+        //这个的初始化位置不能变，必须位于cbs前，pool后
+        await DBCache_1.GDBCache.init();
+        for (let i = 0; i < this._init_cbs.length; ++i) {
+            this._init_cbs[i]();
+        }
+    }
+    registerInitCb(cb) {
+        this._init_cbs.push(cb);
+    }
+}
+exports.GMSSqlMgr = new MSSqlManager();