/// <summary> /// Handles kicking someone out of a guild. /// </summary> /// <param name="target">The <see cref="IGuildMember"/> being kicked out of the guild.</param> /// <param name="userName">The name of the <paramref name="target"/>.</param> void GuildMemberPerformer_GuildKick(IGuildMember target, string userName) { if (target == null) { User.Send(GameMessage.GuildKickFailedInvalidUser, ServerMessageType.GUI, userName); return; } if (target.Guild != User.Guild) { User.Send(GameMessage.GuildKickFailedNotInGuild, ServerMessageType.GUI, target.Name); return; } if (target.GuildRank > ((IGuildMember)User).GuildRank) { User.Send(GameMessage.GuildKickFailedTooHighRank, ServerMessageType.GUI, target.Name); return; } if (!User.Guild.TryKickMember(User, target)) { User.Send(GameMessage.GuildKickFailedUnknownReason, ServerMessageType.GUI, target.Name); return; } User.Send(GameMessage.GuildKick, ServerMessageType.GUI, target.Name); }
/// <summary> /// Does the actual handling of demoting a guild member. /// </summary> /// <param name="invoker">The guild member is who demoting the <paramref name="target"/>.</param> /// <param name="target">The guild member being demoted.</param> /// <returns>True if the <paramref name="invoker"/> successfully demoted the <paramref name="target"/>; /// otherwise false.</returns> protected virtual bool InternalTryDemoteMember(IGuildMember invoker, IGuildMember target) { // Demote --target.GuildRank; if (target.GuildRank < 0 || target.GuildRank > _guildSettings.HighestRank) { const string errmsg = "Somehow, when `{0}` demoted `{1}`, their rank ended up at the invalid value of `{2}`." + " Rank being reset to 0."; if (log.IsErrorEnabled) { log.ErrorFormat(errmsg, invoker, target, target.GuildRank); } Debug.Fail(string.Format(errmsg, invoker, target, target.GuildRank)); target.GuildRank = 0; } // Log the event GuildManager.LogEvent(invoker, GuildEvents.Demote, target); OnMemberDemoted(invoker, target); if (MemberDemoted != null) { MemberDemoted.Raise(invoker, EventArgsHelper.Create(target)); } return(true); }
/// <summary> /// Tries to create a new guild. /// </summary> /// <param name="creator">The one trying to create the guild.</param> /// <param name="name">The name of the guild to create.</param> /// <param name="tag">The tag for the guild to create.</param> /// <returns>The created guild instance if successfully created, or null if the guild could not /// be created.</returns> protected override Guild InternalTryCreateGuild(IGuildMember creator, string name, string tag) { // Let the database assign the ID for us var dummyID = new GuildID(_dbController.ConnectionPool.AutoIncrementValue); // We want to insert the guild into the database first since if that query fails, we know that // we can't create the guild with the given values for whatever reason var values = new GuildTable(iD: dummyID, name: name, tag: tag, created: DateTime.Now); long lastInsertedId; var rowsAffected = _insertGuildQuery.ExecuteWithResult(values, out lastInsertedId); if (rowsAffected <= 0) { const string errmsg = "Failed to create guild using values (name={0}, tag={1}) - insert query" + " returned `{2}` rows affected. Most likely one of the values are not unique."; if (log.IsWarnEnabled) { log.WarnFormat(errmsg, name, tag, rowsAffected); } return(null); } // Set the guild ID Debug.Assert(lastInsertedId <= int.MaxValue); Debug.Assert(lastInsertedId >= int.MinValue); values.ID = new GuildID((int)lastInsertedId); // Create the guild instance using the values we just inserted into the database return(new Guild(this, values)); }
/// <summary> /// Does the actual handling of promoting a guild member. /// </summary> /// <param name="invoker">The guild member is who promoting the <paramref name="target"/>.</param> /// <param name="target">The guild member being promoted.</param> /// <returns>True if the <paramref name="invoker"/> successfully promoted the <paramref name="target"/>; /// otherwise false.</returns> protected virtual bool InternalTryPromoteMember(IGuildMember invoker, IGuildMember target) { // Promote ++target.GuildRank; if (target.GuildRank > invoker.GuildRank) { const string errmsg = "Somehow, when `{0}` promoted `{1}`, their rank [{2}] ended up greater than that of" + " the member who promoted them [{3}]."; if (log.IsErrorEnabled) { log.ErrorFormat(errmsg, invoker, target, target.GuildRank, invoker.GuildRank); } Debug.Fail(string.Format(errmsg, invoker, target, target.GuildRank, invoker.GuildRank)); target.GuildRank = invoker.GuildRank; } // Log the event GuildManager.LogEvent(invoker, GuildEvents.Promote, target); if (MemberPromoted != null) { MemberPromoted.Raise(invoker, EventArgsHelper.Create(target)); } OnMemberPromoted(invoker, target); return(true); }
/// <summary> /// Removes the reference of an online guild member from this guild. This does not make the user join or leave the /// guild in any way, just allows the guild to keep track of the members that are online. /// </summary> /// <param name="member">The online guild member to remove.</param> public void RemoveOnlineMember(IGuildMember member) { if (member.Guild != this) { const string errmsg = "The guild member `{0}` does not belong to this guild [{1}]!"; if (log.IsWarnEnabled) { log.WarnFormat(errmsg, member, this); } Debug.Fail(string.Format(errmsg, member, this)); return; } if (!_onlineMembers.Remove(member)) { const string errmsg = "Member `{0}` was not in the online list for guild `{1}`." + " Not really a problem that can't be easily fixed, but should be avoided since it is needless overhead."; Debug.Fail(string.Format(errmsg, member, this)); return; } if (OnlineUserRemoved != null) { OnlineUserRemoved.Raise(this, EventArgsHelper.Create(member)); } OnOnlineUserRemoved(member); }
/// <summary> /// Makes the <paramref name="invoker"/> try to invite the <paramref name="target"/> to the guild. /// </summary> /// <param name="invoker">The guild member is who inviting the <paramref name="target"/>.</param> /// <param name="target">The guild member being invited to the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully invited the <paramref name="target"/> /// to the guild; otherwise false.</returns> public bool TryInviteMember(IGuildMember invoker, IGuildMember target) { // Ensure the parameters are valid, and the target is not in a guild yet if (!EnsureValidEventSource(invoker, target)) { return(false); } if (target.Guild != null) { const string errmsg = "Guild member `{0}` tried to invite `{1}` into guild `{2}`, but the target" + " is already part of a guild, `{3}`."; if (log.IsInfoEnabled) { log.InfoFormat(errmsg, invoker, target, invoker.Guild, target.Guild); } return(false); } // Ensure the user has the needed permission level for the action if (!EnsureValidRank(invoker, _guildSettings.MinRankInvite)) { return(false); } return(InternalTryInviteMember(invoker, target)); }
/// <summary> /// Makes the <paramref name="invoker"/> try to kick the <paramref name="target"/> out of the guild. /// </summary> /// <param name="invoker">The guild member is who kicking out the <paramref name="target"/>.</param> /// <param name="target">The guild member being kicked out of the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully kicked the <paramref name="target"/> /// out of the guild; otherwise false.</returns> public bool TryKickMember(IGuildMember invoker, IGuildMember target) { // Ensure the user and invoker are in the same guild if (!EnsureValidEventSourceSameGuild(invoker, target)) { return(false); } // Ensure the user has the needed permission level for the action if (!EnsureValidRank(invoker, _guildSettings.MinRankKick)) { return(false); } // The invoker's rank must be greater than or equal to the target's rank if (invoker.GuildRank < target.GuildRank) { const string errmsg = "Guild member `{0}` from guild `{1}` tried to kick out `{2}`, but their rank [{3}] is" + " is lower than the rank of the one they are trying to kick [{4}]."; if (log.IsInfoEnabled) { log.InfoFormat(errmsg, invoker, invoker.Guild, target, invoker.GuildRank, target.GuildRank); } return(false); } return(InternalTryKickMember(invoker, target)); }
/// <summary> /// Makes the <paramref name="invoker"/> try to promote the <paramref name="target"/>. /// </summary> /// <param name="invoker">The guild member is who promoting the <paramref name="target"/>.</param> /// <param name="target">The guild member being promoted.</param> /// <returns>True if the <paramref name="invoker"/> successfully promoted the <paramref name="target"/>; /// otherwise false.</returns> public bool TryPromoteMember(IGuildMember invoker, IGuildMember target) { // Ensure the parameters are valid if (!EnsureValidEventSourceSameGuild(invoker, target)) { return(false); } // Ensure the invoker has the needed permissions if (!EnsureValidRank(invoker, _guildSettings.MinRankPromote)) { return(false); } // Only allow promotions to be done on a member that is a lower rank than the one promoting if (invoker.GuildRank <= target.GuildRank) { const string errmsg = "Guild member `{0}` tried to promote member `{1}`, but their rank [{2}] is" + " is not greater than the rank of the one they are trying to promote [{3}]."; if (log.IsInfoEnabled) { log.InfoFormat(errmsg, invoker, target, invoker.GuildRank, target.GuildRank); } return(false); } if (target.GuildRank == 0) { return(false); } return(InternalTryPromoteMember(invoker, target)); }
/// <summary> /// Makes sure that the guild event invoker is valid and part of a guild. /// </summary> /// <param name="invoker">The guild member invoking the event.</param> /// <returns>True if the invoker is valid; otherwise false.</returns> bool EnsureValidEventSource(IGuildMember invoker) { if (IsDestroyed) { const string errmsg = "Tried to invoke an event on guild `{0}`, but it has been destroyed already!"; Debug.Fail(string.Format(errmsg, this)); if (log.IsErrorEnabled) log.ErrorFormat(errmsg, this); return false; } if (invoker == null) { const string errmsg = "Guild event invoker is null."; Debug.Fail(errmsg); if (log.IsWarnEnabled) log.Warn(errmsg); return false; } if (invoker.Guild != this) { const string errmsg = "Guild event invoker `{0}` is not part of this guild instance (`{1}`)."; Debug.Fail(string.Format(errmsg, invoker, this)); if (log.IsWarnEnabled) log.WarnFormat(errmsg, invoker, this); return false; } return true; }
public async Task <Result <FeedbackMessage> > DroneAsync(IGuildMember member) { if (!member.User.IsDefined(out var user)) { throw new InvalidOperationException(); } var droneMessage = user.ID == _context.User.ID ? _content.GetRandomSelfDroneMessage() : _content.GetRandomTurnTheTablesMessage(); var sendMessage = await _feedback.SendContextualNeutralAsync ( droneMessage, _context.User.ID, ct : this.CancellationToken ); if (!sendMessage.IsSuccess) { return(Result <FeedbackMessage> .FromError(sendMessage)); } var droneResult = await _drone.DroneUserAsync ( _context.GuildID.Value, _context.User.ID, this.CancellationToken ); return(!droneResult.IsSuccess ? Result <FeedbackMessage> .FromError(droneResult) : new FeedbackMessage(_content.GetRandomConfirmationMessage(), _feedback.Theme.Secondary)); }
/// <summary> /// When overridden in the derived class, allows for additional handling of when a member of this /// guild has gone offline. /// </summary> /// <param name="guildMember">The guild member that went offline.</param> protected override void OnOnlineUserRemoved(IGuildMember guildMember) { base.OnOnlineUserRemoved(guildMember); using (var pw = ServerPacket.GuildInfo(x => UserGuildInformation.WriteRemoveOnlineMember(x, guildMember.Name))) { Send(pw); } }
/// <summary> /// When overridden in the derived class, allows for additional handling after a guild member is kicked. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <param name="target">The optional guild member the event involves.</param> protected override void OnMemberKicked(IGuildMember invoker, IGuildMember target) { base.OnMemberKicked(invoker, target); using (var pw = ServerPacket.GuildInfo(x => UserGuildInformation.WriteRemoveMember(x, target.Name))) { Send(pw); } }
/// <summary> /// Gets if the <paramref name="creator"/> is allowed to create a guild. /// </summary> /// <param name="creator">The one trying to create the guild.</param> /// <returns>True if the <paramref name="creator"/> is allowed to create a guild; otherwise false.</returns> protected virtual bool IsValidGuildCreator(IGuildMember creator) { if (creator.Guild != null) { return(false); } return(true); }
/// <summary> /// Makes the <paramref name="invoker"/> try to leave the guild. /// </summary> /// <param name="invoker">The guild member who is leaving.</param> /// <returns>True if the <paramref name="invoker"/> successfully left the guild; otherwise false.</returns> public bool TryLeaveGuild(IGuildMember invoker) { // Ensure a valid invoker if (!EnsureValidEventSource(invoker)) { return(false); } return(InternalTryLeaveGuild(invoker)); }
/// <summary> /// Makes the <paramref name="invoker"/> try to view the list of online guild members. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the online member list; otherwise false.</returns> public bool TryViewOnlineMembers(IGuildMember invoker) { // Ensure the parameters are valid if (!EnsureValidEventSource(invoker)) { return(false); } return(InternalTryViewOnlineMembers(invoker)); }
public static void WriteGuildMemberData(this IPacketWriter writer, IGuildMember m) { writer.WriteString(m.Name, 13); writer.WriteInt(m.Job); writer.WriteInt(m.Level); writer.WriteInt(m.Grade); writer.WriteInt(m.Online ? 1 : 0); writer.WriteInt(m.Commitment); writer.WriteInt(0); // AllianceGrade }
/// <summary> /// Adds the reference of an online guild member to this guild that is new to the guild. /// This does not make the user join or leave the guild in any way, just allows the guild to keep track of the /// members that are online. /// </summary> /// <param name="newMember">The online guild member to add.</param> public void AddNewOnlineMember(IGuildMember newMember) { if (MemberAdded != null) { MemberAdded.Raise(this, EventArgsHelper.Create(newMember)); } OnMemberAdded(newMember); AddOnlineMember(newMember); }
/// <summary> /// When overridden in the derived class, allows for additional handling after a guild member is promoted. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <param name="target">The optional guild member the event involves.</param> protected override void OnMemberPromoted(IGuildMember invoker, IGuildMember target) { base.OnMemberPromoted(invoker, target); var v = new GuildMemberNameRank(target.Name, target.GuildRank); using (var pw = ServerPacket.GuildInfo(x => UserGuildInformation.WriteUpdateMemberRank(x, v))) { Send(pw); } }
/// <summary> /// When overridden in the derived class, allows for additional handling after a new guild member is added. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="newMember"></param> protected override void OnMemberAdded(IGuildMember newMember) { base.OnMemberAdded(newMember); var v = new GuildMemberNameRank(newMember.Name, newMember.GuildRank); using (var pw = ServerPacket.GuildInfo(x => UserGuildInformation.WriteAddMember(x, v))) { Send(pw); } }
public Task <Result> PostUserHttpCatAsync([Description("The user to cattify")] IGuildMember catUser) { if (!catUser.User.HasValue) { return(Task.FromResult <Result>(new GenericError("No user field in the guild member??"))); } var modulo = (int)(catUser.User.Value.ID.Value % 999); return(PostHttpCatAsync(modulo)); }
/// <summary> /// Logs an event from a guild. /// </summary> /// <param name="eventCreator">The guild member that created the event.</param> /// <param name="guildEvent">The type of event that took place.</param> /// <param name="eventTarget">Optionally contains the other guild member that the event involves. This member /// may or may not actually be in the guild at this point.</param> /// <param name="arg0">The optional first argument string.</param> /// <param name="arg1">The optional second argument string.</param> /// <param name="arg2">The optional third argument string.</param> /// <exception cref="ArgumentNullException"><paramref name="eventCreator"/> is null.</exception> public void LogEvent(IGuildMember eventCreator, GuildEvents guildEvent, IGuildMember eventTarget, string arg0, string arg1, string arg2) { if (eventCreator == null) { throw new ArgumentNullException("eventCreator"); } Debug.Assert(EnumHelper <GuildEvents> .IsDefined(guildEvent)); InternalLogEvent(eventCreator, guildEvent, eventTarget, arg0, arg1, arg2); }
/// <summary> /// When overridden in the derived class, logs an event from a guild. /// </summary> /// <param name="eventCreator">The guild member that created the event.</param> /// <param name="guildEvent">The type of event that took place.</param> /// <param name="eventTarget">Optionally contains the other guild member that the event involves. This member /// may or may not actually be in the guild at this point.</param> /// <param name="arg0">The optional first argument string.</param> /// <param name="arg1">The optional second argument string.</param> /// <param name="arg2">The optional third argument string.</param> protected override void InternalLogEvent(IGuildMember eventCreator, GuildEvents guildEvent, IGuildMember eventTarget, string arg0, string arg1, string arg2) { var guildID = eventCreator.Guild.ID; var charID = (CharacterID)eventCreator.ID; var eventID = (byte)guildEvent; var targetID = (eventTarget == null ? null : (CharacterID?)eventTarget.ID); var args = new InsertGuildEventQuery.QueryArgs(guildID, charID, targetID, eventID, arg0, arg1, arg2); _insertGuildEventQuery.Execute(args); }
/// <summary> /// When overridden in the derived class, allows for additional handling after the guild's tag has changed. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <param name="oldTag">The old tag.</param> /// <param name="newTag">The new tag.</param> protected override void OnTagChanged(IGuildMember invoker, string oldTag, string newTag) { using (var pw = ServerPacket.SendMessage(GameMessage.GuildRetagged, oldTag, newTag, invoker.Name)) { Send(pw); } using (var pw = ServerPacket.GuildInfo(x => UserGuildInformation.WriteUpdateNameTag(x, Name, Tag))) { Send(pw); } }
private void CacheGuildMember(object key, IGuildMember member) { CacheInstance(key, member); if (!member.User.HasValue) { return; } var user = member.User.Value; var userKey = KeyHelpers.CreateUserCacheKey(user.ID); Cache(userKey, user); }
/// <summary> /// When overridden in the derived class, displays the members of the guild to the <paramref name="invoker"/>. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the member list; otherwise false.</returns> protected override bool InternalTryViewMembers(IGuildMember invoker) { var user = invoker as INetworkSender; if (user == null) { return(false); } // Get the list of members and their ranks SendGuildMemberList(user, "All guild members:", GetMembers()); return(true); }
/// <summary> /// When overridden in the derived class, displays the online members of the guild to the <paramref name="invoker"/>. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the online member list; otherwise false.</returns> protected override bool InternalTryViewOnlineMembers(IGuildMember invoker) { var user = invoker as INetworkSender; if (user == null) { return(false); } var members = OnlineMembers.OrderBy(x => (int)x.GuildRank).Select(x => new GuildMemberNameRank(x.Name, x.GuildRank)); SendGuildMemberList(user, "Online guild members:", members); return(true); }
/// <summary> /// Makes sure that the guild event invoker and target are valid. /// </summary> /// <param name="invoker">The guild member invoking the event.</param> /// <param name="target">The guild member the event is being invoked on.</param> /// <returns>True if the parameters are valid; otherwise false.</returns> bool EnsureValidEventSource(IGuildMember invoker, IGuildMember target) { if (!EnsureValidEventSource(invoker)) return false; if (target == null) { const string errmsg = "Guild event target is null. Invoker: `{0}`"; Debug.Fail(errmsg); if (log.IsWarnEnabled) log.WarnFormat(errmsg, invoker); return false; } return true; }
/// <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); }
/// <summary> /// Makes the <paramref name="invoker"/> try to view the event log for the guild. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the log; otherwise false.</returns> public bool TryViewEventLog(IGuildMember invoker) { // Ensure the parameters are valid if (!EnsureValidEventSource(invoker)) { return(false); } // Ensure the user has the needed permission level for the action if (!EnsureValidRank(invoker, _guildSettings.MinRankViewLog)) { return(false); } return(InternalTryViewEventLog(invoker)); }
/// <summary> /// Tries to create a new guild. /// </summary> /// <param name="creator">The <see cref="IGuildMember"/> describing the object trying to create the guild.</param> /// <param name="name">The name of the guild to create.</param> /// <param name="tag">The tag for the guild to create.</param> /// <returns>The created guild instance if successfully created, or null if the guild could not /// be created.</returns> public T TryCreateGuild(IGuildMember creator, string name, string tag) { // Check for a valid creator if (!IsValidGuildCreator(creator)) { return(null); } T ret; // Lock to ensure that we don't have to worry about race conditions since its not like guilds are made // often anyways for this to be a performance hit lock (_createSync) { // Check that the name and tag are even available if (!IsNameAvailable(name)) { return(null); } if (!IsTagAvailable(tag)) { return(null); } // Let the derived class try to create the instance ret = InternalTryCreateGuild(creator, name, tag); } // Check that the guild was created successfully if (ret != null) { // Add the creator as the founder of the guild creator.GuildRank = _guildSettings.HighestRank; creator.Guild = ret; // Add the guild to the dictionary lock (_guildsSync) { Debug.Assert(!_guilds.ContainsKey(ret.ID)); _guilds.Add(ret.ID, ret); } } return(ret); }
/// <summary> /// Does the actual handling of inviting a member into the guild. /// </summary> /// <param name="invoker">The guild member is who inviting the <paramref name="target"/>.</param> /// <param name="target">The guild member being invited to the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully invited the <paramref name="target"/> /// to the guild; otherwise false.</returns> protected virtual bool InternalTryInviteMember(IGuildMember invoker, IGuildMember target) { // Send the invite target.SendGuildInvite(invoker, this); // Log the event GuildManager.LogEvent(invoker, GuildEvents.Invite, target); if (MemberInvited != null) { MemberInvited.Raise(invoker, EventArgsHelper.Create(target)); } OnMemberInvited(invoker, target); return(true); }
/// <summary> /// Does the actual handling of kicking a member out of a guild. /// </summary> /// <param name="invoker">The guild member is who kicking out the <paramref name="target"/>.</param> /// <param name="target">The guild member being kicked out of the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully kicked the <paramref name="target"/> /// out of the guild; otherwise false.</returns> protected virtual bool InternalTryKickMember(IGuildMember invoker, IGuildMember target) { // Kick the target out of the guild target.Guild = null; // Log the event GuildManager.LogEvent(invoker, GuildEvents.Kick, target); if (MemberKicked != null) { MemberKicked.Raise(invoker, EventArgsHelper.Create(target)); } OnMemberKicked(invoker, target); return(true); }
/// <summary> /// When overridden in the derived class, tries to acquire the guild member with the given <paramref name="name"/> /// who's object already exists in memory. /// </summary> /// <param name="name">The name of the <see cref="IGuildMember"/> to get.</param> /// <param name="guildMember">When this method returns true, contains the <see cref="IGuildMember"/> /// for the guild member with the given <paramref name="name"/>.</param> /// <returns>True if the <see cref="IGuildMember"/> with the given <paramref name="name"/> was successfully /// loaded; otherwise false.</returns> protected override bool TryGetGuildMember(string name, out IGuildMember guildMember) { guildMember = _findGuildMember(name); return guildMember != null; }
/// <summary> /// When overridden in the derived class, allows for additional handling after a guild member is promoted. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <param name="target">The optional guild member the event involves.</param> protected virtual void OnMemberPromoted(IGuildMember invoker, IGuildMember target) { }
/// <summary> /// When overridden in the derived class, allows for additional handling after the guild's name has changed. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <param name="oldName">The old name.</param> /// <param name="newName">The new name.</param> protected virtual void OnNameChanged(IGuildMember invoker, string oldName, string newName) { }
/// <summary> /// Logs an event from a guild. /// </summary> /// <param name="guildManager">The <see cref="IGuildManager"/>.</param> /// <param name="eventCreator">The guild member that created the event.</param> /// <param name="guildEvent">The type of event that took place.</param> /// <exception cref="ArgumentNullException"><paramref name="eventCreator"/> is null.</exception> public static void LogEvent(this IGuildManager guildManager, IGuildMember eventCreator, GuildEvents guildEvent) { guildManager.LogEvent(eventCreator, guildEvent, null, null, null, null); }
/// <summary> /// Logs an event from a guild. /// </summary> /// <param name="guildManager">The <see cref="IGuildManager"/>.</param> /// <param name="eventCreator">The guild member that created the event.</param> /// <param name="guildEvent">The type of event that took place.</param> /// <param name="eventTarget">Optionally contains the other guild member that the event involves. This member /// may or may not actually be in the guild at this point.</param> /// <param name="arg0">The optional first argument string.</param> /// <exception cref="ArgumentNullException"><paramref name="eventCreator"/> is null.</exception> public static void LogEvent(this IGuildManager guildManager, IGuildMember eventCreator, GuildEvents guildEvent, IGuildMember eventTarget, string arg0) { guildManager.LogEvent(eventCreator, guildEvent, eventTarget, arg0, null, null); }
/// <summary> /// Tries to change the name of the guild. /// </summary> /// <param name="invoker">The guild member trying to change the guild's name.</param> /// <param name="newName">The new name of the guild.</param> /// <returns>True if the name was successfully changed; otherwise false.</returns> public bool TryChangeName(IGuildMember invoker, string newName) { if (!EnsureValidEventSource(invoker)) return false; if (!EnsureValidRank(invoker, _guildSettings.MinRankRename)) return false; if (_name == newName || !GuildManager.IsNameAvailable(newName)) return false; var oldValue = Name; var success = InternalTryChangeName(newName); if (success) { _name = newName; Save(); OnNameChanged(invoker, oldValue, Name); if (NameChanged != null) NameChanged.Raise(this, new GuildRenameEventArgs(invoker, oldValue, Name)); } return success; }
/// <summary> /// When overridden in the derived class, allows for additional handling after a new guild member is added. /// Use this instead of the corresponding event when possible. /// </summary> protected virtual void OnMemberAdded(IGuildMember newMember) { }
/// <summary> /// When overridden in the derived class, allows for additional handling of when a member of this /// guild has gone offline. /// </summary> /// <param name="guildMember">The guild member that went offline.</param> protected virtual void OnOnlineUserRemoved(IGuildMember guildMember) { }
/// <summary> /// Does the actual handling of inviting a member into the guild. /// </summary> /// <param name="invoker">The guild member is who inviting the <paramref name="target"/>.</param> /// <param name="target">The guild member being invited to the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully invited the <paramref name="target"/> /// to the guild; otherwise false.</returns> protected virtual bool InternalTryInviteMember(IGuildMember invoker, IGuildMember target) { // Send the invite target.SendGuildInvite(invoker, this); // Log the event GuildManager.LogEvent(invoker, GuildEvents.Invite, target); if (MemberInvited != null) MemberInvited.Raise(invoker, EventArgsHelper.Create(target)); OnMemberInvited(invoker, target); return true; }
/// <summary> /// When overridden in the derived class, allows for additional handling after the guild's tag has changed. /// Use this instead of the corresponding event when possible. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <param name="oldTag">The old tag.</param> /// <param name="newTag">The new tag.</param> protected virtual void OnTagChanged(IGuildMember invoker, string oldTag, string newTag) { }
/// <summary> /// Makes the <paramref name="invoker"/> try to invite the <paramref name="target"/> to the guild. /// </summary> /// <param name="invoker">The guild member is who inviting the <paramref name="target"/>.</param> /// <param name="target">The guild member being invited to the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully invited the <paramref name="target"/> /// to the guild; otherwise false.</returns> public bool TryInviteMember(IGuildMember invoker, IGuildMember target) { // Ensure the parameters are valid, and the target is not in a guild yet if (!EnsureValidEventSource(invoker, target)) return false; if (target.Guild != null) { const string errmsg = "Guild member `{0}` tried to invite `{1}` into guild `{2}`, but the target" + " is already part of a guild, `{3}`."; if (log.IsInfoEnabled) log.InfoFormat(errmsg, invoker, target, invoker.Guild, target.Guild); return false; } // Ensure the user has the needed permission level for the action if (!EnsureValidRank(invoker, _guildSettings.MinRankInvite)) return false; return InternalTryInviteMember(invoker, target); }
/// <summary> /// Does the actual handling of promoting a guild member. /// </summary> /// <param name="invoker">The guild member is who promoting the <paramref name="target"/>.</param> /// <param name="target">The guild member being promoted.</param> /// <returns>True if the <paramref name="invoker"/> successfully promoted the <paramref name="target"/>; /// otherwise false.</returns> protected virtual bool InternalTryPromoteMember(IGuildMember invoker, IGuildMember target) { // Promote target.GuildRank = new GuildRank((byte)(target.GuildRank + 1)); if (target.GuildRank > invoker.GuildRank) { const string errmsg = "Somehow, when `{0}` promoted `{1}`, their rank [{2}] ended up greater than that of" + " the member who promoted them [{3}]."; if (log.IsErrorEnabled) log.ErrorFormat(errmsg, invoker, target, target.GuildRank, invoker.GuildRank); Debug.Fail(string.Format(errmsg, invoker, target, target.GuildRank, invoker.GuildRank)); target.GuildRank = invoker.GuildRank; } // Log the event GuildManager.LogEvent(invoker, GuildEvents.Promote, target); if (MemberPromoted != null) MemberPromoted.Raise(invoker, EventArgsHelper.Create(target)); OnMemberPromoted(invoker, target); return true; }
/// <summary> /// Tries to change the tag of the guild. /// </summary> /// <param name="invoker">The guild member trying to change the guild's tag.</param> /// <param name="newTag">The new tag of the guild.</param> /// <returns>True if the tag was successfully changed; otherwise false.</returns> public bool TryChangeTag(IGuildMember invoker, string newTag) { if (!EnsureValidEventSource(invoker)) return false; if (!EnsureValidRank(invoker, _guildSettings.MinRankRename)) return false; if (_tag == newTag || !GuildManager.IsTagAvailable(newTag)) return false; var oldValue = Tag; var success = InternalTryChangeTag(newTag); if (success) { _tag = newTag; Save(); OnTagChanged(invoker, oldValue, Tag); if (TagChanged != null) TagChanged.Raise(this, new GuildRenameEventArgs(invoker, oldValue, Tag)); } return success; }
/// <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; }
/// <summary> /// When overridden in the derived class, displays the online members of the guild to the <paramref name="invoker"/>. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the online member list; otherwise false.</returns> protected abstract bool InternalTryViewOnlineMembers(IGuildMember invoker);
/// <summary> /// Does the actual handling of making a member leave the guild. /// </summary> /// <param name="invoker">The guild member who is leaving.</param> /// <returns>True if the <paramref name="invoker"/> successfully left the guild; otherwise false.</returns> protected virtual bool InternalTryLeaveGuild(IGuildMember invoker) { // If they were the only founder remaining, destroy the guild completely instead if (invoker.GuildRank == _guildSettings.HighestRank) { var founders = GetNumberOfFounders(); if (founders == 1) { DestroyGuild(); return true; } } // Leave the guild invoker.Guild = null; return true; }
/// <summary> /// Removes the reference of an online guild member from this guild. This does not make the user join or leave the /// guild in any way, just allows the guild to keep track of the members that are online. /// </summary> /// <param name="member">The online guild member to remove.</param> public void RemoveOnlineMember(IGuildMember member) { if (member.Guild != this) { const string errmsg = "The guild member `{0}` does not belong to this guild [{1}]!"; if (log.IsWarnEnabled) log.WarnFormat(errmsg, member, this); Debug.Fail(string.Format(errmsg, member, this)); return; } if (!_onlineMembers.Remove(member)) { const string errmsg = "Member `{0}` was not in the online list for guild `{1}`." + " Not really a problem that can't be easily fixed, but should be avoided since it is needless overhead."; Debug.Fail(string.Format(errmsg, member, this)); return; } if (OnlineUserRemoved != null) OnlineUserRemoved.Raise(this, EventArgsHelper.Create(member)); OnOnlineUserRemoved(member); }
/// <summary> /// Does the actual handling of kicking a member out of a guild. /// </summary> /// <param name="invoker">The guild member is who kicking out the <paramref name="target"/>.</param> /// <param name="target">The guild member being kicked out of the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully kicked the <paramref name="target"/> /// out of the guild; otherwise false.</returns> protected virtual bool InternalTryKickMember(IGuildMember invoker, IGuildMember target) { // Kick the target out of the guild target.Guild = null; // Log the event GuildManager.LogEvent(invoker, GuildEvents.Kick, target); if (MemberKicked != null) MemberKicked.Raise(invoker, EventArgsHelper.Create(target)); OnMemberKicked(invoker, target); return true; }
/// <summary> /// Makes sure that the guild event invoker and target are valid, and part of the same guild. /// </summary> /// <param name="invoker">The guild member invoking the event.</param> /// <param name="target">The guild member the event is being invoked on.</param> /// <returns>True if the parameters are valid; otherwise false.</returns> bool EnsureValidEventSourceSameGuild(IGuildMember invoker, IGuildMember target) { if (!EnsureValidEventSource(invoker, target)) return false; if (invoker.Guild != target.Guild) { const string errmsg = "Guild event invoker `{0}` is part of guild `{1}`, while their target `{2}` is part" + " of a different guild, `{3}`."; Debug.Fail(errmsg); if (log.IsWarnEnabled) log.WarnFormat(errmsg, invoker, invoker.Guild, target, target.Guild); return false; } return true; }
/// <summary> /// Does the actual handling of demoting a guild member. /// </summary> /// <param name="invoker">The guild member is who demoting the <paramref name="target"/>.</param> /// <param name="target">The guild member being demoted.</param> /// <returns>True if the <paramref name="invoker"/> successfully demoted the <paramref name="target"/>; /// otherwise false.</returns> protected virtual bool InternalTryDemoteMember(IGuildMember invoker, IGuildMember target) { // Demote target.GuildRank = new GuildRank((byte)(target.GuildRank - 1)); if (target.GuildRank < 0 || target.GuildRank > _guildSettings.HighestRank) { const string errmsg = "Somehow, when `{0}` demoted `{1}`, their rank ended up at the invalid value of `{2}`." + " Rank being reset to 0."; if (log.IsErrorEnabled) log.ErrorFormat(errmsg, invoker, target, target.GuildRank); Debug.Fail(string.Format(errmsg, invoker, target, target.GuildRank)); target.GuildRank = 0; } // Log the event GuildManager.LogEvent(invoker, GuildEvents.Demote, target); OnMemberDemoted(invoker, target); if (MemberDemoted != null) MemberDemoted.Raise(invoker, EventArgsHelper.Create(target)); return true; }
/// <summary> /// Makes the <paramref name="invoker"/> try to promote the <paramref name="target"/>. /// </summary> /// <param name="invoker">The guild member is who promoting the <paramref name="target"/>.</param> /// <param name="target">The guild member being promoted.</param> /// <returns>True if the <paramref name="invoker"/> successfully promoted the <paramref name="target"/>; /// otherwise false.</returns> public bool TryPromoteMember(IGuildMember invoker, IGuildMember target) { // Ensure the parameters are valid if (!EnsureValidEventSourceSameGuild(invoker, target)) return false; // Ensure the invoker has the needed permissions if (!EnsureValidRank(invoker, _guildSettings.MinRankPromote)) return false; // Only allow promotions to be done on a member that is a lower rank than the one promoting if (invoker.GuildRank <= target.GuildRank) { const string errmsg = "Guild member `{0}` tried to promote member `{1}`, but their rank [{2}] is" + " is not greater than the rank of the one they are trying to promote [{3}]."; if (log.IsInfoEnabled) log.InfoFormat(errmsg, invoker, target, invoker.GuildRank, target.GuildRank); return false; } if (target.GuildRank == 0) return false; return InternalTryPromoteMember(invoker, target); }
/// <summary> /// Makes the <paramref name="invoker"/> try to view the event log for the guild. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the log; otherwise false.</returns> public bool TryViewEventLog(IGuildMember invoker) { // Ensure the parameters are valid if (!EnsureValidEventSource(invoker)) return false; // Ensure the user has the needed permission level for the action if (!EnsureValidRank(invoker, _guildSettings.MinRankViewLog)) return false; return InternalTryViewEventLog(invoker); }
/// <summary> /// Makes the <paramref name="invoker"/> try to view the list of online guild members. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the online member list; otherwise false.</returns> public bool TryViewOnlineMembers(IGuildMember invoker) { // Ensure the parameters are valid if (!EnsureValidEventSource(invoker)) return false; return InternalTryViewOnlineMembers(invoker); }
/// <summary> /// Makes the <paramref name="invoker"/> try to kick the <paramref name="target"/> out of the guild. /// </summary> /// <param name="invoker">The guild member is who kicking out the <paramref name="target"/>.</param> /// <param name="target">The guild member being kicked out of the guild.</param> /// <returns>True if the <paramref name="invoker"/> successfully kicked the <paramref name="target"/> /// out of the guild; otherwise false.</returns> public bool TryKickMember(IGuildMember invoker, IGuildMember target) { // Ensure the user and invoker are in the same guild if (!EnsureValidEventSourceSameGuild(invoker, target)) return false; // Ensure the user has the needed permission level for the action if (!EnsureValidRank(invoker, _guildSettings.MinRankKick)) return false; // The invoker's rank must be greater than or equal to the target's rank if (invoker.GuildRank < target.GuildRank) { const string errmsg = "Guild member `{0}` from guild `{1}` tried to kick out `{2}`, but their rank [{3}] is" + " is lower than the rank of the one they are trying to kick [{4}]."; if (log.IsInfoEnabled) log.InfoFormat(errmsg, invoker, invoker.Guild, target, invoker.GuildRank, target.GuildRank); return false; } return InternalTryKickMember(invoker, target); }
/// <summary> /// When overridden in the derived class, does the actually handling of viewing the event log for the guild. /// This should send the latest entries of the guild event log to the <paramref name="invoker"/>. /// </summary> /// <param name="invoker">The guild member that invoked the event.</param> /// <returns>True if the <paramref name="invoker"/> successfully viewed the log; otherwise false.</returns> protected abstract bool InternalTryViewEventLog(IGuildMember invoker);
/// <summary> /// Adds the reference of an online guild member to this guild that is new to the guild. /// This does not make the user join or leave the guild in any way, just allows the guild to keep track of the /// members that are online. /// </summary> /// <param name="newMember">The online guild member to add.</param> public void AddNewOnlineMember(IGuildMember newMember) { if (MemberAdded != null) MemberAdded.Raise(this, EventArgsHelper.Create(newMember)); OnMemberAdded(newMember); AddOnlineMember(newMember); }
/// <summary> /// Makes the <paramref name="invoker"/> try to leave the guild. /// </summary> /// <param name="invoker">The guild member who is leaving.</param> /// <returns>True if the <paramref name="invoker"/> successfully left the guild; otherwise false.</returns> public bool TryLeaveGuild(IGuildMember invoker) { // Ensure a valid invoker if (!EnsureValidEventSource(invoker)) return false; return InternalTryLeaveGuild(invoker); }