cgserver 7.8.2113 → 7.9.2113

package/src/Framework/Logic/HttpTool.ts

@@ -0,0 +1,82 @@
+import * as request from "request";
+import * as qs from "querystring";
+import { GLog } from "./Log";
+import { core } from "../Core/Core";
+
+export let GHttpTool:HttpTool=null
+class HttpTool
+{
+    get(options_url:request.OptionsWithUrl|string)
+    {
+        let options:request.OptionsWithUrl=null
+        if(core.isString(options_url))
+        {
+            options={url:options_url as string}
+        }
+        else
+        {
+            options=options_url as request.OptionsWithUrl
+        }
+        return new Promise<{error,response,body}>((resolve,reject)=>
+        {
+            request.get(options, (error, response, body)=> 
+            {
+                let bd=body
+                if(error)
+                {
+                    GLog.error("get:"+options.url)
+                    GLog.error(error)
+                }
+                try
+                {
+                    if(core.isString(body))
+                    {
+                        body = JSON.parse(body)
+                    }
+                }
+                catch(e)
+                {
+                    try{body=qs.parse(body)}catch(e){body=bd}
+                }
+                resolve({error, response, body})
+            })
+        })
+    }
+    post(options_url:request.OptionsWithUrl|string)
+    {
+        let options:request.OptionsWithUrl=null
+        if(core.isString(options_url))
+        {
+            options={url:options_url as string}
+        }
+        else
+        {
+            options=options_url as request.OptionsWithUrl
+        }
+        return new Promise<{error,response,body}>((resolve,reject)=>
+        {
+            request.post(options, (error, response, body)=>
+            {
+                let bd=body
+                if(error)
+                {
+                    GLog.error("post:"+options.url)
+                    GLog.error(error)
+                }
+                try
+                {
+                    if(core.isString(body))
+                    {
+                        body = JSON.parse(body)
+                    }
+                }
+                catch(e)
+                {
+                    try{body=qs.parse(body)}catch(e){body=bd}
+                }
+                resolve({error, response, body})
+            })
+        })
+    }
+}
+GHttpTool = new HttpTool()

package/src/Framework/Logic/Log.ts

@@ -0,0 +1,171 @@
+import * as colors from "colors";
+import * as log4js from "log4js";
+/**
+ * 输出颜色
+ */
+colors.setTheme({  
+  silly: 'rainbow',  
+  input: 'grey',  
+  verbose: 'cyan',  
+  prompt: 'red',  
+  info: 'green',  
+  data: 'blue',  
+  help: 'cyan',  
+  warn: 'yellow',  
+  debug: 'magenta',  
+  error: 'red'  
+});
+export let GLog:Log=null
+class Log
+{
+    //default log
+    protected _logger:log4js.Logger = null
+    //the log from client
+    protected _client_logger:log4js.Logger = null
+    //error and warn
+    protected _errorLogger:log4js.Logger = null
+    protected _inited=false
+    /**
+     * 该level只是用来控制控制台的显示的
+     * -1不输出到console，0，仅错误信息输出到console，1，都输出到console
+     */
+    
+    protected _console_level=0
+    init(cfg:log4js.Configuration,console_level=0)
+    {
+        if(this._inited)
+        {
+            return
+        }
+        this._inited=true
+        colors.enable()
+        log4js.configure(cfg)
+
+        this._logger = log4js.getLogger(cfg.categories.default.appenders[0]||"log_date")
+        this._client_logger = log4js.getLogger(cfg.categories.default.appenders[1]||"client_log_date")
+        this._errorLogger = log4js.getLogger(cfg.categories.default.appenders[2]||"error_log_file")
+
+        this._console_level=console_level
+    }
+    error(message?: any)
+    {
+        if(this._isObject(message))
+        {
+            if(message.stack)
+            {
+                message=message.stack
+            }
+            else
+            {
+                message = JSON.stringify(message)
+            }
+        }
+        this._errorLogger?.error(message)
+        if(this._console_level>=0)
+        {
+            let time_str = this._getTimeStr()
+            console.error(time_str+" "+message)
+        }
+    }
+    info(message:any)
+    {
+        if(this._isObject(message))
+        {
+            message = JSON.stringify(message)
+        }
+        this._logger?.info(message)
+        if(this._console_level>=0)
+        {
+            let time_str = this._getTimeStr()
+            console.log(time_str+" "+message)
+        }
+    }
+    warn(message?: any)
+    {
+        if(this._isObject(message))
+        {
+            message = JSON.stringify(message)
+        }
+        this._errorLogger?.warn(message)
+        if(this._console_level>=0)
+        {
+            let time_str = this._getTimeStr()
+            console.error(time_str+" "+message)
+        }
+    }
+    record(message?: any)
+    {
+        this.info(message)
+    }
+    clientLog(message?: any)
+    {
+        this._client_logger?.error(message)
+    }
+    protected _getTimeStr()
+    {
+        let time = new Date()
+        let time_str=this._format(time,"[YYYY-MM-DD HH:mm:SS.")
+        time_str+=time.getMilliseconds()+"]"
+        return time_str
+    }
+    protected _isObject(param):boolean
+    {
+        return typeof (param) === "object"
+    }
+    protected _isString(param):boolean
+    {
+        return typeof (param) === "string"
+    }
+    protected _isNumber(param):boolean
+    {
+        return typeof (param) === "number"
+    }
+    protected _format(src,formatStr)   
+    {   
+        if(this._isString(src))
+        {
+            let args = Array.prototype.slice.call(arguments, 1)
+            return src.replace(/\{(\d+)\}/g, function(m, i)
+            {
+                return args[i]
+            })
+        }
+        else
+        {
+            if(this._isNumber(src))
+            {
+                src = new Date(src)
+            }
+            let str = formatStr
+            let Week = ['日','一','二','三','四','五','六']
+        
+            let month = src.getMonth()+1
+            let year = src.getFullYear()
+            let date = src.getDate()
+            let hour = src.getHours()
+            let min = src.getMinutes()
+            let sec = src.getSeconds()
+            let day = src.getDay()
+            str=str.replace(/yyyy|YYYY/,year)
+            str=str.replace(/yy|YY/,(year % 100)>9?(year % 100).toString():'0' + (year % 100))
+        
+            str=str.replace(/MM/,month>9?month.toString():'0' + month)
+            str=str.replace(/M/g,month)
+        
+            str=str.replace(/w|W/g,Week[day])
+        
+            str=str.replace(/dd|DD/,date>9?date.toString():'0' + date)
+            str=str.replace(/d|D/g,date)
+        
+            str=str.replace(/hh|HH/,hour>9?hour.toString():'0' + hour)
+            str=str.replace(/h|H/g,hour)
+            str=str.replace(/mm/,min>9?min.toString():'0' + min)
+            str=str.replace(/m/g,min)
+        
+            str=str.replace(/ss|SS/,sec>9?sec.toString():'0' + sec)
+            str=str.replace(/s|S/g,sec)
+            return str
+        }
+    }
+}
+GLog=new Log()

package/src/Framework/Logic/SyncQueueTool.ts

@@ -0,0 +1,51 @@
+import { core } from "../Core/Core"
+
+class SyncQueueItem
+{
+    key=""
+    running=false
+    funcs:{func:Function,thisArg:any,params:any[],resolve?:Function}[]=[]
+    constructor(key:string)
+    {
+        this.key=key
+    }
+    async add(func:Function,thisArg:any=null,...params)
+    {
+        return new Promise((resolve,reject)=>
+        {
+            this.funcs.push({func:func,thisArg:thisArg,params:params,resolve:resolve})
+            this._run()
+        })
+    }
+    protected async _run()
+    {
+        if(this.running)
+        {
+            return
+        }
+        this.running=true
+        while(this.funcs.length>0)
+        {
+            let funcitem = this.funcs.shift()
+            if(!funcitem.func)
+            {
+                continue
+            }
+            let rs = await core.safeCall(funcitem.func,funcitem.thisArg,...funcitem.params)
+            await core.safeCall(funcitem.resolve,null,rs)
+        }
+        this.running=false
+    }
+}
+class SyncQueueTool
+{
+    //队列数据,一个key队列必须有先后
+    protected _queues:{[key:string]:SyncQueueItem}={}
+    async add(key:string,func:Function,thisArg:any=null,...params)
+    {
+        this._queues[key]=this._queues[key]||new SyncQueueItem(key)
+        let error = await this._queues[key].add(func,thisArg,...params)
+        return error
+    }
+}
+export let GSyncQueueTool=new SyncQueueTool()