军团：提取权限判断

game-server/app.ts

@@ -16,7 +16,8 @@ import * as redisService from './app/services/redisService';
 import './app/servers/user.rpc.define'
 import * as  routeUtil from './app/util/routeUtil';
 import { preload } from './preload';
-var globalFilter = require('./app/servers/connector/filter/global');
+import { globalFilter } from'./app/servers/connector/filter/global';
+import { guildAuthFilter } from'./app/servers/guild/filter/guildAuthFilter';
 import { connectRedis } from './config/redis';
 import * as timeTaskService from './app/services/timeTaskService';
 import * as redlockCacheService from './app/services/redlockCacheService';
@@ -222,6 +223,10 @@ app.configure(ALL_ENVS, function () {
     });
 });
 
+app.configure(ALL_ENVS, 'guild', function () {
+    app.filter(guildAuthFilter(app));
+})
+
 // TODO: 所有环境打开监听模块和日志
 app.configure(ALL_ENVS, function () {
     // enable the system monitor modules

game-server/app/servers/connector/filter/global.ts

@@ -5,7 +5,7 @@ import { getWorldChannelSid } from "../../../services/chatService";
 import { resResult, checkWhiteListWithUid } from "../../../pubUtils/util";
 import { STATUS } from "../../../consts";
 import { UserModel } from "../../../db/User";
-module.exports = function(app: Application) {
+export function globalFilter(app: Application) {
     return new Filter(app);
 }
 

game-server/app/servers/guild/filter/guildAuthFilter.ts

@@ -0,0 +1,52 @@
+import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback } from "pinus";
+import { resResult } from "../../../pubUtils/util";
+import { GUILD_AUTH_CHECK_TYPE, GUILD_OPERATE, GUILD_ROUTE_TO_OPERATE, STATUS } from "../../../consts";
+import { UserGuildModel, UserGuildType } from "../../../db/UserGuild";
+import { checkAuth } from "../../../services/guildService";
+
+export function guildAuthFilter(app: Application) {
+    return new Filter(app);
+}
+
+var Filter = function(this: any, app: Application) {
+    this.app = app;
+};
+
+Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
+    const roleId: string = session.get('roleId');
+    
+    const { code, roleId: hisRoleId } = msg;
+
+    let route = routeRecord.route;
+    if(GUILD_ROUTE_TO_OPERATE.has(route)) {
+        let myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
+        let hisUserGuild: UserGuildType;
+
+        let arr = GUILD_ROUTE_TO_OPERATE.get(route);
+        for(let { operate, type } of arr) {
+            if( type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF) {
+                const checkResult = await checkAuth(operate, roleId, code||myUserGuild?.guildCode, myUserGuild);
+                if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
+            } else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF_IF_EXIST) {
+                if(myUserGuild) {
+                    const checkResult = await checkAuth(operate, roleId, code||myUserGuild?.guildCode, myUserGuild);
+                    if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
+                }
+
+            } else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_OTHERS) {
+                hisUserGuild = await UserGuildModel.getMyGuild(hisRoleId, 'auth guildCode job');
+                const checkResult = await checkAuth(GUILD_OPERATE.BE_SET_AUTH, hisRoleId, myUserGuild?.guildCode, hisUserGuild);
+                if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
+            }
+        }
+            
+        msg.myUserGuild = myUserGuild;
+        msg.hisUserGuild = hisUserGuild;
+    }
+
+    next(null);
+};
+
+Filter.prototype.after = function (err: Error, routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, resp: any, next: HandlerCallback) {
+    next(err);
+};

game-server/app/servers/guild/handler/guildBossHandler.ts

@@ -9,13 +9,13 @@ import { findWhere } from 'underscore'
 import { GUILD_STRUCTURE, GUILD_BOSS_STATUS, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
 import { DATA_NAME } from '../../../consts/dataName';
 import { UserGuildModel } from '../../../db/UserGuild';
-import { GUILD_OPERATE } from '../../../consts';
+import { addActive } from '../../../services/guildService';
-import { checkAuth, addActive } from '../../../services/guildService';
 import { GuildModel } from '../../../db/Guild';
 import { getBossByLv } from '../../../pubUtils/data';
 import { lockData } from '../../../services/redLockService';
 import { pushGuildBossSucMsg, getGuildChannelSid } from '../../../services/chatService';
 import { checkTask } from '../../../services/taskService';
+import { guildInter } from '../../../pubUtils/interface';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -60,17 +60,14 @@ export class GuildHandler {
     }
 
     //开启演武场
-    async openBossInstance(msg: {}, session: BackendSession) {
+    async openBossInstance(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
         const sid: string = session.get('sid');
 
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
+        const { myUserGuild: userGuild } = msg;
-        if (!userGuild)
+        
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
-        const checkMyResult = await checkAuth(GUILD_OPERATE.OPEN_BOSS, roleId, null, userGuild);
-        if (!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
         let res: any = await lockData(serverId, DATA_NAME.BOSS_SCRIPT, code);//加锁
         if (!!res.err)
             return resResult(STATUS.REDLOCK_ERR);

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

@@ -1,8 +1,8 @@
 import { Application, BackendSession, ChannelService, HandlerService, } from 'pinus';
 import { resResult, getRandEelm, 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, GUILD_SELECT, USER_GUILD_SELECT, TASK_TYPE } 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, GUILD_SELECT, USER_GUILD_SELECT, TASK_TYPE, DEBUG_MAGIC_WORD } from '../../../consts';
 import { UserGuildModel, UserGuildType } from '../../../db/UserGuild';
-import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly, getMyGuildInfo } from '../../../services/guildService';
+import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly, getMyGuildInfo, refreshUserGuild } from '../../../services/guildService';
 import { GuildModel, GuildType } from '../../../db/Guild';
 import { RoleModel, RoleType } from '../../../db/Role';
 import { ARMY } from '../../../pubUtils/dicParam';
@@ -24,6 +24,7 @@ import { removeTrainRank } from '../../../services/guildTrainService';
 import { pushGuildNoticeUpdateMsg, pushGuildUpStructureMsg, addRoleToGuildChannel, getGuildChannelSid } from '../../../services/chatService';
 import { Rank } from '../../../services/rankService';
 import { checkTask } from '../../../services/taskService';
+import { guildInter } from '../../../pubUtils/interface';
 export default function (app: Application) {
     new HandlerService(app, {});
     return new GuildHandler(app);
@@ -36,7 +37,7 @@ export class GuildHandler {
     }
 
     // 创建军团
-    async createGuild(msg: { name: string, icon: number, notice: string }, session: BackendSession) {
+    async createGuild(msg: guildInter & { name: string, icon: number, notice: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
@@ -44,10 +45,6 @@ export class GuildHandler {
         const serverId = session.get('serverId');
         const { name, icon, notice } = msg;
 
-        // 检查权限是否够，包括是否参过团
-        const checkResult = await checkAuth(GUILD_OPERATE.CREATE_GUILD, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         // 检查名字是否重
         const checkNameResult = await GuildModel.checkName(name, serverId);
         if (checkNameResult) return resResult(STATUS.GUILD_NAME_DUP);
@@ -97,16 +94,13 @@ export class GuildHandler {
     }
 
     // 获取军团列表
-    async getGuildList(msg: { page: number, showPeopleMax: boolean, name: string }, session: BackendSession) {
+    async getGuildList(msg: guildInter & { page: number, showPeopleMax: boolean, name: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         // const sid = session.get('sid');
         const serverId = session.get('serverId');
         const { page = 1, showPeopleMax, name } = msg;
 
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_GUILD_LIST, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guildList = await GuildModel.findByCondition(page, showPeopleMax, name, serverId);
         const applyList = await UserGuildApplyModel.findApplyByRole(roleId);
 
@@ -124,16 +118,13 @@ export class GuildHandler {
     }
 
     // 团长修改军团名等信息
-    async setGuildInfo(msg: { code: string, name: string, notice: string, introduce: string, ceLimit: number, isAuto: boolean }, session: BackendSession) {
+    async setGuildInfo(msg: guildInter & { code: string, name: string, notice: string, introduce: string, ceLimit: number, isAuto: boolean }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const { code, name, notice, introduce, ceLimit, isAuto } = msg;
         if (!name) return resResult(STATUS.WRONG_PARMS);
 
-        const checkResult = await checkAuth(GUILD_OPERATE.SET_INFO, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const select = ['code', 'name', 'notice', 'introduce', 'ceLimit', 'isAuto', 'icon'];
         const guild = await GuildModel.updateInfo(code, { name, notice, introduce, ceLimit, isAuto }, {}, select.join(' '));
         let chatSid = await getGuildChannelSid(code);
@@ -148,15 +139,11 @@ export class GuildHandler {
     }
 
     // 游客查看军团详细信息
-    async getGuildInfo(msg: { code: string }, session: BackendSession) {
+    async getGuildInfo(msg: guildInter & { code: string }, session: BackendSession) {
 
-        const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const { code } = msg;
 
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_GUILD_INFO, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const select = ['code', 'name', 'notice', 'ceLimit', 'isAuto', 'icon', 'lv', 'memberCnt', 'guildCe'];
         const guild = await GuildModel.findByCode(code, serverId, select.join(' '));
         let leader = <RoleType>guild.leader;
@@ -167,21 +154,12 @@ export class GuildHandler {
     }
 
     // 团长授权头衔
-    async setAuth(msg: { roleId: string, auth: number }, session: BackendSession) {
+    async setAuth(msg: guildInter & { roleId: string, auth: number }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');
-        const { roleId: memberRoleId, auth } = msg;
+        const { roleId: memberRoleId, auth, myUserGuild, hisUserGuild } = msg;
-
-        const myUserGuild = await UserGuildModel.getMyGuild(roleId, '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);
-
-        const checkResult = await checkAuth(GUILD_OPERATE.BE_SET_AUTH, memberRoleId, myUserGuild.guildCode, hisUserGuild);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         const { guildCode: code } = myUserGuild;
 
@@ -252,20 +230,16 @@ export class GuildHandler {
     }
 
     // 团员获取自己军团详细信息
-    async getMyGuildInfo(msg: {}, session: BackendSession) {
+    async getMyGuildInfo(msg: guildInter & {}, session: BackendSession) {
-
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const sid = session.get('sid');
-
+        const { myUserGuild } = msg;
-        let userGuild = await getUserGuildWithRefActive(roleId, 'job auth guildCode receivedActive activeRecord activeDaily activeWeekly');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild) {
             return resResult(STATUS.SUCCESS, { hasGuild: false })
         };
 
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_MY_GUILD_INFO, roleId, userGuild.guildCode, userGuild);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         let guild = await getGuildWithRefActive(userGuild.guildCode, serverId);
         if (!guild) {
             return resResult(STATUS.GUILD_NOT_FOUND);
@@ -276,7 +250,7 @@ export class GuildHandler {
     }
 
     // 玩家申请公会
-    async applyGuild(msg: { code: string }, session: BackendSession) {
+    async applyGuild(msg: guildInter & { code: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
@@ -284,10 +258,6 @@ export class GuildHandler {
         const sid = session.get('sid');
         const { code } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.APPLY_GUILD, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guild = await GuildModel.findByCode(code, serverId);
         if (!guild) return resResult(STATUS.GUILD_NOT_FOUND);
 
@@ -301,9 +271,9 @@ export class GuildHandler {
             return resResult(STATUS.GUILD_NOT_REACH_CONDI);
         }
         // TODO 暂时关闭
-        // if(nowSeconds() - role.quitGuildTime < 3600) { // TODO 时间系统参数表配置
+        if(nowSeconds() - role.quitGuildTime < 3600) { // TODO 时间系统参数表配置
-        //     return resResult(STATUS.GUILD_QUIT_TIME);
+            return resResult(STATUS.GUILD_QUIT_TIME);
-        // }
+        }
 
         let hasGuild = false;
         if (isAuto) { // 自动加入
@@ -329,15 +299,10 @@ export class GuildHandler {
     }
 
     // 玩家申请公会
-    async getApplyList(msg: { code: string, lastApplyCode: string }, session: BackendSession) {
+    async getApplyList(msg: guildInter & { code: string, lastApplyCode: string }, session: BackendSession) {
 
-        const roleId = session.get('roleId');
         const { code, lastApplyCode } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_APPLY_LIST, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const result = await UserGuildApplyModel.findApplyByGuild(code, lastApplyCode);
         const list = [];
         for (let cur of result) {
@@ -351,17 +316,12 @@ export class GuildHandler {
     }
 
     // 团长同意/拒绝公会申请
-    async receiveApply(msg: { code: string, applyCodeList: [string], isReceived: boolean }, session: BackendSession) {
+    async receiveApply(msg: guildInter & { code: string, applyCodeList: [string], isReceived: boolean }, session: BackendSession) {
 
-        const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');
         const { code, applyCodeList, isReceived } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.RECEIVE_APPLY, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const applyList = await UserGuildApplyModel.getListByApplyCode(applyCodeList);
 
         const guild = await GuildModel.findByCode(code, serverId);
@@ -392,16 +352,11 @@ export class GuildHandler {
     }
 
     // 团长查看（刷新）可邀请人列表
-    async getInviteMemberList(msg: {}, session: BackendSession) {
+    async getInviteMemberList(msg: guildInter & {}, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
-
+        const { myUserGuild: myGuild } = msg;
-        let myGuild = await UserGuildModel.getMyGuild(roleId, USER_GUILD_SELECT.ENTRY)
-        // 检查权限
-        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())) {
@@ -430,16 +385,11 @@ export class GuildHandler {
     }
 
     // 团长（一键）邀请人
-    async inviteMember(msg: { code: string, roleIds: string[] }, session: BackendSession) {
+    async inviteMember(msg: guildInter & { code: string, roleIds: string[] }, session: BackendSession) {
 
-        const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const { code, roleIds } = msg;
 
-        // 检查权限
-        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, GUILD_SELECT.INVITED_MEMBER);
         if (guild.isMemberMax) return resResult(STATUS.GUILD_MEMBER_MAX);
 
@@ -464,15 +414,11 @@ export class GuildHandler {
     }
 
     // 成员收到邀请列表
-    async getInvitationList(msg: { lastApplyCode: string }, session: BackendSession) {
+    async getInvitationList(msg: guildInter & { lastApplyCode: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const { lastApplyCode } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_INVITATION_LIST, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const result = await UserGuildApplyModel.findInviteByRole(roleId, lastApplyCode);
         const list = result.map(cur => {
             let guild = <GuildType>cur.guild;
@@ -487,16 +433,12 @@ export class GuildHandler {
 
 
     // 成员同意/拒绝邀请
-    async receiveInvitation(msg: { applyCode: string, isReceived: boolean }, session: BackendSession) {
+    async receiveInvitation(msg: guildInter & { applyCode: string, isReceived: boolean }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const { applyCode, isReceived } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.RECEIVE_INVITAION, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const invite = await UserGuildApplyModel.findByCode(applyCode);
         if (!invite) return resResult(STATUS.GUILD_INVITE_NOT_FOUND);
 
@@ -525,18 +467,14 @@ export class GuildHandler {
     }
 
     // 获取军团成员
-    async getGuildMember(msg: { code: string, sort: string }, session: BackendSession) {
+    async getGuildMember(msg: guildInter & { code: string, sort: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         // const serverId = session.get('serverId');
-        const { code, sort } = msg;
+        const { code, sort, myUserGuild } = msg;
-
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_MAIN, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         let select = ['role', 'job'];
-        const checkDetailResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_DETAIL, roleId, code);
+        const checkDetailResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_DETAIL, roleId, code, myUserGuild);
         if (checkDetailResult) {
             select.push('auth', 'activeWeekly activeUpdateTime');
         }
@@ -570,16 +508,11 @@ export class GuildHandler {
     }
 
     // 团长解散军团
-    async dismiss(msg: { code: string }, session: BackendSession) {
+    async dismiss(msg: guildInter & { code: string }, session: BackendSession) {
 
-        const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const { code } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.DISMISS, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guild = await GuildModel.dismiss(code, serverId);
         if (!guild) return resResult(STATUS.GUILD_DELETE_ERROR);
 
@@ -602,7 +535,7 @@ export class GuildHandler {
     }
 
     // 成员退出军团
-    async quit(msg: { code: string }, session: BackendSession) {
+    async quit(msg: guildInter & { code: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
@@ -610,10 +543,6 @@ export class GuildHandler {
         const sid = session.get('sid');
         const { code } = msg;
 
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.QUIT, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const userGuild = await UserGuildModel.quit(code, roleId);
         if (!userGuild) return resResult(STATUS.GUILD_QUIT_ERROR);
 
@@ -640,22 +569,13 @@ export class GuildHandler {
     }
 
     // 团长踢退出军团
-    async kick(msg: { code: string, roleId: string }, session: BackendSession) {
+    async kick(msg: guildInter & { code: string, roleId: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');
         const { code, roleId: memberRoleId } = msg;
 
-        // 检查权限
-        const checkMyAuth = await checkAuth(GUILD_OPERATE.KICK, roleId, code);
-        if (!checkMyAuth) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
-        // 被踢出的权限
-        const checkHisAuth = await checkAuth(GUILD_OPERATE.BE_KICKED, memberRoleId, code);
-        if (!checkHisAuth) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
-
         const userGuild = await UserGuildModel.quit(code, memberRoleId);
         if (!userGuild) return resResult(STATUS.GUILD_KICK_ERROR);
 
@@ -683,7 +603,7 @@ export class GuildHandler {
     }
 
     // 团员弹劾团长
-    async impeach(msg: { code: string, roleId: string }, session: BackendSession) {
+    async impeach(msg: guildInter & { code: string, roleId: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
@@ -691,14 +611,6 @@ export class GuildHandler {
         const serverId = session.get('serverId');
         const { code, roleId: leaderRoleId } = msg;
 
-        // 弹劾的权限
-        const checkMyAuth = await checkAuth(GUILD_OPERATE.IMPEACH, roleId, code);
-        if (!checkMyAuth) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
-        // 被弹劾的权限
-        const checkHisAuth = await checkAuth(GUILD_OPERATE.BE_IMPEACH, leaderRoleId, code);
-        if (!checkHisAuth) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         // 离线72小时
         const { roleName: oldRoleName, quitTime } = await RoleModel.findByRoleId(leaderRoleId);
         if (quitTime > <number>getTimeFun().getBeforeDay(3)) {
@@ -755,7 +667,7 @@ export class GuildHandler {
     }
 
     // 升级建筑物等级
-    async upStructure(msg: { code: string, id: number }, session: BackendSession) {
+    async upStructure(msg: guildInter & { code: string, id: number }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
@@ -763,10 +675,6 @@ export class GuildHandler {
         const sid = session.get('sid');
         const { code, id } = msg;
 
-        // 升级建筑物权限
-        const checkResult = await checkAuth(GUILD_OPERATE.UP_STRUCTURE, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guild = await GuildModel.findByCode(code, serverId, 'lv structure');
         if (!guild) {
             return resResult(STATUS.GUILD_NOT_FOUND);
@@ -816,14 +724,11 @@ export class GuildHandler {
 
 
     // 获取动态
-    async getRec(msg: { code: string }, session: BackendSession) {
+    async getRec(msg: guildInter & { code: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const { code } = msg;
 
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_REC, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         // console.log(startTime)
         const list = await GuildRecModel.getGuildRec(code, <number>getTimeFun().getBeforeDayWithHour(3));
 
@@ -831,16 +736,13 @@ export class GuildHandler {
     }
 
     // 团长发送消息给军团内所有成员的邮箱
-    async sendMail(msg: { code: string, info: string }, session: BackendSession) {
+    async sendMail(msg: guildInter & { code: string, info: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');
         const { code, info } = msg;
 
-        const checkResult = await checkAuth(GUILD_OPERATE.SEND_MAIL, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guild = await GuildModel.findByCode(code, serverId, 'members');
         if (!guild) return resResult(STATUS.GUILD_NOT_FOUND);
 
@@ -854,7 +756,7 @@ export class GuildHandler {
     }
 
     // 团长发送世界频道
-    async recruit(msg: { code: string, info: string }, session: BackendSession) {
+    async recruit(msg: guildInter & { code: string, info: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         // const roleName = session.get('roleName');
@@ -862,9 +764,6 @@ export class GuildHandler {
         const serverId = session.get('serverId');
         const { code, info } = msg;
 
-        const checkResult = await checkAuth(GUILD_OPERATE.RECRUIT, roleId, code);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guild = await GuildModel.findByCode(code, serverId);
         if (!guild) return resResult(STATUS.GUILD_NOT_FOUND);
 
@@ -875,21 +774,18 @@ export class GuildHandler {
     }
 
     // 领取活跃奖励
-    async receiveActiveBox(msg: { code: string, id: number }, session: BackendSession) {
+    async receiveActiveBox(msg: guildInter & { code: string, id: number }, session: BackendSession) {
 
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const sid = session.get('sid');
         const serverId = session.get('serverId');
         const funcs: number[] = session.get('funcs');
-        const { code, id } = msg;
+        const { code, id, myUserGuild } = msg;
 
-        let userGuild = await getUserGuildWithRefActive(roleId, 'receivedActive auth guildCode');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild) return resResult(STATUS.GUILD_NOT_FOUND);
 
-        const checkResult = await checkAuth(GUILD_OPERATE.RECEIVE_ACTIVE, roleId, code, userGuild);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
-
         const guild = await getGuildWithRefActive(code, serverId);
         if (!guild) return resResult(STATUS.GUILD_NOT_FOUND);
 
@@ -915,17 +811,9 @@ export class GuildHandler {
     }
 
     // 查看活跃排行榜
-    async getActiveRank(msg: {}, session: BackendSession) {
+    async getActiveRank(msg: guildInter & {}, session: BackendSession) {
-
-        let roleId = session.get('roleId');
         let serverId = session.get('serverId')
-
+        const { myUserGuild } = msg;
-        const myUserGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
-        if (!myUserGuild) return resResult(STATUS.GUILD_NOT_FOUND);
-
-        // 检查权限
-        const checkResult = await checkAuth(GUILD_OPERATE.GET_ACTIVE_RANK, roleId);
-        if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
 
         let r = new Rank(REDIS_KEY.GUILD_ACTIVE_RANK, { serverId });
         let { ranks, myRank } = await r.getRankListWithMyRank({ guildCode: myUserGuild.guildCode });
@@ -938,8 +826,11 @@ export class GuildHandler {
     }
 
     // debug接口： 添加公会活跃值
-    async debugAddActive(msg: { code: string, active: number, id: number }, session: BackendSession) {
+    async debugAddActive(msg: guildInter & { magicWord: string, code: string, active: number, id: number }, session: BackendSession) {
-
+        const { magicWord } = msg;
+        if (magicWord !== DEBUG_MAGIC_WORD) {
+            return resResult(STATUS.TOKEN_ERR);
+        }
         const roleId = session.get('roleId');
         const serverId = session.get('serverId');
         const { code, active, id } = msg;
@@ -957,16 +848,22 @@ export class GuildHandler {
     }
 
     // debug接口： 调用定时任务
-    async debugWeeklyRask(msg: {}, session: BackendSession) {
+    async debugWeeklyRask(msg: guildInter & { magicWord: string }, session: BackendSession) {
-
+        const { magicWord } = msg;
+        if (magicWord !== DEBUG_MAGIC_WORD) {
+            return resResult(STATUS.TOKEN_ERR);
+        }
         await settleGuildWeekly();
         return resResult(STATUS.SUCCESS);
     }
 
     // debug接口： 添加军团资金
-    async debugAdddFund(msg: { code: string, count: number }, session: BackendSession) {
+    async debugAdddFund(msg: guildInter & { magicWord: string, code: string, count: number }, session: BackendSession) {
 
-        const { code, count } = msg;
+        const { code, count, magicWord } = msg;
+        if (magicWord !== DEBUG_MAGIC_WORD) {
+            return resResult(STATUS.TOKEN_ERR);
+        }
         const guild = await GuildModel.updateInfo(code, {}, { fund: count }, 'fund');
         let chatSid = await getGuildChannelSid(code);
         this.app.rpc.chat.guildRemote.updateInfo.toServer(chatSid, code, { fund: guild.fund });
@@ -974,9 +871,12 @@ export class GuildHandler {
     }
 
     // debug接口： 加长会长离线时间
-    async debugLeaderLeaveTime(msg: { code: string }, session: BackendSession) {
+    async debugLeaderLeaveTime(msg: guildInter & { magicWord: string, code: string }, session: BackendSession) {
 
-        const { code } = msg;
+        const { code, magicWord } = msg;
+        if (magicWord !== DEBUG_MAGIC_WORD) {
+            return resResult(STATUS.TOKEN_ERR);
+        }
         const serverId = session.get('serverId');
         const guild = await GuildModel.findByCode(code, serverId);
         const leader = <RoleType>guild.leader;
@@ -987,8 +887,11 @@ export class GuildHandler {
     }
 
     // debug接口： 加入公会
-    async debugJoinGuild(msg: { code: string }, session: BackendSession) {
+    async debugJoinGuild(msg: guildInter & { magicWord: string, code: string }, session: BackendSession) {
-        const { code } = msg;
+        const { code, magicWord } = msg;
+        if (magicWord !== DEBUG_MAGIC_WORD) {
+            return resResult(STATUS.TOKEN_ERR);
+        }
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');

game-server/app/servers/guild/handler/guildRefineHandler.ts

@@ -9,12 +9,12 @@ import { handleCost, addItems, checkGoods } from '../../../services/rewardServic
 import { GuildModel } from '../../../db/Guild';
 import { findIndex, findWhere } from 'underscore';
 import { lockData } from '../../../services/redLockService';
-import { checkAuth } from '../../../services/guildService';
 import { ARMY } from '../../../pubUtils/dicParam';
 import { CURRENCY_BY_TYPE, CURRENCY_TYPE } from '../../../consts/constModules/itemConst';
 import { openGuildRefine } from '../../../services/guildRefineService';
 import { DATA_NAME } from '../../../consts/dataName';
 import { checkTask } from '../../../services/taskService';
+import { guildInter } from '../../../pubUtils/interface';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -87,15 +87,11 @@ export class GuildRefineHandler {
      * @param msg 
      * @param session 
      */
-    async lightUpTree(msg: { id: number }, session: BackendSession) {
+    async lightUpTree(msg: guildInter & { id: number }, session: BackendSession) {
         let { id } = msg;
-        const roleId: string = session.get('roleId');
         const serverId: number = session.get('serverId');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'auth guildCode');
+        const { myUserGuild: userGuild } = msg
-        if (!userGuild)
+
-            return resResult(STATUS.WRONG_PARMS);
-        const checkMyResult = await checkAuth(GUILD_OPERATE.EQUIP_PRODUCE, roleId, null, userGuild);
-        if (!checkMyResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
         const { guildCode: code } = userGuild;
         let developConsume = getArmyDevelopConsumeById(id);
         if (!developConsume)

game-server/app/services/guildService.ts

@@ -48,10 +48,10 @@ export async function getMyGuildInfo(roleId: string, sid: string, userGuild: Use
  * @param func 操作id
  * @param auth 权限
  */
-export async function checkAuth(func: number, roleId: string, code?: string, userGuild?: UserGuildType) {
+export async function checkAuth(func: number, roleId: string, targetCode?: string, userGuild?: UserGuildType) {
-    const auth = await UserGuildModel.getMyAuth(roleId, code, userGuild);
+    const auth = await UserGuildModel.getMyAuth(roleId, targetCode, userGuild);
     const dicGuildAuth = gameData.guildAuth.get(func);
-    // console.log('*checkAuth*', auth, dicGuildAuth)
+    console.log('*checkAuth*', func, auth, dicGuildAuth)
     if (!dicGuildAuth) return false;
 
     return dicGuildAuth.includes(auth);
@@ -215,6 +215,11 @@ export async function getUserGuildWithRefActive(roleId: string, select?: string,
     let userGuild = await UserGuildModel.getMyGuild(roleId, select ? select + ' wishGoods +refTimeDaily' : '+refTimeDaily');
     // console.log(JSON.stringify(userGuild))
     if (!userGuild) return false;
+    return await refreshUserGuild(userGuild, roleId, notPush);
+}
+
+export async function refreshUserGuild(userGuild: UserGuildType, roleId: string, notPush?: boolean) {
+    if(!userGuild) return false;
     let { receivedActive, refTimeDaily, activeDaily, activeRecord, wishGoods } = userGuild;
 
     const now = new Date();
@@ -236,7 +241,7 @@ export async function getUserGuildWithRefActive(roleId: string, select?: string,
 
         receivedActive = []; refTimeDaily = now; activeDaily = 0; activeRecord = []; wishGoods = [];
         let receiveBoxs = [], wishDntCnt = 0, donateCnt = 0;
-        userGuild = await UserGuildModel.updateInfo(roleId, { receivedActive, refTimeDaily, activeDaily, activeRecord, wishGoods, receiveBoxs, wishDntCnt, donateCnt }, {}, select);
+        userGuild = await UserGuildModel.updateInfo(roleId, { receivedActive, refTimeDaily, activeDaily, activeRecord, wishGoods, receiveBoxs, wishDntCnt, donateCnt }, {});
         if (!userGuild) return false;
     }
 

shared/consts/constModules/guildConst.ts

@@ -74,6 +74,53 @@ export enum GUILD_OPERATE {
     GET_ACTIVE_RANK = 30,           // 查看活跃排行榜
 }
 
+export enum GUILD_AUTH_CHECK_TYPE {
+    CHECK_SELF = 1,
+    CHECK_OTHERS = 2,
+    CHECK_SELF_IF_EXIST = 3,
+}
+
+export const GUILD_ROUTE_OPERATE = [
+    { route: 'guild.guildHandler.createGuild', operate: GUILD_OPERATE.CREATE_GUILD, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getGuildList', operate: GUILD_OPERATE.GET_GUILD_LIST, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.setGuildInfo', operate: GUILD_OPERATE.SET_INFO, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getGuildInfo', operate: GUILD_OPERATE.GET_GUILD_INFO, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.setAuth', operate: GUILD_OPERATE.SET_AUTH, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.setAuth', operate: GUILD_OPERATE.BE_SET_AUTH, type: GUILD_AUTH_CHECK_TYPE.CHECK_OTHERS },
+    { route: 'guild.guildHandler.getMyGuildInfo', operate: GUILD_OPERATE.GET_MY_GUILD_INFO, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_IF_EXIST },
+    { route: 'guild.guildHandler.applyGuild', operate: GUILD_OPERATE.APPLY_GUILD, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getApplyList', operate: GUILD_OPERATE.GET_APPLY_LIST, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.receiveApply', operate: GUILD_OPERATE.RECEIVE_APPLY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getInviteMemberList', operate: GUILD_OPERATE.GET_INIVATION_MEMBER_LIST, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.inviteMember', operate: GUILD_OPERATE.INVATE_MEMBER, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getInvitationList', operate: GUILD_OPERATE.GET_INVITATION_LIST, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.receiveInvitation', operate: GUILD_OPERATE.RECEIVE_INVITAION, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getGuildMember', operate: GUILD_OPERATE.GET_MEMBER_LIST_MAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.dismiss', operate: GUILD_OPERATE.DISMISS, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.quit', operate: GUILD_OPERATE.QUIT, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.kick', operate: GUILD_OPERATE.KICK, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.kick', operate: GUILD_OPERATE.BE_KICKED, type: GUILD_AUTH_CHECK_TYPE.CHECK_OTHERS },
+    { route: 'guild.guildHandler.impeach', operate: GUILD_OPERATE.IMPEACH, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.impeach', operate: GUILD_OPERATE.BE_IMPEACH, type: GUILD_AUTH_CHECK_TYPE.CHECK_OTHERS },
+    { route: 'guild.guildHandler.upStructure', operate: GUILD_OPERATE.UP_STRUCTURE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getRec', operate: GUILD_OPERATE.GET_REC, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.sendMail', operate: GUILD_OPERATE.SEND_MAIL, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.recruit', operate: GUILD_OPERATE.RECRUIT, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.receiveActiveBox', operate: GUILD_OPERATE.RECEIVE_ACTIVE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildHandler.getActiveRank', operate: GUILD_OPERATE.GET_ACTIVE_RANK, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildBossHandler.openBossInstance', operate: GUILD_OPERATE.OPEN_BOSS, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildRefineHandler.lightUpTree', operate: GUILD_OPERATE.EQUIP_PRODUCE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF }
+
+];
+
+export const GUILD_ROUTE_TO_OPERATE = new Map<string, { operate: GUILD_OPERATE, type: number }[]>();
+for(let {route, operate, type} of GUILD_ROUTE_OPERATE) {
+    if(!GUILD_ROUTE_TO_OPERATE.has(route)) {
+        GUILD_ROUTE_TO_OPERATE.set(route, []);
+    }
+    GUILD_ROUTE_TO_OPERATE.get(route).push({ operate, type});
+}
+
 // 军团状态
 export enum GUILD_STATUS {
     RUNNING = 1,              // 运转中

shared/consts/statusCode.ts

@@ -280,7 +280,7 @@ export const STATUS = {
     EQUIP_QUENCH_ERR: { code: 30512, simStr: '该装备不能再淬火或材料不足' },
     EQUIP_REFINE_ERR: { code: 30513, simStr: '该装备等级不足或材料不足' },
     EQUIP_RESTRENGTHEN_NOT_PREVIEW: { code: 30514, simStr: '该装备未预览洗练值' },
-    EQUIP_QUENCH_MAX: { code: 30515, simStr: '该装备淬火最大限制' },
+    EQUIP_QUENCH_MAX: { code: 30515, simStr: '该装备不能再淬火' },
     //全局养成30600-30699
     ROLE_REACH_MAX_TITLE_LEVEL: { code: 30600, simStr: '玩家已达到最高的爵位' },
     ROLE_TERAPH_NOT_STRENGTHEN: { code: 30601, simStr: '玩家神像不能强化' },

shared/pubUtils/interface.ts

@@ -1,5 +1,7 @@
 // 一些通用的interface定义
 
+import { UserGuildType } from "../db/UserGuild";
+
 export interface RewardInter {
     id: number;
     count: number;
@@ -71,3 +73,8 @@ export interface mailData {
     mailType: number;
     sendName: string;
 }
+
+export interface guildInter { 
+    myUserGuild: UserGuildType;
+    hisUserGuild: UserGuildType; 
+}