650 lines
15 KiB
Go
650 lines
15 KiB
Go
package main
|
|
|
|
import (
|
|
"cs"
|
|
"f5"
|
|
"fmt"
|
|
"math/rand"
|
|
"q5"
|
|
)
|
|
|
|
const (
|
|
LoadGuildFlag = iota
|
|
LoadGuildMemberFlag
|
|
LoadGuildReqFlag
|
|
LoadGuildLogFlag
|
|
)
|
|
|
|
type GuildMgr struct {
|
|
cs.MsgHandlerImpl
|
|
guildIds []int64 // 公会列表 guild ids
|
|
guilds map[int64]*Guild // 公会ID -> 公会
|
|
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.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()
|
|
// 加载公会ids
|
|
gm.loadGuildIds()
|
|
//for gm.loadedFlags != 0 {
|
|
// time.Sleep(time.Millisecond * 1000)
|
|
//}
|
|
}
|
|
|
|
// CreateGuild 创建公会
|
|
func (gm *GuildMgr) CreateGuild(name string, leaderId string,
|
|
cb func(errCode int32, errMsg string, guildId int64)) {
|
|
if !gm.CheckJoinGuild(leaderId) {
|
|
cb(1, "xxx", 0)
|
|
return
|
|
}
|
|
|
|
guildId := f5.GetApp().NewUuid()
|
|
if gm.ExistsGuild(guildId) {
|
|
cb(1, "xxx", 0)
|
|
return
|
|
}
|
|
|
|
fields := [][]string{
|
|
{"guild_id", q5.ToString(guildId)},
|
|
{"name", name},
|
|
{"leader_account_id", leaderId},
|
|
{"max_members", q5.ToString(MaxMembers)},
|
|
}
|
|
f5.GetJsStyleDb().Insert(
|
|
FRIEND_DB,
|
|
"t_guild",
|
|
fields,
|
|
func(err error, id int64, affectedRows int64) {
|
|
if err != nil {
|
|
cb(1, "xxx", 0)
|
|
return
|
|
}
|
|
newMember := &GuildMember{accountId: leaderId, level: GuildMemberLevelLeader}
|
|
gm.upsertGuildMember(guildId, newMember,
|
|
func(err error) {
|
|
if err != nil {
|
|
cb(1, "xxx", 0)
|
|
return
|
|
}
|
|
guild := &Guild{
|
|
autoId: id,
|
|
guildId: guildId,
|
|
name: name,
|
|
leaderId: leaderId,
|
|
maxMembers: MaxMembers,
|
|
}
|
|
guild.members = append(guild.members, newMember)
|
|
gm.AddGuild(guildId, guild)
|
|
})
|
|
})
|
|
}
|
|
|
|
// ApplyToGuild 申请加入公会
|
|
func (gm *GuildMgr) ApplyToGuild(guildId int64, applicantAccountId string, cb func(errCode int32, errMsg string)) {
|
|
guild, err := gm.GetGuild(guildId)
|
|
if err != nil {
|
|
cb(1, "xxx")
|
|
}
|
|
|
|
// 是否加入其他公会
|
|
if !gm.CheckJoinGuild(applicantAccountId) {
|
|
cb(1, "xxx")
|
|
}
|
|
|
|
if guild.IsFull() {
|
|
cb(1, "xxx")
|
|
}
|
|
|
|
// 可直接加入
|
|
if guild.joinCond == JoinCondFree {
|
|
gm.JoinGuild(guild, applicantAccountId)
|
|
cb(0, "")
|
|
}
|
|
|
|
if guild.joinCond == JoinCondStar {
|
|
var userStar int32 = 200
|
|
if userStar >= guild.joinCondValue {
|
|
gm.JoinGuild(guild, applicantAccountId)
|
|
cb(0, "")
|
|
}
|
|
}
|
|
|
|
// 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 {
|
|
cb(0, "")
|
|
return
|
|
}
|
|
if rowsAffected <= 0 {
|
|
return
|
|
}
|
|
|
|
pendingReq := &PendingReq{
|
|
applicantAccountId,
|
|
PendingReqIsJoinGuildStatusDefault,
|
|
}
|
|
guild.AddPendingReq(pendingReq)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// Approve 同意申请者加入公会
|
|
func (gm *GuildMgr) Approve(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 通常默认为审核加入
|
|
if guild.joinCond != JoinCondDefault {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
if operatorMember == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 公会干部及以上仅可操作
|
|
err := gm.checkOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
|
|
if err != nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 是否加入其他公会
|
|
if !gm.CheckJoinGuild(accountId) {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if guild.IsFull() {
|
|
cb(1, "XXX")
|
|
}
|
|
guildId := guild.guildId
|
|
|
|
// 是否在申请队列中
|
|
pendingReqStatus := guild.GetPendingReqStatus(accountId)
|
|
if pendingReqStatus < 0 {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
newMember := &GuildMember{accountId: accountId, level: GuildMemberLevelDefault}
|
|
gm.upsertGuildMember(guildId, newMember, func(err error) {
|
|
if err != nil {
|
|
cb(1, "xxx")
|
|
return
|
|
}
|
|
guild.AddMember(newMember)
|
|
gm.AddUserGuild(accountId, guildId)
|
|
gm.updatePendingReqs(guildId, accountId, PendingReqIsJoinGuildStatusJoined, func(err error) {
|
|
logContent := fmt.Sprintf("Approve[operator:%s]", operatorAccountId)
|
|
gm.WriteLog(guildId, accountId, LogTypeApprove, logContent)
|
|
guild.RemovePendingReq(accountId)
|
|
cb(0, "")
|
|
})
|
|
})
|
|
}
|
|
|
|
// Reject 拒绝申请者加入公会
|
|
func (gm *GuildMgr) Reject(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
// 通常默认为审核加入
|
|
if guild.joinCond != JoinCondDefault {
|
|
cb(1, "XXX")
|
|
}
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
if operatorMember == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
// 公会干部及以上仅可操作
|
|
err := gm.checkOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
|
|
if err != nil {
|
|
cb(1, "XXX")
|
|
}
|
|
// 是否加入其他公会
|
|
if !gm.CheckJoinGuild(accountId) {
|
|
cb(1, "XXX")
|
|
}
|
|
// 是否在申请队列中
|
|
pendingReqStatus := guild.GetPendingReqStatus(accountId)
|
|
if pendingReqStatus < 0 {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
gm.updatePendingReqs(guild.guildId, accountId, PendingReqIsJoinGuildStatusReject, func(err error) {
|
|
guild.RemovePendingReq(accountId)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// JoinGuild 直接加入公会
|
|
func (gm *GuildMgr) JoinGuild(guild *Guild, accountId string) {
|
|
newMember := GuildMember{accountId: accountId, level: GuildMemberLevelDefault}
|
|
guildId := guild.guildId
|
|
gm.upsertGuildMember(guildId, &newMember,
|
|
func(err error) {
|
|
if err != nil {
|
|
guild.AddMember(&newMember)
|
|
gm.AddUserGuild(accountId, guildId)
|
|
}
|
|
})
|
|
}
|
|
|
|
// LeaveGuild 离开公会
|
|
func (gm *GuildMgr) LeaveGuild(accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(accountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
if guild.leaderId == accountId {
|
|
cb(1, "XXX")
|
|
}
|
|
member := guild.GetMember(accountId)
|
|
if member == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
|
|
gm.updateGuildMember(guild, member.accountId, fields,
|
|
func(err error) {
|
|
if err != nil {
|
|
cb(1, err.Error())
|
|
}
|
|
|
|
guild.RemoveMember(accountId)
|
|
gm.RemoveUserGuild(accountId)
|
|
// Add logs
|
|
logContent := fmt.Sprintf("LeaveGuild[%d-%s]", guild.guildId, accountId)
|
|
gm.WriteLog(guild.guildId, accountId, LogTypeLeave, logContent)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// DismissMember 开除成员 踢出
|
|
func (gm *GuildMgr) DismissMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if accountId == guild.leaderId || accountId == operatorAccountId {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
if operatorMember == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 公会干部及以上仅可操作
|
|
err := gm.checkOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
|
|
if err != nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
dismissMember := guild.GetMember(accountId)
|
|
if dismissMember == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if dismissMember.level <= operatorMember.level {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
|
|
gm.updateGuildMember(guild, dismissMember.accountId, fields, func(err error) {
|
|
if err != nil {
|
|
cb(1, err.Error())
|
|
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)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// PromoteMember 提升成员为干部
|
|
func (gm *GuildMgr) PromoteMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if accountId == guild.leaderId || accountId == operatorAccountId {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 仅会长操作
|
|
operatorMember := guild.GetMember(operatorAccountId)
|
|
if operatorMember == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if operatorAccountId != guild.leaderId {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
member := guild.GetMember(accountId)
|
|
if member == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if member.level == GuildMemberLevelViceLeader {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
fields := [][]string{{"level", q5.ToString(GuildMemberLevelViceLeader)}}
|
|
gm.updateGuildMember(guild, member.accountId, fields, func(err error) {
|
|
if err != nil {
|
|
cb(1, err.Error())
|
|
return
|
|
}
|
|
|
|
member.level = GuildMemberLevelViceLeader
|
|
logContent := fmt.Sprintf("PromoteMember[%d-%s-%s]", guild.guildId, operatorAccountId, accountId)
|
|
gm.WriteLog(guild.guildId, accountId, LogTypeDismiss, logContent)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// DemoteMember 解除成员干部身份
|
|
func (gm *GuildMgr) DemoteMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if accountId == guild.leaderId || accountId == operatorAccountId {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 仅会长可操作
|
|
if operatorAccountId != guild.leaderId {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
member := guild.GetMember(accountId)
|
|
if member == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
if member.level == GuildMemberLevelDefault {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
fields := [][]string{{"level", q5.ToString(GuildMemberLevelDefault)}}
|
|
gm.updateGuildMember(guild, member.accountId, fields, func(err error) {
|
|
if err != nil {
|
|
cb(1, err.Error())
|
|
return
|
|
}
|
|
|
|
member.level = GuildMemberLevelDefault
|
|
logContent := fmt.Sprintf("DemoteMember[%d-%s-%s]", guild.guildId, operatorAccountId, accountId)
|
|
gm.WriteLog(guild.guildId, accountId, LogTypeDismiss, logContent)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// Disband 解散公会
|
|
func (gm *GuildMgr) Disband(operatorAccountId string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 仅会长可操作
|
|
if operatorAccountId != guild.leaderId {
|
|
cb(1, "XXX")
|
|
}
|
|
guildId := guild.guildId
|
|
guildName := guild.name
|
|
|
|
// 解散公会
|
|
updateFields := [][]string{
|
|
{"is_deleted", q5.ToString(1)},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
|
|
gm.updateGuildMembers(guildId, fields, func(err error) {
|
|
gm.updateAllPendingReqs(guildId, PendingReqIsJoinGuildStatusDisband, func(err error) {
|
|
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)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
// SetNotice 设置公告
|
|
func (gm *GuildMgr) SetNotice(operatorAccountId string, notice *string, cb func(errCode int32, errMsg string)) {
|
|
guild := gm.GetGuildByAccountId(operatorAccountId)
|
|
if guild == nil {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
// 仅会长可操作
|
|
if operatorAccountId != guild.leaderId {
|
|
cb(1, "XXX")
|
|
}
|
|
|
|
updateFields := [][]string{
|
|
{"notice", *notice},
|
|
}
|
|
gm.updateGuild(guild, updateFields, func(err error) {
|
|
if err != nil {
|
|
cb(1, err.Error())
|
|
return
|
|
}
|
|
guild.SetNotice(notice)
|
|
cb(0, "")
|
|
})
|
|
}
|
|
|
|
// WriteLog 记录公会日志
|
|
func (gm *GuildMgr) WriteLog(guildId int64, accountId string, logType int32, content string) {
|
|
_, err := gm.GetGuild(guildId)
|
|
if err != 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]
|
|
}
|
|
|
|
// SearchGuilds 根据关键字搜索公会
|
|
func (gm *GuildMgr) SearchGuilds(keyword string) []*Guild {
|
|
var results []*Guild
|
|
for _, guild := range gm.guilds {
|
|
if containsSubstring(guild.name, keyword) {
|
|
results = append(results, guild)
|
|
}
|
|
}
|
|
return results
|
|
}
|
|
|
|
// 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 int) error {
|
|
if 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, error) {
|
|
if guild, exists := gm.guilds[guildId]; exists {
|
|
return guild, nil
|
|
}
|
|
return nil, fmt.Errorf("guild not found")
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func containsSubstring(s, substr string) bool {
|
|
return len(s) >= len(substr) && s[len(s)-len(substr):] == substr
|
|
}
|