public async Task HandleRoleReactionAdded(GuildEntity guild, SocketReaction reaction)
{
ulong guildId = Convert.ToUInt64(guild.Id);
if (!_rolesUsedByGuild.ContainsKey(guildId))
{
return;
}
if (!_rolesUsedByGuild[guildId].Contains(reaction.Emote.Name))
{
return;
}
ulong roleId = (ulong)_roleByEmojiName[reaction.Emote.Name].GetValue(guild);
if (roleId == default)
{
return;
}
var user = reaction.User.GetValueOrDefault();
if (user == null || !(user is SocketGuildUser socketUser))
{
return;
}
string rolebanId = $"{user.Id}-{roleId}-RoleBan";
var roleBan = _databaseHandler.Get <CaseEntity>(rolebanId);
if (roleBan is { })
private void ReConnectToRelayServer()
{
if (this.ConnectToRelayServer())
{
if (base.Entities == null || base.Entities.Count <IEntity>() <= 0)
{
return;
}
foreach (IEntity entity in base.Entities)
{
if (entity != null && entity.Tag != null && entity.Tag is GuildEntity)
{
GuildEntity guildEntity = entity.Tag as GuildEntity;
if (guildEntity != null && guildEntity.ChatRoom != null)
{
this.ChatRelay.SendMemberInfo(guildEntity.ChatRoom.GuildID, this.GetGameMembers(guildEntity.ChatRoom.GuildID), true);
this.ChatRelay.RequestMemberInfos(guildEntity.GuildID);
}
}
else
{
Log <GuildService> .Logger.ErrorFormat("Detect GuildEntity is null in ReconnectToRelayServer()", new object[0]);
}
}
}
}
public bool AcceptJoin(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, bool accept)
{
Log <GuildAPI> .Logger.InfoFormat("AcceptJoin: GuildMemberRank[{0}]", operatorRank);
if (!operatorRank.HasAcceptJoinPermission(targetMember.Rank))
{
return(false);
}
if (accept)
{
Log <GuildAPI> .Logger.InfoFormat("UserJoinApply: GuildSN[{0}], NexonSN[{1}], CharacterSN[{2}], CharacterName[{3}]", new object[]
{
guild.GuildSN,
targetMember.Key.NexonSN,
targetMember.Key.CharacterSN,
targetMember.Key.CharacterName
});
HeroesGuild.UserJoinApply(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName);
return(true);
}
Log <GuildAPI> .Logger.InfoFormat("UserJoinReject: GuildSN[{0}], NexonSN[{1}], CharacterSN[{2}], CharacterName[{3}]", new object[]
{
guild.GuildSN,
targetMember.Key.NexonSN,
targetMember.Key.CharacterSN,
targetMember.Key.CharacterName
});
HeroesGuild.UserJoinReject(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName);
return(true);
}
public bool ChangeRank(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, GuildMemberRank toRank)
{
Log <GuildAPI> .Logger.InfoFormat("ChangeRank: MemberRank[{0}], MemberSN[{1}], ToRank[{2}]", operatorRank, targetMember.Key.NexonSN, toRank);
if (toRank == GuildMemberRank.Unknown)
{
if (operatorRank.HasSecedePermission(targetMember.Rank, toRank))
{
Log <GuildAPI> .Logger.InfoFormat("UserSecede: ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN);
HeroesGuild.UserSecede(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName);
using (HeroesDataContext heroesDataContext = new HeroesDataContext())
{
heroesDataContext.UpdateGuildCharacterInfo(new long?(targetMember.Key.CID), new long?(0L));
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.GainGuildPoint, GuildLedgerEventType.UpdateGuildUserPoint, "0", "Secede"));
}
return(true);
}
}
else if (operatorRank.HasRankChangePermission(targetMember.Rank, toRank))
{
Log <GuildAPI> .Logger.InfoFormat("UserTypeModify: ServiceCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN);
HeroesGuild.UserTypeModify(GuildAPI.ServerCode, guild.GuildSN, targetMember.Key.NexonSN, targetMember.Key.CharacterSN, targetMember.Key.CharacterName, this.ConvertToGroupUserType(toRank.ToGroupUserType()));
return(true);
}
return(false);
}
public bool CloseGuild(GuildEntity guild, GuildMemberKey key)
{
if (guild == null || key == null)
{
Log <HeroesGuildAPI> .Logger.ErrorFormat("parameter is null in CloseGuild()", new object[0]);
return(false);
}
int num = -1;
try
{
Log <HeroesGuildAPI> .Logger.InfoFormat("Remove: GuildMemberKey[{0}]", key);
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
num = heroesGuildDBDataContext.GuildRemove(new int?(GuildAPI.ServerCode), new int?(key.NexonSN), new int?(guild.GuildSN));
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Remove(CloseGuild) Error: ", ex);
}
if (num == 0)
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, key.CID, OperationType.HeroesCore_CloseGuild, GuildLedgerEventType.Success, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString())));
}
else
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, key.CID, OperationType.HeroesCore_CloseGuild, GuildLedgerEventType.DatabaseFail, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString())));
}
return(num == 0);
}
protected override IEntity MakeEntity(long id, string category)
{
IEntity entity = base.MakeEntity(id, category);
GuildEntity guildEntity = new GuildEntity(this, entity, id);
guildEntity.NewbieRecommendChanged += new EventHandler(this.GuildEntity_UpdateNewbieRecommend);
entity.Tag = guildEntity;
guildEntity.Entity = entity;
entity.Closed += new EventHandler((object sender, EventArgs e) =>
{
this.OnlineGuildIDList.Remove(id);
this.NewbieRecommendGuild.Remove(id);
GuildEntity tag = entity.Tag as GuildEntity;
if (tag != null)
{
tag.Close();
}
Log <GuildService> .Logger.WarnFormat("<GID : {0}> guildEntity closed...", entity.ID);
});
entity.Closed += new EventHandler(this.Entity_Closed);
entity.Used += new EventHandler <EventArgs <IEntityAdapter> >((object sender, EventArgs <IEntityAdapter> e) =>
{
if (entity.UseCount == 0)
{
entity.Close();
}
});
this.OnlineGuildIDList.Add(id);
Log <GuildService> .Logger.WarnFormat("<GID : {0}> guildEntity makeEntity...", entity.ID);
return(entity);
}
public void JoinWebChatMember(HeroesGuildChatRelay server, ChatJoinEventArg arg)
{
if (!FeatureMatrix.IsEnable("UseHeroesGuildChatServer"))
{
arg.Callback(null, arg.AsyncResult);
}
Log <GuildService> .Logger.InfoFormat("JoinWebChatMember is called. [ {0}, {1}, {2} ]", arg.GuildKey, arg.CID, arg.Sender);
IEntity entityByID = base.GetEntityByID(arg.GuildKey);
if (entityByID != null && entityByID.Tag is GuildEntity)
{
Log <GuildService> .Logger.InfoFormat("JoinWebChatMember is called. [ {0}, {1}, {2}, found ]", arg.GuildKey, arg.CID, arg.Sender);
GuildEntity entity = entityByID.Tag as GuildEntity;
if (this.DoJoinWebChatMember(entity, server, arg))
{
arg.Callback(this.GetGameMembers(arg.GuildKey), arg.AsyncResult);
return;
}
Log <GuildService> .Logger.WarnFormat("JoinWebChatMember(). DoJoinWebChatMember is failed [ {0}, {1}, {2} ]", arg.GuildKey, arg.CID, arg.Sender);
}
else
{
Log <GuildService> .Logger.InfoFormat("JoinWebChatMember(). cannot find guild entity [ {0}, {1}, {2} ]", arg.GuildKey, arg.CID, arg.Sender);
}
arg.Callback(null, arg.AsyncResult);
}
public override IEnumerable <object> Run()
{
this.Finished = true;
for (int i = 0; i < 3; ++i)
{
if (this.service.NewbieRecommendGuild.Count == 0)
{
yield return((object)new FailMessage("[FindNewbieRecommendGuildProcessor] service.NewbieRecommendGuild.Count"));
yield break;
}
else
{
int selectedIndex = FindNewbieRecommendGuildProcessor.randomIndex.Next(this.service.NewbieRecommendGuild.Count - 1);
long guildID = this.service.NewbieRecommendGuild[selectedIndex];
IEntity entity = this.service.GetEntityByID(guildID);
if (entity != null)
{
GuildEntity guild = entity.Tag as GuildEntity;
if (guild != null && guild.GuildInfo != null && (guild.GuildInfo.IsNewbieRecommend && guild.OnlineMembers.Count != 0))
{
yield return((object)guild.GuildInfo);
yield break;
}
else
{
this.service.NewbieRecommendGuild.Remove(guildID);
}
}
}
}
yield return((object)new FailMessage("[FindNewbieRecommendGuildProcessor] fail"));
}
public void ResetOnlineGuildDailyGPScheduleFunc()
{
HeroesDataContext heroesDataContext = new HeroesDataContext();
List <long> list = new List <long>(this.OnlineGuildIDList);
GuildGainGPMessage guildGainGPMessage = new GuildGainGPMessage(0L);
foreach (long id in list)
{
IEntity entityByID = base.GetEntityByID(id);
if (entityByID != null && !entityByID.IsClosed)
{
GuildEntity guildEntity = entityByID.Tag as GuildEntity;
if (entityByID != null)
{
heroesDataContext.ResetInGameGuildDailyGainGP(guildEntity.GuildSN);
guildEntity.GuildInfo.DailyGainGP.Clear();
guildGainGPMessage.GuildPoint = guildEntity.GuildInfo.GuildPoint;
foreach (OnlineGuildMember onlineGuildMember in guildEntity.OnlineMembers.Values)
{
onlineGuildMember.RequestFrontendOperation(SendPacket.Create <GuildGainGPMessage>(guildGainGPMessage));
}
}
}
}
DateTime d = GuildContents.GetPrevDailyGPResetTime() + TimeSpan.FromDays(1.0);
this.DailyGPResetScheduleID = Scheduler.Schedule(JobProcessor.Current, Job.Create(new Action(this.ResetOnlineGuildDailyGPScheduleFunc)), d - DateTime.UtcNow + TimeSpan.FromSeconds(30.0));
}
public HeroesGuildMemberInfo GetMemberInfo(GuildEntity guild, GuildMemberKey key)
{
HeroesGuildMemberInfo result;
try
{
Log <GuildAPI> .Logger.InfoFormat("GroupMemberGetInfo: ServerCode[{0}], GuildSN[{1}], MemberNexonSN[{2}]", GuildAPI.ServerCode, guild.GuildSN, key.NexonSN);
GroupMemberInfo groupMemberInfo = HeroesGuild.GroupMemberGetInfo(GuildAPI.ServerCode, guild.GuildSN, key.CharacterSN, key.CharacterName);
HeroesGuildUserType value = this.ConvertToHeroesGuildUserType(groupMemberInfo.emGroupUserType);
if (value.ToGuildMemberRank().IsInvalid())
{
result = null;
}
else
{
result = new HeroesGuildMemberInfo(groupMemberInfo);
}
}
catch (GroupException ex)
{
if (ex.ErrorCode != 15)
{
Log <GuildService> .Logger.Error("GroupMemberGetInfo Error", ex);
}
result = null;
}
catch (Exception ex2)
{
Log <GuildService> .Logger.Error("GroupMemberGetInfo Error", ex2);
result = null;
}
return(result);
}
public OnlineGuildMember(GuildEntity parent, GuildMemberKey key, long fid)
{
this.Parent = parent;
this.Key = key;
this.FID = fid;
this.FrontendConn = GuildService.Instance.Connect(this.Parent.Entity, new Location
{
ID = fid,
Category = "FrontendServiceCore.FrontendService"
});
this.PlayerConn = GuildService.Instance.Connect(this.Parent.Entity, new Location
{
ID = key.CID,
Category = "PlayerService.PlayerService"
});
this.PlayerConn.Closed += delegate(object _, EventArgs <IEntityProxy> __)
{
Log <OnlineGuildMember> .Logger.WarnFormat("[{0}] Charater Logout Detected", this.Key.CharacterName);
GuildService.Instance.LeaveChatRoom(this);
this.Disconnect();
this.Parent.Disconnect(this.Key);
this.Parent.Sync();
};
this.CashShopConn = GuildService.Instance.Connect(this.Parent.Entity, new Location
{
ID = (long)key.NexonSN,
Category = "CashShopService.CashShopService"
});
this.Observables = new ObservableCollection();
this.BriefGuildInfoObservable = this.Observables.AddObservable(this.Key.CID, "BriefGuildInfo");
}
private GuildWebHookSettings GetWebHookSettings(SocketGuild guild, GuildEntity guildEntity)
{
return(new GuildWebHookSettings
{
Guild = guild,
#nullable enable
OutputChannel = new Dictionary <PostType, ITextChannel?> {
public void KickFromChatRoom(GuildEntity entity, GuildMemberKey key)
{
if (this.ChatRelay != null)
{
GuildChatWebMember guildChatWebMember = this.ChatRelay[key.CID];
if (guildChatWebMember != null)
{
Log <GuildService> .Logger.InfoFormat("KickFromChatRoom is called. [ {0} {1} {2} ]", guildChatWebMember.GuildID, guildChatWebMember.CID, guildChatWebMember.Sender);
this.ChatRelay.KickMember(guildChatWebMember.GuildID, guildChatWebMember.CID);
this.LeaveChatRoom(guildChatWebMember);
}
}
}
private void GuildEntity_UpdateNewbieRecommend(object sender, EventArgs arg)
{
GuildEntity guildEntity = sender as GuildEntity;
if (guildEntity != null && guildEntity.GuildInfo != null)
{
if (guildEntity.GuildInfo.IsNewbieRecommend && guildEntity.OnlineMembers.Count != 0)
{
this.NewbieRecommendGuild.Add(guildEntity.GuildID);
return;
}
this.NewbieRecommendGuild.Remove(guildEntity.GuildID);
}
}
public async void InitForGuild(SocketGuild guild, GuildEntity guildEntity)
{
if (_rolesUsedByGuild.ContainsKey(guild.Id))
{
_rolesUsedByGuild.Remove(guild.Id);
}
var list = new HashSet <string>();
_rolesUsedByGuild.Add(guild.Id, list);
foreach (var entry in _roleByEmojiName)
{
ulong roleId = (ulong)entry.Value.GetValue(guildEntity);
if (roleId == default)
{
continue;
}
list.Add(entry.Key);
}
if (!guildEntity.UseRolesCommandSystem)
{
var rolesChannelId = guildEntity.RolesRequestChannelId;
if (rolesChannelId == default)
{
return;
}
var rolesChannel = guild.GetTextChannel(rolesChannelId);
if (rolesChannel == null)
{
return;
}
var pinnedMessages = await rolesChannel.GetPinnedMessagesAsync();
if (pinnedMessages.Count == 0 || !pinnedMessages.Any(m => m.Author.Id == _botClient.CurrentUser.Id))
{
await CreateRoleReactionMessage(rolesChannel, guildEntity);
}
else
{
await EditRoleReactionMessage(rolesChannel.Guild.Id, pinnedMessages.Last() as RestUserMessage);
}
}
if (guildEntity.SupportRequestChannelInfoId != 0 && !string.IsNullOrWhiteSpace(guildEntity.SupportRequestInfo))
{
await AddSupportInfoChannel(guild, guildEntity.SupportRequestChannelInfoId, guildEntity.SupportRequestInfo);
}
}
public void LeaveChatRoom(IGuildChatMember member)
{
IEntity entityByID = base.GetEntityByID(member.GuildID);
if (entityByID != null && entityByID.Tag is GuildEntity)
{
GuildEntity guildEntity = entityByID.Tag as GuildEntity;
if (guildEntity != null && guildEntity.ChatRoom != null)
{
Log <GuildService> .Logger.InfoFormat("LeaveChatRoom is called. [ {0}, {1}, {2} ]", member.GuildID, member.CID, member.Sender);
guildEntity.ChatRoom.LeaveMember(member);
}
}
}
private string GetGameMembers(long guildID)
{
string result = "";
IEntity entityByID = base.GetEntityByID(guildID);
if (entityByID != null && entityByID.Tag != null)
{
GuildEntity guildEntity = entityByID.Tag as GuildEntity;
if (guildEntity != null)
{
result = string.Join(",", guildEntity.OnlineMembers.Keys.ToArray <string>());
}
}
return(result);
}
public bool GuildChatToGameClient(long gid, long cid, string senderName, string message, bool isFromClient)
{
IEntity entityByID = base.GetEntityByID(gid);
if (entityByID != null)
{
GuildEntity guildEntity = entityByID.Tag as GuildEntity;
if (guildEntity != null && guildEntity.ChatRoom != null)
{
guildEntity.ChatRoom.OnReceiveChatMessage(cid, senderName, message, isFromClient);
return(true);
}
}
return(false);
}
private void WebChat(HeroesGuildChatRelay server, ChatEventArg arg)
{
GuildChatWebMember guildChatWebMember = server[arg.CID];
if (guildChatWebMember != null)
{
IEntity entityByID = base.GetEntityByID(guildChatWebMember.GuildID);
if (entityByID != null)
{
GuildEntity guildEntity = entityByID.Tag as GuildEntity;
if (guildEntity != null && guildEntity.ChatRoom != null)
{
guildEntity.ChatRoom.OnReceiveChatMessage(guildChatWebMember.CID, guildChatWebMember.Sender, arg.Message, false);
}
}
}
}
public bool JoinChatRoomFromGame(GuildEntity entity, GuildMemberKey key)
{
Log <GuildService> .Logger.InfoFormat("JoinChatRoomFromGame is called", new object[0]);
if (entity != null)
{
OnlineGuildMember onlineMember = entity.GetOnlineMember(key.CID);
if (onlineMember != null)
{
Log <GuildService> .Logger.InfoFormat("JoinChatRoomFromGame onlineGuildMember is not null", new object[0]);
GuildChatRoom chatRoom = entity.ChatRoom;
return(chatRoom.JoinGameMember(onlineMember));
}
Log <GuildService> .Logger.WarnFormat("JoinChatRoomFromGame onlineGuildMember is null", new object[0]);
}
return(false);
}
public HeroesGuildMemberInfo GetMemberInfo(GuildEntity guild, GuildMemberKey key)
{
try
{
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
List <GuildGroupMemberGetInfoResult> source = heroesGuildDBDataContext.GuildGroupMemberGetInfo(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(key.CharacterSN), key.CharacterName).ToList <GuildGroupMemberGetInfoResult>();
GuildGroupMemberGetInfoResult guildGroupMemberGetInfoResult = source.FirstOrDefault <GuildGroupMemberGetInfoResult>();
if (source.Count <GuildGroupMemberGetInfoResult>() == 1 && guildGroupMemberGetInfoResult != null)
{
return(new HeroesGuildMemberInfo(guildGroupMemberGetInfoResult.CharacterName, (long)guildGroupMemberGetInfoResult.CharacterSN, (HeroesGuildUserType)guildGroupMemberGetInfoResult.emGroupUserType, guildGroupMemberGetInfoResult.GuildSN, guildGroupMemberGetInfoResult.Intro, guildGroupMemberGetInfoResult.NameInGroup, guildGroupMemberGetInfoResult.NexonSN));
}
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Error in GetMemberInfo(GuildEntity guild, GuildMemberKey key)", ex);
}
return(null);
}
public void SyncWebMember(HeroesGuildChatRelay server, ChatMemberSyncEventArg arg)
{
Log <GuildService> .Logger.InfoFormat("SyncWebMember is called. [ {0} ]", arg.GuildKey);
IEntity entityByID = base.GetEntityByID(arg.GuildKey);
if (entityByID != null && entityByID.Tag is GuildEntity)
{
Log <GuildService> .Logger.InfoFormat("SyncWebMember is called. [ {0}, found gid ]", arg.GuildKey);
GuildEntity guildEntity = entityByID.Tag as GuildEntity;
if (this.DoSyncWebMember(guildEntity, server, arg))
{
return;
}
Log <GuildService> .Logger.ErrorFormat("DoSyncWebMember is failed [{0}, {1}, {2}]", guildEntity.ToString(), server.ToString(), arg.ToString());
}
}
public void LeaveGuild(GuildEntity guild, GuildMemberKey key)
{
int num = -1;
try
{
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
num = heroesGuildDBDataContext.GuildUserSecede(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(key.NexonSN), new long?((long)key.CharacterSN), key.CharacterName);
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Error in LeaveGuild(GuildEntity guild, GuildMemberKey key)", ex);
}
if (num == 0)
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, key.CID, OperationType.HeroesCore_LeaveGuild, GuildLedgerEventType.Success, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString(), key.ToString())));
return;
}
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, key.CID, OperationType.HeroesCore_LeaveGuild, GuildLedgerEventType.DatabaseFail, string.Format("GuildSn: {0}, GuildToString: {1}", guild.GuildSN, guild.ToString(), key.ToString())));
}
private void CreateGitHubListenerForGuild(SocketGuild guild, GuildEntity guildEntity)
{
if (string.IsNullOrWhiteSpace(guildEntity.GitHubWebHookListenToUrl)) // || guildEntity.GitHubWebHookMessageChannelId == default)
{
return;
}
var settings = GetWebHookSettings(guild, guildEntity);
guildEntity.GithubListener = new GitHubListener(guildEntity.GitHubWebHookListenToUrl, settings, (msg, severity, ex) =>
{
if (ex != null)
{
settings.ErrorOutputChannel?.SendMessageAsync($"WebHook [{severity}]: {msg}:\n{ex}");
}
else
{
settings.ErrorOutputChannel?.SendMessageAsync($"WebHook [{severity}]: {msg}");
}
});
}
public bool ChangeMaster(GuildEntity guild, GuildMember newMaster, GuildMember oldMaster)
{
GuildMemberKey key = newMaster.Key;
HeroesGuildUserType value = GuildMemberRank.Operator.ToGroupUserType();
int num = -1;
try
{
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
num = heroesGuildDBDataContext.GuildGroupChangeMaster(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(key.NexonSN), new long?((long)key.CharacterSN), key.CharacterName, new int?((int)value));
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Error in ChangeMaster", ex);
}
if (num == 0)
{
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, newMaster.Key.CID, OperationType.HeroesCore_ChangeMaster, GuildLedgerEventType.Success, guild.GuildInfo.MasterName, newMaster.Key.CharacterName));
return(true);
}
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, newMaster.Key.CID, OperationType.HeroesCore_ChangeMaster, GuildLedgerEventType.DatabaseFail, guild.GuildInfo.MasterName, newMaster.Key.CharacterName));
return(false);
}
public bool ChangeMaster(GuildEntity guild, GuildMember newMaster, GuildMember oldMaster)
{
if (!FeatureMatrix.IsEnable("EnableChangeGuildMaster"))
{
return(false);
}
GuildMemberKey key = newMaster.Key;
Log <GuildAPI> .Logger.InfoFormat("ChangeMaster: Guild[{0}], newMasterKey[{1}], oldMasterKey[{2}]", guild.ToString(), key.ToString(), oldMaster.Key.ToString());
Log <GuildAPI> .Logger.InfoFormat("ChangeMaster: serverCode[{0}] guildSn[{1}] NexonSN[{2}] C_SN[{3}] Name[{4}] Rank[{5}]", new object[]
{
GuildAPI.ServerCode,
guild.GuildSN,
key.NexonSN,
key.CharacterSN,
key.CharacterName,
GuildMemberRank.Operator.ToGroupUserType()
});
HeroesGuildUserType type = GuildMemberRank.Operator.ToGroupUserType();
return(HeroesGuild.GroupChangeMaster(GuildAPI.ServerCode, guild.GuildSN, key.NexonSN, (long)key.CharacterSN, key.CharacterName, this.ConvertToGroupUserType(type)));
}
public bool CloseGuild(GuildEntity guild, GuildMemberKey key)
{
Log <GuildAPI> .Logger.InfoFormat("Remove: GuildMemberKey[{0}]", key);
try
{
HeroesGuild.Remove(GuildAPI.ServerCode, key.NexonSN, guild.GuildSN);
}
catch (GroupException ex)
{
if (ex.ErrorCode != 6)
{
Log <GuildService> .Logger.Error("Remove(CloseGuild) Error: ", ex);
}
return(false);
}
catch (Exception ex2)
{
Log <GuildService> .Logger.Error("Remove(CloseGuild) Error: ", ex2);
return(false);
}
return(true);
}
public bool AcceptJoin(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, bool accept)
{
int num = -1;
try
{
if (operatorRank.HasAcceptJoinPermission(targetMember.Rank))
{
HeroesGuildDBDataContext heroesGuildDBDataContext = new HeroesGuildDBDataContext();
if (accept)
{
num = heroesGuildDBDataContext.GuildUserJoinApply(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(targetMember.Key.NexonSN), new long?((long)targetMember.Key.CharacterSN), targetMember.Key.CharacterName);
}
else
{
num = heroesGuildDBDataContext.GuildUserJoinReject(new int?(GuildAPI.ServerCode), new int?(guild.GuildSN), new int?(targetMember.Key.NexonSN), new long?((long)targetMember.Key.CharacterSN), targetMember.Key.CharacterName);
}
}
}
catch (Exception ex)
{
Log <HeroesGuildAPI> .Logger.Error("Error in AcceptJoin(GuildEntity guild, GuildMemberRank operatorRank, GuildMember targetMember, bool accept)", ex);
}
GuildLedgerEventType eventType;
if (num == 0)
{
eventType = GuildLedgerEventType.Success;
}
else
{
eventType = GuildLedgerEventType.DatabaseFail;
}
GuildLog.AddGuildLedger(new LogData((long)guild.GuildSN, targetMember.Key.CID, OperationType.HeroesCore_ResponseJoin, eventType, string.Format("GuildSn: {0}, isAccept: {1}", guild.GuildSN, accept.ToString()), targetMember.Key.ToString()));
return(num == 0);
}
private bool DoJoinWebChatMember(GuildEntity entity, HeroesGuildChatRelay server, ChatJoinEventArg arg)
{
if (entity != null && entity.ChatRoom != null)
{
Log <GuildService> .Logger.InfoFormat("JoinWebChatMember is called. [ {0}, {1}, {2} ]", arg.GuildKey, arg.CID, arg.Sender);
GuildChatWebMember member = new GuildChatWebMember(arg.CID, arg.GuildKey, arg.Sender, server);
if (entity.ChatRoom.JoinWebMember(member))
{
string gameMembers = this.GetGameMembers(arg.GuildKey);
Log <GuildService> .Logger.InfoFormat("JoinWebChatMember is called. [ {0}, {1}, {2}, {3} ]", new object[]
{
arg.GuildKey,
arg.CID,
arg.Sender,
gameMembers
});
server.JoinWebMember(member);
return(true);
}
}
return(false);
}
private bool DoSyncWebMember(GuildEntity entity, HeroesGuildChatRelay server, ChatMemberSyncEventArg arg)
{
if (entity != null && entity.ChatRoom != null)
{
GuildChatRoom chatRoom = entity.ChatRoom;
chatRoom.LeaveAllMembers(entity.GuildID);
foreach (KeyValuePair <long, string> keyValuePair in arg.Members)
{
Log <GuildService> .Logger.InfoFormat("DoSyncWebMember is called. [ {0}, {1}, {2} ]", arg.GuildKey, keyValuePair.Key, keyValuePair.Value);
GuildChatWebMember guildChatWebMember = new GuildChatWebMember(keyValuePair.Key, arg.GuildKey, keyValuePair.Value, server);
if (!chatRoom.JoinWebMember(guildChatWebMember))
{
this.ChatRelay.KickMember(guildChatWebMember.GuildID, guildChatWebMember.CID);
}
else
{
server.JoinWebMember(guildChatWebMember);
}
}
return(true);
}
return(false);
}
