ZYZ/web-server/app/controller/game.ts

import { STATUS } from '@consts';
import { GameModel } from '@db/Game';
import { Controller } from 'egg';
import { RoleModel } from '@db/Role';
import { NoticeModel } from '@db/Notice';
import { ServerParamWithRole, GroupParam } from '../domain/gameField/serverlist';
import { reloadResources } from 'app/pubUtils/data';
import { ServerlistModel } from '@db/Serverlist';
import { dispatch } from 'app/pubUtils/dispatcher';
import { RedisClient } from 'redis';
import { REDIS_KEY } from '@consts';
import { RegionModel } from '@db/Region';
import { getRandEelmWithWeight } from 'app/pubUtils/util';
import { ChannelInfoModel } from '@db/ChannelInfo';

export default class GameController extends Controller {

    public async checkVersion() {
        const { ctx } = this;
        const { version } = ctx.request.body;

        let curRegion = await RegionModel.findRegionByEnv(this.app.config.realEnv);
        if(!curRegion) {
            return ctx.body = ctx.service.utils.resResult(STATUS.VERSION_ERR);
        }

        const versionFlag = ctx.service.utils.compareVersion(version, curRegion.versionCode);
        if (versionFlag >= 0) {
            ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS);
            return;
        }
        //版本号太低
        ctx.body = ctx.service.utils.resResult(STATUS.VERSION_ERR, { version: curRegion.versionCode });
        return;
    }

    public async checkReview() {
        const { ctx } = this;
        const { version, platformAppid, platformAppId, addressType } = ctx.request.body;

        let curRegion = await RegionModel.findRegionByEnv(this.app.config.realEnv);
        if(!curRegion) {
            return ctx.body = ctx.service.utils.resResult(STATUS.VERSION_ERR);
        }

        if(curRegion.addressType != addressType) {
            return ctx.body = ctx.service.utils.resResult(STATUS.ADDRESS_ERR);
        }

        let hasPolicy = false, userPolicyLink = '', privacyPolicyLink = '';       // 是否需要替换协议，有就是用下面两个字段替换
        let platform = platformAppid ?? platformAppId;
        let channelInfo = await ChannelInfoModel.findByPlatform(platform);
        if(channelInfo && !channelInfo.isDefaultPolicy) {
            hasPolicy = true;
            userPolicyLink = channelInfo.userPolicyLink;
            privacyPolicyLink = channelInfo.privacyPolicyLink;
        }

        let isReview = await ctx.service.update.checkReview(curRegion, version);
        let hasNewWebServer = false, webServerUrl = '';
        if(isReview && curRegion.reviewEnv) {
            let reviewRegion = await RegionModel.findRegionByEnv(curRegion.reviewEnv);
            if(reviewRegion) {
                hasNewWebServer = true, webServerUrl = reviewRegion.webHost;
            }
        }

        ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { isReview, hasNewWebServer, webServerUrl, hasPolicy, userPolicyLink, privacyPolicyLink });
        return;
    }

    public async getServerList() {
        try {
            const { ctx } = this;
            let { uid } = ctx;
            const { version, addressType } = ctx.request.body;
            let serverList = new Array<GroupParam>();
            let loginServerList = new Array<ServerParamWithRole>();

            let curRegion = await RegionModel.findRegionByEnv(this.app.config.realEnv);
            if(!curRegion) {
                return ctx.body = ctx.service.utils.resResult(STATUS.VERSION_ERR);
            }

            if(curRegion.addressType != addressType) {
                return ctx.body = ctx.service.utils.resResult(STATUS.ADDRESS_ERR);
            }

            let isReview = await ctx.service.update.checkReview(curRegion, version);
            let env = isReview? curRegion.reviewEnv: ctx.app.config.realEnv;

            let allServers = await ServerlistModel.findByEnv(env||ctx.app.config.realEnv, isReview);
            let roles = await RoleModel.findAllByUid(uid, true, true);
            for (let server of allServers) {
                let curGroup = serverList.find(cur => cur.groupId == server.groupId);
                if (!curGroup) {
                    curGroup = new GroupParam(server);
                    serverList.push(curGroup);
                }
                curGroup.pushServer(server);

                let role = roles.find(role => role.serverId == server.id);
                if (!!role) {
                    let curLoginInfo = new ServerParamWithRole(role, server);
                    loginServerList.push(curLoginInfo);
                }
            }

            loginServerList.sort((a, b) => { return b.updatedAt.getTime() - a.updatedAt.getTime() });

            if (serverList) {
                ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { serverList, loginServerList });
            } else {
                ctx.body = ctx.service.utils.resResult(STATUS.SERVER_NOT_FOUND);
            }
            return

        }catch(e) {
            console.error(e);
        }
    }

    public async newServer() {
        const { ctx } = this;
        const { serverId, serverType, name, host, port, status } = ctx.request.body;
        const serverList = await GameModel.getAllServerList();
        for (let { id, host: preHost, port: prePort } of serverList) {
            if (preHost === host && prePort === port && id === serverId) {
                ctx.body = ctx.service.utils.resResult(STATUS.SERVER_EXISTS);
                return;
            }
        }
        const gameInfo = await GameModel.newServer(serverId, serverType, name, host, port, status);
        if (gameInfo) {
            ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { gameInfo });
        } else {
            ctx.body = ctx.service.utils.resResult(STATUS.NEW_SERVER_ERR);
        }
        return
    }


    public async getnotice() {
        const { ctx } = this;

        let notice = await NoticeModel.getAllNotice();
        let result = notice.map(cur => {
            let { id, title, tag, type, content, time } = cur;
            return {
                id, title, tag, type, content, time
            }
        })

        ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { notice: result });
        return
    }


    public async reloadResource() {
        const { ctx } = this;

        try {

            reloadResources();
            ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { isOK: true });
            return;
        } catch (e) {
            ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { isOK: false, err: (<Error>e).stack });
            return;
        }
    }

    public async queryEnter() {
        const { ctx } = this;
        const { app, userCode } = ctx;

        let redisClient: RedisClient = app.context.redisClient;
        let hash = await redisClient.hvalsAsync(REDIS_KEY.SYS_SERVER);
        let connectors = hash.map(cur => JSON.parse(cur));

        if (!connectors || connectors.length === 0) {
            ctx.body = ctx.service.utils.resResult(STATUS.CONNECTOR_ERR);
            return
        }
        // select connector
        let sum = connectors.reduce((pre, cur) => pre + (cur['num']||0), 0);
        let res;
        if(sum > 0) {
            let serversWithWeight = connectors.map(cur => ({...cur, weight: sum - (cur['num']||0)}));
            let randResult = getRandEelmWithWeight(serversWithWeight);
            res = randResult.dic;
        }
        if(!res) {
            res = dispatch(userCode, connectors, 'connector');
        }
        let { id, serverType, clientHost, clientPort, num = 0 } = res;

        await redisClient.hsetAsync(REDIS_KEY.SYS_SERVER, id, JSON.stringify({ serverType, clientHost, clientPort, id, num: num + 1 }));
        ctx.body = ctx.service.utils.resResult(STATUS.SUCCESS, { host: res.clientHost, port: res.clientPort });
        return
    }
}