743 lines
29 KiB
TypeScript
743 lines
29 KiB
TypeScript
import { Application, BackendSession, pinus } from 'pinus';
|
|
import { resResult, getRandEelm, reduceCe } from '../../../pubUtils/util';
|
|
import { STATUS, GUILD_OPERATE, GUILD_AUTH, GUILD_JOB, GUILD_APPLY_TYPE, GUILD_STRUCTURE, GUILD_REC_TYPE, GUILD_STRUCTURE_NAME } from '../../../consts';
|
|
import { UserGuildModel } from '../../../db/UserGuild';
|
|
import { checkAuth, joinGuild, costFund } from '../../../services/guildService';
|
|
import { GuildModel, GuildType } from '../../../db/Guild';
|
|
import { RoleModel, RoleType } from '../../../db/Role';
|
|
import { GUILD } from '../../../pubUtils/dicParam';
|
|
import { handleCost } from '../../../services/rewardService';
|
|
import { getGoldObject } from '../../../pubUtils/itemUtils';
|
|
import { nowSeconds, getBeforeDaySeconds } from '../../../pubUtils/timeUtil';
|
|
import { GuildListInfo } from '../../../pubUtils/interface';
|
|
import { UserGuildApplyModel } from '../../../db/UserGuildApply';
|
|
import { hasStructureConsume, getStructureConsume, gameData } from '../../../pubUtils/data';
|
|
import { GuildRecModel } from '../../../db/GuildRec';
|
|
import { MailModel } from '../../../db/Mail';
|
|
import { getRedis } from '../../../services/redisService';
|
|
|
|
export default function (app: Application) {
|
|
return new GuildHandler(app);
|
|
}
|
|
|
|
export class GuildHandler {
|
|
constructor(private app: Application) {
|
|
}
|
|
|
|
// 创建军团
|
|
async createGuild(msg: { name: string, icon: number, notice: string }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const roleName = session.get('roleName');
|
|
const sid = session.get('sid');
|
|
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);
|
|
|
|
// 检查元宝是否够
|
|
const role = await RoleModel.findByRoleId(roleId);
|
|
if(GUILD.GUILD_CREATE_COST > role.gold) { // TODO 系统参数表字段更改
|
|
return resResult(STATUS.DAILY_REFRESH_GOLD_LACK);
|
|
}
|
|
|
|
await handleCost(roleId, sid, [getGoldObject(GUILD.GUILD_CREATE_COST)]);
|
|
|
|
// 创建公会
|
|
const guild = await GuildModel.createGuild({ name, icon, notice }, role, serverId);
|
|
if(!guild) return resResult(STATUS.GUILD_CREATE_ERROR);
|
|
guild.guildCe = reduceCe(guild.guildCe);
|
|
guild.leader = <RoleType>guild.leader;
|
|
guild.leader.ce = reduceCe(guild.leader.ce);
|
|
|
|
const userGuild = await UserGuildModel.createUserGuild(guild.code, role, true);
|
|
if(!userGuild) return resResult(STATUS.GUILD_CREATE_ERROR);
|
|
|
|
await RoleModel.joinGuild(roleId);
|
|
await UserGuildApplyModel.deleteApply(roleId); // 删除玩家所有对其他公会的申请
|
|
|
|
// TODO 加入排行
|
|
const rank = 0;
|
|
// TODO 加入channel
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, guild.code, GUILD_REC_TYPE.JOIN_GUILD, [roleName]);
|
|
|
|
// 返回
|
|
const result = { ...guild, rank, myInfo: userGuild};
|
|
return resResult(STATUS.SUCCESS, result);
|
|
}
|
|
|
|
// 获取军团列表
|
|
async getGuildList(msg: { 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);
|
|
|
|
const { quitGuildTime: quitTime = 0 } = await RoleModel.findByRoleId(roleId);
|
|
|
|
const list = new Array<GuildListInfo>();
|
|
for(let guild of guildList) {
|
|
let info = new GuildListInfo(guild);
|
|
|
|
let hasApply = applyList.find(cur => cur.guildCode == guild.code);
|
|
info.setApply(!!hasApply);
|
|
list.push(info);
|
|
}
|
|
return resResult(STATUS.SUCCESS, { quitTime, list });
|
|
}
|
|
|
|
// 团长修改军团名等信息
|
|
async setGuildInfo(msg: { code: string, name: string, notice: string, introduce: string, ceLimit: number, isAuto: boolean }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const { code, name, notice, introduce, ceLimit, isAuto } = msg;
|
|
|
|
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(' '));
|
|
// 返回
|
|
return resResult(STATUS.SUCCESS, { ...guild });
|
|
|
|
}
|
|
|
|
// 游客查看军团详细信息
|
|
async getGuildInfo(msg: { 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;
|
|
delete guild.leader;
|
|
// 返回
|
|
return resResult(STATUS.SUCCESS, { ...guild, leader: leader.roleName });
|
|
|
|
}
|
|
|
|
// 团长授权头衔
|
|
async setAuth(msg: { 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');
|
|
|
|
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;
|
|
|
|
if(auth == hisUserGuild.auth) {
|
|
return resResult(STATUS.GUILD_AUTH_NOT_CHANGE);
|
|
}
|
|
|
|
// 管理员最大数 等策划表
|
|
let guild = await GuildModel.findByCode(code, serverId, 'managerCnt lv');
|
|
if(!guild) {
|
|
return resResult(STATUS.GUILD_NOT_FOUND);
|
|
}
|
|
|
|
let managerCntInc = 0;
|
|
if(auth == GUILD_AUTH.LEADER) { // 转让团长
|
|
managerCntInc = hisUserGuild.auth == GUILD_AUTH.MANAGER?-1: 0;
|
|
} else {
|
|
managerCntInc = auth == GUILD_AUTH.MANAGER? 1: -1;
|
|
}
|
|
|
|
let maxManagerCnt = gameData.centerBase.get(guild.lv);
|
|
if(!maxManagerCnt) return STATUS.DIC_DATA_NOT_FOUND;
|
|
|
|
if(guild.managerCnt + managerCntInc > maxManagerCnt.managerNum) {
|
|
return resResult(STATUS.GUILD_MANAGER_REACH_MAX);
|
|
}
|
|
|
|
const userGuild = await UserGuildModel.updateInfo(memberRoleId, { auth }, 'auth'); // 设置权限
|
|
if(!userGuild) {
|
|
return resResult(STATUS.GUILD_MEMBER_NOT_FOUND);
|
|
}
|
|
|
|
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 }); // 自己降权限
|
|
}
|
|
|
|
guild = await GuildModel.updateInfo(code, updateObject, { managerCnt: managerCntInc }, 'managerCnt'); // 如果有转让团长设置leader
|
|
|
|
// 添加动态
|
|
if(auth == GUILD_AUTH.MANAGER) {
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.SET_MANAGER, [role.roleName]);
|
|
} else if (auth == GUILD_AUTH.LEADER) {
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.SET_LEADER, [roleName, role.roleName]);
|
|
}
|
|
|
|
// 返回
|
|
return resResult(STATUS.SUCCESS, {
|
|
roleId: memberRoleId, auth: userGuild.auth, managerCnt: guild.managerCnt
|
|
});
|
|
|
|
}
|
|
|
|
// 团员获取自己军团详细信息
|
|
async getMyGuildInfo(msg: { }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const serverId = session.get('serverId');
|
|
|
|
const userGuild = await UserGuildModel.getMyGuild(roleId, 'honour job auth guildCode');
|
|
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 GuildModel.findByCode(userGuild.guildCode, serverId);
|
|
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
|
|
|
|
guild.guildCe = reduceCe(guild.guildCe);
|
|
guild.leader = <RoleType>guild.leader;
|
|
guild.leader.ce = reduceCe(guild.leader.ce);
|
|
|
|
// TODO 刷新日活跃，周活跃
|
|
|
|
// TODO 获取排行榜
|
|
const rank = 0;
|
|
|
|
// 返回
|
|
const result = { hasGuild: true, ...guild, rank, myInfo: userGuild};
|
|
return resResult(STATUS.SUCCESS, result);
|
|
}
|
|
|
|
// 玩家申请公会
|
|
async applyGuild(msg: { code: string }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const roleName = session.get('roleName');
|
|
const serverId = session.get('serverId');
|
|
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);
|
|
|
|
const { isMemberMax, isAuto, ceLimit, lv } = guild;
|
|
if(isMemberMax) {
|
|
return resResult(STATUS.GUILD_MEMBER_MAX);
|
|
}
|
|
|
|
const role = await RoleModel.findByRoleId(roleId);
|
|
if(ceLimit > reduceCe(role.ce)) {
|
|
return resResult(STATUS.GUILD_NOT_REACH_CONDI);
|
|
}
|
|
// TODO 暂时关闭
|
|
// if(nowSeconds() - role.quitGuildTime < 3600) { // TODO 时间系统参数表配置
|
|
// return resResult(STATUS.GUILD_QUIT_TIME);
|
|
// }
|
|
|
|
let hasGuild = false;
|
|
if(isAuto) { // 自动加入
|
|
const joinResult = await joinGuild(code, lv, roleId, serverId);
|
|
if(joinResult.status == 0) {
|
|
return joinResult.resResult;
|
|
}
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.JOIN_GUILD, [roleName]);
|
|
|
|
hasGuild = true;
|
|
} else { // 不自动加入，插入申请表
|
|
await UserGuildApplyModel.createUserGuildApply(role, guild, GUILD_APPLY_TYPE.APPLY);
|
|
}
|
|
|
|
// 返回
|
|
return resResult(STATUS.SUCCESS, { code, hasGuild });
|
|
}
|
|
|
|
// 玩家申请公会
|
|
async getApplyList(msg: { 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.getListByGuild(code, lastApplyCode);
|
|
const list = result.map(cur => {
|
|
let role = <RoleType>cur.role;
|
|
delete cur.role;
|
|
return { applyCode: cur.applyCode, ...role, ce: reduceCe(role.ce) };
|
|
});
|
|
|
|
return resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
// 团长同意/拒绝公会申请
|
|
async receiveApply(msg: { code: string, applyCodeList: [string], isReceived: boolean }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
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);
|
|
|
|
let roleIds = new Array<string>();
|
|
if(isReceived) { // 同意申请，加入
|
|
const guild = await GuildModel.findByCode(code, serverId);
|
|
|
|
for(let { roleId } of applyList) {
|
|
const joinResult = await joinGuild(code, guild.lv, roleId, serverId);
|
|
if(joinResult.status == 0) continue;
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.JOIN_GUILD, [joinResult.roleName]);
|
|
|
|
roleIds.push(roleId);
|
|
}
|
|
} else { // 拒绝申请，删除申请
|
|
for(let { roleId } of applyList) {
|
|
// TODO 发送邮件
|
|
}
|
|
|
|
await UserGuildApplyModel.deleteApplyByApplyCode(applyCodeList);
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, { roleIds });
|
|
}
|
|
|
|
// 团长查看（刷新）可邀请人列表
|
|
async getInviteMemberList(msg: { }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const serverId = session.get('serverId');
|
|
// 检查权限
|
|
const checkResult = await checkAuth(GUILD_OPERATE.GET_INIVATION_MEMBER_LIST, roleId);
|
|
if(!checkResult) return resResult(STATUS.GUILD_AUTH_NOT_ENOUGH);
|
|
|
|
// 离线时间，三天内在线且尚未加入军团。按以下规则排序 离线时间 玩家等级 玩家战力
|
|
|
|
const day = getBeforeDaySeconds(3);
|
|
|
|
const { quitGuildTime: quitTime = 0 } = await RoleModel.findByRoleId(roleId);
|
|
const allList = await RoleModel.getInviteList(day, serverId);
|
|
let list = getRandEelm(allList, 10);
|
|
if(!list.length) list = allList;
|
|
list = list.map(cur => {
|
|
return {...cur, ce: reduceCe(cur.ce)}
|
|
});
|
|
|
|
return resResult(STATUS.SUCCESS, { quitTime, list });
|
|
|
|
}
|
|
|
|
// 团长（一键）邀请人
|
|
async inviteMember(msg: { 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);
|
|
if(guild.isMemberMax) return resResult(STATUS.GUILD_MEMBER_MAX);
|
|
|
|
const roleList = await RoleModel.findRoleByField('roleId', roleIds);
|
|
let result = new Array<string>();
|
|
for(let role of roleList) {
|
|
if(!role.hasGuild) {
|
|
await UserGuildApplyModel.createUserGuildApply(role, guild, GUILD_APPLY_TYPE.INVITE);
|
|
result.push(role.roleId);
|
|
}
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, { roleIds: result });
|
|
|
|
}
|
|
|
|
// 成员收到邀请列表
|
|
async getInvitationList(msg: { 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.getListByRole(roleId, lastApplyCode);
|
|
const list = result.map(cur => {
|
|
let guild = <GuildType>cur.guild;
|
|
let leader = <RoleType>guild.leader;
|
|
delete guild.leader;
|
|
delete cur.guild;
|
|
return { applyCode: cur.applyCode, ...guild, leader: leader.roleName };
|
|
});
|
|
|
|
return resResult(STATUS.SUCCESS, { list });
|
|
|
|
}
|
|
|
|
|
|
// 成员同意/拒绝邀请
|
|
async receiveInvitation(msg: { 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);
|
|
|
|
let code: string;
|
|
if(isReceived) { // 同意申请，加入
|
|
const { guildCode } = invite;
|
|
const guild = await GuildModel.findByCode(guildCode, serverId);
|
|
|
|
const joinResult = await joinGuild(guildCode, guild.lv, roleId, serverId);
|
|
if(joinResult.status == 0) {
|
|
return joinResult.resResult;
|
|
}
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.JOIN_GUILD, [joinResult.roleName]);
|
|
|
|
code = guild.code;
|
|
}
|
|
await UserGuildApplyModel.deleteApplyByApplyCode([applyCode]); // 删除这条邀请
|
|
|
|
return resResult(STATUS.SUCCESS, { applyCode, code, isReceived, hasGuild: isReceived });
|
|
}
|
|
|
|
// 获取军团成员
|
|
async getGuildMember(msg: { 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);
|
|
|
|
let select = ['role', 'job'];
|
|
const checkDetailResult = await checkAuth(GUILD_OPERATE.GET_MEMBER_LIST_DETAIL, roleId, code);
|
|
if(checkDetailResult) {
|
|
select.push('auth', 'honourWeekly honourUpdateTime');
|
|
}
|
|
let list = await UserGuildModel.getListByGuild(code, select.join(' '));
|
|
let result = list.map(cur => {
|
|
let role = <RoleType>cur.role;
|
|
delete role._id;
|
|
delete cur.role;
|
|
return { ...cur, ...role, ce: reduceCe(role.ce) };
|
|
});
|
|
let leader = result.shift();
|
|
|
|
result.sort((a, b) => {
|
|
if(sort == 'honour') {
|
|
if(b.honourWeekly == a.honourWeekly) {
|
|
return a.honourUpdateTime - b.honourUpdateTime
|
|
} else {
|
|
return b.honourWeekly - a.honourWeekly
|
|
}
|
|
} else if (sort == 'loginTime') {
|
|
return b.loginTime - a.loginTime;
|
|
} else {
|
|
return b.ce - a.ce;
|
|
}
|
|
});
|
|
|
|
result.unshift(leader);
|
|
return resResult(STATUS.SUCCESS, { list: result });
|
|
}
|
|
|
|
// 团长解散军团
|
|
async dismiss(msg: { 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);
|
|
|
|
await UserGuildModel.dismiss(code);
|
|
const { members } = guild;
|
|
await RoleModel.dissmissGuild(members);
|
|
await UserGuildApplyModel.deleteApplyByGuild(code);
|
|
|
|
// 删除channel
|
|
|
|
return resResult(STATUS.SUCCESS, { code, status: guild.status });
|
|
}
|
|
|
|
// 成员退出军团
|
|
async quit(msg: { code: string }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const roleName = session.get('roleName');
|
|
const serverId = session.get('serverId');
|
|
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);
|
|
|
|
const role = await RoleModel.quitGuild(roleId, nowSeconds());
|
|
if(!role) return resResult(STATUS.GUILD_QUIT_ERROR);
|
|
|
|
const guild = await GuildModel.quit(code, roleId, serverId);
|
|
if(!guild) return resResult(STATUS.GUILD_QUIT_ERROR);
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.QUIT_GUILD, [roleName]);
|
|
|
|
return resResult(STATUS.SUCCESS, { hasGuild: role.hasGuild });
|
|
}
|
|
|
|
// 团长踢退出军团
|
|
async kick(msg: { code: string, roleId: string }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
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);
|
|
|
|
const role = await RoleModel.quitGuild(memberRoleId, nowSeconds());
|
|
if(!role) return resResult(STATUS.GUILD_KICK_ERROR);
|
|
|
|
const guild = await GuildModel.quit(code, memberRoleId, serverId);
|
|
if(!guild) return resResult(STATUS.GUILD_KICK_ERROR);
|
|
|
|
// TODO 发送邮件，发送推送
|
|
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.QUIT_GUILD, [role.roleName]);
|
|
|
|
return resResult(STATUS.SUCCESS, { memberCnt: guild.memberCnt });
|
|
}
|
|
|
|
// 团员弹劾团长
|
|
async impeach(msg: { code: string, roleId: string }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
// 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, loginTime } = await RoleModel.findByRoleId(leaderRoleId);
|
|
if (loginTime > getBeforeDaySeconds(3)) {
|
|
return resResult(STATUS.GUILD_LEADER_LOGIN);
|
|
}
|
|
// 上周周功勋最高的人
|
|
const topUserGuild = await UserGuildModel.findTopHonour(code, 'auth role roleId');
|
|
if (!topUserGuild) {
|
|
return resResult(STATUS.GUILD_MEMBER_NOT_FOUND);
|
|
}
|
|
const topUser = <RoleType>topUserGuild.role;
|
|
// 交换
|
|
|
|
// TODO redlock 推送
|
|
await UserGuildModel.updateInfo(leaderRoleId, { auth: GUILD_AUTH.MEMBER }, 'auth'); // 团长撤
|
|
await UserGuildModel.updateInfo(topUserGuild.roleId, { auth: GUILD_AUTH.LEADER }, 'auth'); // 最高功勋人升
|
|
let managerCntInc = topUserGuild.auth == GUILD_AUTH.MANAGER ? -1 : 0; // 管理人数
|
|
|
|
const guild = await GuildModel.updateInfo(code, { leader: topUser._id }, { managerCnt: managerCntInc }, 'managerCnt'); // 如果有转让团长设置leader
|
|
|
|
// 添加动态
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.IMPEACH, [ oldRoleName, topUser.roleName]);
|
|
|
|
|
|
const leader = { ...topUser, ce: reduceCe(topUser.ce) }
|
|
return resResult(STATUS.SUCCESS, {
|
|
code, managerCnt: guild.managerCnt, leader
|
|
});
|
|
}
|
|
|
|
// 升级建筑物等级
|
|
async upStructure(msg: { code: string, id: number }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
const serverId = session.get('serverId');
|
|
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);
|
|
}
|
|
|
|
// TODO 加写锁
|
|
const { lv, structure } = guild;
|
|
const curStructure = structure.find(cur => cur.id == id);
|
|
if(!curStructure) {
|
|
return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
|
|
}
|
|
if(id != GUILD_STRUCTURE.ARMY_CENTER && curStructure.lv >= lv) { // 中军大帐以外建筑物
|
|
if(curStructure.lv >= lv) {
|
|
return resResult(STATUS.GUILD_STRUCTURE_LV_MAX);
|
|
}
|
|
}
|
|
if(!hasStructureConsume(id, curStructure.lv + 1)) {
|
|
return resResult(STATUS.GUILD_STRUCTURE_LV_MAX);
|
|
}
|
|
const cost = getStructureConsume(id, curStructure.lv);
|
|
const costResult = await costFund(code, cost, sid);
|
|
if(!costResult) {
|
|
return resResult(STATUS.GUILD_FUND_NOT_ENOUGH);
|
|
}
|
|
|
|
const result = await GuildModel.upStructure(code, id, 'code fund structure lv');
|
|
if(!result) {
|
|
return resResult(STATUS.GUILD_STRUCTURE_NOT_FOUND);
|
|
}
|
|
const resultStructure = result.structure.find(cur => cur.id == id);
|
|
|
|
// 添加动态
|
|
const structureName = GUILD_STRUCTURE_NAME.get(id);
|
|
await GuildRecModel.createGuildRec(roleId, code, GUILD_REC_TYPE.STRUCTURE_UP, [structureName, resultStructure.lv.toString()]);
|
|
|
|
return resResult(STATUS.SUCCESS, result);
|
|
}
|
|
|
|
|
|
// 获取动态
|
|
async getRec(msg: { 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);
|
|
|
|
const list = await GuildRecModel.getGuildRec(code);
|
|
|
|
return resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
// 团长发送消息给军团内所有成员的邮箱
|
|
async sendMail(msg: { 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);
|
|
if(!guild) return resResult(STATUS.GUILD_NOT_FOUND);
|
|
|
|
const { members } = guild;
|
|
//下发邮件
|
|
for(let roleId of members) {
|
|
let mail = await MailModel.addMail({roleId, goods: [], sendName: roleName, mailId: 1, sendInfo: info});
|
|
let key = 'login_roleId_' + roleId;
|
|
let sid = await getRedis(key);
|
|
if (!!sid) {
|
|
pinus.app.rpc.connector.connectorRemote.pushMessage.toServer(sid, roleId, 'onMailsAdd', [mail]);
|
|
}
|
|
}
|
|
|
|
return resResult(STATUS.SUCCESS, { isSuccess: true });
|
|
}
|
|
|
|
|
|
// 团长发送世界频道
|
|
async recruit(msg: { code: string, info: string }, session: BackendSession) {
|
|
|
|
const roleId = session.get('roleId');
|
|
// const roleName = session.get('roleName');
|
|
const sid = session.get('sid');
|
|
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);
|
|
|
|
// 发送世界频道消息
|
|
this.app.rpc.chat.chatRemote.sendWorldMessage.toServer('chat-server-1', serverId, { info });
|
|
|
|
return resResult(STATUS.SUCCESS, { isSuccess: true });
|
|
}
|
|
} |