军团：权限判断函数提取

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

@@ -22,7 +22,6 @@ import { Rank } from '../../../services/rankService';
 import { checkTaskWithRole, } from '../../../services/taskService';
 import { pushData, everydayRefresh } from '../../../services/connectorService';
 import { pick } from 'lodash';
-import { WhiteListModel } from '../../../db/WhiteList';
 
 export default function (app: Application) {
     new HandlerService(app, {});

game-server/app/servers/connector/remote/connectorRemote.ts

@@ -2,6 +2,7 @@ import { Application, ChannelService, FrontendSession, pinus, RemoterClass, Hand
 import { STATUS } from '../../../consts/statusCode';
 import { resResult } from '../../../pubUtils/util';
 import { reloadResources } from '../../../pubUtils/data';
+import { UserGuildType } from '../../../db/UserGuild';
 export default function (app: Application) {
     new HandlerService(app, {});
     return new ConnectorRemote(app);
@@ -38,6 +39,22 @@ export class ConnectorRemote {
         }
     }
 
+    public async setOtherUserGuildSession(params: { roleId: string, userGuild: UserGuildType}[]) {
+        let sessionService = this.app.get('sessionService');
+        for(let {roleId, userGuild} of params) {
+            let sessions = sessionService.getByUid(roleId);
+            if(!!sessions) {
+                sessions.forEach(session => {
+                    if(userGuild && userGuild.status == 1) {
+                        sessionService.aimportAll(session.id, { guildCode: userGuild?.guildCode, guildAuth: userGuild?.auth });
+                    } else {
+                        sessionService.aimportAll(session.id, { guildCode: '', guildAuth: 0 });
+                    }
+                })
+            }
+        }
+    }
+
     /**
      * 重载json资源
      */

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

@@ -2,7 +2,7 @@ import {Application, RouteRecord, FrontendOrBackendSession, HandlerCallback } fr
 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";
+import { checkAuth, setUserGuildSession } from "../../../services/guildService";
 
 export function guildAuthFilter(app: Application) {
     return new Filter(app);
@@ -14,28 +14,44 @@ var Filter = function(this: any, app: Application) {
 
 Filter.prototype.before = async function (routeRecord: RouteRecord, msg: any, session: FrontendOrBackendSession, next: HandlerCallback) {
     const roleId: string = session.get('roleId');
+    let guildCode: string = session.get('guildCode');
+    let guildAuth: number = session.get('guildAuth');
+    console.log('********guildAuth', guildAuth);
     
     const { code, roleId: hisRoleId } = msg;
 
     let route = routeRecord.route;
     if(GUILD_ROUTE_TO_OPERATE.has(route)) {
-        let myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
+        let myUserGuild: UserGuildType;
         let hisUserGuild: UserGuildType;
 
+        if(!guildAuth) {
+            myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
+            if(myUserGuild) {
+                guildCode = myUserGuild.guildCode;
+                guildAuth = myUserGuild.auth;
+            }
+            setUserGuildSession(session, myUserGuild);
+        }
+
         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);
+                myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
+                const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
                 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) {
+                if(!!guildCode) {
-                    const checkResult = await checkAuth(operate, roleId, code||myUserGuild?.guildCode, myUserGuild);
+                    myUserGuild = await UserGuildModel.getMyGuild(roleId, '+refTimeDaily');
+                    const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
                     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);
+                const checkResult = await checkAuth(operate, code||guildCode, hisUserGuild?.auth);
+                if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
+            } else if (type == GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION) {
+                const checkResult = await checkAuth(operate, code||guildCode, guildAuth);
                 if (!checkResult) return next(new Error(), resResult(STATUS.GUILD_AUTH_NOT_ENOUGH));
             }
         }

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

@@ -15,6 +15,7 @@ import { handleCost } from "../../../services/rewardService";
 import { addActive } from "../../../services/guildService";
 import { Rank } from "../../../services/rankService";
 import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { guildInter } from "../../../pubUtils/interface";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -134,8 +135,8 @@ export class CityActivityHandler {
     }
 
     // 开始挑战
-    async checkBattle(msg: { cityId: number, costGold: boolean, heroes: number[] }, session: BackendSession) {
+    async checkBattle(msg: guildInter & { cityId: number, costGold: boolean, heroes: number[] }, session: BackendSession) {
-        let { cityId, costGold, heroes } = msg;
+        let { cityId, costGold, heroes, myUserGuild: userGuild } = msg;
         if (!heroes || heroes.length <= 0) return resResult(STATUS.WRONG_PARMS);
 
         const roleId = session.get('roleId');
@@ -161,8 +162,6 @@ export class CityActivityHandler {
         // TODO 测试完成后去掉这条判断
         // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
 
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'job');
-
         let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
         if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
 

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

@@ -9,10 +9,11 @@ import { GuildModel } from '../../../db/Guild';
 import { handleCost, addItems } from '../../../services/rewardService';
 import { CHAT_SERVER, GUILD_POINT_WAYS } from '../../../consts';
 import { getDonation } from '../../../services/donateService';
-import { getUserGuildWithRefActive } from '../../../services/guildService';
+import { getUserGuildWithRefActive, refreshUserGuild } from '../../../services/guildService';
 import { ARMY } from '../../../pubUtils/dicParam';
 import { addActive } from '../../../services/guildService'
 import { checkActivityTask, checkTask } from '../../../services/taskService';
+import { guildInter } from '../../../pubUtils/interface';
 export default function (app: Application) {
     new HandlerService(app, {});
     return new DonationHandler(app);
@@ -27,11 +28,12 @@ export class DonationHandler {
      * @param msg 
      * @param session 
      */
-    async getDonation(msg: {}, session: BackendSession) {
+    async getDonation(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
+        const { myUserGuild } = msg;
 
-        let userGuild = await getUserGuildWithRefActive(roleId, 'donateCnt receiveBoxs guildCode');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code, donateCnt, receiveBoxs } = userGuild;
@@ -43,16 +45,15 @@ export class DonationHandler {
      * @param msg 
      * @param session 
      */
-    async donate(msg: { id: number }, session: BackendSession) {
+    async donate(msg: guildInter & { id: number }, session: BackendSession) {
-        const { id } = msg;
+        const { id, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const roleName: string = session.get('roleName');
         const serverId: number = parseInt(session.get('serverId'));
         const sid: string = session.get('sid');
         const funcs: number[] = session.get('funcs');
-        let userGuild = await getUserGuildWithRefActive(roleId, 'donateCnt receiveBoxs guildCode');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
-        if (!userGuild)
+        if (!userGuild) return resResult(STATUS.WRONG_PARMS);
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code, donateCnt: resdonateCnt } = userGuild;
         if (resdonateCnt >= ARMY.ARMY_DONATE_TIMES)
             return resResult(STATUS.GUILD_DONATE_TIMES_NOT_ENOUGH);
@@ -84,13 +85,13 @@ export class DonationHandler {
      * @param msg 
      * @param session 
      */
-    async receiveBox(msg: { id: number }, session: BackendSession) {
+    async receiveBox(msg: guildInter & { id: number }, session: BackendSession) {
-        const { id } = msg;
+        const { id, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const roleName: string = session.get('roleName');
         const sid: string = session.get('sid');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await getUserGuildWithRefActive(roleId, 'donateCnt receiveBoxs guildCode');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code, receiveBoxs: resReceiveBoxs } = userGuild;

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

@@ -15,6 +15,7 @@ import { GuildActivityCityModel } from "../../../db/GuildActivityCity";
 import { Rank } from "../../../services/rankService";
 import { getTimeFun } from "../../../pubUtils/timeUtil";
 import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { guildInter } from "../../../pubUtils/interface";
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -61,8 +62,8 @@ export class GateActivityHandler {
     }
 
     // 开启挑战
-    async checkBattle(msg: { heroes: number[] }, session: BackendSession) {
+    async checkBattle(msg: guildInter & { heroes: number[] }, session: BackendSession) {
-        let { heroes } = msg;
+        let { heroes, myUserGuild: userGuild } = msg;
         if (!heroes || heroes.length <= 0) return resResult(STATUS.WRONG_PARMS);
 
         const roleId = session.get('roleId');
@@ -80,8 +81,6 @@ export class GateActivityHandler {
         // TODO 测试完成后去掉这条判断
         // if(!statusResult.isOpen) return resResult(STATUS.GUILD_ACTIVITY_NOT_OPEN);
 
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'job');
-
         let guildActivityRec = await GuildActivityRecordModel.getRecord(guildCode, serverId, this.aid);
         if (!guildActivityRec) return resResult(STATUS.INTERNAL_ERR);
 

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

@@ -45,11 +45,9 @@ export class GuildHandler {
     }
 
     // 获得boss关卡
-    async getBossInstance(msg: {}, session: BackendSession) {
+    async getBossInstance(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
+        let { myUserGuild: userGuild } = msg;
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         let bossInstance = await BossInstanceModel.findBossInstance(code);
         if (!bossInstance) {
@@ -61,8 +59,6 @@ export class GuildHandler {
 
     //开启演武场
     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'));
         const { myUserGuild: userGuild } = msg;
@@ -104,12 +100,10 @@ export class GuildHandler {
         return resResult(STATUS.SUCCESS, result);
     }
 
-    async battleBoss(msg: {}, session: BackendSession) {
+    async battleBoss(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
         const roleName: string = session.get('roleName');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode job');
+        const { myUserGuild: userGuild } = msg;
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         let bossInstance = await BossInstanceModel.findBossInstance(code);
         if (!bossInstance)
@@ -138,14 +132,11 @@ export class GuildHandler {
         return resResult(STATUS.SUCCESS, { battleCode });
     }
 
-    async action(msg: { damage: number, battleCode: string }, session: BackendSession) {
+    async action(msg: guildInter & { damage: number, battleCode: string }, session: BackendSession) {
-        const { battleCode, damage } = msg;
+        const { battleCode, damage, myUserGuild: userGuild } = msg;
         const roleId: string = session.get('roleId');
         const roleName: string = session.get('roleName');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         let flag = await checkBossBattleMemberExists(code, serverId, roleId, battleCode);
         if (!flag) {
@@ -166,15 +157,12 @@ export class GuildHandler {
         }
     }
 
-    async battleBossEnd(msg: { battleCode: string }, session: BackendSession) {
+    async battleBossEnd(msg: guildInter & { battleCode: string }, session: BackendSession) {
-        const { battleCode } = msg;
+        const { battleCode, myUserGuild: userGuild } = msg;
         const roleId = session.get('roleId');
         const sid = session.get('sid');
         const funcs: number[] = session.get('funcs');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         const battleRecord = await BattleRecordModel.getBattleRecordByCode(battleCode, true);
         if (!battleRecord || battleRecord.status != 0 || roleId != battleRecord.roleId) {

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

@@ -2,7 +2,7 @@ import { Application, BackendSession, ChannelService, HandlerService, } from 'pi
 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, DEBUG_MAGIC_WORD } from '../../../consts';
 import { UserGuildModel, UserGuildType } from '../../../db/UserGuild';
-import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly, getMyGuildInfo, refreshUserGuild } from '../../../services/guildService';
+import { checkAuth, joinGuild, getGuildWithRefActive, getUserGuildWithRefActive, addActive, settleGuildWeekly, getMyGuildInfo, refreshUserGuild, setUserGuildSession } from '../../../services/guildService';
 import { GuildModel, GuildType } from '../../../db/Guild';
 import { RoleModel, RoleType } from '../../../db/Role';
 import { ARMY } from '../../../pubUtils/dicParam';
@@ -79,8 +79,7 @@ export class GuildHandler {
         let rank = await r.getMyRank({ guildCode: guild.code });
 
         // 加入channel
-        session.set('guildCode', guild.code);
+        setUserGuildSession(session, userGuild);
-        session.push('guildCode', () => { });
         addRoleToGuildChannel(roleId, sid, guild.code);
 
         // 添加动态
@@ -157,6 +156,7 @@ export class GuildHandler {
     async setAuth(msg: guildInter & { roleId: string, auth: number }, session: BackendSession) {
 
         const roleId = session.get('roleId');
+        const sid = session.get('sid');
         const roleName = session.get('roleName');
         const serverId = session.get('serverId');
         const { roleId: memberRoleId, auth, myUserGuild, hisUserGuild } = msg;
@@ -193,12 +193,14 @@ export class GuildHandler {
         if (!userGuild) {
             return resResult(STATUS.GUILD_MEMBER_NOT_FOUND);
         }
+        await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: memberRoleId, userGuild }]);
 
         const role = await RoleModel.findByRoleId(memberRoleId);
         let updateObject = {};
         if (auth == GUILD_AUTH.LEADER) { // 转让团长
             updateObject['leader'] = role._id;
-            await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}); // 自己降权限
+            let myUserGuild = await UserGuildModel.updateInfo(roleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}); // 自己降权限
+            setUserGuildSession(session, myUserGuild);
             await updateUserInfo(REDIS_KEY.GUILD_INFO, code, [{ field: 'leader', value: new GuildLeader(role) }]);
         }
 
@@ -467,14 +469,15 @@ export class GuildHandler {
     }
 
     // 获取军团成员
-    async getGuildMember(msg: guildInter & { code: string, sort: string }, session: BackendSession) {
+    async getGuildMember(msg: { code: string, sort: string }, session: BackendSession) {
 
         const roleId = session.get('roleId');
+        const guildAuth: number = session.get('guildAuth');
         // const serverId = session.get('serverId');
-        const { code, sort, myUserGuild } = msg;
+        const { code, sort } = msg;
 
         let select = ['role', 'job'];
-        const checkDetailResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_DETAIL, roleId, code, myUserGuild);
+        const checkDetailResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_DETAIL, code, guildAuth);
         if (checkDetailResult) {
             select.push('auth', 'activeWeekly activeUpdateTime');
         }
@@ -511,6 +514,7 @@ export class GuildHandler {
     async dismiss(msg: guildInter & { code: string }, session: BackendSession) {
 
         const serverId = session.get('serverId');
+        const sid = session.get('sid');
         const { code } = msg;
 
         const guild = await GuildModel.dismiss(code, serverId);
@@ -521,6 +525,8 @@ export class GuildHandler {
         await RoleModel.dissmissGuild(members);
         await UserGuildApplyModel.deleteApplyByGuild(code);
 
+        await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid, members.map(roleId => { return { roleId, userGuild: null } })); // 更新session
+
         // 删除channel
 
         let chatSid = await getGuildChannelSid(code);
@@ -562,8 +568,7 @@ export class GuildHandler {
         this.app.rpc.chat.guildRemote.addRec.toServer(chatSid, rec);
         this.app.rpc.chat.guildRemote.memberQuit.toServer(chatSid, code, roleId, guild, sid);
 
-        session.set('guildCode', '');
+        setUserGuildSession(session, null);
-        session.push('guild', () => { });
 
         return resResult(STATUS.SUCCESS, { hasGuild: role.hasGuild });
     }
@@ -597,6 +602,8 @@ export class GuildHandler {
         // 添加动态
         const rec = await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.QUIT_GUILD, [role.roleName]);
         this.app.rpc.chat.guildRemote.addRec.toServer(chatSid, rec);
+        await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: memberRoleId, userGuild }]);
+
         await sendMailByContent(MAIL_TYPE.GUILD_BE_KICK, memberRoleId, { sendName: roleName, params: [guild.name] });
 
         return resResult(STATUS.SUCCESS, { memberCnt: guild.memberCnt });
@@ -642,8 +649,12 @@ export class GuildHandler {
         const topUser = <RoleType>topUserGuild.role;
         // 交换
 
-        await UserGuildModel.updateInfo(leaderRoleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
+        let oldLeaderUserGuild = await UserGuildModel.updateInfo(leaderRoleId, { auth: GUILD_AUTH.MEMBER, job: GUILD_JOB.SHIBING }, {}, 'auth'); // 团长撤
-        await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.JIANGJUN }, {}, 'auth'); // 最高功勋人升
+        await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: leaderRoleId, oldLeaderUserGuild }]); // 更新session
+
+        let newLeaderUserGuild = await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER, job: GUILD_JOB.JIANGJUN }, {}, 'auth'); // 最高功勋人升
+        await this.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId: topUserGuild.roleId, newLeaderUserGuild }]); // 更新session
+
         let managerCntInc = topUserGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
 
         const guild = await GuildModel.updateInfo(code, { leader: topUser._id }, { managerCnt: managerCntInc }, 'managerCnt name'); // 如果有转让团长设置leader
@@ -924,8 +935,7 @@ export class GuildHandler {
             this.app.rpc.chat.guildRemote.addRec.toServer(chatSid, rec);
             this.app.rpc.chat.guildRemote.memberQuit.toServer(chatSid, oldCode, roleId, guild, sid);
 
-            session.set('guildCode', '');
+            setUserGuildSession(session, userGuild);
-            session.push('guild', () => { });
         }
 
         const joinResult = await joinGuild(code, guild.name, lv, roleId, serverId, session);

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

@@ -30,11 +30,8 @@ export class GuildRefineHandler {
      * @param msg 
      * @param session 
      */
-    async getRefine(msg: {}, session: BackendSession) {
+    async getRefine(msg: guildInter & {}, session: BackendSession) {
-        const roleId = session.get('roleId');
+        const { myUserGuild: userGuild } = msg;
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         let guildRefine = await GuildRefineModel.getRefine(code);
         if (!guildRefine) {
@@ -47,16 +44,13 @@ export class GuildRefineHandler {
      * @param msg 
      * @param session 
      */
-    async refineEquip(msg: { pid: number }, session: BackendSession) {
+    async refineEquip(msg: guildInter & { pid: number }, session: BackendSession) {
-        let { pid } = msg;
+        let { pid, myUserGuild: userGuild } = msg;
         const roleId: string = session.get('roleId');
         const sid: string = session.get('sid');
         const roleName: string = session.get('roleName');
         const funcs: number[] = session.get('funcs');
         let pieceInfo = getGoodById(pid);
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         let { guildCode: code } = userGuild;
 
         let { scienceTrees } = await GuildRefineModel.getRefine(code);
@@ -87,7 +81,7 @@ export class GuildRefineHandler {
      * @param msg 
      * @param session 
      */
-    async lightUpTree(msg: guildInter & { id: number }, session: BackendSession) {
+    async lightUpTree(msg: guildInter & guildInter & { id: number }, session: BackendSession) {
         let { id } = msg;
         const serverId: number = session.get('serverId');
         const { myUserGuild: userGuild } = msg
@@ -136,15 +130,12 @@ export class GuildRefineHandler {
      * @param msg 
      * @param session 
      */
-    async assistRefine(msg: { id: number }, session: BackendSession) {
+    async assistRefine(msg: guildInter & { id: number }, session: BackendSession) {
-        let { id } = msg;
+        let { id, myUserGuild: userGuild } = msg;
         const roleId: string = session.get('roleId');
         const serverId: number = session.get('serverId');
         const sid: string = session.get('sid');
         const funcs: number[] = session.get('funcs');
-        let userGuild = await UserGuildModel.getMyGuild(roleId, 'guildCode');
-        if (!userGuild)
-            return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
         let res: any = await lockData(serverId, DATA_NAME.GUILD_ASSIST_REFINE, code);//加锁
         if (!!res.err)

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

@@ -4,7 +4,7 @@ import { STATUS, TASK_TYPE } from '../../../consts';
 import { GuildTrainModel } from '../../../db/GuildTrain';
 import { BattleRecordModel } from '../../../db/BattleRecord';
 import { nowSeconds, getTimeFun, getZeroPoint } from '../../../pubUtils/timeUtil';
-import { getUserGuild, getGuildTrainInfo, unlockTrain, getGuildTrainRewards, getGuildTrainInstance, getTrainBoxRewardsResult } from '../../../services/guildTrainService';
+import { refreshTrain, getGuildTrainInfo, unlockTrain, getGuildTrainRewards, getGuildTrainInstance, getTrainBoxRewardsResult } from '../../../services/guildTrainService';
 import { findIndex, findWhere } from 'underscore'
 import { lockData } from '../../../services/redLockService';
 import { GUILD_REPORT_NUM, GUILD_POINT_WAYS } from '../../../consts/constModules/guildConst';
@@ -20,6 +20,7 @@ import { DATA_NAME } from '../../../consts/dataName';
 import { pushGuildTrainSucMsg } from '../../../services/chatService';
 import { checkActivityTask, checkTask } from '../../../services/taskService';
 import { sendPopUpActivityData } from '../../../services/guildActivityService';
+import { guildInter } from '../../../pubUtils/interface';
 
 export default function (app: Application) {
     new HandlerService(app, {});
@@ -32,10 +33,11 @@ export class GuildTrainHandler {
     }
 
     //获得试炼的详情
-    async getTrainInstance(msg: {}, session: BackendSession) {
+    async getTrainInstance(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await getUserGuild(roleId, serverId);
+        const { myUserGuild } = msg;
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -44,10 +46,11 @@ export class GuildTrainHandler {
         return resResult(STATUS.SUCCESS, result);
     }
     //获得试炼战报
-    async getTrainReports(msg: {}, session: BackendSession) {
+    async getTrainReports(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await getUserGuild(roleId, serverId);
+        const { myUserGuild } = msg;
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -69,10 +72,11 @@ export class GuildTrainHandler {
     }
 
     //获得试炼宝箱
-    async getTrainBoxs(msg: {}, session: BackendSession) {
+    async getTrainBoxs(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await getUserGuild(roleId, serverId);
+        const { myUserGuild } = msg;
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -84,12 +88,12 @@ export class GuildTrainHandler {
      * @param msg 
      * @param session 
      */
-    async trainBattleStart(msg: { hid: number, trainId: number, difficulty: number }, session: BackendSession) {
+    async trainBattleStart(msg: guildInter & { hid: number, trainId: number, difficulty: number }, session: BackendSession) {
-        const { hid, difficulty, trainId } = msg;
+        const { hid, difficulty, trainId, myUserGuild } = msg;
         const roleId = session.get('roleId');
         const roleName = session.get('roleName');
         const serverId = parseInt(session.get('serverId'));
-        let userGuild = await getUserGuild(roleId, serverId);
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -126,14 +130,14 @@ export class GuildTrainHandler {
      * @param msg 
      * @param session 
      */
-    async trainBattleEnd(msg: { battleCode: string, isSuccess: boolean }, session: BackendSession) {
+    async trainBattleEnd(msg: guildInter & { battleCode: string, isSuccess: boolean }, session: BackendSession) {
-        const { battleCode, isSuccess } = msg;
+        const { battleCode, isSuccess, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
         const roleName: string = session.get('roleName');
         const sid: string = session.get('sid');
         const funcs: number[] = session.get('funcs');
-        let userGuild = await getUserGuild(roleId, serverId);
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -260,13 +264,13 @@ export class GuildTrainHandler {
      * @param msg 
      * @param session 
      */
-    async getTrainInstanceBox(msg: { trainId: number, hid: number, index: number }, session: BackendSession) {
+    async getTrainInstanceBox(msg: guildInter & { trainId: number, hid: number, index: number }, session: BackendSession) {
-        let { trainId, hid, index } = msg;
+        let { trainId, hid, index, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
         const roleName: string = session.get('roleName');
         const sid = session.get('sid');
-        let userGuild = await getUserGuild(roleId, serverId);
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -320,13 +324,13 @@ export class GuildTrainHandler {
      * @param msg 
      * @param session 
      */
-    async getTrainLvUpRewards(msg: { trainId: number }, session: BackendSession) {
+    async getTrainLvUpRewards(msg: guildInter & { trainId: number }, session: BackendSession) {
-        let { trainId } = msg;
+        let { trainId, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const roleName: string = session.get('roleName');
         const sid: string = session.get('sid');
         const serverId: number = parseInt(session.get('serverId'));
-        let userGuild = await getUserGuild(roleId, serverId);
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;
@@ -346,12 +350,12 @@ export class GuildTrainHandler {
     }
 
     //购买挑战次数
-    async purchaseTrainCount(msg: { count: number }, session: BackendSession) {
+    async purchaseTrainCount(msg: guildInter & { count: number }, session: BackendSession) {
-        let { count } = msg;
+        let { count, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
         const sid: string = session.get('sid');
-        let userGuild = await getUserGuild(roleId, serverId);
+        let userGuild = await refreshTrain(myUserGuild, roleId, serverId);
         if (!userGuild)
             return resResult(STATUS.WRONG_PARMS);
         if (userGuild.buyTrainCount >= ARMY.ARMY_TRAIN_BUYTIMES)

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

@@ -8,6 +8,7 @@ import { UserGuildActivityRecModel } from "../../../db/UserGuildActivityRec";
 import { addActive } from "../../../services/guildService";
 import { Rank } from "../../../services/rankService";
 import { checkActivityTask, checkTask } from "../../../services/taskService";
+import { guildInter } from "../../../pubUtils/interface";
 
 export default function (app: Application) {
     new HandlerService(app, {});

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

@@ -8,11 +8,12 @@ import { getArmyWishPoolBaseByLv, getGoodById } from '../../../pubUtils/data';
 import { addItems, checkGoods } from '../../../services/rewardService';
 import { IT_TYPE } from '../../../consts/constModules/itemConst';
 import { GUILD_STRUCTURE } from '../../../consts/constModules/guildConst';
-import { getUserGuildWithRefActive, getWishPool } from '../../../services/guildService';
+import { refreshUserGuild, getWishPool, getUserGuildWithRefActive } from '../../../services/guildService';
 import { findIndex, findWhere } from 'underscore';
 import { RoleModel } from '../../../db/Role';
 import { getRoleOnlineInfo } from '../../../services/redisService';
 import { ARMY } from '../../../pubUtils/dicParam';
+import { guildInter } from '../../../pubUtils/interface';
 export default function(app: Application) {
     return new WishPoolHandler(app);
 }
@@ -22,9 +23,10 @@ export class WishPoolHandler {
     
     }
 
-    async getWishPool(msg: {}, session: BackendSession) {
+    async getWishPool(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
-        let userGuild = await getUserGuildWithRefActive(roleId, 'wishDntCnt wishGoods guildCode');
+        const { myUserGuild } = msg;
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild) 
             return resResult(STATUS.WRONG_PARMS);
         let res = await getWishPool(userGuild);
@@ -32,8 +34,8 @@ export class WishPoolHandler {
     }
     
     //  许愿
-    async wishGoods(msg: {goodId: number, type: number}, session: BackendSession) {
+    async wishGoods(msg: guildInter & {goodId: number, type: number}, session: BackendSession) {
-        const { goodId, type } = msg;
+        const { goodId, type, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const serverId: number = parseInt(session.get('serverId'));
         let count;
@@ -42,7 +44,7 @@ export class WishPoolHandler {
             return resResult(STATUS.WRONG_PARMS);
         if (!(goodInfo.itid == IT_TYPE.HERO_PIECE && type == 2 ) && !(goodInfo.itid == IT_TYPE.EQUIP_PIECE && type == 1 )) 
             return resResult(STATUS.WRONG_PARMS);
-        let userGuild = await getUserGuildWithRefActive(roleId, ' wishDntCnt wishGoods guildCode wishGoods');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild) 
             return resResult(STATUS.WRONG_PARMS);
         let result = await checkGoods(roleId, [goodId]);
@@ -85,8 +87,8 @@ export class WishPoolHandler {
     }
 
     //  捐赠
-    async donateGoods(msg: {wishRoleId: string, id: string}, session: BackendSession) {
+    async donateGoods(msg: guildInter & {wishRoleId: string, id: string}, session: BackendSession) {
-        let { wishRoleId, id } = msg;
+        let { wishRoleId, id, myUserGuild } = msg;
         const dntRoleId: string = session.get('roleId');
         const dntRoleName: string = session.get('roleName');
         if (wishRoleId == dntRoleId)
@@ -98,7 +100,7 @@ export class WishPoolHandler {
         if (!wishUserGuild) 
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code, wishGoods } = wishUserGuild;
-        let dntRoleGuild = await getUserGuildWithRefActive(dntRoleId, ' wishDntCnt wishGoods guildCode');
+        let dntRoleGuild = await refreshUserGuild(myUserGuild, dntRoleId);
         if (!dntRoleGuild) 
             return resResult(STATUS.WRONG_PARMS);
         if (dntRoleGuild.guildCode != code) 
@@ -125,12 +127,12 @@ export class WishPoolHandler {
         });
     }
 
-    async receiveGoods(msg: { id: string }, session: BackendSession) {
+    async receiveGoods(msg: guildInter & { id: string }, session: BackendSession) {
-        let { id } = msg;
+        let { id, myUserGuild } = msg;
         const roleId: string = session.get('roleId');
         const roleName: string = session.get('roleName');
         const sid: string = session.get('sid');
-        let userGuild = await getUserGuildWithRefActive(roleId, 'wishDntCnt wishGoods guildCode');
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild) 
             return resResult(STATUS.WRONG_PARMS);
         const { wishGoods } = userGuild;
@@ -148,9 +150,10 @@ export class WishPoolHandler {
         return resResult(STATUS.SUCCESS, { goods, wishGoods });
     }
 
-    async getReports(msg: {}, session: BackendSession) {
+    async getReports(msg: guildInter & {}, session: BackendSession) {
         const roleId: string = session.get('roleId');
-        let userGuild = await getUserGuildWithRefActive(roleId, ' guildCode');
+        const { myUserGuild } = msg;
+        let userGuild = await refreshUserGuild(myUserGuild, roleId);
         if (!userGuild) 
             return resResult(STATUS.WRONG_PARMS);
         const { guildCode: code } = userGuild;

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

@@ -16,7 +16,6 @@ import { changeEquip, dressEquip, checkMaterialEnough, takeOffEquipAndCalPlayerC
 import { findIndex, pick } from 'underscore';
 import { pushEquipRefineSucMsg, pushNormalEquipMsg, pushNormalItemMsg } from "../../../services/chatService";
 import { checkTaskWithHero, checkTaskWithEquip, checkTask, checkTaskWithArgs, checkTaskConditionEquipSuitJewelStage, checkActivityTask } from "../../../services/taskService";
-import { AttributeCal } from "../../../domain/roleField/attribute";
 import { QuenchLogParam } from "../../../domain/roleField/equip";
 
 export default function (app: Application) {

game-server/app/services/guildService.ts

@@ -48,13 +48,15 @@ export async function getMyGuildInfo(roleId: string, sid: string, userGuild: Use
  * @param func 操作id
  * @param auth 权限
  */
-export async function checkAuth(func: number, roleId: string, targetCode?: string, userGuild?: UserGuildType) {
+export async function checkAuth(func: number, targetCode: string, guildAuth: number, myGuildCode = targetCode ) {
-    const auth = await UserGuildModel.getMyAuth(roleId, targetCode, userGuild);
+    if(targetCode != myGuildCode || !guildAuth) {
+        guildAuth = GUILD_AUTH.OTHERS;
+    }
     const dicGuildAuth = gameData.guildAuth.get(func);
-    console.log('*checkAuth*', func, auth, dicGuildAuth)
+    console.log('*checkAuth*', func, guildAuth, dicGuildAuth)
     if (!dicGuildAuth) return false;
 
-    return dicGuildAuth.includes(auth);
+    return dicGuildAuth.includes(guildAuth);
 }
 
 /**
@@ -115,8 +117,8 @@ export async function joinGuild(code: string, guildName: string, lv: number, rol
     //成长任务-加入军团
     await checkActivityTask(serverId, sid, [], roleId, TASK_TYPE.GUILD_JOIN, 1);
 
-    session.set('guildCode', code);
+    await pinus.app.rpc.connector.connectorRemote.setOtherUserGuildSession.toServer(sid,[{ roleId, userGuild }]);
-    session.push('guildCode', () => { });
+
     return { status: 0, guild, userGuild, roleName: role.roleName, memberCnt: guild.memberCnt, guildCe: guild.guildCe }
 }
 
@@ -328,3 +330,17 @@ export async function getWishPool(userGuild: UserGuildType) {
     });
     return { list, wishDntCnt: wishDntCnt || 0, wishGoods };
 }
+
+export function setUserGuildSession(session:FrontendOrBackendSession, myUserGuild: UserGuildType) {
+    if(myUserGuild) {
+        session.set('guildCode', myUserGuild.guildCode);
+        session.set('guildAuth', myUserGuild.auth);
+        session.push('guildCode', () => {});
+        session.push('guildAuth', () => {});
+    } else {
+        session.set('guildCode', null);
+        session.set('guildAuth', null);
+        session.push('guildCode', () => {});
+        session.push('guildAuth', () => {});
+    }
+}

game-server/app/services/guildTrainService.ts

@@ -21,10 +21,7 @@ import { getGuildChannelSid } from './chatChannelService';
  * @param roleId 
  * @param serverId 
  */
-export async function getUserGuild(roleId: string, serverId: number) {
+export async function refreshTrain(userGuild: UserGuildType, roleId: string, serverId: number) {
-    let userGuild = await UserGuildModel.getMyGuild(roleId,'trainCount trainTime trainRewards guildCode buyTrainCount');
-    if (!userGuild)
-        return;
     let { trainCount, trainTime, buyTrainCount, guildCode} = userGuild;
     await resetTrain(guildCode, serverId);//检查重置练兵场
     if (trainTime < getZeroPoint()) {//重置挑战次数和购买次数

shared/consts/constModules/guildConst.ts

@@ -72,12 +72,23 @@ export enum GUILD_OPERATE {
     BE_IMPEACH = 28,                // 被弹劾
     RECEIVE_ACTIVE = 29,            // 领取每日活跃宝箱
     GET_ACTIVE_RANK = 30,           // 查看活跃排行榜
+    BOSS_BATTLE = 31,               // 挑战演舞台
+    DONATE = 32,                    // 捐献所操作
+    REFINE = 33,                    // 炼器
+    ASSIST_REFINE = 34,             // 助力研发
+    TRAIN = 35,                     // 练兵
+    WISH_POOL = 36,                 // 许愿池
+    GATE_ACTIVITY = 37,             // 蛮夷入侵挑战
+    CITY_ACTIVITY_DECLARE = 38,     // 诸侯混战宣战
+    CITY_ACTIVITY = 39,             // 诸侯混战挑战
+    RACE_ACTIVITY = 40,             // 粮草先行挑战
 }
 
 export enum GUILD_AUTH_CHECK_TYPE {
-    CHECK_SELF = 1,
+    CHECK_SELF = 1,                 // 查询自己的权限，传递自己的userGuild数据
-    CHECK_OTHERS = 2,
+    CHECK_OTHERS = 2,               // 自己的权限和对方的权限，两者的userGuild数据都传递
-    CHECK_SELF_IF_EXIST = 3,
+    CHECK_SELF_IF_EXIST = 3,        // 如果加入了军团会判断权限，如果没有加入则会进入接口内
+    CHECK_SELF_WITH_SESSION = 4,    // 不查询userGuild，只靠session中的auth判断
 }
 
 export const GUILD_ROUTE_OPERATE = [
@@ -109,7 +120,48 @@ export const GUILD_ROUTE_OPERATE = [
     { 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 }
+    { route: 'guild.guildRefineHandler.lightUpTree', operate: GUILD_OPERATE.EQUIP_PRODUCE, 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 },
+    { route: 'guild.guildBossHandler.getBossInstance', operate: GUILD_OPERATE.BOSS_BATTLE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildBossHandler.battleBoss', operate: GUILD_OPERATE.BOSS_BATTLE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildBossHandler.action', operate: GUILD_OPERATE.BOSS_BATTLE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildBossHandler.battleBossEnd', operate: GUILD_OPERATE.BOSS_BATTLE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.donateHandler.getDonation', operate: GUILD_OPERATE.DONATE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.donateHandler.donate', operate: GUILD_OPERATE.DONATE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.donateHandler.receiveBox', operate: GUILD_OPERATE.DONATE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildRefineHandler.getRefine', operate: GUILD_OPERATE.REFINE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildRefineHandler.refineEquip', operate: GUILD_OPERATE.REFINE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildRefineHandler.assistRefine', operate: GUILD_OPERATE.ASSIST_REFINE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.getTrainInstance', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.getTrainReports', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.getTrainBoxs', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.trainBattleStart', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.trainBattleEnd', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.getTrainInstanceBox', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.getTrainLvUpRewards', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.guildTrainHandler.purchaseTrainCount', operate: GUILD_OPERATE.TRAIN, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.wishPoolHandler.getWishPool', operate: GUILD_OPERATE.WISH_POOL, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.wishPoolHandler.wishGoods', operate: GUILD_OPERATE.WISH_POOL, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.wishPoolHandler.donateGoods', operate: GUILD_OPERATE.WISH_POOL, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.wishPoolHandler.receiveGoods', operate: GUILD_OPERATE.WISH_POOL, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.wishPoolHandler.getReports', operate: GUILD_OPERATE.WISH_POOL, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.gateActivityHandler.getGateActivity', operate: GUILD_OPERATE.GATE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.gateActivityHandler.checkBattle', operate: GUILD_OPERATE.GATE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.gateActivityHandler.action', operate: GUILD_OPERATE.GATE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.gateActivityHandler.hitGate', operate: GUILD_OPERATE.GATE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.gateActivityHandler.battleEnd', operate: GUILD_OPERATE.GATE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.cityActivityHandler.getCityActivity', operate: GUILD_OPERATE.CITY_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.cityActivityHandler.getCityStatus', operate: GUILD_OPERATE.CITY_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.cityActivityHandler.declareCity', operate: GUILD_OPERATE.CITY_ACTIVITY_DECLARE, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.cityActivityHandler.checkBattle', operate: GUILD_OPERATE.CITY_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF },
+    { route: 'guild.cityActivityHandler.hitGate', operate: GUILD_OPERATE.CITY_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.cityActivityHandler.battleEnd', operate: GUILD_OPERATE.CITY_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.raceActivityHandler.getRaceActivity', operate: GUILD_OPERATE.RACE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.raceActivityHandler.join', operate: GUILD_OPERATE.RACE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.raceActivityHandler.getRace', operate: GUILD_OPERATE.RACE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.raceActivityHandler.useItem', operate: GUILD_OPERATE.RACE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
+    { route: 'guild.raceActivityHandler.battleEnd', operate: GUILD_OPERATE.RACE_ACTIVITY, type: GUILD_AUTH_CHECK_TYPE.CHECK_SELF_WITH_SESSION },
 
 ];
 

shared/db/UserGuild.ts

@@ -91,23 +91,6 @@ export default class UserGuild extends BaseModel {
     @prop({ required: true, default: 0 })
     wishDntCnt: number;//今天许愿池捐献次数
 
-    
-
-    public static async getMyAuth(roleId: string, guildCode?: string, userGuild?: UserGuildType) {
-        let myGuild: UserGuildType;
-        if(!userGuild) {
-            myGuild = await this.getMyGuild(roleId, 'auth');
-        } else {
-            myGuild = userGuild;
-        }
-
-        if(guildCode && userGuild && userGuild.guildCode != guildCode) {
-            return GUILD_AUTH.OTHERS;
-        }
-
-        return myGuild?myGuild.auth: GUILD_AUTH.OTHERS;
-    }
-
     public static async getMyGuild(roleId: string, select?: string) {
 
         const myGuild: UserGuildType = await UserGuildModel.findOne({ roleId, status: USER_GUILD_STATUS.ON })

shared/resource/jsons/dic_army_authority.json

@@ -148,5 +148,55 @@
         "id": 30,
         "name": "查看军团活跃榜",
         "authority": "1&2&3&4"
+    },
+    {
+        "id": 31,
+        "name": "演舞台挑战",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 32,
+        "name": "捐献所操作",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 33,
+        "name": "炼器",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 34,
+        "name": "助力科技树研发",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 35,
+        "name": "练兵场训练",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 36,
+        "name": "许愿池操作",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 37,
+        "name": "蛮夷入侵挑战",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 38,
+        "name": "诸侯混战宣战",
+        "authority": "1"
+    },
+    {
+        "id": 39,
+        "name": "诸侯混战挑战",
+        "authority": "1&2&3"
+    },
+    {
+        "id": 40,
+        "name": "粮草先行活动",
+        "authority": "1&2&3"
     }
 ]