735 lines
31 KiB
TypeScript
735 lines
31 KiB
TypeScript
import { Application, BackendSession, ChannelService, HandlerService, } from "pinus";
|
|
import { resResult, getRandEelm, getResStr, shouldRefresh, sortArrRandom, checkRoleIsRobot, getRobotSysType, makeRobotId } from "../../../pubUtils/util";
|
|
import { STATUS, ROLE_SELECT, FRIEND_DROP_TYPE, FRIEND_RELATION_TYPE, POPULATE_TYPE, BLOCK_OPEATE, CONSUME_TYPE, ITID, HERO_SELECT, EQUIP_SELECT, REDIS_KEY, MSG_SOURCE, MSG_TYPE, TASK_TYPE, ROBOT_SYS_TYPE } from "../../../consts";
|
|
import { RoleModel, RoleType } from "../../../db/Role";
|
|
import { getTimeFun, getZeroPointD } from "../../../pubUtils/timeUtil";
|
|
import { FriendApplyModel } from "../../../db/FriendApply";
|
|
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, getApplyList, getFriendList, getMyApplyParam, getMyParamAsFriend } from "../../../services/friendService";
|
|
import { FriendPointModel } from "../../../db/FriendPoint";
|
|
import { gameData, getDicFriendByLv } from "../../../pubUtils/data";
|
|
import { addItems, handleCost } from "../../../services/rewardService";
|
|
import { getFriendPointObject } from "../../../pubUtils/itemUtils";
|
|
import { RewardInter } from "../../../pubUtils/interface";
|
|
import { FriendPresentLogModel } from '../../../db/FriendPresentLog';
|
|
import { HeroModel, EPlace } from "../../../db/Hero";
|
|
import { EquipModel } from "../../../db/Equip";
|
|
import { getPlayerMainAttribute } from "../../../services/pvpService";
|
|
import { FRIEND } from "../../../pubUtils/dicParam";
|
|
import { PlayerDetail, PlayerDetailHero } from "../../../domain/battleField/guild";
|
|
import { createPrivateMsg, pushMsgToRole, pushPresent } from "../../../services/chatService";
|
|
import { Rank } from "../../../services/rankService";
|
|
import { checkTaskWithRoles, checkTask, checkActivityTask } from "../../../services/taskService";
|
|
import { ComBattleTeamModel } from "../../../db/ComBattleTeam";
|
|
|
|
|
|
export default function (app: Application) {
|
|
new HandlerService(app, {});
|
|
return new FriendHandler(app);
|
|
}
|
|
|
|
export class FriendHandler {
|
|
channelService: ChannelService;
|
|
|
|
constructor(private app: Application) {
|
|
this.channelService = this.app.get('channelService');
|
|
}
|
|
|
|
// 获取推荐好友列表
|
|
public async getRecommend(msg: {}, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
|
|
const day = <number>getTimeFun().getBeforeHour(FRIEND.FRIEND_RECONMMEND_ACTIVETIME);
|
|
|
|
const { lv, serverId: myServerId, userInfo: { serverType: myServerType } } = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_MY_SERVER);
|
|
let allList = await RoleModel.getRecommedList(lv - FRIEND.FRIEND_RECONMMEND_LEVEL, lv + FRIEND.FRIEND_RECONMMEND_LEVEL, day);
|
|
|
|
// 筛掉自己今天申请过的人
|
|
let applyList = await FriendApplyModel.getSentApplyList(roleId, getZeroPointD());
|
|
allList = allList.filter(cur => {
|
|
return !applyList.find(ccur => ccur.roleId == cur.roleId);
|
|
});
|
|
|
|
let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
|
|
|
|
let myServerList = new Array<FriendRecommendParams>();
|
|
let otherServerList = new Array<FriendRecommendParams>();
|
|
for (let role of allList) {
|
|
let type = getRecommendType(myFriendRelation, roleId, role.roleId);
|
|
if (type == FRIEND_RELATION_TYPE.NORMAL) {
|
|
let param = new FriendRecommendParams(role);
|
|
param.setType(type);
|
|
|
|
let { serverId } = role;
|
|
let serverName = await getServerName(serverId);
|
|
param.setServerName(serverId, serverName);
|
|
|
|
if (myServerId == serverId) {
|
|
myServerList.push(param);
|
|
} else {
|
|
otherServerList.push(param);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// 前4个是本服的，后4个随意，优先本服，其他补上
|
|
let myServerLen = myServerList.length > FRIEND.FRIEND_RECONMMEND_SERVICE ? FRIEND.FRIEND_RECONMMEND_SERVICE : myServerList.length;
|
|
let list1: FriendRecommendParams[] = getRandEelm(myServerList, myServerLen);
|
|
|
|
let otherServerLen = otherServerList.length > FRIEND.FRIEND_RECONMMEND_NUM - myServerLen ? FRIEND.FRIEND_RECONMMEND_NUM - myServerLen : otherServerList.length;
|
|
let list2: FriendRecommendParams[] = getRandEelm(otherServerList, otherServerLen);
|
|
|
|
if (list2.length < FRIEND.FRIEND_RECONMMEND_NUM - myServerLen) {
|
|
if (myServerList.length <= FRIEND.FRIEND_RECONMMEND_NUM - list2.length) {
|
|
list1 = myServerList;
|
|
} else {
|
|
list1 = getRandEelm(myServerList, FRIEND.FRIEND_RECONMMEND_NUM - list2.length);
|
|
}
|
|
}
|
|
list1 = sortArrRandom(list1);
|
|
list2 = sortArrRandom(list2);
|
|
|
|
let list = list1.concat(list2);
|
|
|
|
return resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
// 搜索好友
|
|
public async searchUser(msg: { value: string }, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
|
|
let { value } = msg;
|
|
let allList = await RoleModel.searchByNameOrId(value);
|
|
let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
|
|
|
|
let list = new Array<FriendRecommendParams>();
|
|
for (let role of allList) {
|
|
let type = getRecommendType(myFriendRelation, roleId, role.roleId);
|
|
let param = new FriendRecommendParams(role);
|
|
param.setType(type);
|
|
|
|
let { serverId } = role;
|
|
let serverName = await getServerName(serverId);
|
|
param.setServerName(serverId, serverName);
|
|
|
|
list.push(param);
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
// 申请
|
|
public async applyFriend(msg: { roleIds: string[] }, session: BackendSession) {
|
|
|
|
let roleId: string = session.get('roleId');
|
|
let roleIds = msg.roleIds;
|
|
|
|
const role = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_ROLE_ID);
|
|
let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
|
|
|
|
let str = '', resultRoleIds = new Array<string>();
|
|
for (let hisRoleId of roleIds) {
|
|
let type = getRecommendType(myFriendRelation, roleId, hisRoleId);
|
|
if (type == FRIEND_RELATION_TYPE.HAS_FRIEND) {
|
|
str = getResStr(STATUS.FRIEND_HAS_ADD); continue;
|
|
} else if (type == FRIEND_RELATION_TYPE.HAS_BLOCKED) {
|
|
str = getResStr(STATUS.FRIEND_HAS_BLOCKED); continue;
|
|
} else if (type == FRIEND_RELATION_TYPE.MYSELF) {
|
|
str = getResStr(STATUS.FRIEND_YOURSELF); continue;
|
|
}
|
|
|
|
let incResult = await RoleModel.increaseFriendApplyCnt(hisRoleId, 1, FRIEND.FRIEND_MANAGE_APPLICATION);
|
|
if (!incResult) {
|
|
str = getResStr(STATUS.FRIEND_HIS_APPLY_MAX); continue;
|
|
}
|
|
|
|
let apply = await FriendApplyModel.createApply(hisRoleId, role);
|
|
resultRoleIds.push(hisRoleId);
|
|
let hisOnlineInfo = await getRoleOnlineInfo(hisRoleId);
|
|
let uids = [];
|
|
if (hisOnlineInfo.isOnline) {
|
|
uids.push({ uid: hisRoleId, sid: hisOnlineInfo.sid });
|
|
let myApply = await getMyApplyParam(apply.applyCode, role);
|
|
this.channelService.pushMessageByUids('onFriendApply', resResult(STATUS.SUCCESS, { apply: myApply }), uids);
|
|
}
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
isSuccess: str == '',
|
|
msg: str,
|
|
roleIds: resultRoleIds
|
|
});
|
|
}
|
|
|
|
// 获取申请列表
|
|
public async getApplyList(msg: {}, session: BackendSession) {
|
|
|
|
let roleId: string = session.get('roleId');
|
|
let result = await getApplyList(roleId);
|
|
return resResult(STATUS.SUCCESS, {
|
|
list: result
|
|
});
|
|
}
|
|
|
|
// （一键）同意/拒绝申请
|
|
public async handleApply(msg: { applyCodeList: string[], isPass: boolean }, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
let sid: string = session.get('sid');
|
|
|
|
const serverId = session.get('serverId');
|
|
|
|
let { applyCodeList, isPass } = msg;
|
|
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
let roles = new Array<RoleType>();
|
|
let friendCnt = role.friendCnt;
|
|
|
|
let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
|
|
|
|
let applyList = await FriendApplyModel.getApplyListByCode(applyCodeList);
|
|
let list = new Array<FriendListParam>();
|
|
|
|
let str = '', resultApplyCodeList = new Array<string>();
|
|
if (isPass) {
|
|
for (let apply of applyList) {
|
|
let type = getRecommendType(myFriendRelation, roleId, apply.frdRoleId);
|
|
if (type == FRIEND_RELATION_TYPE.HAS_FRIEND) {
|
|
str = getResStr(STATUS.FRIEND_HAS_ADD);
|
|
resultApplyCodeList.push(apply.applyCode); continue;
|
|
} else if (type == FRIEND_RELATION_TYPE.HAS_BLOCKED) {
|
|
resultApplyCodeList.push(apply.applyCode);
|
|
str = getResStr(STATUS.FRIEND_HAS_BLOCKED); continue;
|
|
} else if (type == FRIEND_RELATION_TYPE.MYSELF) {
|
|
resultApplyCodeList.push(apply.applyCode);
|
|
str = getResStr(STATUS.FRIEND_YOURSELF); continue;
|
|
}
|
|
|
|
// 好友数量校验
|
|
let friend = <RoleType>apply.friend;
|
|
str = await increaseFrdCnt(role, friend, friendCnt);
|
|
if (str != '') continue;
|
|
roles.push(friend);
|
|
|
|
// 创建friendShip
|
|
let friendShip = await FriendShipModel.createFriendShip([roleId, friend.roleId]);
|
|
if (!friendShip) {
|
|
str = getResStr(STATUS.FRIEND_SHIP_CREATE_ERROR); continue;
|
|
}
|
|
|
|
await FriendRelationModel.addFriend(roleId, friend, friendShip);
|
|
await FriendRelationModel.addFriend(friend.roleId, role, friendShip);
|
|
|
|
let param = new FriendListParam(friend, roleId, friendShip);
|
|
let hisOnlineInfo = await getRoleOnlineInfo(friend.roleId);
|
|
param.setOnline(hisOnlineInfo.isOnline);
|
|
|
|
let { serverId } = friend;
|
|
let serverName = await getServerName( serverId);
|
|
param.setServerName(serverId, serverName);
|
|
|
|
param.setType(FRIEND_RELATION_TYPE.HAS_FRIEND);
|
|
list.push(param);
|
|
if (hisOnlineInfo.isOnline) {
|
|
let myParam = await getMyParamAsFriend(friendShip, role, friend.roleId);
|
|
this.channelService.pushMessageByUids('onFriendAdd', resResult(STATUS.SUCCESS, { friend: myParam }), [{ uid: friend.roleId, sid: hisOnlineInfo.sid }]);
|
|
}
|
|
|
|
resultApplyCodeList.push(apply.applyCode);
|
|
}
|
|
} else {
|
|
resultApplyCodeList = applyCodeList;
|
|
}
|
|
|
|
let deleteCount = await FriendApplyModel.deleteApply(resultApplyCodeList);
|
|
role = await RoleModel.increaseFriendApplyCnt(roleId, -1 * deleteCount, FRIEND.FRIEND_MANAGE_APPLICATION);
|
|
roles.push(role);
|
|
// 任务
|
|
await checkTaskWithRoles(serverId, roleId, sid, TASK_TYPE.FRIEND_NUM, roles);
|
|
|
|
// 特殊处理：如果他点一键同意，有很多人，这个单独的人就不做这个额外的提示，直接把他好友申请删掉就好
|
|
if (str == getResStr(STATUS.FRIEND_HAS_ADD) && resultApplyCodeList.length > 1) str = '';
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
isSuccess: str == '',
|
|
msg: str,
|
|
applyCodeList: resultApplyCodeList,
|
|
list,
|
|
friendCnt
|
|
});
|
|
}
|
|
|
|
// 获取好友列表
|
|
public async getFriendList(msg: {}, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
let res = await getFriendList(role);
|
|
|
|
return resResult(STATUS.SUCCESS, res);
|
|
}
|
|
|
|
// 获取黑名单
|
|
public async getBlackList(msg: {}, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
let list = new Array<BlackListParam>();
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.BLACKLIST);
|
|
let blacklist = myRelation ? myRelation.blacklist : [];
|
|
for (let bl of blacklist) {
|
|
let friendRole = <RoleType>bl.role;
|
|
if (!friendRole) continue;
|
|
let param = new BlackListParam(friendRole);
|
|
let isOnline = await isRoleOnline(friendRole.roleId);
|
|
param.setOnline(isOnline);
|
|
|
|
let { serverId } = friendRole;
|
|
let serverName = await getServerName(serverId);
|
|
param.setServerName(serverId, serverName);
|
|
|
|
param.setType(FRIEND_RELATION_TYPE.HAS_BLOCKED);
|
|
|
|
list.push(param);
|
|
|
|
}
|
|
|
|
let { friendCnt = 0, blockCnt = 0 } = role;
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
list,
|
|
friendCnt, blockCnt
|
|
});
|
|
}
|
|
|
|
|
|
// 拉黑/移除
|
|
public async setBlackList(msg: { roleId: string, type: number }, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
let sid: string = session.get('sid');
|
|
|
|
const serverId = session.get('serverId');
|
|
let { roleId: hisRoleId, type } = msg;
|
|
|
|
let role = await RoleModel.findByRoleId(roleId);
|
|
let friend: RoleType;
|
|
|
|
let str = '', list = new Array<BlackListParam>(), frdRoleIds = new Array<string>(), blackRoleIds = new Array<string>();
|
|
if (type == BLOCK_OPEATE.ADD) { // 拉黑
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
|
|
let friends = myRelation ? myRelation.friends : [];
|
|
let blacklist = myRelation ? myRelation.blacklist : [];
|
|
let curFriend = friends.find(cur => cur.roleId == hisRoleId);
|
|
let curBlack = blacklist.find(cur => cur.roleId == hisRoleId);
|
|
if (curBlack) {
|
|
return resResult(STATUS.FRIEND_BLACK_HAS_ADD);
|
|
}
|
|
|
|
role = await RoleModel.increaseBlockCnt(roleId, 1, curFriend ? -1 : 0, FRIEND.FRIEND_BLACKLIST_MAX); // 增加黑名单人数
|
|
if (!role) {
|
|
return resResult(STATUS.FRIEND_BLACK_MAX)
|
|
}
|
|
friend = await RoleModel.increaseFriendCnt(hisRoleId, curFriend ? -1 : 0); // 对方好友减少
|
|
|
|
let friendShip: FriendShipType;
|
|
if (!!curFriend) {
|
|
await FriendShipModel.clearValue([roleId, hisRoleId]);
|
|
friendShip = <FriendShipType>curFriend.friendShip;
|
|
}
|
|
|
|
await FriendRelationModel.moveFromFriend(hisRoleId, role, friendShip, false, !!curFriend); //从对方好友删除
|
|
await FriendRelationModel.moveFromFriend(roleId, friend, friendShip, true, !!curFriend); // 删除好友关系并拉黑
|
|
let { myRecApplyCount, hisRecApplyCount } = await FriendApplyModel.deleteApplyByRoles(roleId, hisRoleId); // 删除双方的申请
|
|
if(myRecApplyCount > 0) await RoleModel.increaseFriendApplyCnt(roleId, -1 * myRecApplyCount, FRIEND.FRIEND_MANAGE_APPLICATION);
|
|
if(hisRecApplyCount > 0) await RoleModel.increaseFriendApplyCnt(roleId, -1 * hisRecApplyCount, FRIEND.FRIEND_MANAGE_APPLICATION);
|
|
|
|
let param = new BlackListParam(friend);
|
|
let isOnline = await isRoleOnline(friend.roleId);
|
|
param.setOnline(isOnline);
|
|
|
|
let { serverId } = friend;
|
|
let serverName = await getServerName(serverId);
|
|
param.setServerName(serverId, serverName);
|
|
|
|
param.setType(FRIEND_RELATION_TYPE.HAS_BLOCKED);
|
|
list.push(param);
|
|
frdRoleIds.push(roleId);
|
|
} else if (type == BLOCK_OPEATE.REMOVE_FRIEND) { // 仅移除
|
|
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND);
|
|
let friends = myRelation ? myRelation.friends : [];
|
|
let curFriend = friends.find(cur => cur.roleId == hisRoleId);
|
|
if (!curFriend) {
|
|
return resResult(STATUS.FRIEND_NOT_FOUND);
|
|
}
|
|
|
|
role = await RoleModel.increaseFriendCnt(roleId, -1); // 减少好友
|
|
if (!role) {
|
|
return resResult(STATUS.FRIEND_NOT_FOUND)
|
|
}
|
|
friend = await RoleModel.increaseFriendCnt(hisRoleId, -1); // 对方好友减少
|
|
|
|
let friendShip: FriendShipType;
|
|
|
|
await FriendShipModel.clearValue([roleId, hisRoleId]);
|
|
friendShip = <FriendShipType>curFriend.friendShip;
|
|
|
|
await FriendRelationModel.moveFromFriend(hisRoleId, role, friendShip, false, !!curFriend); //从对方好友删除
|
|
await FriendRelationModel.moveFromFriend(roleId, friend, friendShip, false, !!curFriend); // 删除好友关系并拉黑
|
|
|
|
frdRoleIds.push(roleId);
|
|
|
|
} else if (type == BLOCK_OPEATE.REMOVE_BLACK || type == BLOCK_OPEATE.REMOVE_AND_APPLY) {
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.BLACKLIST);
|
|
let blacklist = myRelation ? myRelation.blacklist : [];
|
|
|
|
let curFriend = blacklist.find(cur => cur.roleId == hisRoleId);
|
|
if (!curFriend) {
|
|
return resResult(STATUS.FRIEND_BLACK_NOT_FOUND);
|
|
}
|
|
|
|
role = await RoleModel.increaseBlockCnt(roleId, -1, 0, 100); // 黑名单人数减
|
|
if (!role) {
|
|
return resResult(STATUS.FRIEND_BLACK_MAX)
|
|
}
|
|
await FriendRelationModel.removeFromBlack(roleId, hisRoleId);
|
|
|
|
if (type == BLOCK_OPEATE.REMOVE_AND_APPLY) {
|
|
// 申请好友
|
|
friend = await RoleModel.increaseFriendApplyCnt(hisRoleId, 1, FRIEND.FRIEND_MANAGE_APPLICATION);
|
|
if (!friend) {
|
|
str = getResStr(STATUS.FRIEND_HIS_APPLY_MAX);
|
|
} else {
|
|
await FriendApplyModel.createApply(hisRoleId, role);
|
|
}
|
|
}
|
|
blackRoleIds.push(roleId);
|
|
|
|
} else {
|
|
return resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
|
|
let { friendCnt = 0, blockCnt = 0 } = role;
|
|
|
|
// 任务
|
|
await checkTaskWithRoles(serverId, roleId, sid, TASK_TYPE.FRIEND_NUM, [role, friend]);
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
frdRoleIds, blackRoleIds,
|
|
isSuccess: str == '',
|
|
msg: str,
|
|
list,
|
|
friendCnt, blockCnt
|
|
});
|
|
}
|
|
|
|
// 赠送爱心/一键赠送
|
|
public async sendHeart(msg: { roleId: string }, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
let roleName: string = session.get('roleName');
|
|
let sid: string = session.get('sid');
|
|
let serverId: number = session.get('serverId');
|
|
|
|
|
|
let { roleId: hisRoleId } = msg;
|
|
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND); // 好友关系，只有friendship被populate了
|
|
let friends = myRelation ? myRelation.friends : [];
|
|
let arr = new Array<Relation>();
|
|
if (hisRoleId != '') {
|
|
let cur = friends.find(cur => cur.roleId == hisRoleId);
|
|
if (!cur) return resResult(STATUS.FRIEND_NOT_FOUND);
|
|
|
|
arr.push(cur);
|
|
} else {
|
|
arr = friends;
|
|
}
|
|
let canSendList = await sortByBeSentHeart(roleId, arr);
|
|
|
|
let { lv } = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_LV);
|
|
let dicFriendLv = getDicFriendByLv(lv);
|
|
if (!dicFriendLv) return resResult(STATUS.DIC_DATA_NOT_FOUND);
|
|
|
|
// 情谊值有上限，送到上限为止
|
|
let max = dicFriendLv.sendMax;
|
|
let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
|
|
let { sendCnt: todaySendCnt = 0 } = frdPointRec || {};
|
|
|
|
let todaySendInc = 0;
|
|
let list = new Array<FriendValueListParam>();
|
|
|
|
let uids = [];
|
|
for (let relation of canSendList) {
|
|
|
|
if (todaySendCnt + FRIEND.FRIEND_FRIENDPOINT_ADD > max) break;
|
|
let fs = <FriendShipType>relation.friendShip;
|
|
let ref = shouldRefresh(fs.refTime, new Date());
|
|
let sendHeartRec = await FriendShipModel.sendHeart(roleId, relation.roleId, 1, FRIEND.FRIEND_RECEIVE_SINGLE, ref);
|
|
if (!sendHeartRec) continue;
|
|
|
|
let param = new FriendValueListParam(relation.roleId, roleId, sendHeartRec);
|
|
list.push(param);
|
|
|
|
todaySendCnt += FRIEND.FRIEND_FRIENDPOINT_ADD;
|
|
todaySendInc += FRIEND.FRIEND_FRIENDPOINT_ADD;
|
|
|
|
let hisOnlineInfo = await getRoleOnlineInfo(relation.roleId);
|
|
if (hisOnlineInfo.isOnline) {
|
|
uids.push({ uid: relation.roleId, sid: hisOnlineInfo.sid });
|
|
}
|
|
}
|
|
this.channelService.pushMessageByUids('onFriendSendHeart', resResult(STATUS.SUCCESS, { roleId }), uids);
|
|
if (todaySendInc <= 0) return resResult(STATUS.FRIEND_HAS_SENT);
|
|
|
|
// 更新情谊值
|
|
frdPointRec = await FriendPointModel.updateSendCntToday(roleId, roleName, todaySendInc, max, FRIEND_DROP_TYPE.SEND_GIFT);
|
|
// 任务
|
|
await checkTask(roleId, sid, TASK_TYPE.FRIEND_SEND_HEART, todaySendInc, true, {});
|
|
// 活动任务
|
|
if (todaySendInc > 0) {
|
|
await checkActivityTask(serverId, sid, roleId, TASK_TYPE.FRIEND_SEND_HEART, todaySendInc);
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
todaySendCnt, list
|
|
})
|
|
}
|
|
|
|
|
|
// 领取爱心/一键领取
|
|
public async receiveHeart(msg: { roleId: string }, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
let roleName: string = session.get('roleName');
|
|
let sid: string = session.get('sid');
|
|
|
|
let { roleId: hisRoleId } = msg;
|
|
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND); // 好友关系，只有friendship被populate了
|
|
let friends = myRelation ? myRelation.friends : [];
|
|
let arr = new Array<Relation>();
|
|
if (hisRoleId != '') {
|
|
let cur = friends.find(cur => cur.roleId == hisRoleId);
|
|
if (!cur) return resResult(STATUS.FRIEND_NOT_FOUND);
|
|
|
|
arr.push(cur);
|
|
} else {
|
|
arr = friends;
|
|
}
|
|
let canReceiveList = await sortByBeSentHeart(roleId, arr);
|
|
|
|
let { lv } = await RoleModel.findByRoleId(roleId, ROLE_SELECT.GET_LV);
|
|
let dicFriendLv = getDicFriendByLv(lv);
|
|
if (!dicFriendLv) return resResult(STATUS.DIC_DATA_NOT_FOUND);
|
|
|
|
// 情谊值有上限，到上限为止
|
|
let max = dicFriendLv.receiveMax;
|
|
let frdPointRec = await FriendPointModel.getFrdPointRecToday(roleId, FRIEND_DROP_TYPE.SEND_GIFT);
|
|
let { cnt: todayReceiveCnt = 0 } = frdPointRec || {};
|
|
|
|
let todayReceiveInc = 0;
|
|
let list = new Array<FriendValueListParam>();
|
|
for (let relation of canReceiveList) {
|
|
if (relation.beSentHeart > 0) {
|
|
if (todayReceiveCnt + FRIEND.FRIEND_FRIENDPOINT_ADD > max) break;
|
|
|
|
// 收取爱心
|
|
let fs = <FriendShipType>relation.friendShip;
|
|
let ref = shouldRefresh(fs.refTime, new Date());
|
|
let receiveHeartRec = await FriendShipModel.receiveHeart(roleId, relation.roleId, 1, relation.beSentHeart, ref);
|
|
if (!receiveHeartRec) continue;
|
|
|
|
let param = new FriendValueListParam(relation.roleId, roleId, receiveHeartRec);
|
|
list.push(param);
|
|
|
|
todayReceiveCnt += FRIEND.FRIEND_FRIENDPOINT_ADD;
|
|
todayReceiveInc += FRIEND.FRIEND_FRIENDPOINT_ADD;
|
|
}
|
|
}
|
|
if (todayReceiveInc <= 0) return resResult(STATUS.FRIEND_HAS_RECEIVE);
|
|
let fp = getFriendPointObject(todayReceiveCnt);
|
|
let goods = await addItems(roleId, roleName, sid, [fp])
|
|
|
|
frdPointRec = await FriendPointModel.updatePointToday(roleId, roleName, todayReceiveInc, max, FRIEND_DROP_TYPE.SEND_GIFT);
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
simpleGoods: goods,
|
|
todayReceiveCnt, list
|
|
})
|
|
}
|
|
|
|
// 赠送礼物
|
|
public async sendPresent(msg: { roleId: string, items: RewardInter[] }, session: BackendSession) {
|
|
let roleId: string = session.get('roleId');
|
|
let roleName: string = session.get('roleName');
|
|
let sid: string = session.get('sid');
|
|
let serverId: string = session.get('serverId');
|
|
|
|
let { roleId: hisRoleId, items } = msg;
|
|
let myRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.FRIEND_NAME_ONLY);
|
|
let friends = myRelation ? myRelation.friends : [];
|
|
let curFriend = friends.find(cur => cur.roleId == hisRoleId);
|
|
if (!curFriend) return resResult(STATUS.FRIEND_NOT_FOUND);
|
|
|
|
let friendValueInc = 0;
|
|
for (let { id, count } of items) {
|
|
let dicGood = gameData.goods.get(id);
|
|
if (!dicGood) {
|
|
return resResult(STATUS.DIC_DATA_NOT_FOUND);
|
|
}
|
|
|
|
let dicItid = ITID.get(dicGood.itid);
|
|
if (dicItid.type == CONSUME_TYPE.FRIEND_FAVOUR) {
|
|
friendValueInc += dicGood.value * count;
|
|
} else {
|
|
return resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
}
|
|
|
|
let costResult = await handleCost(roleId, sid, items);
|
|
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
|
|
|
|
let result = await FriendShipModel.addFriendValue(roleId, hisRoleId, friendValueInc);
|
|
if (!result) return resResult(STATUS.FRIEND_NOT_FOUND);
|
|
|
|
// TODO 日志可以转到log服
|
|
await FriendPresentLogModel.createRecord(roleId, hisRoleId, items);
|
|
for (let { id, count } of items) {
|
|
const msgData = await createPrivateMsg(roleId, roleName, MSG_TYPE.RICH_TEXT, MSG_SOURCE.PRIVATE_SEND_GIFT, JSON.stringify({ id, count }), hisRoleId, null);
|
|
await pushMsgToRole(msgData);
|
|
let hisRole = <RoleType>curFriend.role;
|
|
await pushPresent(roleId, roleName, serverId, hisRole.roleName, id);
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, {
|
|
roleId: hisRoleId,
|
|
...result
|
|
});
|
|
}
|
|
|
|
async getPlayerSimpleInfo(msg: { roleId: string }, session: BackendSession) {
|
|
|
|
let roleId: string = session.get('roleId');
|
|
|
|
let { roleId: targetRoleId } = msg;
|
|
let isRobot = checkRoleIsRobot(targetRoleId);
|
|
if(isRobot) {
|
|
let role = await RoleModel.findByRoleId(roleId, null, true);
|
|
let sysType = getRobotSysType(targetRoleId);
|
|
let addObj: any = { roleId: makeRobotId(''), roleName: '', guildName: '' };
|
|
if(sysType == ROBOT_SYS_TYPE.COM_BTL) {
|
|
let comBattle = await ComBattleTeamModel.findByRoleId(targetRoleId);
|
|
if(comBattle) {
|
|
addObj = comBattle.roleStatus.find(cur => cur.roleId == targetRoleId)||{};
|
|
}
|
|
}
|
|
let param = new FriendRecommendParams({...role, ...addObj});
|
|
param.setType(FRIEND_RELATION_TYPE.ROBOT);
|
|
let { serverId } = role;
|
|
let serverName = await getServerName(serverId);
|
|
param.setServerName(serverId, serverName);
|
|
|
|
return resResult(STATUS.SUCCESS, {...param, isRobot });
|
|
} else {
|
|
|
|
let role = await RoleModel.findByRoleId(targetRoleId, null, true);
|
|
let myFriendRelation = await FriendRelationModel.findFriendByRole(roleId, POPULATE_TYPE.NOT);
|
|
|
|
let type = getRecommendType(myFriendRelation, roleId, role.roleId);
|
|
let param = new FriendRecommendParams(role);
|
|
param.setType(type);
|
|
|
|
let { serverId } = role;
|
|
let serverName = await getServerName(serverId);
|
|
param.setServerName(serverId, serverName);
|
|
return resResult(STATUS.SUCCESS, {...param, isRobot });
|
|
}
|
|
|
|
}
|
|
|
|
async getPlayerDetail(msg: { roleId: string }, session: BackendSession) {
|
|
|
|
// let roleId = session.get('roleId');
|
|
let { roleId: oppoRoleId } = msg;
|
|
|
|
let result: PlayerDetail;
|
|
|
|
let dbHeroes = await HeroModel.findByRole(oppoRoleId);
|
|
let role = await RoleModel.findByRoleId(oppoRoleId, null, true);
|
|
if(!role) return resResult(STATUS.ROLE_NOT_FOUND);
|
|
|
|
let { topLineup, topLineupCe, towerLv, showLineup } = role;
|
|
|
|
let heroes = new Array<PlayerDetailHero>();
|
|
|
|
if (showLineup && showLineup.length) { // 设置过展示阵容
|
|
for (let hid of showLineup) {
|
|
let curHero = dbHeroes.find(cur => cur.hid == hid);
|
|
if (curHero) {
|
|
let { lv, star, colorStar, quality, skinId } = curHero;
|
|
heroes.push({
|
|
actorId: hid, skinId, lv, star, colorStar, quality,
|
|
score: 0
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
for (let { hid } of topLineup) {
|
|
let curHero = dbHeroes.find(cur => cur.hid == hid);
|
|
if (curHero) {
|
|
let { lv, star, colorStar, quality, skinId } = curHero;
|
|
heroes.push({
|
|
actorId: hid, lv, skinId, star, colorStar, quality,
|
|
score: 0
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
let r = new Rank(REDIS_KEY.PVP_RANK, {});
|
|
let rank = await r.getMyRank({ roleId: oppoRoleId });//去redis中获取排名
|
|
|
|
result = new PlayerDetail({ ...role, defCe: topLineupCe, heroes });
|
|
result.setWarStar(role.warStar, rank, towerLv - 1);
|
|
|
|
return resResult(STATUS.SUCCESS, result);
|
|
}
|
|
|
|
// 查看对象武将详细
|
|
public async getHeroDetail(msg: { roleId: string, hids: number[] }, session: BackendSession) {
|
|
// let roleId: string = session.get('roleId');
|
|
// let sid: string = session.get('sid');
|
|
|
|
let { roleId: hisRoleId, hids } = msg;
|
|
|
|
let role = await RoleModel.findByRoleId(hisRoleId, ROLE_SELECT.ATTR);
|
|
if (!role) return resResult(STATUS.ROLE_NOT_FOUND);
|
|
|
|
let heroList = await HeroModel.findByHidRange(hids, hisRoleId, HERO_SELECT.HERO_DETAIL, true);
|
|
if (heroList.length <= 0) return resResult(STATUS.HERO_NOT_FIND);
|
|
|
|
let list = new Array();
|
|
for (let { roleId, roleName, hid, hName, ce, lv, star, colorStar, quality, job, skinId, attr: heroAttrs, ePlace } of heroList) {
|
|
|
|
let equips = await EquipModel.findListByHidAndRole(hisRoleId, hid, EQUIP_SELECT.HERO_DETAIL);
|
|
|
|
let attributes = getPlayerMainAttribute(heroAttrs, role.attr);
|
|
|
|
list.push({
|
|
roleId, roleName, hid, hName, ce, lv, star, colorStar, quality, job, skinId,
|
|
equips: equips.map(cur => {
|
|
let curEplace = ePlace.find(ccur => cur.ePlaceId == ccur.id) || new EPlace();
|
|
let { lv = 0, refineLv = 0 } = curEplace;
|
|
return { ...cur, lv, refineLv }
|
|
}), attributes
|
|
});
|
|
|
|
}
|
|
|
|
|
|
return resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
} |