Merge branch 'master' of gitlab.trgame.cn:zyztech/zyz_server

game-server/app/servers/battle/handler/guildHandler.ts

@@ -1,6 +1,6 @@
 import { Application, BackendSession, pinus, ChannelService } from 'pinus';
-import { resResult, getRandEelm, getRefTime } from '../../../pubUtils/util';
+import { resResult, getRandEelm, getRefTime, shouldRefresh, sortArrRandom } from '../../../pubUtils/util';
-import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB, GUILD_APPLY_TYPE, GUILD_STRUCTURE, GUILD_REC_TYPE, GUILD_STRUCTURE_NAME, MAIL_TYPE, REDIS_KEY, CHAT_SERVER } from '../../../consts';
+import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB, GUILD_APPLY_TYPE, GUILD_STRUCTURE, GUILD_REC_TYPE, GUILD_STRUCTURE_NAME, MAIL_TYPE, REDIS_KEY, CHAT_SERVER, GUILD_SELECT, USER_GUILD_SELECT } from '../../../consts';
 import { UserGuildModel } from '../../../db/UserGuild';
 import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly } from '../../../services/guildService';
 import { GuildModel, GuildType } from '../../../db/Guild';
@@ -163,7 +163,7 @@ export class GuildHandler {
         const { roleId: memberRoleId, auth } = msg;
 
         const myUserGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
-        const hisUserGuild = await UserGuildModel.getMyGuild(memberRoleId, 'auth guildCode');
+        const hisUserGuild = await UserGuildModel.getMyGuild(memberRoleId, 'auth guildCode job');
 
         const checkMyResult = await checkAuth(GUILD_OPERATE.SET_AUTH, roleId, null, myUserGuild);
         if(!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
@@ -199,7 +199,7 @@ export class GuildHandler {
             return resResult(STATUS.GUILD_MANAGER_REACH_MAX);
         }
 
-        const userGuild = await UserGuildModel.updateInfo(memberRoleId, { auth }, {}, 'auth'); // 设置权限
+        const userGuild = await UserGuildModel.updateInfo(memberRoleId, { auth, job: auth == GUILD_AUTH.LEADER? GUILD_JOB.JIANGJUN: hisUserGuild.job }, {}, 'auth'); // 设置权限
         if(!userGuild) {
             return resResult(STATUS.GUILD_MEMBER_NOT_FOUND);
         }
@@ -208,7 +208,7 @@ export class GuildHandler {
         let updateObject = {};
         if(auth == GUILD_AUTH.LEADER) { // 转让团长
             updateObject['leader'] = role._id;
-            await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.MEMBER }, {}); // 自己降权限
+            await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}); // 自己降权限
             await redisUserInfoUpdate(REDIS_KEY.GUILD_INFO, code, [{field: 'leader', value: new GuildLeader(role) } ]);
         }
 
@@ -338,7 +338,7 @@ export class GuildHandler {
         const checkResult = await checkAuth(GUILD_OPERATE.GET_APPLY_LIST, roleId);
         if(!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        const result = await UserGuildApplyModel.getListByGuild(code, lastApplyCode);
+        const result = await UserGuildApplyModel.findApplyByGuild(code, lastApplyCode);
         const list = [];
         for(let cur of result) {
             let role = <RoleType>cur.role;
@@ -385,7 +385,7 @@ export class GuildHandler {
                 await sendMail(MAIL_TYPE.GUILD_APPLY_REFUSE, roleId, roleName, [guild.name]);
             }
 
-            await UserGuildApplyModel.deleteApplyByApplyCode(applyCodeList);
+            await UserGuildApplyModel.deleteByApplyCode(applyCodeList);
         }
 
         return resResult(STATUS.SUCCESS, { roleIds });
@@ -396,18 +396,28 @@ export class GuildHandler {
     
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
+
+        let myGuild = await UserGuildModel.getMyGuild(roleId, USER_GUILD_SELECT.ENTRY)
         // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_INIVATION_MEMBER_LIST, roleId);
+        const checkResult = await checkAuth(GUILD_OPERATE.GET_INIVATION_MEMBER_LIST, roleId, myGuild.guildCode, myGuild);
         if(!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
+        let guild = await GuildModel.findByCode(myGuild.guildCode, serverId, GUILD_SELECT.INVITED_MEMBER);
+        let invitedMembers = guild.invitedMembers;
+        if(shouldRefresh(guild.inviteTime, new Date(), 0)) {
+            invitedMembers = [];
+        }
+
         // 离线时间，三天内在线且尚未加入军团。按以下规则排序  离线时间 玩家等级 玩家战力
         
         const day = getBeforeDaySeconds(3);
 
         const { quitGuildTime: quitTime = 0 } = await RoleModel.findByRoleId(roleId);
-        const allList = await RoleModel.getInviteList(day, serverId);
+        let allList = await RoleModel.getInviteList(day, serverId);
+        allList = allList.filter(cur => !invitedMembers.includes(cur.roleId))
         let list = getRandEelm(allList, 10);
         if(!list.length) list = allList;
+        list = sortArrRandom(list);
 
         let result = [];
         for(let cur of list) {
@@ -430,7 +440,7 @@ export class GuildHandler {
         const checkResult = await checkAuth(GUILD_OPERATE.INVATE_MEMBER, roleId, code);
         if(!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        const guild = await GuildModel.findByCode(code, serverId);
+        const guild = await GuildModel.findByCode(code, serverId, GUILD_SELECT.INVITED_MEMBER);
         if(guild.isMemberMax) return resResult(STATUS.GUILD_MEMBER_MAX);
 
         const roleList = await RoleModel.findRoleByField('roleId', roleIds);
@@ -442,8 +452,9 @@ export class GuildHandler {
                 result.push(role.roleId);
                 let hisSid = await getRedis(`login_roleId_${role.roleId}`);
                 uids.push({ uid: role.roleId, sid: hisSid })
-                }
+            }
         }
+        await GuildModel.recordInvitedMember(code, serverId, roleIds, shouldRefresh(guild.inviteTime, new Date(), 0));
         this.channelService.pushMessageByUids('onGuildInvite', resResult(STATUS.SUCCESS, { code }), uids);
 
         return resResult(STATUS.SUCCESS, { roleIds: result });
@@ -460,7 +471,7 @@ export class GuildHandler {
         const checkResult = await checkAuth(GUILD_OPERATE.GET_INVITATION_LIST, roleId);
         if(!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        const result = await UserGuildApplyModel.getListByRole(roleId, lastApplyCode);
+        const result = await UserGuildApplyModel.findInviteByRole(roleId, lastApplyCode);
         const list = result.map(cur => {
             let guild = <GuildType>cur.guild;
             let leader = <RoleType>guild.leader;
@@ -505,7 +516,7 @@ export class GuildHandler {
 
             code = guild.code;
         }
-        await UserGuildApplyModel.deleteApplyByApplyCode([applyCode]); // 删除这条邀请
+        await UserGuildApplyModel.deleteByApplyCode([applyCode]); // 删除这条邀请
 
         return resResult(STATUS.SUCCESS, { applyCode, code, isReceived, hasGuild: isReceived });
     }
@@ -692,8 +703,8 @@ export class GuildHandler {
         const topUser = <RoleType>topUserGuild.role;
         // 交换
 
-        await UserGuildModel.updateInfo(leaderRoleId, { auth: GUILD_AUTH.MEMBER }, {}, 'auth'); // 团长撤
+        await UserGuildModel.updateInfo(leaderRoleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
-        await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER }, {}, 'auth'); // 最高功勋人升
+        await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.JIANGJUN }, {}, 'auth'); // 最高功勋人升
         let managerCntInc = topUserGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
 
         const guild = await GuildModel.updateInfo(code, { leader: topUser._id }, { managerCnt: managerCntInc }, 'managerCnt name'); // 如果有转让团长设置leader
@@ -727,44 +738,30 @@ export class GuildHandler {
         const checkResult = await checkAuth(GUILD_OPERATE.UP_STRUCTURE, roleId, code);
         if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
-        let res:any = await lockData(serverId, DATA_NAME.UP_STRUCTURE, code);// 加锁
-        if (!!res.err) return resResult(STATUS.REDLOCK_ERR);
-
         const guild = await GuildModel.findByCode(code, serverId, 'lv structure');
         if(!guild) {
-            res.releaseCallback();//解锁
             return resResult(STATUS.GUILD_NOT_FOUND);
         }
 
         const { lv, structure } = guild;
         const curStructure = structure.find(cur => cur.id == id);
         if(!curStructure) {
-            res.releaseCallback(); //解锁
             return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
         }
         if(id != GUILD_STRUCTURE.ARMY_CENTER && curStructure.lv >= lv) { // 中军大帐以外建筑物
             if(curStructure.lv >= lv) {
-                res.releaseCallback(); //解锁
                 return resResult(STATUS.GUILD_STRUCTURE_LV_MAX);
             }
         }
         if(!hasStructureConsume(id, curStructure.lv + 1)) {
-            res.releaseCallback(); //解锁
             return resResult(STATUS.GUILD_STRUCTURE_LV_MAX);
         }
         const cost = getStructureConsume(id, curStructure.lv);
-        const costResult = await GuildModel.costFund(code, cost);
+        
-        if(!costResult) {
+        const result = await GuildModel.upStructure(code, id, cost, 'code fund structure lv');
-            res.releaseCallback(); //解锁
+        if(!result) {
             return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
         }
-        
-        const result = await GuildModel.upStructure(code, id, 'code fund structure lv');
-        if(!result) {
-            res.releaseCallback(); //解锁
-            return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
-        }
-        res.releaseCallback(); //解锁
         const resultStructure = result.structure.find(cur => cur.id == id);
 
         // 修改信息

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

@@ -1,5 +1,5 @@
 import { Application, BackendSession, ChannelService } from "pinus";
-import { resResult, getRandEelm, getResStr, shouldRefresh } from "../../../pubUtils/util";
+import { resResult, getRandEelm, getResStr, shouldRefresh, getRefTime, sortArrRandom } 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 } from "../../../consts";
 import { RoleModel, RoleType } from "../../../db/Role";
 import { getBeforeHourSeconds } from "../../../pubUtils/timeUtil";
@@ -43,6 +43,12 @@ export class FriendHandler {
         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, getRefTime(new Date(), 0));
+        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>();
@@ -80,6 +86,8 @@ export class FriendHandler {
                 list1 = getRandEelm(myServerList, FRIEND.FRIEND_RECONMMEND_NUM - list2.length);
             }
         }
+        list1 = sortArrRandom(list1);
+        list2 = sortArrRandom(list2);
         
         let list = list1.concat(list2);
 

shared/consts/constModules/selectConst.ts

@@ -32,9 +32,12 @@ export enum USER_GUILD_SELECT {
 }
 
 export enum GUILD_SELECT {
-   ENTRY = 'guildCode lv memberCnt'
+   // 初始登录
+   ENTRY = 'guildCode lv memberCnt',
+   // 获得邀请列表
+   INVITED_MEMBER = '_id code isMemberMax +invitedMembers +inviteTime'
 }
 
 export enum FRIEND_SHIP_SELECT {
     GET_FRIEND_VALUE = 'friendValue friendLv'
-}
+}

shared/consts/dataName.ts

@@ -5,7 +5,6 @@ export enum DATA_NAME {
     GUILD = 'Guild',
     GUILD_REFINE = 'GuildRefine',
     GUILD_ASSIST_REFINE = 'GuildAssistRefine',
-    UP_STRUCTURE = 'GuildStructure',
     JOIN_GUILD = 'JoinGuild',
     REFRESH_ACTIVE = 'GuildRefActive',
     WEEKLY_GUILD_SUM = 'WeeklyGuildSum',   // 每周结算活跃和奖励

shared/db/FriendApply.ts

@@ -42,6 +42,13 @@ export default class FriendApply extends BaseModel {
         return list;
     }
 
+    // 获取自己发出的申请列表
+    public static async getSentApplyList(roleId: string, time: Date) {
+        const list: FriendApplyType[] = await FriendApplyModel.find({ frdRoleId: roleId, updatedAt: { $gt: time } }, { _id: 0 })
+            .lean({ getters: true });
+        return list;
+    }
+
     // 根据applyCode获得申请
     public static async getApplyListByCode(applyCodeList: string[]) {
         const list: FriendApplyType[] = await FriendApplyModel.find({ applyCode: { $in: applyCodeList } }, { _id: 0 })

shared/db/Guild.ts

@@ -2,9 +2,10 @@ import BaseModel from './BaseModel';
 import { index, getModelForClass, prop, DocumentType, Ref } from '@typegoose/typegoose';
 import Role, { RoleType } from './Role';
 import { genCode } from '../pubUtils/util';
-import { GUILD_STRUCTURE, GUILD_STATUS, GUILD_PER_PAGE } from '../consts';
+import { GUILD_STRUCTURE, GUILD_STATUS, GUILD_PER_PAGE, GUILD_SELECT } from '../consts';
 import { getCurWeekTime, nowSeconds } from '../pubUtils/timeUtil';
 import { reduceCe } from '../pubUtils/util';
+import { now } from 'underscore';
 
 class Structure {
     @prop({ required: true })
@@ -71,13 +72,18 @@ export default class Guild extends BaseModel {
     guildCe: number;                         // 总战力
 
     @prop({ required: true, type: String, default: [], select: false })
-    members: string[];                  // 军团成员的roleId，用于增加战力的时候加入总战力
+    members: string[];                     // 军团成员的roleId，用于增加战力的时候加入总战力
+
+    @prop({ required: true, type: String, default: [], select: false })
+    invitedMembers: string[];               // 今天已邀请的玩家
+    @prop({ required: true, default: new Date(), select: false })
+    inviteTime: Date;               // 今天已邀请的玩家
 
     @prop({ required: true, type: Structure, default: getInitStructure(), _id: false })
     structure: Structure[]
 
     @prop({ required: true, default: GUILD_STATUS.RUNNING, enum: GUILD_STATUS })
-    status: number;
+    status: number;                      // 军团状态
 
     @prop({ required: true, default: 1, select: false })
     serverId: number;                 // 分服
@@ -182,12 +188,12 @@ export default class Guild extends BaseModel {
         return result;
     }
 
-    public static async upStructure(code: string, id: number, select?: string) {
+    public static async upStructure(code: string, id: number, cost: number, select?: string) {
         if (id == GUILD_STRUCTURE.ARMY_CENTER) {
-            const result: GuildType = await GuildModel.findOneAndUpdate({ code, 'structure.id': id }, { $inc: { 'structure.$.lv': 1, lv: 1 }, $set: { isMemberMax: false } }, { new: true }).select(select).lean();
+            const result: GuildType = await GuildModel.findOneAndUpdate({ code, 'structure.id': id, fund: { $gte: cost } }, { $inc: { 'structure.$.lv': 1, lv: 1, fund: -1 * cost }, $set: { isMemberMax: false } }, { new: true }).select(select).lean();
             return result;
         } else {
-            const result: GuildType = await GuildModel.findOneAndUpdate({ code, 'structure.id': id }, { $inc: { 'structure.$.lv': 1 } }, { new: true }).select(select).lean();
+            const result: GuildType = await GuildModel.findOneAndUpdate({ code, 'structure.id': id, fund: { $gte: cost } }, { $inc: { 'structure.$.lv': 1, fund: -1 * cost } }, { new: true }).select(select).lean();
             return result;
         }
     }
@@ -212,6 +218,21 @@ export default class Guild extends BaseModel {
         const result = await GuildModel.findOneAndUpdate({ code, status: GUILD_STATUS.RUNNING, serverId, resetTrainTime:{$ne:time}},{$set: {trainId: 1, resetTrainTime: time, trainLv}}, {new: true}).lean(lean);
         return result;
     }
+
+    // 记录已邀请过的人
+    public static async recordInvitedMember(code: string, serverId: number, roleIds: string[], shouldRefresh: boolean) {
+        let result: GuildType;
+        if(shouldRefresh) {
+            result = await GuildModel.findOneAndUpdate( { code, serverId }, { $set: { invitedMembers: roleIds, inviteTime: new Date() }}, { new: true})
+            .select(GUILD_SELECT.INVITED_MEMBER)
+            .lean();
+        } else {
+            result = await GuildModel.findOneAndUpdate( { code, serverId }, { $push: { invitedMembers: { $each: roleIds } }, $set: { inviteTime: new Date() }}, { new: true})
+            .select(GUILD_SELECT.INVITED_MEMBER)
+            .lean();
+        }
+        return result;
+    }
 }
 
 export const GuildModel = getModelForClass(Guild);

shared/db/GuildRec.ts

@@ -27,7 +27,7 @@ export default class GuildRec extends BaseModel {
 
     public static async createGuildRec(roleId: string, guildCode: string, type: number, params: string[]) {
         const doc = new GuildRecModel();
-        const update = Object.assign(doc.toJSON(), { roleId, guildCode, type, params });
+        const update = Object.assign(doc.toJSON(), { roleId, guildCode, type, params, createTime: nowSeconds() });
         delete update._id;
         const recCode = genCode(10);
         const result: GuildRecType = await GuildRecModel.findOneAndUpdate({ recCode }, update, { upsert: true, new: true }).lean();

shared/db/Role.ts

@@ -439,10 +439,15 @@ export default class Role extends BaseModel {
         return result;
     }
 
-    // 获取未加入公会且登录时间在三天内的人
+    /**
+     * 获取未加入公会且登录时间在三天内的人
+     * @param time 
+     * @param serverId 
+     * @param invitedMembers 当天已邀请过的人
+     */
     public static async getInviteList(time: number, serverId: number) {
         const result = await RoleModel.find({ loginTime: { $gt: time }, hasGuild: false, serverId })
-        .select('roleId roleName ce headHid sHid lv title job quitTime')
+        .select({roleId: 1, roleName: 1,ce: 1,headHid: 1,sHid: 1,lv: 1,title: 1,job: 1,quitTime: 1, _id: 0})
         .sort({quitTime: -1, lv: -1, ce: -1})
         .limit(100).lean({getters: true});
         return result;

shared/db/UserGuildApply.ts

@@ -46,8 +46,8 @@ export default class UserGuildApply extends BaseModel {
     }
 
     // 根据唯一code批量删除
-    public static async deleteApplyByApplyCode(applyCodeList: string[]) {
+    public static async deleteByApplyCode(applyCodeList: string[]) {
-        const result = await UserGuildApplyModel.deleteMany({ applyCode: { $in: applyCodeList}, type: GUILD_APPLY_TYPE.APPLY });
+        const result = await UserGuildApplyModel.deleteMany({ applyCode: { $in: applyCodeList} });
         return result;
     }
 
@@ -70,7 +70,7 @@ export default class UserGuildApply extends BaseModel {
     }
 
     // 查询公会收到的申请
-    public static async getListByGuild(code: string, lastApplyCode: string) {
+    public static async findApplyByGuild(code: string, lastApplyCode: string) {
         let condition = { guildCode: code, type: GUILD_APPLY_TYPE.APPLY };
         if(lastApplyCode) {
             const lastApply = await this.findByCode(lastApplyCode);
@@ -85,7 +85,7 @@ export default class UserGuildApply extends BaseModel {
     }
 
     // 查询玩家的邀请列表
-    public static async getListByRole(roleId: string, lastApplyCode: string) {
+    public static async findInviteByRole(roleId: string, lastApplyCode: string) {
         let condition = { roleId, type: GUILD_APPLY_TYPE.INVITE };
         if(lastApplyCode) {
             const lastApply = await this.findByCode(lastApplyCode);

shared/pubUtils/dictionary/DicGuildActiveDayReward.ts

@@ -20,7 +20,7 @@ let arr = JSON.parse(str);
 export const dicGuildActiveDayReward = new Map<number, DicGuildActiveDayReward>();
 
 arr.forEach(o => {
-    o.reward = parseGoodStr(o.reward)
+    o.reward = parseGoodStr(o.Reward)
     dicGuildActiveDayReward.set(o.id, o);
 });
 arr = undefined;

shared/pubUtils/util.ts

@@ -293,6 +293,15 @@ export function getRandEelm(source: Array<any> = [], cnt = 1): Array<any> {
     return source.filter((_item, idx) => idxs.has(idx));
 }
 
+/**
+ * 不改变原数组长度，将内部元素打乱
+ * @param source 
+ */
+export function sortArrRandom(source = []) {
+    let arr = deepCopy(source);
+    return arr.sort(() => { return Math.random()-0.5; });
+}
+
 /**
  * 在给定数值的浮动范围中随机一个值
  * @param base 基础数值