public bool JoinGuild(uint id, GuildRank rank = GuildRank.Member, int donation = 0)
{
if (_data != null)
{
return(false);
}
_data = new DbGuildAttr
{
Id = _client.UID,
GuildId = id,
Rank = rank,
JoinDate = (uint)Common.Clock
};
ServerDatabase.Context.GuildAttributes.AddOrUpdate(_data);
var guild = GuildManager.GetGuild(GuildId);
if (guild != null)
{
guild.Amount++;
guild.SaveInfo();
}
AddMemberList(id, _client.Name, Rank, _client.Level);
SynchroInfo(true);
if (guild != null)
{
guild.SendInfoToClient(_client);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="GuildMemberTable"/> class.
/// </summary>
/// <param name="characterID">The initial value for the corresponding property.</param>
/// <param name="guildID">The initial value for the corresponding property.</param>
/// <param name="joined">The initial value for the corresponding property.</param>
/// <param name="rank">The initial value for the corresponding property.</param>
public GuildMemberTable(CharacterID @characterID, GuildID @guildID, DateTime @joined, GuildRank @rank)
{
CharacterID = @characterID;
GuildID = @guildID;
Joined = @joined;
Rank = @rank;
}
public bool SetRank(GuildRank rank, bool leader = false)
{
if (!(rank != GuildRank.GuildLeader && _data.Rank != GuildRank.GuildLeader || leader))
{
return(false);
}
var guild = GuildManager.GetGuild(GuildId);
if (guild == null)
{
return(false);
}
_data.Rank = rank;
SaveInfo();
if (!guild.EditMemberList(_client.Name, rank))
{
return(false);
}
SynchroInfo();
return(true);
}
public GuildMember(Guild Guild, int CharacterID, GuildRank Rank, ushort Corp)
{
this.Guild = Guild;
this.CharacterID = CharacterID;
this.Rank = Rank;
this.Corp = Corp;
}
private static void HandleGuildMail(GameSession session, IPacketReader packet)
{
string title = packet.ReadUnicodeString();
string body = packet.ReadUnicodeString();
Player sender = session.Player;
Guild guild = sender.Guild;
if (guild == null)
{
return;
}
byte senderRank = sender.GuildMember.Rank;
GuildRank guildRank = guild.Ranks[senderRank];
if (!guildRank.HasRight(GuildRights.CanGuildMail))
{
session.Send(GuildPacket.ErrorNotice((byte)GuildErrorNotice.InsufficientPermissions));
return;
}
session.Send(GuildPacket.SendMail());
IEnumerable <long> recipientIds = guild.Members.Select(c => c.Player.CharacterId);
foreach (long recipientId in recipientIds)
{
MailHelper.SendMail(MailType.Player, recipientId, sender.CharacterId, sender.Name, title, body, "", "", new(), 0, 0, out Mail mail);
}
}
public bool NewRank(PlayerObject Self)
{
if (Ranks.Count >= byte.MaxValue)
{
Self.ReceiveChat("You cannot have anymore ranks.", ChatType.System);
return(false);
}
int NewIndex = Ranks.Count > 1? Ranks.Count - 1: 1;
GuildRank NewRank = new GuildRank()
{
Index = NewIndex, Name = String.Format("Rank-{0}", NewIndex), Options = (GuildRankOptions)0
};
Ranks.Insert(NewIndex, NewRank);
Ranks[Ranks.Count - 1].Index = Ranks.Count - 1;
List <GuildRank> NewRankList = new List <GuildRank>();
NewRankList.Add(NewRank);
SendServerPacket(new ServerPackets.GuildMemberChange()
{
Name = Self.Name, Status = (byte)6, Ranks = NewRankList
});
NeedSave = true;
return(true);
}
public object SetRank(Guid guildId, LookupKey lookupKey, [FromBody] GuildRank guildRank)
{
if (lookupKey.IsInvalid)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest, lookupKey.IsIdInvalid ? @"Invalid player id." : @"Invalid player name."
));
}
if (guildRank.Rank <= 0 || guildRank.Rank >= Options.Instance.Guild.Ranks.Length)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest, $@"Invalid guild rank, should be > 0 and < {Options.Instance.Guild.Ranks.Length}."
));
}
var guild = Guild.LoadGuild(guildId);
if (guild == null)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
$@"Guild does not exist."
));
}
var(client, player) = Player.Fetch(lookupKey);
//Player not found
if (player == null)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
$@"Player not found."
));
}
//Player is not a member of this guild
if (!guild.IsMember(player.Id))
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
$@"{player.Name} is not a member of {guild.Name}."
));
}
//Cannot kick the owner!
if (player.GuildRank == 0)
{
return(Request.CreateErrorResponse(
HttpStatusCode.BadRequest,
$@"Cannot change rank of the guild owner, transfer ownership first!"
));
}
guild.SetPlayerRank(player, guildRank.Rank, null);
return(player);
}
public void UpdateMemberRank(GuildMember Member, GuildRank NewRank)
{
Member.Rank = NewRank;
Member.Save();
//broadcast to members
using (var packet = new Packet(SH29Type.UpdateGuildMemberRank))
{
packet.WriteString(Member.Character.Character.Name, 16);
packet.WriteByte((byte)NewRank);
Broadcast(packet);
}
//broadcast to zones
using (var packet = new InterPacket(InterHeader.ZoneGuildMemberRankUpdate))
{
packet.WriteInt(ID);
packet.WriteInt(Member.Character.ID);
packet.WriteByte((byte)NewRank);
ZoneManager.Broadcast(packet);
}
}
public GuildObject(PlayerObject owner, string name)
{
Name = name;
GuildRank Owner = new GuildRank()
{
Name = "Leader", Options = (GuildRankOptions)255, Index = 0
};
GuildMember Leader = new GuildMember()
{
name = owner.Info.Name, Player = owner, Id = owner.Info.Index, LastLogin = Envir.Now, Online = true
};
Owner.Members.Add(Leader);
Ranks.Add(Owner);
Membercount++;
NeedSave = true;
if (Level < Settings.Guild_ExperienceList.Count)
{
MaxExperience = Settings.Guild_ExperienceList[Level];
}
if (Level < Settings.Guild_MembercapList.Count)
{
MemberCap = Settings.Guild_MembercapList[Level];
}
FlagColour = Color.FromArgb(255, Envir.Random.Next(255), Envir.Random.Next(255), Envir.Random.Next(255));
}
public MemberInfo(DbGuildMemberInfo info)
{
Name = info.Name;
Rank = info.Rank;
Level = (byte)info.Level;
TotalDonation = (int)info.Donation;
}
public bool AddMemberList(string name, GuildRank rank, byte level)
{
_members.Add(new MemberInfo {
Name = name, Rank = rank, Level = level
});
return(true);
}
public bool EditMemberList(string name, GuildRank rank)
{
for (var i = 0; i < _members.Count; i++)
{
if (_members[i].Name == name)
{
var member = _members[i];
if (member.Rank != GuildRank.DeputyLeader && rank == GuildRank.DeputyLeader)
{
DeputyLeaders++;
}
else if (member.Rank == GuildRank.DeputyLeader && rank != GuildRank.DeputyLeader)
{
DeputyLeaders--;
}
member.Rank = rank;
_members[i] = member;
return(true);
}
}
return(false);
}
public GuildMember(string name, int level, bool online, GuildRank rank)
{
this.name = name;
this.level = level;
this.online = online;
this.rank = rank;
}
public GuildMember(Guild Guild, int CharacterID, GuildRank Rank, ushort Corp)
{
this.Guild = Guild;
this.CharacterID = CharacterID;
this.Rank = Rank;
this.Corp = Corp;
}
public ActionResult DeleteConfirmed(int id)
{
GuildRank guildRank = db.GuildRank.Find(id);
db.GuildRank.Remove(guildRank);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// When overridden in the derived class, handles when the <see cref="GuildMemberInfo{T}.Owner"/> is promoted.
/// </summary>
/// <param name="rank">The new rank.</param>
protected override void HandlePromotion(GuildRank rank)
{
if (!Owner.IsLoaded)
{
return;
}
Owner.Send(GameMessage.GuildPromotion, ServerMessageType.GUI, _guildSettings.GetRankName(rank));
}
/// <summary>
/// Determines whether a member with <paramref name="rank1"/> is able to kick a member with <paramref name="rank2"/>.
/// </summary>
/// <param name="rank1">Rank of the kicker</param>
/// <param name="rank2">Rank of the member being kicked</param>
/// <returns>Returns whether <paramref name="rank1"/> can kick <paramref name="rank2"/></returns>
public static bool CanKickout(GuildRank rank1, GuildRank rank2)
{
if (rank1 == GuildRank.GuildLeader)
{
return(true);
}
return(false);
}
public bool DemoteMember(string name, GuildRank rank = GuildRank.Member)
{
if (string.IsNullOrEmpty(name))
{
return(false);
}
var guildId = _client.GuildId;
if (guildId == 0)
{
return(false);
}
var guild = GuildManager.GetGuild(guildId);
if (guild == null)
{
return(false);
}
if (_client.GuildRank != GuildRank.GuildLeader)
{
return(false);
}
var target = PlayerManager.GetUser(name);
if (target == null)
{
_client.SendSysMessage("The player is offline!");
return(false);
}
if (_client.UID == target.UID)
{
return(false);
}
var targetGuildId = target.GuildId;
if (targetGuildId == 0 || targetGuildId != guildId)
{
return(false);
}
if (!target.GuildAttribute.SetRank(GuildRank.Member))
{
return(false);
}
guild.BroadcastMessage(string.Format("{0} was discharged from the Deputy Leader position.", name, GuildRank.DeputyLeader));
guild.BroadcastGuildMsg(GuildPackets.Create(GuildAction.Unknown41, 990, 0));
return(true);
}
public GuildMember(Database.Records.CharacterRecord character, Guild guild)
{
this.OwnGuild = guild;
this.Character = character;
this.ID = character.ID;
this.Rank = (GuildRank)character.GuildRank;
character.GuildRights.Split(',').ToList().FindAll(x => x != "").ForEach(x => this.Rights.Add(int.Parse(x)));
this.CharacterName = character.Nickname;
this.SetOffline();
}
public GuildMember(Guild Guild, WorldCharacter Character, GuildRank Rank, ushort Corp)
{
this.Guild = Guild;
this.Character = Character;
this.Rank = Rank;
this.Corp = Corp;
ThreadLocker = new object();
}
/// <summary>
/// Checks if the user meets the required guild rank.
/// </summary>
/// <param name="requiredRank">The required guild rank.</param>
/// <returns>If false, the command should be aborted.</returns>
bool CheckGuildPermissions(GuildRank requiredRank)
{
if (((IGuildMember)User).GuildRank < requiredRank)
{
User.Send(GameMessage.GuildInsufficientPermissions, ServerMessageType.GUI, GuildSettings.GetRankName(requiredRank));
return(false);
}
return(true);
}
/// <summary>
/// Checks if the user meets the required guild rank.
/// </summary>
/// <param name="requiredRank">The required guild rank.</param>
/// <returns>If false, the command should be aborted.</returns>
bool CheckGuildPermissions(GuildRank requiredRank)
{
if (((IGuildMember)User).GuildRank < requiredRank)
{
User.Send(GameMessage.GuildInsufficientPermissions, ServerMessageType.GUI, GuildSettings.GetRankName(requiredRank));
return false;
}
return true;
}
public ActionResult Edit([Bind(Include = "RankID,RankName")] GuildRank guildRank)
{
if (ModelState.IsValid)
{
db.Entry(guildRank).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("~/Views/Admin/GuildRanks/Edit.cshtml", guildRank));
}
public GuildMember(Guild Guild, WorldCharacter Character, GuildRank Rank, ushort Corp)
{
this.Guild = Guild;
this.Character = Character;
this.Rank = Rank;
this.Corp = Corp;
ThreadLocker = new object();
}
public ActionResult Create([Bind(Include = "RankID,RankName")] GuildRank guildRank)
{
if (ModelState.IsValid)
{
db.GuildRank.Add(guildRank);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("~/Views/Admin/GuildRanks/Create.cshtml", guildRank));
}
public bool AddMemberList(uint id, string name, GuildRank rank, byte level)
{
var guild = GuildManager.GetGuild(id);
if (guild == null)
{
return(false);
}
return(guild.AddMemberList(name, rank, level));
}
public bool SetIdRank(uint guildId, GuildRank rank, bool synchro = true)
{
_data.GuildId = guildId;
_data.Rank = rank;
SaveInfo();
if (synchro)
{
SynchroInfo();
}
return(true);
}
/// <summary>
/// Removes, at most, one entry from the database where the user id is <paramref name="userId"/> and guild id is <paramref name="guildId"/> and the rank is not <paramref name="guildRank"/>.
/// </summary>
/// <param name="userId"></param>
/// <param name="guildId"></param>
/// <param name="guildRank"></param>
public void DeleteGuildAttr(uint userId, uint guildId, GuildRank guildRank)
{
using (var session = NHibernateHelper.OpenSession())
{
session
.GetNamedQuery("DeleteUserGuildAttr")
.SetParameter("userId", userId)
.SetParameter("guildId", guildId)
.SetParameter("guildRank", guildRank)
.ExecuteUpdate();
}
}
public string GetRankString(GuildRank rank)
{
const string FORMAT = "{0:d} {1} {2} {3} {4}";
switch (rank)
{
case GuildRank.GuildLeader: return(string.Format(FORMAT, rank, 1, 1, 0, 0));
case GuildRank.DeputyLeader: return(string.Format(FORMAT, rank, DeputyLeaders, 5, 0, 0));
default: return(string.Format(FORMAT, rank, 0, 0, 0, 0));
}
}
// GET: GuildRanks/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
GuildRank guildRank = db.GuildRank.Find(id);
if (guildRank == null)
{
return(HttpNotFound());
}
return(View("~/Views/Admin/GuildRanks/Delete.cshtml", guildRank));
}
public void AddMember(string name, int level, GuildRank rank = GuildRank.Member)
{
var member = new GuildMember {
name = name, level = level, online = true, rank = rank
};
if (members != null)
{
Array.Resize(ref members, members.Length + 1);
members[members.Length - 1] = member;
}
else
{
members = new GuildMember[] { member };
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GuildSettings"/> class.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="rankNames" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="nameRules" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException"><paramref name="tagRules" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">There must be exactly one rank name for each rank.</exception>
/// <exception cref="ArgumentException">Guild rank names may not be empty or null.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>inviteResponseTime</c> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>minRankRename</c> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>minRankViewLog</c> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>minRankKick</c> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>minRankInvite</c> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>minRankPromote</c> is out of range.</exception>
/// <exception cref="ArgumentOutOfRangeException"><c>minRankDemote</c> is out of range.</exception>
public GuildSettings(int inviteResponseTime, GuildRank highestRank, string[] rankNames, StringRules nameRules,
StringRules tagRules, GuildRank minRankRename, GuildRank minRankViewLog, GuildRank minRankKick,
GuildRank minRankInvite, GuildRank minRankPromote, GuildRank minRankDemote)
{
if (rankNames == null)
throw new ArgumentNullException("rankNames");
if (rankNames.Length != highestRank + 1)
throw new ArgumentException("There must be exactly one rank name for each rank.", "rankNames");
if (rankNames.Any(x => string.IsNullOrEmpty(x)))
throw new ArgumentException("Guild rank names may not be empty or null.", "rankNames");
if (nameRules == null)
throw new ArgumentNullException("nameRules");
if (tagRules == null)
throw new ArgumentNullException("tagRules");
if (inviteResponseTime <= 0)
throw new ArgumentOutOfRangeException("inviteResponseTime");
if (minRankRename > highestRank)
throw new ArgumentOutOfRangeException("minRankRename");
if (minRankViewLog > highestRank)
throw new ArgumentOutOfRangeException("minRankViewLog");
if (minRankKick > highestRank)
throw new ArgumentOutOfRangeException("minRankKick");
if (minRankInvite > highestRank)
throw new ArgumentOutOfRangeException("minRankInvite");
if (minRankPromote > highestRank)
throw new ArgumentOutOfRangeException("minRankPromote");
if (minRankDemote > highestRank)
throw new ArgumentOutOfRangeException("minRankDemote");
_inviteResponseTime = inviteResponseTime;
_highestRank = highestRank;
_rankNames = rankNames;
_nameRules = nameRules;
_tagRules = tagRules;
_minRankRename = minRankRename;
_minRankViewLog = minRankViewLog;
_minRankKick = minRankKick;
_minRankInvite = minRankInvite;
_minRankPromote = minRankPromote;
_minRankDemote = minRankDemote;
}
private static async Task Client_UserLeft(SocketGuildUser user)
{
if (MinecraftGuildModel.TryGetGuildOfUser(user.Id, out MinecraftGuild userGuild))
{
GuildRank rank = userGuild.GetMemberRank(user.Id);
if (rank == GuildRank.Captain)
{
await AdminTaskInteractiveMessage.CreateAdminTaskMessage($"Guild Captain left Server", $"Guild: `{userGuild.Name}`\nCaptain: `{user}`, Id: `{user.Id}`{(string.IsNullOrEmpty(user.Nickname) ? "" : $", Nickname: `{user.Nickname}`")}");
}
else
{
userGuild.MemberIds.Remove(user.Id);
userGuild.MateIds.Remove(user.Id);
await MinecraftGuildModel.SaveAll();
}
}
BotVarCollection guildBotVars = BotVarManager.GetGuildBotVarCollection(user.Guild.Id);
if (guildBotVars.TryGetBotVar(Var.MinecraftBranchRoleBotVarId, out ulong minecraftBranchRole))
{
if (user.Roles.Any(role => { return(role.Id == minecraftBranchRole); }))
{
await AdminTaskInteractiveMessage.CreateAdminTaskMessage($"Minecraft Branch Member left Server", $"Name: `{user}`, Id: `{user.Id}`{(string.IsNullOrEmpty(user.Nickname) ? "" : $", Nickname: `{user.Nickname}`")}");
}
}
if (TryGetLogChannel(user.Guild, DiscordEventType.UserLeft, out SocketTextChannel channel, out EmbedBuilder embed))
{
embed.Title = $"{user} left";
StringBuilder description = new StringBuilder();
if (!string.IsNullOrEmpty(user.Nickname))
{
description.AppendLine($"**Nickname**: \"{user.Nickname}\"");
}
if (user.Roles.Count > 1)
{
description.AppendLine($"**Roles**: `{string.Join(", ", user.Roles)}`");
}
embed.ThumbnailUrl = user.GetDefaultAvatarUrl();
embed.Description = description.ToString();
await channel.SendEmbedAsync(embed);
}
}
public void NewMember(PlayerObject newmember)
{
if (Ranks.Count < 2)
{
Ranks.Add(new GuildRank()
{
Name = "Members", Index = 1
});
}
GuildRank currentrank = Ranks[Ranks.Count - 1];
GuildMember Member = new GuildMember()
{
name = newmember.Info.Name, Player = newmember, Id = newmember.Info.Index, LastLogin = Envir.Now, Online = true
};
currentrank.Members.Add(Member);
PlayerLogged(newmember, true, true);
Membercount++;
NeedSave = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="GuildMemberTable"/> class.
/// </summary>
/// <param name="characterID">The initial value for the corresponding property.</param>
/// <param name="guildID">The initial value for the corresponding property.</param>
/// <param name="joined">The initial value for the corresponding property.</param>
/// <param name="rank">The initial value for the corresponding property.</param>
public GuildMemberTable(CharacterID @characterID, GuildID @guildID, DateTime @joined, GuildRank @rank)
{
CharacterID = @characterID;
GuildID = @guildID;
Joined = @joined;
Rank = @rank;
}
public void AddMember(WorldCharacter Character, GuildRank Rank, MySqlConnection con = null, bool BroadcastAdd = true, bool SendGuildInfoToClient = true)
{
lock (ThreadLocker)
{
var conCreated = (con == null);
if (conCreated)
{
con = Program.DatabaseManager.GetClient().GetConnection();
}
//add to db
int result;
using (var cmd = con.CreateCommand())
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "GuildMember_Create";
cmd.Parameters.Add(new MySqlParameter("@pGuildID", ID));
cmd.Parameters.Add(new MySqlParameter("@pCharacterID", Character.ID));
cmd.Parameters.Add(new MySqlParameter("@pRank", (byte)Rank));
cmd.Parameters.Add(new MySqlParameter("@pCorp", Convert.ToInt16("0")));
result = Convert.ToInt32(cmd.ExecuteScalar());
}
if (result == -1)
return;
//create object
var newMember = new GuildMember(this, Character, Rank, 0);
//update character
Character.Guild = this;
Character.GuildMember = newMember;
Character.GuildAcademy = Academy;
//add to list
Members.Add(newMember);
if (BroadcastAdd)
{
newMember.BroadcastGuildName();
//broadcast that guild member joined
using (var packet = new Packet(SH29Type.GuildMemberJoined))
{
newMember.WriteInfo(packet);
Broadcast(packet, newMember);
}
using (var packet = new Packet(SH29Type.GuildMemberLoggedIn))
{
packet.WriteString(newMember.Character.Character.Name, 16);
Broadcast(packet, newMember);
}
//let zone know that a new member has been added to guild
using (var packet = new InterPacket(InterHeader.ZONE_GuildMemberAdd))
{
packet.WriteInt(ID);
packet.WriteInt(Character.ID);
packet.WriteByte((byte)newMember.Rank);
packet.WriteUShort(newMember.Corp);
Managers.ZoneManager.Instance.Broadcast(packet);
}
}
//send guild info to new member
if (SendGuildInfoToClient)
{
SendMemberList(newMember.Character.Client);
using (var packet = new Packet(SH4Type.CharacterGuildinfo))
{
WriteGuildInfo(packet);
newMember.Character.Client.SendPacket(packet);
}
}
if (conCreated)
{
con.Dispose();
}
}
}
public void UpdateMemberRank(GuildMember Member, GuildRank NewRank)
{
Member.Rank = NewRank;
Member.Save();
//broadcast to members
using (var packet = new Packet(SH29Type.UpdateGuildMemberRank))
{
packet.WriteString(Member.Character.Character.Name, 16);
packet.WriteByte((byte)NewRank);
Broadcast(packet);
}
//broadcast to zones
using (var packet = new InterPacket(InterHeader.ZONE_GuildMemberRankUpdate))
{
packet.WriteInt(ID);
packet.WriteInt(Member.Character.ID);
packet.WriteByte((byte)NewRank);
ZoneManager.Instance.Broadcast(packet);
}
}
/// <summary>
/// Gets the name of the given <paramref name="rank"/>.
/// </summary>
/// <param name="rank">The guild rank.</param>
/// <returns>The name of the given <paramref name="rank"/>.</returns>
public string GetRankName(GuildRank rank)
{
return _rankNames[rank];
}
/// <summary>
/// Ensures a guild member invoking an event meets the rank requirements to invoke the event.
/// </summary>
/// <param name="invoker">The guild member invoking the event.</param>
/// <param name="minRequiredRank">The minimum rank required to invoke the event.</param>
/// <returns>True if the <paramref name="invoker"/> is a high enough rank to invoke the event;
/// otherwise false.</returns>
static bool EnsureValidRank(IGuildMember invoker, GuildRank minRequiredRank)
{
if (invoker.GuildRank < minRequiredRank)
{
const string errmsg =
"Guild member `{0}` from guild `{1}` tried to invoke an event, but their rank was not" +
" high enough (rank: `{2}` req: `{3}`).";
if (log.IsInfoEnabled)
log.InfoFormat(errmsg, invoker, invoker.Guild, invoker.GuildRank, minRequiredRank);
return false;
}
return true;
}
