cgserver 7.8.2113 → 7.9.2113

package/src/Framework/Core/Timer.ts

@@ -0,0 +1,147 @@
+import { core } from './Core';
+import { GLog } from '../Logic/Log';
+export class Timer
+{
+    protected _deadline:number = -1
+    get deadline()
+    {
+        return this._deadline
+    }
+    protected _handler = null
+    get handler()
+    {
+        return this._handler
+    }
+    get isRunning()
+    {
+        if(this._handler)
+        {
+            return true
+        }
+        return false
+    }
+    protected _call_back:Function = null
+    protected _left_time:number = -1
+    protected _is_interval:boolean=false
+    constructor()
+    {
+
+    }
+    setTimeout(handler: any, timeout?: any, ...args: any[])
+    {
+        this._call_back = handler
+        this.clear()
+        if(timeout==undefined)
+        {
+            timeout = 30000
+        }
+        this._deadline = Date.now() +　timeout
+        this._handler = setTimeout(()=>
+        {
+            this._deadline = -1
+            this._handler = null
+            this._left_time = -1
+            try
+            {
+                this._call_back()
+            }
+            catch(e)
+            {
+                if(e&&e.stack)
+                {
+                    GLog.error(e.stack)
+                }
+                else
+                {   
+                    GLog.error(e)
+                }
+            }
+        }, timeout, ...args)
+    }
+    setInterval(handler: any, timeout?: any, ...args: any[])
+    {
+        this._call_back = handler
+        this.clear()
+        this._is_interval=true
+        if(timeout==undefined)
+        {
+            timeout = 30000
+        }
+        this._deadline = -1
+        this._left_time=timeout
+        this._handler = setInterval(()=>
+        {
+            try
+            {
+                this._call_back()
+            }
+            catch(e)
+            {
+                if(e&&e.stack)
+                {
+                    GLog.error(e.stack)
+                }
+                else
+                {   
+                    GLog.error(e)
+                }
+            }
+        }, timeout, ...args)
+    }
+    pause()
+    {
+        if(this._handler)
+        {
+            if(!this._is_interval)
+            {
+                this._left_time = this._deadline - Date.now()
+                clearTimeout(this._handler)
+            }
+            else
+            {
+                clearInterval(this._handler)
+            }
+            this._deadline = -1
+            this._handler = null
+        }
+    }
+    resume()
+    {
+        if(this._left_time>0)
+        {
+            if(!this._is_interval)
+            {
+                this._deadline = Date.now() + this._left_time
+                this._handler = setTimeout(()=>
+                {
+                    this._call_back()
+                    this._deadline = -1
+                    this._handler = null
+                    this._left_time = -1
+                }, this._left_time)
+            }
+            else
+            {
+                this.setInterval(this._call_back,this._left_time)
+            }
+        }
+    }
+    clear()
+    {
+        if(this._handler)
+        {
+            if(!this._is_interval)
+            {
+                clearTimeout(this._handler)
+            }
+            else
+            {
+                clearInterval(this._handler)
+            }
+        }
+        this._deadline = -1
+        this._handler = null
+        this._left_time = -1
+        this._is_interval=false
+    }
+}

package/src/Framework/Database/Decorator/AutoIncrement.ts

@@ -0,0 +1,9 @@
+import { Property, TableProperty } from "./Property"
+
+export function AutoIncrement(target: any, propertyName: string) 
+{
+    let table:TableProperty=target[TableProperty.key]=target[TableProperty.key]||new TableProperty()
+    table.items[propertyName]=table.items[propertyName]||new Property()
+    let pt:Property = table.items[propertyName]
+    pt.auto_increment=true
+}

package/src/Framework/Database/Decorator/DBCache.ts

@@ -0,0 +1,74 @@
+import { GLog } from './../../Logic/Log';
+import * as fs from "fs";
+
+export class VersionModel
+{
+    table:string=""
+    version:number=0
+    /**
+     * 创建时间
+     */
+    create_time:number=0
+
+    /**
+     * 创建时间
+     */
+    update_time:number=0
+}
+
+export let GDBCache:DBCache=null
+class DBCache
+{
+    protected _versions:{[table_name:string]:VersionModel}={}
+    protected _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)
+            {
+                GLog.info("error:"+this._path)
+                process.exit()
+            }
+        }
+        else
+        {
+            this._versions={}
+            fs.writeFileSync(this._path,JSON.stringify(this._versions))
+        }
+    }
+    async setVersion(table:string,version:number)
+    {
+        let vm:VersionModel = 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:string)
+    {
+        let vm:VersionModel = this._versions[table]
+        if(!vm)
+        {
+            return -1
+        }
+        return vm.version
+    }
+}
+GDBCache=new DBCache()

package/src/Framework/Database/Decorator/NotNull.ts

@@ -0,0 +1,9 @@
+import { Property, TableProperty } from "./Property"
+
+export function NotNull(target: any, propertyName: string) 
+{
+    let table:TableProperty=target[TableProperty.key]=target[TableProperty.key]||new TableProperty()
+    table.items[propertyName]=table.items[propertyName]||new Property()
+    let pt:Property = table.items[propertyName]
+    pt.is_notnull=true
+}

package/src/Framework/Database/Decorator/PrimaryKey.ts

@@ -0,0 +1,9 @@
+import { Property, TableProperty } from "./Property"
+
+export function PrimaryKey(target: any, propertyName: string) 
+{
+    let table:TableProperty=target[TableProperty.key]=target[TableProperty.key]||new TableProperty()
+    table.items[propertyName]=table.items[propertyName]||new Property()
+    let pt:Property = table.items[propertyName]
+    pt.is_primary=true
+}

package/src/Framework/Database/Decorator/Property.ts

@@ -0,0 +1,64 @@
+export class EPropertyType
+{
+    public static Char="char";
+    public static NVarchar="nvarchar";
+    public static Varchar="varchar";
+
+    public static BigInt="bigint";
+    public static Decimal="decimal";
+    public static Double="double";
+    public static Float="float";
+    public static Int="int";
+    public static MediumInt="Mediumint";
+    public static Real="real";
+    public static SmallInt="smallint";
+    public static TinyInt="tinyint";
+    
+    public static LongText="longtext";
+    public static MediumText="mediumtext";
+    public static Text="text";
+    public static TinyText="tinytext";
+
+    public 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":""
+    }
+}
+export class Property
+{
+    public is_primary:boolean=false
+    public is_notnull:boolean=false
+    public auto_increment:boolean=false
+    public auto_start:number=1//包含
+    public type:string=EPropertyType.Varchar
+    public type_len:number=45
+    public default:any=null
+}
+export class TableProperty
+{
+    public static key="___table___"
+    public table:string=null
+    public version:number=1
+    public engine:string="InnoDB"
+    public auto_increment:number=null
+    public charset:string="utf8mb4"
+    public comment:string=null
+    public items:{[name:string]:Property}={}
+}

package/src/Framework/Database/Decorator/Table.ts

@@ -0,0 +1,13 @@
+import { TableProperty } from "./Property"
+
+export function Table(table_name:string,version:number,comment?:string,charset?:string,auto_increment?:number) {
+    return function(constructor: Function)
+    {
+        let table:TableProperty = constructor.prototype[TableProperty.key]=constructor.prototype[TableProperty.key]||new 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
+    }
+}

package/src/Framework/Database/Decorator/Type.ts

@@ -0,0 +1,21 @@
+import { Property, EPropertyType, TableProperty } from "./Property"
+
+export function Type(type:string,def?:any,len?:number) 
+{
+    return function (target: any, propertyName: string) 
+    {
+        let table:TableProperty=target[TableProperty.key]=target[TableProperty.key]||new TableProperty()
+        table.items[propertyName]=table.items[propertyName]||new Property()
+        let pt:Property = table.items[propertyName]
+        pt.type=type
+        if(def!=undefined)
+        {
+            pt.default=def
+        }
+        else
+        {
+            pt.default=EPropertyType.defs[type]
+        }
+        pt.type_len=len||pt.type_len
+    }
+}

package/src/Framework/Database/MSSqlManager.ts

@@ -0,0 +1,52 @@
+import * as mssql from "mssql";
+import { GServerCfg } from "../Config/IServerConfig";
+import { GDBCache } from "./Decorator/DBCache";
+
+export class MssqlReturn
+{
+    error=null
+    fields=null
+    list:Array<any>=null
+}
+
+export let GMSSqlMgr:MSSqlManager=null
+class MSSqlManager
+{
+    protected _init_cbs=[]
+    protected _pool:mssql.ConnectionPool = null
+    get pool()
+    {
+        return this._pool
+    }
+    get isValid()
+    {
+        return !!this._pool
+    }
+    constructor()
+    {
+        
+    }
+    async init()
+    {
+        if(this._pool
+            ||!GServerCfg.db.mssql
+            ||!GServerCfg.db.mssql.open)
+        {
+            return
+        }
+
+        this._pool  = await mssql.connect(<any>GServerCfg.db.mssql)
+        console.log("mssql config="+JSON.stringify(GServerCfg.db.mssql))
+        //这个的初始化位置不能变，必须位于cbs前，pool后
+        await GDBCache.init()
+        for(let i=0;i<this._init_cbs.length;++i)
+        {
+            this._init_cbs[i]()
+        }
+    }
+    registerInitCb(cb:Function)
+    {
+        this._init_cbs.push(cb)
+    }
+}
+GMSSqlMgr=new MSSqlManager()

package/src/Framework/Database/MongoBaseService.ts

@@ -0,0 +1,136 @@
+import { GMongoMgr } from "./MongoManager";
+import * as mongo from 'mongodb';
+
+export class MongoBaseService<T>
+{
+    protected _table:string=""
+    get table()
+    {
+        return this._table
+    }
+    protected _inited=false
+    get isInited()
+    {
+        return this._inited
+    }
+    get mongo()
+    {
+        return GMongoMgr.mongo
+    }
+    protected _t_type:{ new(): T}=null
+    constructor(table:string,type: { new(): T})
+    {
+        this._t_type=type
+        this._table=table
+    }
+    async getNextId()
+    {
+        let id = await GMongoMgr.getAutoIds(this._table)
+        return id
+    }
+    /**
+     * 没有id(非_id)的表不能使用该函数
+     * @param id 
+     */
+    async getById(id:any)
+    {
+        let rs=await GMongoMgr.findOne(this._table,null,{id:id})
+        return rs.one
+    }
+    async get(proterty?:{},where?:{})
+    {
+        let rs = await GMongoMgr.findOne(this._table,proterty,where)
+        return rs.one
+    }
+    async countDocuments(where?:{},options?: mongo.CountDocumentsOptions)
+    {
+        let rs = await GMongoMgr.countDocuments(this._table,where)
+        return rs.count
+    }
+    async gets(property?:{},where?:{},sort?:{},skip=0,limit=0)
+    {
+        let rs = await GMongoMgr.findMany(this._table,property,where,sort,skip,limit)
+        return rs.list
+    }
+    async getRandoms(num:number,proterty?:{},where?:{})
+    {
+        let rs = await GMongoMgr.simpleAggregate(this._table,proterty,where,null,num)
+        return rs.list
+    }
+    async updateOne(model,where?:{},upsert=false)
+    {
+        let rs = await GMongoMgr.updateOne(this._table,model,where,upsert)
+        return rs
+    }
+    async updateMany(model,where?:{})
+    {
+        let rs = await GMongoMgr.updateMany(this._table,model,where)
+        return rs
+    }
+    async insert(model:T)
+    {
+        let rs = await GMongoMgr.insertOne(this._table,model)
+        return rs
+    }
+    async deleteOne(where)
+    {
+        let rs = await GMongoMgr.deleteOne(this._table,where)
+        return rs
+    }
+    async deleteMany(where)
+    {
+        let rs = await GMongoMgr.deleteMany(this._table,where)
+        return rs
+    }
+    async createIndex(index:any,options?:mongo.CreateIndexesOptions)
+    {
+        let rs = await GMongoMgr.createIndex(this._table,index,options)
+        return rs
+    }
+    aggregate(pipeline?: Document[], options?: mongo.AggregateOptions)
+    {
+        let ret = GMongoMgr.aggregate(this._table,pipeline,options)
+        return ret
+    }
+    /**
+     * 仅仅支持一级
+     * @param array 数据名称 比如 items
+     * @param where 数组内赛选条件 比如 "items.id":1
+     * @param pre_match 数组上一级赛选条件 比如 "user_id":1
+     */
+    async getsInArray<T>(array:string,where?:any,pre_match?:any)
+    {
+        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:T[] = []
+        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<T>(array:string,where?:any,pre_match?:any)
+    {
+        let items = await this.getsInArray<T>(array,where,pre_match)
+        if(items.length<=0)
+        {
+            return null
+        }
+        return items[0]
+    }
+}