989 lines
27 KiB
Go
989 lines
27 KiB
Go
package main
|
|
|
|
import (
|
|
"cs"
|
|
"f5"
|
|
"fmt"
|
|
"math/rand"
|
|
"q5"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
LoadGuildFlag = iota
|
|
LoadGuildMemberFlag
|
|
LoadGuildReqFlag
|
|
LoadGuildLogFlag
|
|
)
|
|
|
|
type GuildMgr struct {
|
|
cs.MsgHandlerImpl
|
|
guilds map[int64]*Guild // 公会ID -> 公会
|
|
guildIds []int64 // 公会列表 guildIds
|
|
guildLogs map[int64][]*GuildLog // 公会ID -> []公会日志列表
|
|
userGuilds map[string]int64 // accountId -> 公会ID
|
|
loadedFlags int64
|
|
}
|
|
|
|
func NewGuildMgr() *GuildMgr {
|
|
return &GuildMgr{
|
|
guilds: make(map[int64]*Guild),
|
|
guildLogs: make(map[int64][]*GuildLog),
|
|
userGuilds: make(map[string]int64),
|
|
}
|
|
}
|
|
|
|
func (gm *GuildMgr) init() {
|
|
gm.guildIds = make([]int64, 0, 200)
|
|
gm.loadFromDB()
|
|
}
|
|
|
|
func (gm *GuildMgr) loadFromDB() {
|
|
q5.SetBitFlag(&gm.loadedFlags, LoadGuildFlag)
|
|
q5.SetBitFlag(&gm.loadedFlags, LoadGuildMemberFlag)
|
|
q5.SetBitFlag(&gm.loadedFlags, LoadGuildReqFlag)
|
|
q5.SetBitFlag(&gm.loadedFlags, LoadGuildLogFlag)
|
|
|
|
// 加载公会
|
|
gm.loadGuildFromDB()
|
|
// 加载公会成员
|
|
gm.loadGuildMemberFromDB()
|
|
// 加载公会申请者列表
|
|
gm.loadPendingReqsFromDB()
|
|
// 加载公会日志
|
|
gm.loadGuildLogsFromDB()
|
|
//for gm.loadedFlags != 0 {
|
|
// time.Sleep(time.Millisecond * 1000)
|
|
//}
|
|
}
|
|
|
|
// CreateGuild 创建公会
|
|
func (gm *GuildMgr) CreateGuild(avatar int32, name *string, leaderId string,
|
|
cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
if gm.CheckJoinGuild(leaderId) {
|
|
cb(ERR_CODE_JOINED_GUILD, "Joined guild", nil)
|
|
return
|
|
}
|
|
|
|
guildId := f5.GetApp().NewUuid()
|
|
if gm.ExistsGuild(guildId) {
|
|
cb(ERR_CODE_CREATE_GUILD_FAIL, "create error ", nil)
|
|
return
|
|
}
|
|
|
|
unixSec := time.Now().Unix()
|
|
fields := [][]string{
|
|
{"guild_id", q5.ToString(guildId)},
|
|
{"name", *name},
|
|
{"leader_account_id", leaderId},
|
|
{"avatar", q5.ToString(avatar)},
|
|
{"max_members", q5.ToString(MaxMembers)},
|
|
{"createtime", q5.ToString(unixSec)},
|
|
{"modifytime", q5.ToString(unixSec)},
|
|
}
|
|
f5.GetJsStyleDb().Insert(
|
|
FRIEND_DB,
|
|
"t_guild",
|
|
fields,
|
|
func(err error, id int64, affectedRows int64) {
|
|
if err != nil {
|
|
cb(ERR_CODE_CREATE_GUILD_DB_FAIL, "create guild db error ", nil)
|
|
return
|
|
}
|
|
newMember := &GuildMember{AccountId: leaderId, Level: GuildMemberLevelLeader}
|
|
gm.upsertGuildMember(guildId, newMember,
|
|
func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_CREATE_GUILD_MEMBER_DB_FAIL, "create guild member db error", nil)
|
|
return
|
|
}
|
|
|
|
guild := &Guild{
|
|
AutoId: id,
|
|
GuildId: guildId,
|
|
Name: *name,
|
|
LeaderId: leaderId,
|
|
Avatar: avatar,
|
|
Notice: "",
|
|
JoinCond: 0,
|
|
JoinCondValue: 0,
|
|
TotalStars: 0,
|
|
TotalKills: 0,
|
|
ChickenDinners: 0,
|
|
MaxMembers: MaxMembers,
|
|
Members: make(map[string]*GuildMember, MaxMembers),
|
|
PendingReqs: make(map[string]int32, MaxPendingReqs),
|
|
}
|
|
guild.AddMember(newMember)
|
|
gm.AddGuild(guildId, guild)
|
|
gm.AddUserGuild(leaderId, guildId)
|
|
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["auto_id"] = q5.ToString(id)
|
|
prop["guild_id"] = q5.ToString(guildId)
|
|
prop["guild_name"] = *name
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
leaderId,
|
|
"127.0.0.1",
|
|
EVENT_CREATE,
|
|
prop,
|
|
)
|
|
cb(ERR_CODE_OK, "Create OK", guild)
|
|
})
|
|
})
|
|
}
|
|
|
|
// ApplyToGuild 申请加入公会
|
|
func (gm *GuildMgr) ApplyToGuild(guildId int64, applicantAccountId string, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
guild := gm.GetGuild(guildId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "ApplyToGuild guild no exists", nil)
|
|
return
|
|
}
|
|
// 是否加入其他公会
|
|
if gm.CheckJoinGuild(applicantAccountId) {
|
|
cb(ERR_CODE_JOINED_GUILD, "ApplyToGuild joined guild", nil)
|
|
return
|
|
}
|
|
|
|
if guild.IsFull() {
|
|
cb(ERR_CODE_GUILD_MEMBER_FULL, "ApplyToGuild guild member full", nil)
|
|
return
|
|
}
|
|
// 可直接加入
|
|
if guild.JoinCond == JoinCondFree {
|
|
gm.JoinGuild(guild, applicantAccountId, cb)
|
|
return
|
|
}
|
|
|
|
if guild.JoinCond == JoinCondStar {
|
|
profile := cacheMgr.GetPlayerProfile(applicantAccountId)
|
|
if profile == nil {
|
|
cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "applicantAccountId no exists", nil)
|
|
return
|
|
}
|
|
if profile.Star < guild.JoinCondValue {
|
|
cb(ERR_CODE_APPLY_GUILD_FAIL, "ApplyToGuild Fail, user star error", nil)
|
|
return
|
|
}
|
|
gm.JoinGuild(guild, applicantAccountId, cb)
|
|
return
|
|
}
|
|
|
|
// IF exists, then replace it fields `isJoinGuild` is 0
|
|
where := [][]string{
|
|
{"guild_id", q5.ToString(guildId)},
|
|
{"account_id", applicantAccountId},
|
|
}
|
|
insertKv := [][]string{
|
|
{"guild_id", q5.ToString(guildId)},
|
|
{"account_id", applicantAccountId},
|
|
{"is_join_guild", q5.ToString(PendingReqIsJoinGuildStatusDefault)},
|
|
}
|
|
updateKv := [][]string{
|
|
{"is_join_guild", q5.ToString(PendingReqIsJoinGuildStatusDefault)},
|
|
}
|
|
f5.GetJsStyleDb().Upsert(
|
|
FRIEND_DB,
|
|
"t_guild_pending_request",
|
|
where,
|
|
updateKv,
|
|
insertKv,
|
|
func(err error, lastInsertId int64, rowsAffected int64) {
|
|
if err != nil || rowsAffected <= 0 {
|
|
cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, "ApplyToGuild guild pending request db error", nil)
|
|
return
|
|
}
|
|
|
|
pendingReq := &PendingReq{
|
|
applicantAccountId,
|
|
PendingReqIsJoinGuildStatusDefault,
|
|
}
|
|
guild.AddPendingReq(pendingReq)
|
|
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guildId)
|
|
prop["join_cond"] = q5.ToString(guild.JoinCond)
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
applicantAccountId,
|
|
"127.0.0.1",
|
|
EVENT_APPLY,
|
|
prop,
|
|
)
|
|
cb(ERR_CODE_OK, "ApplyToGuild ok", guild)
|
|
})
|
|
}
|
|
|
|
// Approve 同意申请者加入公会
|
|
func (gm *GuildMgr) Approve(operatorAccountId, accountId string, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "Approve guild no exists", nil)
|
|
return
|
|
}
|
|
|
|
// 默认为审核加入
|
|
if guild.JoinCond != JoinCondDefault {
|
|
cb(ERR_CODE_JOINED_GUILD, "Approve joined guild", nil)
|
|
return
|
|
}
|
|
|
|
// 公会干部及以上仅可操作
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
err := gm.CheckOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
|
|
if err != nil {
|
|
cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "Approve operator member no perm", nil)
|
|
return
|
|
}
|
|
|
|
// 是否加入其他公会
|
|
if gm.CheckJoinGuild(accountId) {
|
|
cb(ERR_CODE_JOINED_GUILD, "Approve joined guild", nil)
|
|
return
|
|
}
|
|
|
|
guildId := guild.GuildId
|
|
// 是否在申请队列中
|
|
pendingReqStatus := guild.GetPendingReqStatus(accountId)
|
|
if pendingReqStatus < 0 {
|
|
cb(ERR_CODE_GUILD_PENDING_REQUEST_NO_EXISTS, "Approve pending request no exists", nil)
|
|
return
|
|
}
|
|
|
|
if guild.IsFull() {
|
|
cb(ERR_CODE_GUILD_MEMBER_FULL, "Approve guild member full", nil)
|
|
return
|
|
}
|
|
newMember := &GuildMember{AccountId: accountId, Level: GuildMemberLevelDefault}
|
|
gm.upsertGuildMember(guildId, newMember, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, "Approve update guild member db error", nil)
|
|
return
|
|
}
|
|
guild.AddMember(newMember)
|
|
gm.AddUserGuild(accountId, guildId)
|
|
gm.updatePendingReqs(guildId, accountId, PendingReqIsJoinGuildStatusJoined, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, "Approve db error", nil)
|
|
return
|
|
}
|
|
|
|
logContent := fmt.Sprintf("Approve[operator:%s]", operatorAccountId)
|
|
gm.WriteLog(guildId, accountId, LogTypeApprove, logContent)
|
|
guild.RemovePendingReq(accountId)
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guildId)
|
|
prop["applicant_account_id"] = q5.ToString(accountId)
|
|
prop["members_count"] = q5.ToString(guild.GetMembersCount())
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
operatorAccountId,
|
|
"127.0.0.1",
|
|
EVENT_APPROVE,
|
|
prop,
|
|
)
|
|
|
|
cb(ERR_CODE_OK, "Approve ok", guild)
|
|
})
|
|
})
|
|
}
|
|
|
|
// Reject 拒绝申请者加入公会
|
|
func (gm *GuildMgr) Reject(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "Reject guild no exists")
|
|
return
|
|
}
|
|
// 通常默认为审核加入
|
|
if guild.JoinCond != JoinCondDefault {
|
|
cb(ERR_CODE_JOINED_GUILD, "Reject joined guild")
|
|
return
|
|
}
|
|
|
|
// 公会干部及以上仅可操作
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
err := gm.CheckOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
|
|
if err != nil {
|
|
cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "Reject operator member no perm")
|
|
return
|
|
}
|
|
// 是否加入其他公会
|
|
if gm.CheckJoinGuild(accountId) {
|
|
cb(ERR_CODE_JOINED_GUILD, "Reject joined guild")
|
|
return
|
|
}
|
|
// 是否在申请队列中
|
|
pendingReqStatus := guild.GetPendingReqStatus(accountId)
|
|
if pendingReqStatus < 0 {
|
|
cb(ERR_CODE_GUILD_PENDING_REQUEST_NO_EXISTS, "Reject pending request no exists")
|
|
return
|
|
}
|
|
|
|
gm.updatePendingReqs(guild.GuildId, accountId, PendingReqIsJoinGuildStatusReject, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, "Reject db error")
|
|
return
|
|
}
|
|
|
|
guild.RemovePendingReq(accountId)
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guild.GuildId)
|
|
prop["reject_account_id"] = q5.ToString(accountId)
|
|
prop["members_count"] = q5.ToString(guild.GetMembersCount())
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
operatorAccountId,
|
|
"127.0.0.1",
|
|
EVENT_REJECT,
|
|
prop,
|
|
)
|
|
|
|
cb(ERR_CODE_OK, "Reject ok")
|
|
})
|
|
}
|
|
|
|
// JoinGuild 直接加入公会
|
|
func (gm *GuildMgr) JoinGuild(guild *Guild, accountId string, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
newMember := GuildMember{AccountId: accountId, Level: GuildMemberLevelDefault}
|
|
guildId := guild.GuildId
|
|
gm.upsertGuildMember(guildId, &newMember,
|
|
func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, "JoinGuild Fail, upsertGuildMember", nil)
|
|
return
|
|
}
|
|
guild.AddMember(&newMember)
|
|
gm.AddUserGuild(accountId, guildId)
|
|
|
|
cb(ERR_CODE_OK, "ApplyToGuild OK", guild)
|
|
|
|
user := friendMgr.GetUser(accountId)
|
|
cacheMgr.LoadPlayerProfile(user, func(playerProfile *PlayerProfile) {})
|
|
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guild.GuildId)
|
|
prop["members_count"] = q5.ToString(guild.GetMembersCount())
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
accountId,
|
|
"127.0.0.1",
|
|
EVENT_JOIN,
|
|
prop,
|
|
)
|
|
})
|
|
}
|
|
|
|
// LeaveGuild 离开公会
|
|
func (gm *GuildMgr) LeaveGuild(accountId string, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
guild := gm.GetGuildByAccountId(accountId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "no join guild]", nil)
|
|
return
|
|
}
|
|
member := guild.GetMember(accountId)
|
|
if member == nil {
|
|
cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists", nil)
|
|
return
|
|
}
|
|
membersCount := guild.GetMembersCount()
|
|
// 解散公会
|
|
if membersCount <= 1 {
|
|
gm.Disband(accountId, cb)
|
|
return
|
|
}
|
|
|
|
// 重新选举公长
|
|
if accountId == guild.LeaderId {
|
|
newLeader := guild.NewLeader(accountId)
|
|
if newLeader == nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, "error", nil)
|
|
return
|
|
}
|
|
f5.GetSysLog().Info("LeaveGuild guildId:%d, newLeader:%s", guild.GuildId, newLeader.AccountId)
|
|
|
|
updateFields := [][]string{
|
|
{"leader_account_id", q5.ToString(newLeader.AccountId)},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
guild.LeaderId = newLeader.AccountId
|
|
|
|
// 新会长
|
|
newMemberFields := [][]string{{"level", q5.ToString(newLeader.Level)}}
|
|
gm.updateGuildMember(guild, newLeader.AccountId, newMemberFields,
|
|
func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
|
|
gm.updateGuildMember(guild, member.AccountId, fields,
|
|
func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
guild.RemoveMember(accountId)
|
|
gm.RemoveUserGuild(accountId)
|
|
|
|
// Add logs
|
|
logContent := fmt.Sprintf("MemberCount[%d]", guild.GetMembersCount())
|
|
gm.WriteLog(guild.GuildId, accountId, LogTypeLeave, logContent)
|
|
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guild.GuildId)
|
|
prop["members_count"] = q5.ToString(guild.GetMembersCount())
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
accountId,
|
|
"127.0.0.1",
|
|
EVENT_LEAVE,
|
|
prop,
|
|
)
|
|
cb(ERR_CODE_OK, "LeaveGuild OK", guild)
|
|
})
|
|
}
|
|
|
|
// DismissMember 开除成员 踢出
|
|
func (gm *GuildMgr) DismissMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "DismissMember guild no exists", nil)
|
|
return
|
|
}
|
|
|
|
if accountId == guild.LeaderId || accountId == operatorAccountId {
|
|
cb(ERR_CODE_GUILD_BLOCKED_LEADER, "DismissMember Blocked leader", nil)
|
|
return
|
|
}
|
|
|
|
// 公会干部及以上仅可操作
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
err := gm.CheckOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
|
|
if err != nil {
|
|
cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "DismissMember operator member no perm", nil)
|
|
return
|
|
}
|
|
|
|
dismissMember := guild.GetMember(accountId)
|
|
if dismissMember == nil {
|
|
cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists", nil)
|
|
return
|
|
}
|
|
|
|
if dismissMember.Level <= operatorMember.Level {
|
|
cb(ERR_CODE_GUILD_DISMISS_MEMBER_NO_PERM, "Approve dismiss member no perm", nil)
|
|
return
|
|
}
|
|
|
|
fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
|
|
gm.updateGuildMember(guild, dismissMember.AccountId, fields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
guild.RemoveMember(accountId)
|
|
gm.RemoveUserGuild(accountId)
|
|
// Add logs
|
|
logContent := fmt.Sprintf("DismissMember[%d-%s-%s]", guild.GuildId, operatorAccountId, accountId)
|
|
gm.WriteLog(guild.GuildId, accountId, LogTypeDismiss, logContent)
|
|
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guild.GuildId)
|
|
prop["accountId"] = q5.ToString(accountId)
|
|
prop["members_count"] = q5.ToString(guild.GetMembersCount())
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
operatorAccountId,
|
|
"127.0.0.1",
|
|
EVENT_DISMISS_MEMBER,
|
|
prop,
|
|
)
|
|
|
|
cb(ERR_CODE_OK, "DismissMember OK", guild)
|
|
})
|
|
}
|
|
|
|
// SetMemberLevel 设置公会成员等级
|
|
func (gm *GuildMgr) SetMemberLevel(operatorAccountId, accountId string, newLevel int32, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
// 干部, 精英, 副会长
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "SetMemberLevel guild no exists", nil)
|
|
return
|
|
}
|
|
|
|
if accountId == guild.LeaderId || accountId == operatorAccountId {
|
|
cb(ERR_CODE_GUILD_BLOCKED_LEADER, "SetMemberLevel no operate your self account", nil)
|
|
return
|
|
}
|
|
|
|
member := guild.GetMember(accountId)
|
|
if member == nil {
|
|
cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists", nil)
|
|
return
|
|
}
|
|
|
|
beforeLevel := member.Level
|
|
if member.Level == newLevel {
|
|
cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "SetMemberLevel error", nil)
|
|
return
|
|
}
|
|
|
|
// 副会长上限2个
|
|
if newLevel == GuildMemberLevelViceLeader && guild.GetMembersViceLeaderCount() >= MaxMembersViceLeader {
|
|
cb(ERR_CODE_GUILD_SETMEMBERLEVEL_VICE_LEADER_MAX_LIMIT, "SetMemberLevel Vice leader max limit", nil)
|
|
return
|
|
}
|
|
|
|
fields := [][]string{{"level", q5.ToString(newLevel)}}
|
|
gm.updateGuildMember(guild, member.AccountId, fields, nil)
|
|
member.Level = newLevel
|
|
|
|
// 转让公长
|
|
if newLevel == GuildMemberLevelLeader {
|
|
updateFields := [][]string{
|
|
{"leader_account_id", q5.ToString(member.AccountId)},
|
|
}
|
|
gm.updateGuild(guild, updateFields, nil)
|
|
guild.LeaderId = member.AccountId
|
|
|
|
oldMember := guild.GetMember(operatorAccountId)
|
|
oldMemberFields := [][]string{{"level", q5.ToString(GuildMemberLevelDefault)}}
|
|
gm.updateGuildMember(guild, oldMember.AccountId, oldMemberFields, nil)
|
|
oldMember.Level = GuildMemberLevelDefault
|
|
}
|
|
|
|
logContent := fmt.Sprintf("SetMemberLevel[%d-%s-%s-%d-%d]", guild.GuildId, operatorAccountId, accountId, beforeLevel, newLevel)
|
|
gm.WriteLog(guild.GuildId, accountId, LogTypeChangeLevel, logContent)
|
|
|
|
// Add event
|
|
prop := map[string]string{
|
|
"guild_id": q5.ToString(guild.GuildId),
|
|
"accountId": q5.ToString(accountId),
|
|
"beforeMemberLevel": q5.ToString(beforeLevel),
|
|
"afterMemberLevel": q5.ToString(newLevel),
|
|
"members_count": q5.ToString(guild.GetMembersCount()),
|
|
}
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
operatorAccountId,
|
|
"127.0.0.1",
|
|
EVENT_SET_MEMBER_LEVEL,
|
|
prop,
|
|
)
|
|
|
|
cb(ERR_CODE_OK, "SetMemberLevel OK", guild)
|
|
|
|
// 转让公长
|
|
//if newLevel == GuildMemberLevelLeader {
|
|
// updateFields := [][]string{
|
|
// {"leader_account_id", q5.ToString(guild.LeaderId)},
|
|
// }
|
|
// gm.updateGuild(guild, updateFields, nil)
|
|
// guild.LeaderId = member.AccountId
|
|
// oldMember := guild.GetMember(operatorAccountId)
|
|
// oldMemberFields := [][]string{{"level", q5.ToString(GuildMemberLevelDefault)}}
|
|
// gm.updateGuildMember(guild, oldMember.AccountId, oldMemberFields, nil)
|
|
// oldMember.Level = GuildMemberLevelDefault
|
|
//}
|
|
//
|
|
//gm.updateGuildMember(guild, member.AccountId, fields, func(err error) {
|
|
// if err != nil {
|
|
// cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
|
|
// return
|
|
// }
|
|
//
|
|
// // 转让会长的操作
|
|
// if newLevel == GuildMemberLevelLeader {
|
|
// updateFields := [][]string{
|
|
// {"leader_account_id", q5.ToString(member.AccountId)},
|
|
// }
|
|
// gm.updateGuild(guild, updateFields, func(err error) {
|
|
// if err != nil {
|
|
// cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
|
|
// return
|
|
// }
|
|
// guild.LeaderId = member.AccountId
|
|
// // 旧会长 -> 普通成员
|
|
// oldMember := guild.GetMember(operatorAccountId)
|
|
// oldMemberFields := [][]string{{"level", q5.ToString(GuildMemberLevelDefault)}}
|
|
// gm.updateGuildMember(guild, oldMember.AccountId, oldMemberFields,
|
|
// func(err error) {
|
|
// if err != nil {
|
|
// cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
|
|
// return
|
|
// }
|
|
// oldMember.Level = GuildMemberLevelDefault
|
|
// })
|
|
// })
|
|
// }
|
|
//
|
|
// newMemberFields := [][]string{{"level", q5.ToString(newLevel)}}
|
|
// gm.updateGuildMember(guild, member.AccountId, newMemberFields,
|
|
// func(err error) {
|
|
// if err != nil {
|
|
// cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
|
|
// return
|
|
// }
|
|
// member.Level = newLevel
|
|
// })
|
|
//
|
|
// logContent := fmt.Sprintf("SetMemberLevel[%d-%s-%s-%d-%d]", guild.GuildId, operatorAccountId, accountId, beforeLevel, newLevel)
|
|
// gm.WriteLog(guild.GuildId, accountId, LogTypeChangeLevel, logContent)
|
|
//
|
|
// // Add event
|
|
// prop := make(map[string]string)
|
|
// prop["guild_id"] = q5.ToString(guild.GuildId)
|
|
// prop["accountId"] = q5.ToString(accountId)
|
|
// prop["beforeMemberLevel"] = q5.ToString(beforeLevel)
|
|
// prop["afterMemberLevel"] = q5.ToString(newLevel)
|
|
// prop["members_count"] = q5.ToString(guild.GetMembersCount())
|
|
// f5.GetTgLog().AddTrackLog(
|
|
// GAME_ID,
|
|
// operatorAccountId,
|
|
// "127.0.0.1",
|
|
// EVENT_SET_MEMBER_LEVEL,
|
|
// prop,
|
|
// )
|
|
//
|
|
// cb(ERR_CODE_OK, "SetMemberLevel OK")
|
|
//})
|
|
}
|
|
|
|
// Disband 解散公会
|
|
func (gm *GuildMgr) Disband(operatorAccountId string, cb func(errCode int32, errMsg string, guild *Guild)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(ERR_CODE_GUILD_NO_EXISTS, "Disband guild no exists", nil)
|
|
return
|
|
}
|
|
|
|
// 仅会长可操作
|
|
if operatorAccountId != guild.LeaderId {
|
|
cb(ERR_CODE_GUILD_NO_LEADER_PERM, "Disband only leader perm", nil)
|
|
return
|
|
}
|
|
guildId := guild.GuildId
|
|
guildName := guild.Name
|
|
|
|
// 解散公会
|
|
updateFields := [][]string{
|
|
{"is_deleted", q5.ToString(1)},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
|
|
gm.updateGuildMembers(guildId, fields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
gm.updateAllPendingReqs(guildId, PendingReqIsJoinGuildStatusDisband, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, err.Error(), nil)
|
|
return
|
|
}
|
|
logContent := fmt.Sprintf("GuildDisbanded[%d-%s]", guildId, guildName)
|
|
gm.WriteLog(guildId, operatorAccountId, LogTypeDisband, logContent)
|
|
|
|
// delete user guilds
|
|
for _, member := range guild.Members {
|
|
delete(gm.userGuilds, member.AccountId)
|
|
}
|
|
guild.Members = nil
|
|
delete(gm.guilds, guildId)
|
|
delete(gm.guildLogs, guildId)
|
|
gm.RemoveGuild(guildId)
|
|
|
|
// Add event
|
|
prop := make(map[string]string)
|
|
prop["guild_id"] = q5.ToString(guild.GuildId)
|
|
f5.GetTgLog().AddTrackLog(
|
|
GAME_ID,
|
|
operatorAccountId,
|
|
"127.0.0.1",
|
|
EVENT_DISBAND,
|
|
prop,
|
|
)
|
|
|
|
cb(ERR_CODE_OK, "Disband ok", guild)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
func (gm *GuildMgr) CheckGuildAndPermission(operatorAccountId string) (*Guild, bool) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
return nil, false
|
|
}
|
|
if operatorAccountId != guild.LeaderId {
|
|
return nil, false
|
|
}
|
|
return guild, true
|
|
}
|
|
|
|
func (gm *GuildMgr) SetAvatar(operatorAccountId string, avatar int32, cb func(errCode int32, errMsg string)) {
|
|
guild, ok := gm.CheckGuildAndPermission(operatorAccountId)
|
|
if !ok || guild.Avatar == avatar {
|
|
cb(ERR_CODE_REQUEST_PARAMS_ERROR, "params is null")
|
|
return
|
|
}
|
|
|
|
updateFields := [][]string{
|
|
{"avatar", q5.ToString(avatar)},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
|
|
return
|
|
}
|
|
guild.Avatar = avatar
|
|
|
|
cb(ERR_CODE_OK, "SetNotice OK")
|
|
})
|
|
}
|
|
|
|
func (gm *GuildMgr) SetName(operatorAccountId string, name *string, cb func(errCode int32, errMsg string)) {
|
|
guild, ok := gm.CheckGuildAndPermission(operatorAccountId)
|
|
if !ok || name == nil || guild.Name == *name {
|
|
cb(ERR_CODE_REQUEST_PARAMS_ERROR, "params is null")
|
|
return
|
|
}
|
|
|
|
updateFields := [][]string{
|
|
{"name", *name},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
|
|
return
|
|
}
|
|
guild.Name = *name
|
|
|
|
cb(ERR_CODE_OK, "SetNotice OK")
|
|
})
|
|
}
|
|
|
|
// SetNotice 设置公告
|
|
func (gm *GuildMgr) SetNotice(operatorAccountId string, notice *string, cb func(errCode int32, errMsg string)) {
|
|
guild, ok := gm.CheckGuildAndPermission(operatorAccountId)
|
|
if !ok || notice == nil || guild.Notice == *notice {
|
|
cb(ERR_CODE_REQUEST_PARAMS_ERROR, "params is null")
|
|
return
|
|
}
|
|
|
|
updateFields := [][]string{
|
|
{"notice", *notice},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
|
|
return
|
|
}
|
|
guild.Notice = *notice
|
|
cb(ERR_CODE_OK, "SetNotice OK")
|
|
})
|
|
}
|
|
|
|
// SetJoinCond 请求设置公会加入条件
|
|
func (gm *GuildMgr) SetJoinCond(operatorAccountId string, joinCond, joinCondValue int32, cb func(errCode int32, errMsg string)) {
|
|
guild, ok := gm.CheckGuildAndPermission(operatorAccountId)
|
|
if !ok {
|
|
cb(ERR_CODE_REQUEST_PARAMS_ERROR, "params is null")
|
|
return
|
|
}
|
|
|
|
updateFields := [][]string{
|
|
{"join_cond", q5.ToString(joinCond)},
|
|
{"join_cond_value", q5.ToString(0)},
|
|
}
|
|
if joinCond == JoinCondStar {
|
|
updateFields = [][]string{
|
|
{"join_cond", q5.ToString(joinCond)},
|
|
{"join_cond_value", q5.ToString(joinCondValue)},
|
|
}
|
|
} else {
|
|
joinCondValue = 0
|
|
}
|
|
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
|
|
return
|
|
}
|
|
guild.JoinCond = joinCond
|
|
guild.JoinCondValue = joinCondValue
|
|
cb(ERR_CODE_OK, "SetJoinCond OK")
|
|
})
|
|
}
|
|
|
|
// WriteLog 记录公会日志
|
|
func (gm *GuildMgr) WriteLog(guildId int64, accountId string, logType int32, content string) {
|
|
guild := gm.GetGuild(guildId)
|
|
if guild == nil {
|
|
return
|
|
}
|
|
|
|
_, exists := gm.guildLogs[guildId]
|
|
if !exists {
|
|
gm.guildLogs[guildId] = make([]*GuildLog, DefaultLogs)
|
|
}
|
|
log := &GuildLog{
|
|
GuildId: guildId,
|
|
AccountId: accountId,
|
|
LogType: logType,
|
|
Content: content,
|
|
}
|
|
gm.guildLogs[guildId] = append(gm.guildLogs[guildId], log)
|
|
gm.insertGuildLog(log)
|
|
}
|
|
|
|
func (gm *GuildMgr) GetLogs(guildID int64) []*GuildLog {
|
|
return gm.guildLogs[guildID]
|
|
}
|
|
|
|
// SearchGuild 根据关键字搜索公会
|
|
func (gm *GuildMgr) SearchGuild(sinceId int64, name string, cb func(errCode int32, errMsg string, lastId int64, guildIds []int64)) {
|
|
gm.findGuildIdsByName(sinceId, name, func(err error, lastId int64, guildIds []int64) {
|
|
if err != nil {
|
|
cb(ERR_CODE_SEARCH_USERS_DB_FAIL, "SearchUsers username db error", sinceId, guildIds)
|
|
return
|
|
}
|
|
if len(guildIds) <= 0 {
|
|
cb(ERR_CODE_SEARCH_NO_RESULT, "SearchGuilds result is empty", lastId, guildIds)
|
|
}
|
|
cb(0, "OK", lastId, guildIds)
|
|
})
|
|
}
|
|
|
|
// RandomGuilds 随机10个公会
|
|
func (gm *GuildMgr) RandomGuilds() []*Guild {
|
|
count := len(gm.guilds)
|
|
|
|
var results []*Guild
|
|
if count <= RandomGuildCount {
|
|
for _, guildId := range gm.guildIds {
|
|
results = append(results, gm.guilds[guildId])
|
|
}
|
|
return results
|
|
}
|
|
|
|
for i := 0; i < RandomGuildCount; i++ {
|
|
j := rand.Intn(len(gm.guildIds))
|
|
gm.guildIds[i], gm.guildIds[j] = gm.guildIds[j], gm.guildIds[i]
|
|
}
|
|
for i := 0; i < RandomGuildCount; i++ {
|
|
randGuildId := gm.guildIds[i]
|
|
results = append(results, gm.guilds[randGuildId])
|
|
}
|
|
return results
|
|
}
|
|
|
|
func (gm *GuildMgr) CheckOperatorPerm(operatorMember *GuildMember, level int32) error {
|
|
if operatorMember == nil || operatorMember.Level > level {
|
|
return fmt.Errorf("CheckOperatorPerm: no permission[%s-%d]", operatorMember.AccountId, operatorMember.Level)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (gm *GuildMgr) ExistsGuild(guildId int64) bool {
|
|
_, ok := gm.guilds[guildId]
|
|
return ok
|
|
}
|
|
|
|
func (gm *GuildMgr) AddUserGuild(accountId string, guildId int64) {
|
|
gm.userGuilds[accountId] = guildId
|
|
}
|
|
|
|
func (gm *GuildMgr) RemoveUserGuild(accountId string) {
|
|
delete(gm.userGuilds, accountId)
|
|
}
|
|
|
|
func (gm *GuildMgr) AddGuild(guildId int64, guild *Guild) {
|
|
if _, exists := gm.guilds[guildId]; !exists {
|
|
gm.guilds[guildId] = guild
|
|
gm.guildIds = append(gm.guildIds, guildId)
|
|
}
|
|
}
|
|
|
|
func (gm *GuildMgr) GetGuild(guildId int64) *Guild {
|
|
if guild, exists := gm.guilds[guildId]; exists {
|
|
return guild
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (gm *GuildMgr) GetGuildByAccountId(accountId string) *Guild {
|
|
if guildId, exists := gm.userGuilds[accountId]; exists {
|
|
if guild, exists2 := gm.guilds[guildId]; exists2 {
|
|
return guild
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (gm *GuildMgr) GetGuildIdByAccountId(accountId string) int64 {
|
|
if guildId, exists := gm.userGuilds[accountId]; exists {
|
|
return guildId
|
|
}
|
|
return -1
|
|
}
|
|
|
|
func (gm *GuildMgr) CheckJoinGuild(accountId string) bool {
|
|
_, exists := gm.userGuilds[accountId]
|
|
return exists
|
|
}
|
|
|
|
func (gm *GuildMgr) loadGuildIds() {
|
|
gm.guildIds = make([]int64, 0, len(gm.guilds))
|
|
for guildId := range gm.guilds {
|
|
gm.guildIds = append(gm.guildIds, guildId)
|
|
}
|
|
}
|
|
|
|
func (gm *GuildMgr) RemoveGuild(guildId int64) {
|
|
guildIndex := -1
|
|
for i, gId := range gm.guildIds {
|
|
if gId == guildId {
|
|
guildIndex = i
|
|
}
|
|
}
|
|
if guildIndex < 0 {
|
|
return
|
|
}
|
|
copy(gm.guildIds[guildIndex:], gm.guildIds[guildIndex+1:])
|
|
gm.guildIds[len(gm.guildIds)-1] = 0
|
|
gm.guildIds = gm.guildIds[:len(gm.guildIds)-1]
|
|
}
|
|
|
|
func (gm *GuildMgr) GetGuildLogs(guildId int64) []*GuildLog {
|
|
if logs, exists := gm.guildLogs[guildId]; exists {
|
|
return logs
|
|
}
|
|
return nil
|
|
}
|