cgserver 7.9.2113 → 7.11.2113

package/src/Framework/Core/Timer.ts

@@ -1,147 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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]
-    }
-}