xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

军团：提取权限判断

Browse Source
This commit is contained in:
luying
2021-07-31 18:49:01 +08:00
parent 0b6ac18d45
commit 2cf9fafdbb
10 changed files with 197 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
game-server/app.ts
View File

@@ -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

2
game-server/app/servers/connector/filter/global.ts
View File

@@ -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);
}

52
game-server/app/servers/guild/filter/guildAuthFilter.ts Normal file
View File

@@ -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);
};

13
game-server/app/servers/guild/handler/guildBossHandler.ts
View File

@@ -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 { checkAuth, addActive } from '../../../services/guildService';
import { 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');
if (!userGuild)
return resResult(STATUS.WRONG_PARMS);
const { myUserGuild: userGuild } = msg;
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);

225
game-server/app/servers/guild/handler/guildHandler.ts
View File

@@ -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 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 { roleId: memberRoleId, auth, myUserGuild, hisUserGuild } = msg;
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');
let userGuild = await getUserGuildWithRefActive(roleId, 'job auth guildCode receivedActive activeRecord activeDaily activeWeekly');
const { myUserGuild } = msg;
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 时间系统参数表配置
// return resResult(STATUS.GUILD_QUIT_TIME);
// }
if(nowSeconds() - role.quitGuildTime < 3600) { // TODO 时间系统参数表配置
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');
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);
const { myUserGuild: myGuild } = msg;
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 checkResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_MAIN, roleId, code);
if (!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
const { code, sort, myUserGuild } = msg;
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) {
let roleId = session.get('roleId');
async getActiveRank(msg: guildInter & {}, session: BackendSession) {
let serverId = session.get('serverId')
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);
const { myUserGuild } = msg;
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) {
const { code } = msg;
async debugJoinGuild(msg: guildInter & { magicWord: string, code: string }, session: BackendSession) {
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');

12
game-server/app/servers/guild/handler/guildRefineHandler.ts
View File

@@ -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');
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 { myUserGuild: userGuild } = msg
const { guildCode: code } = userGuild;
let developConsume = getArmyDevelopConsumeById(id);
if (!developConsume)

13
game-server/app/services/guildService.ts
View File

@@ -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) {
const auth = await UserGuildModel.getMyAuth(roleId, code, userGuild);
export async function checkAuth(func: number, roleId: string, targetCode?: string, userGuild?: UserGuildType) {
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;
}

47
shared/consts/constModules/guildConst.ts
View File

@@ -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, // 运转中

2
shared/consts/statusCode.ts
View File

@@ -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: '玩家神像不能强化' },

9
shared/pubUtils/interface.ts
View File

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