split warn punishments into a separate table

Added warn endpoints
Reminders should now be able to ping everyone if the user who created the reminder has that permission

src/EllieBot/Services/GrpcApi/ExprsSvc.cs

@@ -6,7 +6,7 @@ using EllieBot.Modules.Utility;
 
 namespace EllieBot.GrpcApi;
 
-public class ExprsSvc : GrpcExprs.GrpcExprsBase, IEService
+public class ExprsSvc : GrpcExprs.GrpcExprsBase, IGrpcSvc, IEService
 {
     private readonly EllieExpressionsService _svc;
     private readonly IQuoteService _qs;
@@ -19,6 +19,9 @@ public class ExprsSvc : GrpcExprs.GrpcExprsBase, IEService
         _client = client;
     }
 
+    public ServerServiceDefinition Bind()
+        => GrpcExprs.BindService(this);
+
     private ulong GetUserId(Metadata meta)
         => ulong.Parse(meta.FirstOrDefault(x => x.Key == "userid")!.Value);
 

src/EllieBot/Services/GrpcApi/GreetByeSvc.cs

@@ -3,7 +3,7 @@ using GreetType = EllieBot.Services.GreetType;
 
 namespace EllieBot.GrpcApi;
 
-public sealed class GreetByeSvc : GrpcGreet.GrpcGreetBase, IEService
+public sealed class GreetByeSvc : GrpcGreet.GrpcGreetBase, IGrpcSvc, IEService
 {
     private readonly GreetService _gs;
     private readonly DiscordSocketClient _client;
@@ -14,6 +14,9 @@ public sealed class GreetByeSvc : GrpcGreet.GrpcGreetBase, IEService
         _client = client;
     }
 
+    public ServerServiceDefinition Bind()
+        => GrpcGreet.BindService(this);
+
     private static GrpcGreetSettings ToConf(GreetSettings? conf)
     {
         if (conf is null)
@@ -50,11 +53,14 @@ public sealed class GreetByeSvc : GrpcGreet.GrpcGreetBase, IEService
         var settings = await _gs.GetGreetSettingsAsync(gid, type);
 
         if (settings is null)
-            return new();
+            return new()
+            {
+                Success = false
+            };
 
         return new()
         {
-            Settings = ToConf(settings)
+            Success = true
         };
     }
 

src/EllieBot/Services/GrpcApi/OtherSvc.cs

@@ -11,7 +11,7 @@ public static class GrpcApiExtensions
         => ulong.Parse(context.RequestHeaders.FirstOrDefault(x => x.Key == "userid")!.Value);
 }
 
-public sealed class OtherSvc : GrpcOther.GrpcOtherBase, IEService
+public sealed class OtherSvc : GrpcOther.GrpcOtherBase, IGrpcSvc, IEService
 {
     private readonly IDiscordClient _client;
     private readonly XpService _xp;
@@ -39,6 +39,9 @@ public sealed class OtherSvc : GrpcOther.GrpcOtherBase, IEService
         _cache = cache;
     }
 
+    public ServerServiceDefinition Bind()
+        => GrpcOther.BindService(this);
+
     [GrpcNoAuthRequired]
     public override async Task<BotOnGuildReply> BotOnGuild(BotOnGuildRequest request, ServerCallContext context)
     {
@@ -52,6 +55,22 @@ public sealed class OtherSvc : GrpcOther.GrpcOtherBase, IEService
         return reply;
     }
 
+    public override async Task<GetRolesReply> GetRoles(GetRolesRequest request, ServerCallContext context)
+    {
+        var g = await _client.GetGuildAsync(request.GuildId);
+        var roles = g?.Roles;
+        var reply = new GetRolesReply();
+        reply.Roles.AddRange(roles?.Select(x => new RoleReply()
+        {
+            Id = x.Id,
+            Name = x.Name,
+            Color = x.Color.ToString(),
+            IconUrl = x.GetIconUrl() ?? string.Empty,
+        }) ?? new List<RoleReply>());
+
+        return reply;
+    }
+
     public override async Task<GetTextChannelsReply> GetTextChannels(
         GetTextChannelsRequest request,
         ServerCallContext context)

src/EllieBot/Services/GrpcApi/WarnSvc.cs

@@ -0,0 +1,222 @@
+using Grpc.Core;
+using EllieBot.Db.Models;
+using EllieBot.Modules.Administration.Services;
+using Enum = System.Enum;
+
+namespace EllieBot.GrpcApi;
+
+public sealed class WarnSvc : GrpcWarn.GrpcWarnBase, IGrpcSvc, IEService
+{
+    private readonly UserPunishService _ups;
+    private readonly DiscordSocketClient _client;
+
+    public WarnSvc(UserPunishService ups, DiscordSocketClient client)
+    {
+        _ups = ups;
+        _client = client;
+    }
+
+    public ServerServiceDefinition Bind()
+        => GrpcWarn.BindService(this);
+
+    public override async Task<WarnSettingsReply> GetWarnSettings(
+        WarnSettingsRequest request,
+        ServerCallContext context)
+    {
+        var list = await _ups.WarnPunishList(request.GuildId);
+
+        var wsr = new WarnSettingsReply();
+
+        wsr.Punishments.AddRange(list.Select(x => new WarnPunishment()
+        {
+            Action = x.Punishment.ToString(),
+            Duration = x.Time,
+            Threshold = x.Count,
+            Role = x.RoleId is ulong rid
+                ? _client.GetGuild(request.GuildId)?.GetRole(rid)?.Name ?? x.RoleId?.ToString() ?? string.Empty
+                : string.Empty
+        }));
+
+        return wsr;
+    }
+
+    public override async Task<SetWarnExpiryReply> SetWarnExpiry(
+        SetWarnExpiryRequest request,
+        ServerCallContext context)
+    {
+        if (request.ExpiryDays > 366)
+        {
+            return new SetWarnExpiryReply()
+            {
+                Success = false
+            };
+        }
+
+        await _ups.WarnExpireAsync(request.GuildId, request.ExpiryDays, request.DeleteOnExpire);
+
+        return new SetWarnExpiryReply()
+        {
+            Success = true
+        };
+    }
+
+    public override async Task<DeleteWarnpReply> DeleteWarnp(DeleteWarnpRequest request, ServerCallContext context)
+    {
+        var succ = await _ups.WarnPunishRemove(request.GuildId, request.Threshold);
+
+        return new DeleteWarnpReply
+        {
+            Success = succ
+        };
+    }
+
+    public override async Task<AddWarnpReply> AddWarnp(AddWarnpRequest request, ServerCallContext context)
+    {
+        if (request.Punishment.Threshold <= 0)
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "Threshold must be greater than 0"));
+
+        var g = _client.GetGuild(request.GuildId);
+
+        if (g is null)
+            throw new RpcException(new Status(StatusCode.NotFound, "Guild not found"));
+
+        if (!Enum.TryParse<PunishmentAction>(request.Punishment.Action, out var action))
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid action"));
+
+        IRole? role = null;
+        if (action == PunishmentAction.AddRole && ulong.TryParse(request.Punishment.Role, out var roleId))
+        {
+            role = g.GetRole(roleId);
+
+            if (role is null)
+                return new AddWarnpReply()
+                {
+                    Success = false
+                };
+
+            if (!ulong.TryParse(context.RequestHeaders.GetValue("userid"), out var userId))
+                return new AddWarnpReply()
+                {
+                    Success = false
+                };
+
+            var user = await ((IGuild)g).GetUserAsync(userId);
+
+            if (user is null)
+                throw new RpcException(new Status(StatusCode.NotFound, "User not found"));
+
+            var userMaxRole = user.GetRoles().MaxBy(x => x.Position)?.Position ?? 0;
+            if (g.OwnerId != user.Id && userMaxRole <= role.Position)
+            {
+                return new AddWarnpReply()
+                {
+                    Success = false
+                };
+            }
+        }
+
+        var duration = TimeSpan.FromMinutes(request.Punishment.Duration);
+
+        var succ = await _ups.WarnPunish(request.GuildId,
+            request.Punishment.Threshold,
+            action,
+            duration,
+            role
+        );
+
+        return new AddWarnpReply()
+        {
+            Success = succ
+        };
+    }
+
+    public override async Task<GetLatestWarningsReply> GetLatestWarnings(
+        GetLatestWarningsRequest request,
+        ServerCallContext context)
+    {
+        var (latest, count) = await _ups.GetLatestWarnings(request.GuildId, request.Page);
+
+        var reply = new GetLatestWarningsReply()
+        {
+            TotalCount = count
+        };
+
+        reply.Warnings.AddRange(latest.Select(MapWarningToGrpcWarning));
+
+        return reply;
+    }
+
+    public override async Task<GetUserWarningsReply> GetUserWarnings(
+        GetUserWarningsRequest request,
+        ServerCallContext context)
+    {
+        IReadOnlyCollection<Db.Models.Warning> latest = [];
+        var count = 0;
+        if (ulong.TryParse(request.User, out var userId))
+        {
+            (latest, count) = await _ups.GetUserWarnings(request.GuildId, userId, request.Page);
+        }
+        else if (_client.GetGuild(request.GuildId)?.Users.FirstOrDefault(x => x.Username == request.User) is { } user)
+        {
+            (latest, count) = await _ups.GetUserWarnings(request.GuildId, user.Id, request.Page);
+        }
+        else
+        {
+        }
+
+        var reply = new GetUserWarningsReply
+        {
+            TotalCount = count
+        };
+
+        reply.Warnings.AddRange(latest.Select(MapWarningToGrpcWarning));
+
+        return reply;
+    }
+
+    private Warning MapWarningToGrpcWarning(Db.Models.Warning x)
+    {
+        return new Warning
+        {
+            Id = new kwum(x.Id).ToString(),
+            Forgiven = x.Forgiven,
+            ForgivenBy = x.ForgivenBy ?? string.Empty,
+            Reason = x.Reason ?? string.Empty,
+            Timestamp = x.DateAdded is { } da ? Ellie.Common.Extensions.ToTimestamp(da) : 0,
+            Weight = x.Weight,
+            Moderator = x.Moderator ?? string.Empty,
+            User = _client.GetUser(x.UserId)?.Username ?? x.UserId.ToString(),
+            UserId = x.UserId
+        };
+    }
+
+    public override async Task<ForgiveWarningReply> ForgiveWarning(
+        ForgiveWarningRequest request,
+        ServerCallContext context)
+    {
+        if (!kwum.TryParse(request.WarnId, out var wid))
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid warning ID"));
+
+        var succ = await _ups.ForgiveWarning(request.GuildId, wid, request.ModName);
+
+        return new ForgiveWarningReply
+        {
+            Success = succ
+        };
+    }
+
+    public override async Task<ForgiveWarningReply> DeleteWarning(
+        ForgiveWarningRequest request,
+        ServerCallContext context)
+    {
+        if (!kwum.TryParse(request.WarnId, out var wid))
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid warning ID"));
+
+        var succ = await _ups.WarnDelete(request.GuildId, wid);
+
+        return new ForgiveWarningReply
+        {
+            Success = succ
+        };
+    }
+}

src/EllieBot/Services/GrpcApiPermsInterceptor.cs

@@ -45,7 +45,7 @@ public sealed partial class GrpcApiPermsInterceptor : Interceptor
                 return await continuation(request, context);
 
             // otherwise the method requires auth, and if it requires auth then the guildid has to be specified
-            if (!metadata.ContainsKey("guildid"))
+            if (string.IsNullOrWhiteSpace(gidString))
                 throw new RpcException(new(StatusCode.Unauthenticated, "guildid has to be specified."));
 
             var userId = ulong.Parse(metadata["userid"]);

src/EllieBot/Services/GrpcApiService.cs

@@ -9,22 +9,16 @@ public class GrpcApiService : IEService, IReadyExecutor
     private Server? _app;
 
     private readonly DiscordSocketClient _client;
-    private readonly OtherSvc _other;
-    private readonly ExprsSvc _exprs;
-    private readonly GreetByeSvc _greet;
+    private readonly IEnumerable<IGrpcSvc> _svcs;
     private readonly IBotCredsProvider _creds;
 
     public GrpcApiService(
         DiscordSocketClient client,
-        OtherSvc other,
-        ExprsSvc exprs,
-        GreetByeSvc greet,
+        IEnumerable<IGrpcSvc> svcs,
         IBotCredsProvider creds)
     {
         _client = client;
-        _other = other;
-        _exprs = exprs;
-        _greet = greet;
+        _svcs = svcs;
         _creds = creds;
     }
 
@@ -53,21 +47,19 @@ public class GrpcApiService : IEService, IReadyExecutor
                     new[] { new KeyCertificatePair(cert.CertChain, cert.CertPrivateKey) });
             }
 
-
-            _app = new Server()
+            _app = new()
             {
-                Services =
-                {
-                    GrpcOther.BindService(_other).Intercept(interceptor),
-                    GrpcExprs.BindService(_exprs).Intercept(interceptor),
-                    GrpcGreet.BindService(_greet).Intercept(interceptor),
-                },
                 Ports =
                 {
                     new(host, port, serverCreds),
                 }
             };
 
+            foreach (var svc in _svcs)
+            {
+                _app.Services.Add(svc.Bind().Intercept(interceptor));
+            }
+
             _app.Start();
 
             Log.Information("Grpc Api Server started on port {Host}:{Port}", host, port);

src/EllieBot/Services/IGrpcSvc.cs

@@ -0,0 +1,8 @@
+using Grpc.Core;
+
+namespace EllieBot.GrpcApi;
+
+public interface IGrpcSvc
+{
+    ServerServiceDefinition Bind();
+}