Better implementation of /warn

Signed-off-by: mctaylors <cantsendmails@mctaylors.ru>

locale/Messages.resx

@@ -705,4 +705,55 @@
   <data name="SettingsWarnPunishmentDuration" xml:space="preserve">
       <value>Punishment duration for warnings</value>
   </data>
+  <data name="ListWarnTitle" xml:space="preserve">
+      <value>Here's your warnings, {0}:</value>
+  </data>
+  <data name="YouHaveNoWarnings" xml:space="preserve">
+      <value>You have no warnings!</value>
+  </data>
+  <data name="ReceivedOn" xml:space="preserve">
+      <value>Received on {0}</value>
+  </data>
+  <data name="UserWarnRemoved" xml:space="preserve">
+      <value>Warning #{0} has been removed from {1}</value>
+  </data>
+  <data name="YourWarningHasBeenRevoked" xml:space="preserve">
+      <value>Your warning has been revoked</value>
+  </data>
+  <data name="WrongWarningNumberSelected" xml:space="preserve">
+      <value>Wrong warning number selected!</value>
+  </data>
+  <data name="UserCannotWarnBot" xml:space="preserve">
+      <value>You cannot warn me!</value>
+  </data>
+  <data name="UserCannotWarnOwner" xml:space="preserve">
+      <value>You cannot warn the owner of this guild!</value>
+  </data>
+  <data name="UserCannotWarnTarget" xml:space="preserve">
+      <value>You cannot warn this member!</value>
+  </data>
+  <data name="UserCannotWarnThemselves" xml:space="preserve">
+      <value>You cannot warn yourself!</value>
+  </data>
+  <data name="UserCannotUnwarnBot" xml:space="preserve">
+      <value>You cannot unwarn me!</value>
+  </data>
+  <data name="UserCannotUnwarnOwner" xml:space="preserve">
+      <value>You cannot unwarn the owner of this guild!</value>
+  </data>
+  <data name="UserCannotUnwarnTarget" xml:space="preserve">
+      <value>You cannot unwarn this member!</value>
+  </data>
+  <data name="UserCannotUnwarnThemselves" xml:space="preserve">
+      <value>You cannot unwarn yourself!</value>
+  </data>
+  <data name="BotCannotWarnMembers" xml:space="preserve">
+      <value>I cannot warn members from this guild!</value>
+  </data>
+  <data name="BotCannotWarnTarget" xml:space="preserve">
+      <value>I cannot warn this member!</value>
+  </data>
+  <data name="BotCannotUnwarnTarget" xml:space="preserve">
+      <value>I cannot unwarn this member!</value>
+  </data>
 </root>

locale/Messages.ru.resx

@@ -705,4 +705,55 @@
   <data name="SettingsWarnPunishmentDuration" xml:space="preserve">
       <value>Длительность наказания для предупреждений</value>
   </data>
+  <data name="ListWarnTitle" xml:space="preserve">
+      <value>Вот ваши предупреждения, {0}:</value>
+  </data>
+  <data name="YouHaveNoWarnings" xml:space="preserve">
+      <value>У вас нет предупреждений!</value>
+  </data>
+  <data name="ReceivedOn" xml:space="preserve">
+      <value>Получено {0}</value>
+  </data>
+  <data name="UserWarnRemoved" xml:space="preserve">
+      <value>Предупреждение №{0} было снято с {1}</value>
+  </data>
+  <data name="YourWarningHasBeenRevoked" xml:space="preserve">
+      <value>Ваше предупреждение было отозвано</value>
+  </data>
+  <data name="WrongWarningNumberSelected" xml:space="preserve">
+      <value>Выбрано неверное число предупреждения!</value>
+  </data>
+  <data name="UserCannotWarnBot" xml:space="preserve">
+      <value>Ты не можешь меня предупредить!</value>
+  </data>
+  <data name="UserCannotWarnOwner" xml:space="preserve">
+      <value>Ты не можешь предупредить владельца этого сервера!</value>
+  </data>
+  <data name="UserCannotWarnTarget" xml:space="preserve">
+      <value>Ты не можешь предупредить этого участника!</value>
+  </data>
+  <data name="UserCannotWarnThemselves" xml:space="preserve">
+      <value>Ты не можешь себя предупредить!</value>
+  </data>
+  <data name="UserCannotUnwarnBot" xml:space="preserve">
+      <value>Ты не можешь снять с меня предупреждения!</value>
+  </data>
+  <data name="UserCannotUnwarnOwner" xml:space="preserve">
+      <value>Ты не можешь снять предупреждения с владельца этого сервера!</value>
+  </data>
+  <data name="UserCannotUnwarnTarget" xml:space="preserve">
+      <value>Ты не можешь снять предупреждения с этого участника!</value>
+  </data>
+  <data name="UserCannotUnwarnThemselves" xml:space="preserve">
+      <value>Ты не можешь снять с себя предупреждения!</value>
+  </data>
+  <data name="BotCannotUnwarnTarget" xml:space="preserve">
+      <value>Я не могу снимать предупреждения этого участника!</value>
+  </data>
+  <data name="BotCannotWarnTarget" xml:space="preserve">
+      <value>Я не могу предупредить этого участника!</value>
+  </data>
+  <data name="BotCannotWarnMembers" xml:space="preserve">
+      <value>Я не могу предупреждать участников этого сервера!</value>
+  </data>
 </root>

locale/Messages.tt-ru.resx

@@ -685,7 +685,7 @@
       <value>вы схлопотали варн</value>
   </data>
   <data name="YourWarningsHaveBeenRevoked" xml:space="preserve">
-      <value>вы получили амнистию</value>
+      <value>вы получили карт-бланш</value>
   </data>
   <data name="DescriptionActionWarns" xml:space="preserve">
       <value>варнов: {0}</value>
@@ -705,4 +705,55 @@
   <data name="SettingsWarnThreshold" xml:space="preserve">
       <value>сколько варнов чтобы потом бан</value>
   </data>
+  <data name="ListWarnTitle" xml:space="preserve">
+      <value>хаха, смотри {0}, это все ты заслужил:</value>
+  </data>
+  <data name="YouHaveNoWarnings" xml:space="preserve">
+      <value>ого, да на тебя еще нет претензий!</value>
+  </data>
+  <data name="ReceivedOn" xml:space="preserve">
+      <value>получил {0}</value>
+  </data>
+  <data name="UserWarnRemoved" xml:space="preserve">
+      <value>варн {0} снят с {1}</value>
+  </data>
+  <data name="YourWarningHasBeenRevoked" xml:space="preserve">
+      <value>вы получили амнистию</value>
+  </data>
+  <data name="WrongWarningNumberSelected" xml:space="preserve">
+      <value>да нету такого варна вроде</value>
+  </data>
+  <data name="UserCannotWarnBot" xml:space="preserve">
+      <value>ээбля френдли фаер огонь по своим</value>
+  </data>
+  <data name="UserCannotWarnThemselves" xml:space="preserve">
+      <value>самовар нельзя</value>
+  </data>
+  <data name="UserCannotWarnTarget" xml:space="preserve">
+      <value>варн этому шизику нельзя</value>
+  </data>
+  <data name="UserCannotWarnOwner" xml:space="preserve">
+      <value>варн админу нельзя</value>
+  </data>
+  <data name="UserCannotUnwarnBot" xml:space="preserve">
+      <value>ну, к сожалению тебе этого не дано</value>
+  </data>
+  <data name="UserCannotUnwarnOwner" xml:space="preserve">
+      <value>разварн админу нельзя</value>
+  </data>
+  <data name="UserCannotUnwarnTarget" xml:space="preserve">
+      <value>разварн этому шизику нельзя</value>
+  </data>
+  <data name="UserCannotUnwarnThemselves" xml:space="preserve">
+      <value>саморазвар нельзя</value>
+  </data>
+  <data name="BotCannotWarnTarget" xml:space="preserve">
+      <value>я не могу его заварить...</value>
+  </data>
+  <data name="BotCannotUnwarnTarget" xml:space="preserve">
+      <value>я не могу его разварить...</value>
+  </data>
+  <data name="BotCannotWarnMembers" xml:space="preserve">
+      <value>я не могу ваще никого варить...</value>
+  </data>
 </root>

src/Commands/WarnCommandGroup.cs

@@ -14,8 +14,10 @@ using Remora.Discord.Commands.Conditions;
 using Remora.Discord.Commands.Contexts;
 using Remora.Discord.Commands.Feedback.Services;
 using Remora.Discord.Extensions.Embeds;
+using Remora.Discord.Extensions.Formatting;
 using Remora.Rest.Core;
 using Remora.Results;
+using static System.DateTimeOffset;
 
 namespace Octobot.Commands;
 
@@ -49,7 +51,8 @@ public class WarnCommandGroup : CommandGroup
     [DiscordDefaultDMPermission(false)]
     [RequireContext(ChannelContext.Guild)]
     [RequireDiscordPermission(DiscordPermission.KickMembers)]
-    [RequireBotDiscordPermissions(DiscordPermission.KickMembers)]
+    [RequireBotDiscordPermissions(DiscordPermission.KickMembers,
+        DiscordPermission.ModerateMembers, DiscordPermission.BanMembers)]
     [Description("Warn user")]
     [UsedImplicitly]
     public async Task<Result> ExecuteWarnAsync(
@@ -89,15 +92,37 @@ public class WarnCommandGroup : CommandGroup
     private async Task<Result> WarnUserAsync(IUser executor, IUser target, string reason, IGuild guild,
         GuildData data, Snowflake channelId, IUser bot, CancellationToken ct = default)
     {
+        var interactionResult
+            = await _utility.CheckInteractionsAsync(guild.ID, executor.ID, target.ID, "Warn", ct);
+        if (!interactionResult.IsSuccess)
+        {
+            return ResultExtensions.FromError(interactionResult);
+        }
+
+        if (interactionResult.Entity is not null)
+        {
+            var errorEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, bot)
+                .WithColour(ColorsList.Red).Build();
+
+            return await _feedback.SendContextualEmbedResultAsync(errorEmbed, ct: ct);
+        }
+
         var memberData = data.GetOrCreateMemberData(target.ID);
-        memberData.Warns++;
+        var warns = memberData.Warns;
+
+        warns.Add(new Warn
+        {
+            WarnedBy = executor.ID.Value,
+            At = UtcNow,
+            Reason = reason
+        });
 
         var warnsThreshold = GuildSettings.WarnsThreshold.Get(data.Settings);
 
         var builder = new StringBuilder()
             .AppendBulletPointLine(string.Format(Messages.DescriptionActionReason, reason))
             .AppendBulletPointLine(string.Format(Messages.DescriptionActionWarns,
-                warnsThreshold is 0 ? memberData.Warns : $"{memberData.Warns}/{warnsThreshold}"));
+                warnsThreshold is 0 ? warns.Count : $"{warns.Count}/{warnsThreshold}"));
 
         var title = string.Format(Messages.UserWarned, target.GetTag());
         var description = builder.ToString();
@@ -119,10 +144,10 @@ public class WarnCommandGroup : CommandGroup
         _utility.LogAction(
             data.Settings, channelId, executor, title, description, target, ColorsList.Yellow, false, ct);
 
-        if (memberData.Warns >= warnsThreshold &&
+        if (warns.Count >= warnsThreshold &&
             GuildSettings.WarnPunishment.Get(data.Settings) is not "off" and not "disable" and not "disabled")
         {
-            memberData.Warns = 0;
+            warns.Clear();
             return await PunishUserAsync(target, guild, data, channelId, bot, CancellationToken);
         }
 
@@ -170,14 +195,15 @@ public class WarnCommandGroup : CommandGroup
     [DiscordDefaultDMPermission(false)]
     [RequireContext(ChannelContext.Guild)]
     [RequireDiscordPermission(DiscordPermission.KickMembers)]
-    [RequireBotDiscordPermissions(DiscordPermission.KickMembers)]
     [Description("Remove warns from user")]
     [UsedImplicitly]
     public async Task<Result> ExecuteUnwarnAsync(
         [Description("User to remove warns from")]
         IUser target,
-        [Description("Warns remove reason")] [MaxLength(256)]
+        [Description("Warn remove reason")] [MaxLength(256)]
-        string reason)
+        string reason,
+        [Description("Number of the warning to be deleted")]
+        int? number = null)
     {
         if (!_context.TryGetContextIDs(out var guildId, out var channelId, out var executorId))
         {
@@ -205,14 +231,37 @@ public class WarnCommandGroup : CommandGroup
         var data = await _guildData.GetData(guild.ID, CancellationToken);
         Messages.Culture = GuildSettings.Language.Get(data.Settings);
 
+        if (number is not null)
+        {
+            return await RemoveUserWarnAsync(executor, target, reason, number.Value, guild, data, channelId, bot,
+                CancellationToken);
+        }
+
         return await RemoveUserWarnsAsync(executor, target, reason, guild, data, channelId, bot, CancellationToken);
     }
 
-    private async Task<Result> RemoveUserWarnsAsync(IUser executor, IUser target, string reason, IGuild guild,
+    private async Task<Result> RemoveUserWarnAsync(IUser executor, IUser target, string reason, int warnNumber,
-        GuildData data, Snowflake channelId, IUser bot, CancellationToken ct = default)
+        IGuild guild, GuildData data, Snowflake channelId, IUser bot, CancellationToken ct = default)
     {
+        var interactionResult
+            = await _utility.CheckInteractionsAsync(guild.ID, executor.ID, target.ID, "Unwarn", ct);
+        if (!interactionResult.IsSuccess)
+        {
+            return ResultExtensions.FromError(interactionResult);
+        }
+
+        if (interactionResult.Entity is not null)
+        {
+            var errorEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, bot)
+                .WithColour(ColorsList.Red).Build();
+
+            return await _feedback.SendContextualEmbedResultAsync(errorEmbed, ct: ct);
+        }
+
         var memberData = data.GetOrCreateMemberData(target.ID);
-        if (memberData.Warns is 0)
+        var warns = memberData.Warns;
+
+        if (warns.Count is 0)
         {
             var failedEmbed = new EmbedBuilder().WithSmallTitle(Messages.UserHasNoWarnings, bot)
                 .WithColour(ColorsList.Red).Build();
@@ -220,10 +269,82 @@ public class WarnCommandGroup : CommandGroup
             return await _feedback.SendContextualEmbedResultAsync(failedEmbed, ct: ct);
         }
 
-        memberData.Warns = 0;
+        var index = warnNumber - 1;
+
+        if (index >= warns.Count || index < 0)
+        {
+            var failedEmbed = new EmbedBuilder().WithSmallTitle(Messages.WrongWarningNumberSelected, bot)
+                .WithColour(ColorsList.Red).Build();
+
+            return await _feedback.SendContextualEmbedResultAsync(failedEmbed, ct: ct);
+        }
+
+        var builder = new StringBuilder()
+            .Append("> ").AppendLine(warns[index].Reason)
+            .AppendBulletPointLine(string.Format(Messages.DescriptionActionReason, reason));
+
+        warns.RemoveAt(index);
+
+        var title = string.Format(Messages.UserWarnRemoved, warnNumber, target.GetTag());
+        var description = builder.ToString();
+
+        var dmChannelResult = await _userApi.CreateDMAsync(target.ID, ct);
+        if (dmChannelResult.IsDefined(out var dmChannel))
+        {
+            var dmEmbed = new EmbedBuilder().WithGuildTitle(guild)
+                .WithTitle(Messages.YourWarningHasBeenRevoked)
+                .WithDescription(description)
+                .WithActionFooter(executor)
+                .WithCurrentTimestamp()
+                .WithColour(ColorsList.Green)
+                .Build();
+
+            await _channelApi.CreateMessageWithEmbedResultAsync(dmChannel.ID, embedResult: dmEmbed, ct: ct);
+        }
+
+        var embed = new EmbedBuilder().WithSmallTitle(
+                title, target)
+            .WithColour(ColorsList.Green).Build();
+
+        _utility.LogAction(
+            data.Settings, channelId, executor, title, description, target, ColorsList.Yellow, false, ct);
+
+        return await _feedback.SendContextualEmbedResultAsync(embed, ct: ct);
+    }
+
+    private async Task<Result> RemoveUserWarnsAsync(IUser executor, IUser target, string reason,
+        IGuild guild, GuildData data, Snowflake channelId, IUser bot, CancellationToken ct = default)
+    {
+        var interactionResult
+            = await _utility.CheckInteractionsAsync(guild.ID, executor.ID, target.ID, "Unwarn", ct);
+        if (!interactionResult.IsSuccess)
+        {
+            return ResultExtensions.FromError(interactionResult);
+        }
+
+        if (interactionResult.Entity is not null)
+        {
+            var errorEmbed = new EmbedBuilder().WithSmallTitle(interactionResult.Entity, bot)
+                .WithColour(ColorsList.Red).Build();
+
+            return await _feedback.SendContextualEmbedResultAsync(errorEmbed, ct: ct);
+        }
+
+        var memberData = data.GetOrCreateMemberData(target.ID);
+        var warns = memberData.Warns;
+
+        if (warns.Count is 0)
+        {
+            var failedEmbed = new EmbedBuilder().WithSmallTitle(Messages.UserHasNoWarnings, bot)
+                .WithColour(ColorsList.Red).Build();
+
+            return await _feedback.SendContextualEmbedResultAsync(failedEmbed, ct: ct);
+        }
 
         var builder = new StringBuilder().AppendBulletPointLine(string.Format(Messages.DescriptionActionReason, reason));
 
+        warns.Clear();
+
         var title = string.Format(Messages.UserWarnsRemoved, target.GetTag());
         var description = builder.ToString();
 
@@ -250,4 +371,76 @@ public class WarnCommandGroup : CommandGroup
 
         return await _feedback.SendContextualEmbedResultAsync(embed, ct: ct);
     }
+
+    [Command("listwarn")]
+    [DiscordDefaultDMPermission(false)]
+    [Ephemeral]
+    [Description("(Ephemeral) Get your current warns")]
+    [UsedImplicitly]
+    public async Task<Result> ExecuteListWarnsAsync()
+    {
+        if (!_context.TryGetContextIDs(out var guildId, out _, out var executorId))
+        {
+            return new ArgumentInvalidError(nameof(_context), "Unable to retrieve necessary IDs from command context");
+        }
+
+        var botResult = await _userApi.GetCurrentUserAsync(CancellationToken);
+        if (!botResult.IsDefined(out var bot))
+        {
+            return Result.FromError(botResult);
+        }
+
+        var executorResult = await _userApi.GetUserAsync(executorId, CancellationToken);
+        if (!executorResult.IsDefined(out var executor))
+        {
+            return Result.FromError(executorResult);
+        }
+
+        var guildResult = await _guildApi.GetGuildAsync(guildId, ct: CancellationToken);
+        if (!guildResult.IsDefined(out var guild))
+        {
+            return Result.FromError(guildResult);
+        }
+
+        var data = await _guildData.GetData(guild.ID, CancellationToken);
+        Messages.Culture = GuildSettings.Language.Get(data.Settings);
+
+        return await ListWarnsAsync(executor, data, bot, CancellationToken);
+    }
+
+    private async Task<Result> ListWarnsAsync(IUser executor, GuildData data, IUser bot, CancellationToken ct = default)
+    {
+        var memberData = data.GetOrCreateMemberData(executor.ID);
+        var warns = memberData.Warns;
+
+        if (warns.Count is 0)
+        {
+            var failedEmbed = new EmbedBuilder().WithSmallTitle(Messages.YouHaveNoWarnings, bot)
+                .WithColour(ColorsList.Green).Build();
+
+            return await _feedback.SendContextualEmbedResultAsync(failedEmbed, ct: ct);
+        }
+
+        var warnsThreshold = GuildSettings.WarnsThreshold.Get(data.Settings);
+
+        var description = new StringBuilder()
+            .AppendLine(string.Format(Messages.DescriptionActionWarns,
+                warnsThreshold is 0 ? warns.Count : $"{warns.Count}/{warnsThreshold}"));
+
+        var warnCount = 0;
+        foreach (var warn in warns)
+        {
+            warnCount++;
+            description.Append(warnCount).Append(". ").AppendLine(warn.Reason)
+                .AppendSubBulletPoint(Messages.IssuedBy).Append(' ').AppendLine(Mention.User(warn.WarnedBy.ToSnowflake()))
+                .AppendSubBulletPointLine(string.Format(Messages.ReceivedOn, Markdown.Timestamp(warn.At)));
+        }
+
+        var embed = new EmbedBuilder()
+            .WithSmallTitle(string.Format(Messages.ListWarnTitle, executor.GetTag()), executor)
+            .WithDescription(description.ToString())
+            .WithColour(ColorsList.Default).Build();
+
+        return await _feedback.SendContextualEmbedResultAsync(embed, ct: ct);
+    }
 }

src/Data/MemberData.cs

@@ -5,20 +5,25 @@ namespace Octobot.Data;
 /// </summary>
 public sealed class MemberData
 {
-    public MemberData(ulong id, List<Reminder>? reminders = null)
+    public MemberData(ulong id, List<Reminder>? reminders = null, List<Warn>? warns = null)
     {
         Id = id;
         if (reminders is not null)
         {
             Reminders = reminders;
         }
+
+        if (warns is not null)
+        {
+            Warns = warns;
+        }
     }
 
     public ulong Id { get; }
     public DateTimeOffset? BannedUntil { get; set; }
     public DateTimeOffset? MutedUntil { get; set; }
-    public int Warns { get; set; }
     public bool Kicked { get; set; }
     public List<ulong> Roles { get; set; } = [];
     public List<Reminder> Reminders { get; } = [];
+    public List<Warn> Warns { get; } = [];
 }

src/Data/Warn.cs

@@ -0,0 +1,10 @@
+using Remora.Rest.Core;
+
+namespace Octobot.Data;
+
+public struct Warn
+{
+    public ulong WarnedBy { get; init; }
+    public DateTimeOffset At { get; init; }
+    public string Reason { get; init; }
+}

src/Messages.Designer.cs

@@ -1247,6 +1247,13 @@ namespace Octobot {
             }
         }
 
+        internal static string YouHaveNoWarnings
+        {
+            get {
+                return ResourceManager.GetString("YouHaveNoWarnings", resourceCulture);
+            }
+        }
+
         internal static string ReceivedTooManyWarnings
         {
             get {
@@ -1265,5 +1272,117 @@ namespace Octobot {
                 return ResourceManager.GetString("ButtonOpenWiki", resourceCulture);
             }
         }
+
+        internal static string ListWarnTitle
+        {
+            get {
+                return ResourceManager.GetString("ListWarnTitle", resourceCulture);
+            }
+        }
+
+        internal static string ReceivedOn
+        {
+            get {
+                return ResourceManager.GetString("ReceivedOn", resourceCulture);
+            }
+        }
+
+        internal static string UserWarnRemoved
+        {
+            get {
+                return ResourceManager.GetString("UserWarnRemoved", resourceCulture);
+            }
+        }
+
+        internal static string YourWarningHasBeenRevoked
+        {
+            get {
+                return ResourceManager.GetString("YourWarningHasBeenRevoked", resourceCulture);
+            }
+        }
+
+        internal static string WrongWarningNumberSelected
+        {
+            get {
+                return ResourceManager.GetString("WrongWarningNumberSelected", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotWarnBot
+        {
+            get {
+                return ResourceManager.GetString("UserCannotWarnBot", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotWarnOwner
+        {
+            get {
+                return ResourceManager.GetString("UserCannotWarnOwner", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotWarnTarget
+        {
+            get {
+                return ResourceManager.GetString("UserCannotWarnTarget", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotWarnThemselves
+        {
+            get {
+                return ResourceManager.GetString("UserCannotWarnThemselves", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotUnwarnBot
+        {
+            get {
+                return ResourceManager.GetString("UserCannotUnwarnBot", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotUnwarnOwner
+        {
+            get {
+                return ResourceManager.GetString("UserCannotUnwarnOwner", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotUnwarnTarget
+        {
+            get {
+                return ResourceManager.GetString("UserCannotUnwarnTarget", resourceCulture);
+            }
+        }
+
+        internal static string UserCannotUnwarnThemselves
+        {
+            get {
+                return ResourceManager.GetString("UserCannotUnwarnThemselves", resourceCulture);
+            }
+        }
+
+        internal static string BotCannotWarnTarget
+        {
+            get {
+                return ResourceManager.GetString("BotCannotWarnTarget", resourceCulture);
+            }
+        }
+
+        internal static string BotCannotWarnMembers
+        {
+            get {
+                return ResourceManager.GetString("BotCannotWarnMembers", resourceCulture);
+            }
+        }
+
+        internal static string BotCannotUnwarnTarget
+        {
+            get {
+                return ResourceManager.GetString("BotCannotUnwarnTarget", resourceCulture);
+            }
+        }
     }
 }