ZYZ/game-server/app/servers/connector/handler/entryHandler.ts

import { STATUS } from './../../../consts/statusCode';
import { EquipModel } from './../../../db/Equip';
import { RoleModel } from './../../../db/Role';
import { UserModel } from '../../../db/User';
import { GMUserModel  } from '../../../db/GMUser';
import { Application } from 'pinus';
import {FrontendSession} from 'pinus';
import { HeroModel } from './../../../db/Hero';
import { resResult, returnHeroCeRatio, reduceCe } from '../../../pubUtils/util';
import { FUNC_OPT_TYPE } from '../../../consts';
import { getAp } from '../../../services/actionPointService';
import { ItemModel } from '../../../db/Item';
import { switchOnFunc } from '../../../services/funcSwitchService';

export default function (app: Application) {
    return new EntryHandler(app);
}

export class EntryHandler {
    constructor(private app: Application) {
    }

    /**
     * New client entry chat server.
     *
     * @param  {Object}   msg     request message
     * @param  {Object}   session current session object
     */
    async enter(msg: { token: string, serverId: number }, session: FrontendSession) {
        let self = this;
        let serverId = msg.serverId;
        let sessionService = self.app.get('sessionService');

        let user = await UserModel.findUserByToken(msg.token);
        if (!user) {
            console.log('user token not found');
            return resResult(STATUS.TOKEN_ERR);
        }

        let role = await RoleModel.findByUid(user.uid, serverId);
        if (!role) {
            return resResult(STATUS.ROLE_NOT_FOUND);
        }
        self.remoteLogin(role.roleId);
        await sessionService.akick(role.roleId);//
        await session.abind(role.roleId);
        session.set('uid', role.roleId);
        session.set('roleId', role.roleId);
        session.set('roleName', role.roleName);
        session.set('eventStatus', role.eventStatus);
        session.set('sid', self.app.get('serverId'));
        session.set('serverId', role.serverId);
        session.set('funcs', role.funcs||[]);
        session.push('sid', () => {});
        session.push('roleId', () => {});
        session.push('roleName', () => {});
        session.push('eventStatus', () => {});
        session.push('serverId', () => {});
        session.push('funcs', () => {});
        // session.push('rid', function (err) {
        //     if (err) {
        //         console.error('set rid for session service failed! error is : %j', err.stack);
        //     }
        // });
        session.on('closed', this.onUserLeave.bind(this));

        let channelService = self.app.get('channelService');
        let channel = channelService.getChannel(role.roleId, true);
        if (channel.getMembers().indexOf(role.roleId) === -1) {
            channel.add(role.roleId, self.app.get('serverId'));
        }

        // put user into channel
        // console.log(JSON.stringify(self.app.rpc.battle))
        // await self.app.rpc.battle.battleRemote.add.route(session)(role.roleId, self.app.get('serverId'), role.serverId, true);
        // let users = await self.app.rpc.chat.chatRemote.add.route(session)(role.roleId, self.app.get('serverId'), rid, true);
        let heros = await HeroModel.findByRole(role.roleId);
        let equips = await EquipModel.findbyRole(role.roleId);
        let items = await ItemModel.findbyRole(role.roleId);


        role['heros'] = heros.map(cur => returnHeroCeRatio(cur));
        role['equips'] = equips;
        role['consumeGoods'] = items;
        let apJson = await getAp(Date.now(), role.roleId);
        role['apJson'] = apJson;
        role['ce'] = reduceCe(role.ce);

        await switchOnFunc(role.roleId, FUNC_OPT_TYPE.LEVEL_UP, role.lv, session);
        return resResult(STATUS.SUCCESS, { role });
    }

    remoteLogin(uid: string) {
        let sessionService = this.app.get('sessionService');
        let sessions = sessionService.getByUid(uid);
        if (!!sessions) {
            sessions.forEach(session=>{
                let roleId = session.get('roleId');
                let sid = session.get('sid');
                let uids = [{uid: roleId, sid}];
                this.app.get('channelService').pushMessageByUids('onRemoteLogin', resResult(STATUS.LOGIN_ERR ), uids);
            });
        }
    }
    /**
     * User log out handler
     *
     * @param {Object} app current application
     * @param {Object} session current session object
     *
     */
    onUserLeave(session: FrontendSession, reason: string) {
        if (!session || !session.uid) {
            return;
        }

        let roleId = session.get('roleId');
        let sid = session.get('sid');
        let serverId = session.get('serverId');

        let channelService = this.app.get('channelService');
        let channel = channelService.getChannel(roleId, true);
        channel.leave(roleId, sid);
        // this.app.rpc.battle.battleRemote.kick.route(session)(roleId, this.app.get('serverId'), serverId);
        // this.app.rpc.chat.chatRemote.kick.route(session, true)(session.uid, this.app.get('serverId'), session.get('rid'));
    }


    /**
     * New client entry chat server.
     *
     * @param  {Object}   msg     request message
     * @param  {Object}   session current session object
     */
    async gmEnter(msg: { token: string, serverId: number }, session: FrontendSession) {
        
        let self = this;

        let user = await GMUserModel.getGmAccountByToken(msg.token);
        if (!user) {
            console.log('user token not found');
            return resResult(STATUS.TOKEN_ERR);
        }

        console.log(self.app.get('serverId'));
        await session.abind(user.username);
        session.set('uid', user.uid);
        session.set('roleId', user.username);
        session.set('roleName', user.name);
        session.set('eventStatus', 0);
        session.set('sid', self.app.get('serverId'));
        session.push('sid', () => {});
        session.push('roleId', () => {});
        session.push('roleName', () => {});
        session.push('eventStatus', () => {});
        // session.push('rid', function (err) {
        //     if (err) {
        //         console.error('set rid for session service failed! error is : %j', err.stack);
        //     }
        // });
        session.on('closed', this.onUserLeave.bind(this));

        // put user into channel
        return resResult(STATUS.SUCCESS);
    }
}