红点：优先提出好友推送系统

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

@@ -23,6 +23,8 @@ import { addRoleToGuildChannel, addRoleToSysChannel, addRoleToWorldChannel, leav
 import { reportOneOnline } from '../../../services/timeTaskService';
 import { Rank } from '../../../services/rankService';
 import { checkTaskWithRole, getCurTask } from '../../../services/taskService';
+import { pushData } from '../../../services/connectorService';
+
 export default function (app: Application) {
     return new EntryHandler(app);
 }
@@ -47,7 +49,7 @@ export class EntryHandler {
             return resResult(STATUS.TOKEN_ERR);
         }
 
-        let role = await RoleModel.findByUidAndSetTime(user.uid, serverId, ROLE_SELECT.ENTRY, true);
+        let role = await RoleModel.findByUidAndSetTime(user.uid, serverId, null, true);
         if (!role) {
             return resResult(STATUS.ROLE_NOT_FOUND);
         }
@@ -114,6 +116,8 @@ export class EntryHandler {
         // 任务
         checkTaskWithRole(serverId, role.roleId, self.app.get('serverId'), role.funcs, TASK_TYPE.LOGIN_SUM, role);
         checkTaskWithRole(serverId, role.roleId, self.app.get('serverId'), role.funcs, TASK_TYPE.LOGIN_SERIES, role);
+        // 推送数据
+        pushData(role, session);
 
         role['heros'] = heros;
         role['equips'] = equips;

game-server/app/servers/role/handler/friendHandler.ts

@@ -4,11 +4,11 @@ import { STATUS, ROLE_SELECT, FRIEND_DROP_TYPE, FRIEND_RELATION_TYPE, POPULATE_T
 import { RoleModel, RoleType } from "../../../db/Role";
 import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
 import { FriendApplyModel } from "../../../db/FriendApply";
-import { FriendApplyParams, FriendListParam, FriendRecommendParams, BlackListParam, FriendValueListParam } from "../../../domain/roleField/friend";
+import { FriendListParam, FriendRecommendParams, BlackListParam, FriendValueListParam } from "../../../domain/roleField/friend";
 import { FriendShipModel, FriendShipType } from "../../../db/FriendShip";
 import { FriendRelationModel, Relation } from "../../../db/FriendRelation";
 import { isRoleOnline, getServerName, getRoleOnlineInfo } from "../../../services/redisService";
-import { increaseFrdCnt, getRecommendType, sortByBeSentHeart } from "../../../services/friendService";
+import { increaseFrdCnt, getRecommendType, sortByBeSentHeart, getApplyList, getFriendList } from "../../../services/friendService";
 import { FriendPointModel } from "../../../db/FriendPoint";
 import { gameData, getDicFriendByLv } from "../../../pubUtils/data";
 import { addItems, handleCost } from "../../../services/rewardService";
@@ -167,32 +167,7 @@ export class FriendHandler {
     public async getApplyList(msg: {}, session: BackendSession) {
 
         let roleId: string = session.get('roleId');
-
+        let result = await getApplyList(roleId);
-        let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
-        let list = await FriendApplyModel.getApplyList(roleId);
-        let result = new Array<FriendApplyParams>();
-        let delApplyCodeList = new Array<string>();
-        for (let apply of list) {
-            let friend = <RoleType>apply.friend;
-            let type = getRecommendType(myFriendRelation, roleId, friend.roleId);
-
-            let param = new FriendApplyParams(apply.applyCode, friend);
-
-            let { serverId, userInfo: { serverType } } = friend;
-            let serverName = await getServerName(serverType, serverId);
-            param.setServerName(serverId, serverName);
-
-            param.setType(type);
-            if (type != FRIEND_RELATION_TYPE.NORMAL) {
-                delApplyCodeList.push(apply.applyCode);
-                continue;
-            }
-
-            result.push(param);
-        }
-        await FriendApplyModel.deleteApply(delApplyCodeList);
-        await RoleModel.increaseFriendApplyCnt(roleId, -1 * delApplyCodeList.length, 50);
-
         return resResult(STATUS.SUCCESS, {
             list: result
         });
@@ -247,8 +222,8 @@ export class FriendHandler {
                 await FriendRelationModel.addFriend(friend.roleId, role, friendShip);
 
                 let param = new FriendListParam(friend, roleId, friendShip);
-                let isOnline = await isRoleOnline(friend.roleId);
+                let hisOnlineInfo = await getRoleOnlineInfo(friend.roleId);
-                param.setOnline(isOnline);
+                param.setOnline(hisOnlineInfo.isOnline);
 
                 let { serverId, userInfo: { serverType } } = friend;
                 let serverName = await getServerName(serverType, serverId);
@@ -256,6 +231,10 @@ export class FriendHandler {
 
                 param.setType(FRIEND_RELATION_TYPE.HAS_FRIEND);
                 list.push(param);
+                if (hisOnlineInfo.isOnline) {
+                    this.channelService.pushMessageByUids('onFriendAdd', resResult(STATUS.SUCCESS, { friend: param }), [{ uid: friend.roleId, sid: hisOnlineInfo.sid }]);
+                }
+
                 resultApplyCodeList.push(apply.applyCode);
             }
         } else {
@@ -285,54 +264,9 @@ export class FriendHandler {
         let roleId: string = session.get('roleId');
 
         let role = await RoleModel.findByRoleId(roleId);
-        let list = new Array<FriendListParam>();
+        let res = await getFriendList(role);
-        let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
-        let friendList = myRelation ? myRelation.friends : [];
 
-        for (let friend of friendList) {
+        return resResult(STATUS.SUCCESS, res);
-            let friendRole = <RoleType>friend.role;
-            let friendShip = <FriendShipType>friend.friendShip;
-            if (!friendRole || !friendShip) continue;
-
-            let fs = <FriendShipType>friend.friendShip;
-            let ref = shouldRefresh(fs.refTime, new Date());
-            if (ref) {
-                friendShip = await FriendShipModel.refreshSendAndReceive(roleId, friendRole.roleId);
-            }
-
-            let param = new FriendListParam(friendRole, roleId, friendShip);
-            let { serverId, userInfo: { serverType } } = friendRole;
-            let serverName = await getServerName(serverType, serverId);
-            param.setServerName(serverId, serverName);
-
-            let isOnline = await isRoleOnline(friendRole.roleId);
-            param.setOnline(isOnline);
-
-            param.setType(FRIEND_RELATION_TYPE.HAS_FRIEND);
-
-            list.push(param);
-        }
-
-        list.sort((a, b) => {
-            if (a.isOnline != b.isOnline) {
-                return a.isOnline ? 1 : -1
-            }
-            if (a.quitTime != b.quitTime) {
-                return b.quitTime - a.quitTime
-            }
-            return a.friendValue - b.friendValue;
-        });
-
-        let { friendCnt = 0, blockCnt = 0 } = role;
-        let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
-        let { cnt: todayReceiveCnt = 0, sendCnt: todaySendCnt = 0 } = frdPointRec || {};
-
-        return resResult(STATUS.SUCCESS, {
-            todayReceiveCnt,
-            todaySendCnt,
-            list,
-            friendCnt, blockCnt
-        });
     }
 
     // 获取黑名单

game-server/app/services/connectorService.ts

@@ -0,0 +1,173 @@
+/**
+ * entry触发后引起的下发
+ */
+import { getMails } from './mailService';
+import { recentGuildMsgs, recentPrivateChatInfos, recentSysMsgs, recentWorldMsgs } from './chatService';
+import { getCurTask } from './taskService';
+
+import { RoleType } from '../db/Role';
+import { FrontendOrBackendSession, pinus } from 'pinus';
+import { resResult } from '../pubUtils/util';
+import { STATUS, USER_GUILD_SELECT, GUILD_SELECT } from '../consts';
+// import { getAllShopList } from './shopService';
+// import { getGeneralRank } from './rankService';
+import { getFriendList, getApplyList } from './friendService';
+// import { getDailyBattleList } from './dailyBattleService';
+// import { getExpeditionStatus } from './expeditionService';
+// import { getTowerStatus, getHungupRewards, getTasks } from './battleService';
+// import { getAllAssistCnt } from './comBattleService';
+// import { getDungeonData } from './dungeonService';
+// import { PvpSeasonResultModel } from '../db/PvpSeasonResult';
+import { nowSeconds } from '../pubUtils/timeUtil';
+// import { getGachaList } from './gachaService';
+// import { getSchoolList } from './roleService';
+// import { addRoleToGuildChannel } from './chatChannelService';
+// import { getMyGuildInfo, getGuildWithRefActive, getUserGuildWithRefActive, getWishPool } from './guildService';
+// import { getAuction } from './auctionService';
+// import { getGuildTrainInstance } from './guildTrainService';
+// import { BossInstanceModel } from '../db/BossInstance';
+// import { getBossInstanceInfo } from './guildBossService';
+// import { getEvent } from './eventSercive';
+// import { getBattleListOfMain } from './normalBattleService';
+
+export async function pushData(role: RoleType, session: FrontendOrBackendSession) {
+    try{
+        const { roleId, serverId, roleName, guildCode } = role;
+        const sid = session.get('sid');
+    
+        // // 商店
+        // const shop = await getAllShopList(roleId);
+        // pushEntryData('shop', roleId, sid, shop);
+        // // 排行榜
+        // const rank = await getGeneralRank(role, serverId);
+        // pushEntryData('rank', roleId, sid, rank);
+        // // 邮件
+        // const mails = await getMails(roleId, serverId);
+        // pushEntryData('mail', roleId, sid, mails);
+        // 好友
+        const friendList = await getFriendList(role);
+        const applyList = await getApplyList(roleId);
+        pushEntryData('friend', roleId, sid, { friendList, applyList });
+        // // 每日关卡
+        // const daily = await getDailyBattleList(role);
+        // pushEntryData('daily', roleId, sid, daily);
+        // // 远征
+        // const expedition = await getExpeditionStatus(roleId, roleName);
+        // pushEntryData('expedition', roleId, sid, expedition);
+        // // 镇念塔
+        // const tower = await getTowerEntryData(role);
+        // pushEntryData('tower', roleId, sid, tower);
+        // // 寻宝
+        // const assistCnt = await getAllAssistCnt(roleId);
+        // pushEntryData('comBattle', roleId, sid, { assistCnt })
+        // // 秘境
+        // const dungeon = await getDungeonData(role);
+        // pushEntryData('dungeon', roleId, sid, dungeon);
+        // // PVP
+        // const hasSeasonReward = await getPvpEntryData(roleId);
+        // pushEntryData('pvp', roleId, sid, { hasSeasonReward });
+        // // 招募
+        // const gacha = await getGachaList(roleId);
+        // pushEntryData('gacha', roleId, sid, gacha);
+        // // 百家学宫
+        // const school = await getSchoolList(roleId);
+        // pushEntryData('school', roleId, sid, school);        
+        // // 军团
+        // const { hasGuild, guild, userGuild, guildResult } = await getGuildEntryData(role, sid, session);
+        // if(hasGuild) {
+        //     pushEntryData('guild', roleId, sid, guildResult);
+        //     // 拍卖
+        //     const auction = await getAuction(guildCode, session);
+        //     pushEntryData('auction', roleId, sid, auction);
+        //     // 练兵场
+        //     const train = await getGuildTrainInstance(roleId, guild, userGuild);
+        //     pushEntryData('train', roleId, sid, train);
+        //     // 演武台boss
+        //     const bossInstance = await BossInstanceModel.findBossInstance(guild.code);
+        //     if(bossInstance) {
+        //         const boss = await getBossInstanceInfo(bossInstance, roleId);
+        //         pushEntryData('boss', roleId, sid, boss);
+        //     }
+        //     // 许愿池
+        //     const wishPool = await getWishPool(userGuild);
+        //     pushEntryData('wishPool', roleId, sid, wishPool);
+        // }
+        // // 任务
+        // const { mainTask, dailyTask, achievement } = await getCurTask(role.roleId, session);
+        // pushEntryData('task', roleId, sid, { mainTask, dailyTask, achievement });
+        // // 聊天
+        // const worldMsgs = await recentWorldMsgs(serverId);
+        // const sysMsgs = await recentSysMsgs(serverId);
+        // const guildMsgs = await recentGuildMsgs(guildCode);
+        // const recentPrivateChats = await recentPrivateChatInfos(roleId, roleName);
+        // pushEntryData('chat', roleId, sid, { worldMsgs, sysMsgs, guildMsgs, recentPrivateChats });
+        // // 奇遇
+        // const event = await getEvent(role.eventStatus, roleId, roleName);
+        // pushEntryData('event', roleId, sid, event);
+        // // 主线关卡列表
+        // const battle = await getBattleListOfMain(role);
+        // pushEntryData('battle', roleId, sid, battle);
+
+    }catch(e) {
+        console.error(e.stack);
+    }
+ }
+
+ function pushEntryData<T>(type: string, roleId: string, sid: string, param: T) {
+    let uids = [{ uid: roleId, sid }];
+    let data = { type };
+    data[type] = param;
+    pinus.app.channelService.pushMessageByUids('onEntryData', resResult(STATUS.SUCCESS, data), uids);//通知在线玩家练兵场重置，
+}
+
+// /**
+//  * 镇念塔初始数据
+//  * @param role 
+//  */
+// async function getTowerEntryData(role: RoleType) {
+//     const { roleId } = role;
+//     const status = await getTowerStatus(role);
+//     const hungUp = await getHungupRewards(roleId);
+//     const tasks = await getTasks(role);
+//     if(hungUp.status == -1) {
+//         return { status, hungUp: {}, tasks }
+//     } else {
+//         return { status, hungUp: hungUp.data, tasks }
+//     }
+// }
+
+// /**
+//  * 获取是否存在pvp赛季奖励
+//  * @param roleId 
+//  */
+// async function getPvpEntryData(roleId: string) {
+//     let pvpSeasonResult = await PvpSeasonResultModel.getPvpSeasonResult(roleId);
+//     if(!pvpSeasonResult) return false;
+
+//     let { oldSeasonData, show} = pvpSeasonResult;
+//     // 旧赛季结算的时候，会在pvpSeasonResult表中存上一赛季的时间，并更新show字段
+//     return oldSeasonData.seasonEndTime <= nowSeconds() && show;
+// }
+
+// /**
+//  * 获取军团信息，并加入军团频道
+//  * @param role 
+//  * @param sid 
+//  * @param session 
+//  */
+// async function getGuildEntryData(role: RoleType, sid: string, session: FrontendOrBackendSession) {
+
+//     if (role.hasGuild) {
+//         let userGuild = await getUserGuildWithRefActive(role.roleId, 'job auth guildCode receivedActive activeRecord activeDaily activeWeekly wishDntCnt wishGoods');
+//         if (userGuild) {
+//             let guild = await getGuildWithRefActive(userGuild.guildCode, role.serverId);
+//             if (guild) {
+//                 addRoleToGuildChannel(role.roleId, sid, userGuild.guildCode);
+                
+//                 let result = await getMyGuildInfo(role.roleId, sid, userGuild, guild, role.serverId, session);
+//                 return { hasGuild: true, guild, userGuild, guildResult: result};
+//             }
+//         }
+//     }
+//     return { hasGuild: false }
+// }

game-server/app/services/friendService.ts

@@ -1,11 +1,98 @@
 import { gameData, getDicFriendByLv } from "../pubUtils/data";
 import { RoleType, RoleModel } from "../db/Role";
-import { FriendRelationType, Relation } from "../db/FriendRelation";
+import { FriendRelationType, Relation, FriendRelationModel } from "../db/FriendRelation";
-import { getResStr } from "../pubUtils/util";
+import { getResStr, shouldRefresh } from "../pubUtils/util";
-import { STATUS, FRIEND_RELATION_TYPE } from "../consts";
+import { STATUS, FRIEND_RELATION_TYPE, POPULATE_TYPE, FRIEND_DROP_TYPE } from "../consts";
 import { FriendShipType, FriendShipModel } from "../db/FriendShip";
 import { outputCnt } from '../pubUtils/friendUtil';
-import { isRoleOnline } from "./redisService";
+import { isRoleOnline, getServerName } from "./redisService";
+import { FriendApplyModel } from "../db/FriendApply";
+import { FriendApplyParams, FriendListParam } from "../domain/roleField/friend";
+import { FriendPointModel } from "../db/FriendPoint";
+
+export async function getFriendList(role: RoleType) {
+    let { roleId } = role;
+    let list = new Array<FriendListParam>();
+    let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
+    let friendList = myRelation ? myRelation.friends : [];
+
+    for (let friend of friendList) {
+        let friendRole = <RoleType>friend.role;
+        let friendShip = <FriendShipType>friend.friendShip;
+        if (!friendRole || !friendShip) continue;
+
+        let fs = <FriendShipType>friend.friendShip;
+        let ref = shouldRefresh(fs.refTime, new Date());
+        if (ref) {
+            friendShip = await FriendShipModel.refreshSendAndReceive(roleId, friendRole.roleId);
+        }
+
+        let param = new FriendListParam(friendRole, roleId, friendShip);
+        let { serverId, userInfo: { serverType } } = friendRole;
+        let serverName = await getServerName(serverType, serverId);
+        param.setServerName(serverId, serverName);
+
+        let isOnline = await isRoleOnline(friendRole.roleId);
+        param.setOnline(isOnline);
+
+        param.setType(FRIEND_RELATION_TYPE.HAS_FRIEND);
+
+        list.push(param);
+    }
+
+    list.sort((a, b) => {
+        if (a.isOnline != b.isOnline) {
+            return a.isOnline ? 1 : -1
+        }
+        if (a.quitTime != b.quitTime) {
+            return b.quitTime - a.quitTime
+        }
+        return a.friendValue - b.friendValue;
+    });
+
+    let { friendCnt = 0, blockCnt = 0 } = role;
+    let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
+    let { cnt: todayReceiveCnt = 0, sendCnt: todaySendCnt = 0 } = frdPointRec || {};
+    
+    return {  
+        todayReceiveCnt,
+        todaySendCnt,
+        list,
+        friendCnt, blockCnt
+    }
+}
+
+/**
+ * 获取玩家申请列表
+ * @param roleId 玩家id
+ */
+export async function getApplyList(roleId: string) {
+    let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
+    let list = await FriendApplyModel.getApplyList(roleId);
+    let result = new Array<FriendApplyParams>();
+    let delApplyCodeList = new Array<string>();
+    for (let apply of list) {
+        let friend = <RoleType>apply.friend;
+        let type = getRecommendType(myFriendRelation, roleId, friend.roleId);
+
+        let param = new FriendApplyParams(apply.applyCode, friend);
+
+        let { serverId, userInfo: { serverType } } = friend;
+        let serverName = await getServerName(serverType, serverId);
+        param.setServerName(serverId, serverName);
+
+        param.setType(type);
+        if (type != FRIEND_RELATION_TYPE.NORMAL) {
+            delApplyCodeList.push(apply.applyCode);
+            continue;
+        }
+
+        result.push(param);
+    }
+    await FriendApplyModel.deleteApply(delApplyCodeList);
+    await RoleModel.increaseFriendApplyCnt(roleId, -1 * delApplyCodeList.length, 50);
+    return result;
+}
 
 /**
  * 增加双方好友数