import { core } from "cgserver";
import { GCacheTool } from "cgserver";
import { GLog } from "cgserver";
import * as _ from "underscore";
import { GBulletinSer } from "../../../Common/Service/BulletinService";
import { AddressItem, ExtUserModel, GExtUserSer, UserMatchInfo } from "../../../Common/Service/ExtUserService";
import { GMarqueeSer } from "../../../Common/Service/MarqueeService";
import { GHallCfg } from "../Config/HallConfig";
import { EErrorCode } from "../Config/_error_";
import { UserValidate } from "../Decorator/UserValidate";
import { BaseHallController } from "./BaseHallController";
import { GEmailSer } from "../../../Common/Service/EmailService";
import { GGameStatisticsSer } from "../../../Common/Service/GameStatistics";
import { GGameConfigSer } from "../../../Common/Service/GameConfigService";
import { GRankSer } from "../../../Common/Service/RankService";
import { GSmsTool } from "cgserver";
import { GQiniuTool } from "cgserver";
import { GQASer } from "../../../Common/Service/QAService";
import { ETaskType, GTaskSer } from "../../../Common/Service/TaskService";
import { ECurrencyWhy, GStatisticsCurrency, StatisticsCurrencyModel } from "../../../Common/Service/StatisticsCurrency";
import { GCheckInSer } from "../../../Common/Service/CheckInService";
import { GRoomSer } from "../../../Common/Service/RoomService";
import { GMongoCacheSer } from "cgserver";
import { EUserState } from "cgserver";
import { BagItemItem, BagModel, GBagSer } from "../../../Common/Service/BagService";
import { GMatchInsSer, MatchInsModel, MatchPlayer } from "../../../Common/Service/MatchInstanceService";
import { GMatchSer } from "../../../Common/Service/MatchService";
import { BlindModel, GBlindSer } from "../../../Common/Service/BlindService";
import { GNewsSer, NewsModel } from "../../../Common/Service/NewsService";
import { AdModel, GAdSer } from "../../../Common/Service/AdService";
import { GRLSBTool } from "../Logic/RLSBTool";
import { GItemCfg } from "../../../Common/Config/ItemConfig";

//先去掉其他的，只支持OpenSocial登陆
export class LogicController extends BaseHallController
{
    async onLogin()
    {
        let params = this.postData
        let key = "account_login_token_"+params.account_id
        let token = await GMongoCacheSer.getData(key)
        if(!token||token!=params.token)
        {
            this.showJson({errcode:EErrorCode.Wrong_Token})
            return
        }
        let user = await GExtUserSer.getByAccountId(params.account_id)
        if(!user)
        {
            this.showJson({errcode:EErrorCode.User_Not_Exist})
            return
        }
        if (user.state == EUserState.Ban) 
        {
            this.showJson({errcode:EErrorCode.User_Be_Ban})
            return
        }
        //兼容老数据
        if(!user.crystal&&user.crystal!=0)
        {
            user.crystal=0
            GExtUserSer.updateOne({crystal:0},{_id:user._id})
        }
        //兼容老数据完毕
        this._login(user)
        let time = core.getStartTime()

        let rig = await GMongoCacheSer.getData(user.id+"")
        let msg = <any>{}
        msg.user = user
        msg.user.ip = this.remoteHost
        msg.rig = rig
        msg.session_id=this._session_id
        msg.allowance=GHallCfg.allowance
        msg.ad_allowance=GHallCfg.ad_allowance

        key = time+"_allowance_"+this.selfUser.id
        let already = GCacheTool.get(key)||0

        msg.left_allowance=GHallCfg.day_allowance_num-already
        msg.total_allowance=GHallCfg.day_allowance_num
        
        key = time+"_loginbouns_"+this.selfUser.id
        let ret = GCacheTool.get(key)
        if(ret)
        {
            msg.daily_prize = 0
        }
        else
        {
            msg.daily_prize = GHallCfg.daily_prize
        }
        this.showJson(msg)
    }
    /**
     * 登录奖励
     */
    @UserValidate
    async onGetLoginBouns()
    {
        let time = core.getStartTime()
        let key = time+"_loginbouns_"+this.selfUser.id
        let ret = GCacheTool.get(key)
        if(ret)//领取过了
        {
            this.showJson({errcode:EErrorCode.DayDaily_Done})
            return
        }
        let ad = this.postData.ad
        await GExtUserSer.updateOne({"$inc":{coin:GHallCfg.daily_prize}},{_id:this.selfUser._id})
        await GRankSer.addData("rank_coin_all",this.selfUser.id,this.selfUser.coin+GHallCfg.daily_prize,this.selfUser.coin)
        await this.update_user(this.selfUser.id)
        this.showJson({coin:this.selfUser.coin,dtcoin:GHallCfg.daily_prize})
    }
    /**
     * 破产补助
     */
     @UserValidate
     async onGetAllowance()
     {
         let time = core.getStartTime()
         let key = time+"_loginbouns_"+this.selfUser.id
         let ret = GCacheTool.get(key)
         if(ret)//领取过了
         {
             this.showJson({errcode:EErrorCode.DayDaily_Done})
             return
         }
         let ad = this.postData.ad
         await GExtUserSer.updateOne({"$inc":{coin:GHallCfg.daily_prize}},{_id:this.selfUser._id})
         await GRankSer.addData("rank_coin_all",this.selfUser.id,this.selfUser.coin+GHallCfg.daily_prize,this.selfUser.coin)
         await this.update_user(this.selfUser.id)
         this.showJson({coin:this.selfUser.coin,dtcoin:GHallCfg.daily_prize})
     }
    @UserValidate
    async onGetMarquee()
    {
        let params = this.postData
        let mq_list=await GMarqueeSer.gets()
        this.showJson({mq_list:mq_list})
    }
    @UserValidate
    async onGetBulletin()
    {
        let params = this.postData
        let bt_list = await GBulletinSer.gets()
        this.showJson({bt_list:bt_list})
    }
    @UserValidate
    async onClientLog()
    {
        let params = this.postData
        GLog.clientLog(params.user_id+":="+params.log)
    }
    @UserValidate
    async onGetCfg()
    {
        let params = this.postData
        let cfg_name = params.cfg_name
        let content = GHallCfg.getServerCfg(cfg_name)
        this.showJson({cfg_name:cfg_name,content:content})
    }
    @UserValidate
    async onGetPhoneCode()
    {
        let params = this.postData
        let phone = params.phone
        if(!core.isPhoneNo(phone))
        {
            this.showJson({errcode:EErrorCode.Wrong_Phone})
            return
        }
        let key = "phone_code_"+phone
        let code = GCacheTool.get(key)
        if(code)
        {
            this.showJson({errcode:EErrorCode.PhoneCode_Too_Quick})
            return
        }
        code=_.random(123456,999999)
        let error = await GSmsTool.sendSMS(code,phone)
        if(error)
        {
            this.showJson({errcode:EErrorCode.PhoneCode_GetFailed})
            return
        }
        GCacheTool.add(key,code,5*60*1000)
        this.showJson()
    }
    @UserValidate
    async onBindPhone()
    {
        let params = this.postData
        let club_id = params.club_id
        let phone = params.phone
        let code = params.code
        let key = "phone_code_"+phone
        let cache_code = GCacheTool.get(key)
        if(!cache_code
            ||cache_code!=code)
        {
            this.showJson({errcode:EErrorCode.Phone_Bind_Failed})
            return
        }
        let rs = await GExtUserSer.updateOne({phone:phone},{id:this.selfUser.id})
        if(rs.errcode)
        {
            this.showJson({errcode:rs.errcode})
            return
        }
        let email = await GEmailSer.send(club_id,-1,this.selfUser.id,"绑定手机赠送金币","恭喜您成功绑定手机特赠送金币1000!",{coin:1000})
        if(!email)
        {
            this.showJson({errcode:EErrorCode.Handle_Failed})
            return
        }
        this.showJson()
    }
    
    @UserValidate
    onGetQiniuUploadToken(params)
    {
        let uploadToken = GQiniuTool.getUploadToken(params.filename)
        this.showJson({upload_token:uploadToken,host:GQiniuTool.host})
    }

    @UserValidate
    onChat()
    {
        let params=this.postData
        let type = params.type
        let content = params.content
        let user_id_list = params.user_id_list
        //todo
    }
    //游戏首页获取各个游戏的状态信息(当前在线人数，关闭等)
    @UserValidate
    async onGetGameListStates()
    {
        let params=this.postData
        let games = params.games
        let list = await GGameStatisticsSer.gets(null,{game_name:{$in:games}})
        this.showJson({games_states:list})
    }
    @UserValidate
    async onGetGameListConfigs()
    {
        let params = this.postData
        let games = params.games
        let games_configs = await GGameConfigSer.gets(null,{game_name:{$in:games}})
        this.showJson({games_configs:games_configs})
    }
    @UserValidate
    async onGetUser()
    {
        let user = await GExtUserSer.getById(this.selfUser.id)
        if(!user)
        {
            this.showJson({errcode:EErrorCode.User_Not_Exist})
            return
        }
        this._login(user)
        user.bank_pwd = null
        delete user.bank_pwd
        this.showJson({user:this._self_user})
    }
    @UserValidate
    async onGetSimpleUser()
    {
        let user = await GExtUserSer.get({id:1,nickname:1,logo:1,sex:1},this.selfUser.id)
        if(!user)
        {
            this.showJson({errcode:EErrorCode.User_Not_Exist})
            return
        }
        this.showJson({user:user})
    }
    //获取背包
    @UserValidate
    async onGetBag()
    {
        this.showJson({})
    }
    @UserValidate
    async onGetEmails()
    {
        let params= this.postData
        let min_id = params.min_id||-1
        let club_id = params.club_id
        let emails = await GEmailSer.getByUserId(club_id,this._self_user.id,min_id)
        this.showJson({emails:emails})
    }
    //阅读后就删除
    @UserValidate
    async onReadEmail()
    {
        let errcode = await GEmailSer.read(this.postData.email_id)
        this.showJson({errcode:errcode})
    }
    @UserValidate
    async onRemoveEmail()
    {
        let errcode = await GEmailSer.deleteOne({_id:this.postData.email_id})
        this.showJson({errcode:errcode})
    }
    @UserValidate
    async onGetAttachment()
    {
        let email_id = this.postData.email_id
        let rs = await GEmailSer.getAttachment(email_id)
        this.showJson({attachment:rs.att})
    }
    @UserValidate
    async onQaList()
    {
        let min_time = this.postData.min_time
        let qa_list = await GQASer.getByUserId(null,this._self_user.id,min_time)
        this.showJson({qa_list:qa_list})
    }
    @UserValidate
    async onQaAdd()
    {
        let content = this.postData.content
        let qa = await GQASer.add(null,this._self_user.id,content)
        this.showJson({qa:qa})
    }
    @UserValidate
    async onQaReply()
    {
        let user = await GExtUserSer.getById(this._self_user.id)
        let qa_id=this.postData.qa_id
        let content = this.postData.content
        let errcode = await GQASer.updateReply(qa_id,user.id,user.nickname,content)
        if(errcode)
        {
            this.showJson({errcode:errcode})
        }
        else
        {
            let qa=await GQASer.get(qa_id)
            this.showJson({qa:qa})
        }
    }
    @UserValidate
    async onQaRead(params)
    {
        let qa_id=this.postData.qa_id
        GQASer.updateOne({is_read:1},{_id:qa_id})
        this.showJson({})
    }
    @UserValidate
    async onQaRemove()
    {
        let qa_id=this.postData.qa_id
        GQASer.deleteOne({_id:qa_id})
        this.showJson()
    }
    /**
     * 获取任务配置
     * @param params 
     */
     @UserValidate
     async onGetTaskCfg()
    {
        let taskcfg = GTaskSer.task
        let task_box = GTaskSer.task_box
        this.showJson({tasks:taskcfg,task_box:task_box})
    }
    /**
     * 客户端请求获取任务状态，活跃度
     * @param params 
     */
    @UserValidate
    async onGetTaskStates()
    {
        let states = await GTaskSer.getByUserId(this._self_user.id)
        this.showJson({states:states})
    }
    @UserValidate
    async onTaskGetBoxPrize()
    {
        let liveness = this.postData.liveness
        let rs = await GTaskSer.getBoxPrize(this._self_user.id,liveness)
        this.showJson({prize:rs.prize,liveness:liveness,errcode:rs.errcode})
    }
    @UserValidate
    async onShareSuccess()
    {
        //0分享给微信好友，1分享给朋友圈
        let share_type = this.postData.share_type
        if(share_type==0)
        {
            GTaskSer.onUserAction(this._self_user.id,ETaskType.ShareWeChatFriend,1)
        }
        else
        {
            GTaskSer.onUserAction(this._self_user.id,ETaskType.ShareWeChatGroup,1)
        }
        let key = "share_num_user_"+this.selfUser.id
        let curDate = new Date()
        let curDateSec = curDate.getHours()*60*60+curDate.getMinutes()*60+curDate.getSeconds()
        let totalDateSec = 24*60*60
        let expireTime = totalDateSec - curDateSec
        await GMongoCacheSer.updateOne({$inc:{data:1},expireAt:expireTime},{key:key},true)
        let num = await GMongoCacheSer.getData(key)
        if(num==1&&GHallCfg.ShareCrystal>0)
        {
            //可以获得分享奖励
            await GExtUserSer.updateOne({$inc:{crystal:GHallCfg.ShareCrystal}},{id:this._self_user.id})
            await this.update_user(this._self_user.id)
            this.showJson({dtCrystal:GHallCfg.ShareCrystal,crystal:this.selfUser.crystal})
            //钻石统计
            let scm = new StatisticsCurrencyModel()
            scm.from_id = this._self_user.id
            scm.create_time = scm.create_time
            scm.game_name = "hall"
            scm.why = ECurrencyWhy.ShareZS
            scm.crystal = this.selfUser.crystal
            GStatisticsCurrency.insert(scm)
        }
        this.showJson()
    }
    @UserValidate
    async onGetCheck()
    {
        let month_info = 0
        let cm = await GCheckInSer.getByUserId(this._self_user.id)
        if(cm)
        {
            month_info = cm.month_info
        }
        this.showJson({
            month_info:month_info,
            cfg:GHallCfg.check_prize
        })
    }
    @UserValidate
    async onCheck(params)
    {
        let rs = await GCheckInSer.check(this._self_user.id)
        if(rs.errcode)
        {
            this.showJson({errcode:rs.errcode})
            return
        }
        let prize=
        {
            base:GHallCfg.check_prize.day,
            extra:0,
            extra2:0
        }
        //连续多少天，
        let num = 0
        let total=0
        let ci = rs.cm.month_info
        let time = new Date()
        let d = time.getDate()-1
        for(;d>=0;--d)
        {
            if((ci&(1<<d))>0)
            {
                ++num
            }
            else
            {
                break
            }
        }
        for(;d>=0;--d)
        {
            if((ci&(1<<d))>0)
            {
                ++total
            }
        }
        if(num>7)
        {
            num=7
        }
        prize.extra = GHallCfg.check_prize.continue_days[num]||0
        prize.extra2=GHallCfg.check_prize.total_days[total]||0
        let dtcoin = prize.base+prize.extra+prize.extra2
        await GExtUserSer.updateOne({$inc:{coin:dtcoin}},{id:this.selfUser.id})
        await GRankSer.addData("rank_coin_all",this.selfUser.id,this.selfUser.coin+dtcoin,this.selfUser.coin)
        this.showJson({month_info:rs.cm.month_info,prize:prize})
    }
    
    @UserValidate
    async onRoomInfos()
    {
        let all = await GRoomSer.gets()
        this.showJson({room_infos:all})
    }
    /**
     * 获取背包数据
     */
    @UserValidate
    async onBagItems()
    {
        let items = await GBagSer.getByUserId(this.selfUser.id)
        this.showJson({bagitems:items,items:GItemCfg.allItems})
    }
    @UserValidate
    async onMatchSignup()
    {
        let rs = await GMatchInsSer.onSignup(this.selfUser,this.postData.ins_id)
        this.showJson(rs)
    }
    @UserValidate
    async onAllMatches()
    {
        let allmatches = await GMatchSer.gets()
        let allmatchins = await GMatchInsSer.getAllWithState()
        this.showJson({
            matches:allmatches,
            matchins:allmatchins
        })
    }
    @UserValidate
    async onAllBlinds()
    {
        let blinds:BlindModel[] = await GBlindSer.gets()
        this.showJson({
            blinds:blinds
        })
    }
    @UserValidate
    async onAllNews()
    {
        let news:NewsModel[] = await GNewsSer.gets(null,{open:{"$gt":0}})
        this.showJson({
            news:news
        })
    }
    @UserValidate
    async onAllAds()
    {
        let ads:AdModel[] = await GAdSer.gets(null,{open:{"$gt":0}})
        this.showJson({
            ads:ads
        })
    }
    @UserValidate
    async onAddAddressInfo()
    {
        let params = this.postData
        let address:AddressItem = params.address
        if(!address.create_time||address.create_time<0)
        {
            this.showJson({
                errcode:EErrorCode.Wrong_Param
            })
            return
        }
        let rs = await GExtUserSer.addAddress(this.selfUser.id,address)
        if(rs.errcode)
        {
            this.showJson({
                errcode:rs.errcode||{id:10086,des:"添加失败!"}
            })
            return
        }
        let user = await GExtUserSer.getById(this.selfUser.id)
        this._login(user)
        this.showJson({
            user:this._self_user
        })
    }
    @UserValidate
    async onUpdateAddressInfo()
    {
        let params = this.postData
        let address:AddressItem = params.address
        if(!address||!address.create_time||address.create_time<0)
        {
            this.showJson({
                errcode:EErrorCode.Wrong_Param
            })
            return
        }
        let rs = await GExtUserSer.updateAddress(this.selfUser.id,address)
        if(rs.errcode||rs.rs.modifiedCount<=0)
        {
            this.showJson({
                errcode:rs.errcode||{id:10086,des:"修改失败!"}
            })
            return
        }
        let user = await GExtUserSer.getById(this.selfUser.id)
        this._login(user)
        this.showJson({
            user:this._self_user
        })
    }
    @UserValidate
    async onRemoveAddressInfo()
    {
        let params = this.postData
        let create_time:number = params.create_time
        if(!create_time||create_time<0)
        {
            this.showJson({
                errcode:EErrorCode.Wrong_Param
            })
            return
        }
        let rs = await GExtUserSer.removeAddress(this.selfUser.id,create_time)
        if(rs.errcode)
        {
            this.showJson({
                errcode:rs.errcode||{id:10086,des:"移除失败!"}
            })
            return
        }
        let user = await GExtUserSer.getById(this.selfUser.id)
        this._login(user)
        this.showJson({
            user:this._self_user
        })
    }
    @UserValidate
    async onUpdatebind()
    {
        let params = this.postData
        let pre_user_id = parseInt(params.pre_user_id)
        let rs = await GExtUserSer.onBind(this.selfUser,pre_user_id)
        if(rs.errcode)
        {
            this.showJson({
                errcode:rs.errcode
            })
            return
        }
        this._login(rs.user)
        this.showJson({
            user:rs.user,
            pre_user:
            {
                id:rs.pre_user.id,
                nickname:rs.pre_user.nickname,
                logo:rs.pre_user.logo,
                sex:rs.pre_user.sex
            }
        })
    }
    @UserValidate
    async onGetMyMatches()
    {
        let user = await GExtUserSer.get({"matchinfos":1},{id:this.selfUser.id})
        let matchinfos:{[ins_id:string]:UserMatchInfo} = user.matchinfos||{}
        let allinsids:string[]=[]
        for(let key in matchinfos)
        {
            allinsids.push(key)
        }
        if(allinsids.length>0)
        {
            let all = await GMatchInsSer.gets({id:1,state:1,match:1,start_time:1,player_num:1},{id:{"$in":allinsids}})
            all=all||[]
            for(let i=0;i<all.length;++i)
            {
                let ins:MatchInsModel = all[i]
                let mi = matchinfos[ins.id]
                mi["match"]=
                {
                    id:ins.match.id,
                    state:ins.state,
                    name:ins.match.name,
                    icon:ins.match.icon,
                    reward:ins.match.reward,
                    start_time:ins.start_time,
                    player_num:ins.player_num
                }
            }
        }
        this.showJson({matchinfos:matchinfos})
    }
    @UserValidate
    async onGetFollwers()
    {
        let followers = await GExtUserSer.getFollwers(this.selfUser.id)
        this.showJson({followers:followers})
    }
    @UserValidate
    async onGetSignConfig()
    {
        this.showJson({signs:GHallCfg.signs})
    }
    @UserValidate
    async onSign()
    {
        let today_sign=false
        if(this.selfUser.sign_count)
        {
           let sign_start_time = core.getStartTime(this.selfUser.sign_time||0)
           let today = core.getTodayStartTime()
           if(sign_start_time==today)
           {
                today_sign=true
           } 
        }
        if(today_sign)
        {
            this.showJson({errcode:EErrorCode.Repeat_Sign})
            return
        }
        let sign_count = this.selfUser.sign_count||0
        let model={"$set":{sign_time:Date.now()}}
        let i = sign_count%7
        let mii = GHallCfg.signs[i]
        if(mii.id==-99)
        {
            model["$inc"]={coin:mii.count,sign_count:1}
        }
        let res = await GExtUserSer.updateOne(model,{id:this.selfUser.id})
        if(res.errcode)
        {
            this.showJson({errcode:res.errcode})
            return
        }
        let user = await GExtUserSer.getById(this.selfUser.id)
        this._login(user)
        this.showJson({user:this._self_user})
    }
    @UserValidate
    async onGetTaskMoney()
    {
        let task_name = this.postData.task
        if(!task_name)
        {
            this.showJson({errcode:EErrorCode.Wrong_Param})
            return
        }
        let suser:ExtUserModel = await GExtUserSer.get({id:1,taskstatus:1},{id:this.selfUser.id})
        if(!suser.taskstatus)
        {
            this.showJson({errcode:EErrorCode.Wrong_Param})
            return
        }
        let task = suser.taskstatus[task_name]
        if(!task||task.money<=0)
        {
            this.showJson({errcode:EErrorCode.Wrong_Param})
            return
        }
        let model = {"$inc":{}}
        model["$inc"]["taskstatus."+task_name+".money"]=-task.money
        model["$inc"]["coin"]=task.money
        let rs = await GExtUserSer.updateOne(model,{id:this.selfUser.id})
        if(rs.errcode)
        {
            this.showJson({errcode:rs.errcode})
            return
        }
        let user = await GExtUserSer.getById(this.selfUser.id)
        this._login(user)
        this.showJson({user:this._self_user,money:task.money})
    }
    @UserValidate
    async onGetMatchPlayers()
    {
        let ins_id = this.postData.ins_id
        let matchins:MatchInsModel = await GMatchInsSer.get({id:1,players:1,player_num:1},{id:ins_id})
        if(!matchins||!matchins.players)
        {
            this.showJson({players:[]})
            return
        }
        let all:MatchPlayer[]=[]
        for(let key in matchins.players)
        {
            let p = matchins.players[key]
            if(p.point>0)
            {
                all.push(p)
            }
        }
        this.showJson({players:all,player_num:matchins.player_num})
    }
    async onRLSBVerify()
    {
        let params = this.postData
        let userid = params.userid
        GLog.error(params)
        let name=params.name
        let cardno:string=params.cardno
        cardno=cardno.replaceAll("'","")
        let token=params.token
        let errcode = await GRLSBTool.verify(name,cardno,token)
        if(errcode)
        {
            this.showJson({code:1,errcode:errcode})
            return
        }
        await GExtUserSer.updateOne({nickname:name,idcard_no:cardno},{id:userid})
        this.showJson({code:0})
    }
    @UserValidate
    async onChooseAddress()
    {
        let address_time = this.postData.address_time||0
        address_time=parseInt(address_time)||0
        await GExtUserSer.updateOne({address_time:address_time},{id:this.selfUser.id})
        this.showJson()
    }

    @UserValidate
    async onExchangeitem()
    {
        let item_id = this.postData.item_id
        let item = GItemCfg.getItemById(item_id)
        if(!item||!item.coin)
        {
            this.showJson({errcode:EErrorCode.Wrong_Param})
            return
        }
        let user = await GExtUserSer.getById(this.selfUser.id)
        if(user.coin<item.coin)
        {
            this.showJson({errcode:EErrorCode.Not_Enough_Coin})
            return
        }
        
        let rs = await GExtUserSer.updateOne({"$inc":{coin:-item.coin}},{id:this.selfUser.id})
        if(rs.errcode)
        {
            this.showJson({errcode:rs.errcode})
            return
        }
        let bagitem = await GBagSer.addItem(user.id,item)
        if(!bagitem)
        {
            this.showJson({errcode:EErrorCode.Handle_Failed})
            return
        }
        user = await GExtUserSer.getById(this.selfUser.id)
        this._login(user)
        this.showJson({coin:user.coin,bagitem:bagitem})
    }
    @UserValidate
    async onFocus()
    {
        let insid = this.postData.insid
        if(!insid)
        {
            this.showJson({errcode:EErrorCode.Wrong_Param})
            return
        }
        let focusmatches=this.selfUser.focusmatches||[]
        let rs = await GExtUserSer.updateOne({"$addToSet":{"focusmatches":insid}},{id:this.selfUser.id})
        if(rs.errcode)
        {
            this.showJson({errcode:rs.errcode})
            return
        }
        focusmatches.push(insid)
        this.selfUser.focusmatches=focusmatches
        this.showJson()
    }
    @UserValidate
    async onFocusIns()
    {
        let matchinses = await GMatchInsSer.gets(null,{"id":{"$in":this.selfUser.focusmatches||[]}})
        this.showJson({matchinses:matchinses})
    }
}