Reintroduce ModixController to get rid of redundant code, also fixes …

…internal authentication towards the AuthenticationService

src/Modix.Web/Controllers/AutocompleteController.cs

@@ -2,57 +2,39 @@
 using Discord.WebSocket;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Modix.Controllers;
 using Modix.Data.Utilities;
 using Modix.Services.Core;
 using Modix.Services.Utilities;
-using Modix.Web.Models;
 using Modix.Web.Shared.Models.Common;
 
 namespace Modix.Web.Controllers;
 
 [Route("~/api/autocomplete")]
 [ApiController]
 [Authorize]
-public class AutocompleteController : ControllerBase
+public class AutocompleteController : ModixController
 {
-    private readonly DiscordSocketClient _discordSocketClient;
     private readonly IUserService _userService;
 
-    public AutocompleteController(DiscordSocketClient discordSocketClient, IUserService userService)
+    public AutocompleteController(DiscordSocketClient discordSocketClient, IUserService userService, Modix.Services.Core.IAuthorizationService authorizationService)
+        : base(discordSocketClient, authorizationService)
     {
-        _discordSocketClient = discordSocketClient;
         _userService = userService;
     }
 
 
     [HttpGet("users/{query}")]
-    public async Task<IEnumerable<ModixUser>> AutocompleteUsers(string query)
+    public async Task<IEnumerable<ModixUser>> AutocompleteUsersAsync(string query)
     {
-        // TODO: Move this to a base class like ModixController?
-        var guildCookie = Request.Cookies[CookieConstants.SelectedGuild];
-
-        SocketGuild guildToSearch;
-        if (!string.IsNullOrWhiteSpace(guildCookie))
-        {
-            var guildId = ulong.Parse(guildCookie);
-            guildToSearch = _discordSocketClient.GetGuild(guildId);
-        }
-        else
-        {
-            guildToSearch = _discordSocketClient.Guilds.First();
-        }
-
-        if (guildToSearch?.Users is null)
-            return [];
-
-        var result = guildToSearch.Users
+        var result = UserGuild.Users
                 .Where(d => d.Username.OrdinalContains(query) || d.Id.ToString() == query)
                 .Take(10)
                 .Select(FromIGuildUser);
 
         if (!result.Any() && ulong.TryParse(query, out var userId))
         {
-            var user = await _userService.GetUserInformationAsync(guildToSearch.Id, userId);
+            var user = await _userService.GetUserInformationAsync(UserGuild.Id, userId);
 
             if (user is not null)
             {
@@ -63,7 +45,6 @@ public async Task<IEnumerable<ModixUser>> AutocompleteUsers(string query)
         return result;
     }
 
-
     public static ModixUser FromIGuildUser(IGuildUser user) => new()
     {
         Name = user.GetDisplayName(),

src/Modix.Web/Controllers/GuildStatsController.cs

@@ -2,6 +2,8 @@
 using Discord.WebSocket;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Modix.Controllers;
+using Modix.Services.Core;
 using Modix.Services.GuildStats;
 using Modix.Web.Models;
 using Modix.Web.Shared.Models.Stats;
@@ -11,43 +13,25 @@ namespace Modix.Web.Controllers;
 [Route("~/api")]
 [ApiController]
 [Authorize]
-public class GuildStatsController : ControllerBase
+public class GuildStatsController : ModixController
 {
     private readonly IGuildStatService _guildStatService;
-    private readonly DiscordSocketClient _discordSocketClient;
 
-    public GuildStatsController(IGuildStatService guildStatService, DiscordSocketClient discordSocketClient)
+    public GuildStatsController(IGuildStatService guildStatService, DiscordSocketClient discordSocketClient, Modix.Services.Core.IAuthorizationService authorizationService)
+        : base(discordSocketClient, authorizationService)
     {
         _guildStatService = guildStatService;
-        _discordSocketClient = discordSocketClient;
     }
 
     [HttpGet("guildstats")]
-    public async Task<GuildStatData> GuildStats()
+    public async Task<GuildStatData> GuildStatsAsync()
     {
-        // TODO: Move this to a base class like ModixController?
-        var guildCookie = Request.Cookies[CookieConstants.SelectedGuild];
-
-        SocketGuild guildToSearch;
-        if (!string.IsNullOrWhiteSpace(guildCookie))
-        {
-            var guildId = ulong.Parse(guildCookie);
-            guildToSearch = _discordSocketClient.GetGuild(guildId);
-        }
-        else
-        {
-            guildToSearch = _discordSocketClient.Guilds.First();
-        }
-
-
-        var userId = ulong.Parse(User.FindFirst(d => d.Type == ClaimTypes.NameIdentifier)?.Value);
-
-        var roleCounts = await _guildStatService.GetGuildMemberDistributionAsync(guildToSearch);
-        var messageCounts = await _guildStatService.GetTopMessageCounts(guildToSearch, userId);
+        var roleCounts = await _guildStatService.GetGuildMemberDistributionAsync(UserGuild);
+        var messageCounts = await _guildStatService.GetTopMessageCounts(UserGuild, SocketUser.Id);
 
         var guildRoleCounts = roleCounts.Select(x => new GuildRoleMemberCount(x.Name, x.Count, x.Color));
         var topUserMessageCounts = messageCounts.Select(x => new PerUserMessageCount(x.Username, x.Discriminator, x.Rank, x.MessageCount, x.IsCurrentUser));
 
-        return new GuildStatData(guildToSearch.Name, [..guildRoleCounts], [..topUserMessageCounts]);
+        return new GuildStatData(UserGuild.Name, [..guildRoleCounts], [..topUserMessageCounts]);
     }
 }

src/Modix.Web/Controllers/ModixController.cs

@@ -0,0 +1,71 @@
+#nullable enable
+using System.Security.Claims;
+using Discord.WebSocket;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Modix.Web.Models;
+
+namespace Modix.Controllers;
+
+[Authorize]
+public class ModixController : Controller
+{
+    protected DiscordSocketClient DiscordSocketClient { get; private set; }
+    protected SocketGuildUser SocketUser { get; private set; }
+    protected SocketGuild UserGuild => SocketUser.Guild;
+
+    protected Services.Core.IAuthorizationService ModixAuth { get; private set; }
+
+    public ModixController(DiscordSocketClient client, Services.Core.IAuthorizationService modixAuth)
+    {
+        DiscordSocketClient = client;
+        ModixAuth = modixAuth;
+    }
+
+
+    public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        if (!DiscordSocketClient.Guilds.Any())
+            return;
+
+        if (User is null)
+        {
+            await HttpContext.ChallengeAsync();
+            return;
+        }
+
+        var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+        if (!ulong.TryParse(userId, out var userSnowflake))
+        {
+            await HttpContext.ChallengeAsync();
+            return;
+        }
+
+        var guildCookie = Request.Cookies[CookieConstants.SelectedGuild];
+        SocketGuild guildToSearch;
+
+        if (!string.IsNullOrWhiteSpace(guildCookie))
+        {
+            var guildId = ulong.Parse(guildCookie);
+            guildToSearch = DiscordSocketClient.GetGuild(guildId);
+        }
+        else
+        {
+            guildToSearch = DiscordSocketClient.Guilds.First();
+        }
+
+        SocketUser = guildToSearch.GetUser(userSnowflake);
+
+        if (SocketUser is null)
+        {
+            await HttpContext.ChallengeAsync();
+            return;
+        }
+
+        await ModixAuth.OnAuthenticatedAsync(SocketUser.Id, SocketUser.Guild.Id, [.. SocketUser.Roles.Select(x => x.Id) ]);
+
+        await next();
+    }
+}

src/Modix.Web/Controllers/RolesController.cs

@@ -1,42 +1,25 @@
 using Discord.WebSocket;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Modix.Web.Models;
+using Modix.Controllers;
 using Modix.Web.Shared.Models.Common;
 
 namespace Modix.Web.Controllers;
 
 [Route("~/api/roles")]
 [ApiController]
 [Authorize]
-public class RolesController : ControllerBase
+public class RolesController : ModixController
 {
-    private readonly DiscordSocketClient _discordSocketClient;
-
-    public RolesController(DiscordSocketClient discordSocketClient)
+    public RolesController(DiscordSocketClient discordSocketClient, Modix.Services.Core.IAuthorizationService authorizationService)
+        : base(discordSocketClient, authorizationService)
     {
-        _discordSocketClient = discordSocketClient;
     }
 
     [HttpGet]
     public async Task<Dictionary<ulong, RoleInformation>> GetRoles()
     {
-        // TODO: Move this to a base class like ModixController?
-
-        var guildCookie = Request.Cookies[CookieConstants.SelectedGuild];
-
-        SocketGuild guildToSearch;
-        if (!string.IsNullOrWhiteSpace(guildCookie))
-        {
-            var guildId = ulong.Parse(guildCookie);
-            guildToSearch = _discordSocketClient.GetGuild(guildId);
-        }
-        else
-        {
-            guildToSearch = _discordSocketClient.Guilds.First();
-        }
-
-        return guildToSearch.Roles
+        return UserGuild.Roles
             .Select(x => new RoleInformation(x.Id, x.Name, x.Color.ToString()))
             .ToDictionary(x => x.Id);
     }

src/Modix.Web/Controllers/TagsController.cs

@@ -1,51 +1,34 @@
 using System.Diagnostics;
-using System.Security.Claims;
 using Discord.WebSocket;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Modix.Controllers;
 using Modix.Data.Models.Core;
 using Modix.Data.Models.Tags;
 using Modix.Services.Tags;
-using Modix.Web.Models;
 using Modix.Web.Shared.Models.Tags;
 
 namespace Modix.Web.Controllers;
 
 [Route("~/api/tags")]
 [ApiController]
 [Authorize]
-public class TagsController : ControllerBase
+public class TagsController : ModixController
 {
     private readonly ITagService _tagService;
-    private readonly DiscordSocketClient _discordSocketClient;
 
-    public TagsController(ITagService tagService, DiscordSocketClient discordSocketClient)
+    public TagsController(ITagService tagService, DiscordSocketClient discordSocketClient, Modix.Services.Core.IAuthorizationService authorizationService)
+        : base(discordSocketClient, authorizationService)
     {
         _tagService = tagService;
-        _discordSocketClient = discordSocketClient;
     }
 
     [HttpGet]
     public async Task<IEnumerable<TagData>> GetTagsAsync()
     {
-        // TODO: Move this to a base class like ModixController?
-
-        var guildCookie = Request.Cookies[CookieConstants.SelectedGuild];
-
-        SocketGuild guildToSearch;
-        if (!string.IsNullOrWhiteSpace(guildCookie))
-        {
-            var guildId = ulong.Parse(guildCookie);
-            guildToSearch = _discordSocketClient.GetGuild(guildId);
-        }
-        else
-        {
-            guildToSearch = _discordSocketClient.Guilds.First();
-        }
-
         var summaries = await _tagService.GetSummariesAsync(new TagSearchCriteria
         {
-            GuildId = guildToSearch.Id,
+            GuildId = UserGuild.Id,
         });
 
         return summaries.Select(CreateFromSummary);
@@ -57,25 +40,8 @@ public async Task<IActionResult> CreateTagAsync([FromBody] TagCreationData tagCr
     {
         try
         {
-            // TODO: Move this to a base class like ModixController?
-
-            var guildCookie = Request.Cookies[CookieConstants.SelectedGuild];
-
-            SocketGuild guildToSearch;
-            if (!string.IsNullOrWhiteSpace(guildCookie))
-            {
-                var guildId = ulong.Parse(guildCookie);
-                guildToSearch = _discordSocketClient.GetGuild(guildId);
-            }
-            else
-            {
-                guildToSearch = _discordSocketClient.Guilds.First();
-            }
-
-            var userId = ulong.Parse(User.FindFirst(ClaimTypes.NameIdentifier)?.Value);
-
-            await _tagService.CreateTagAsync(guildToSearch.Id, userId, tagCreationData.Name, tagCreationData.Content);
-            var createdTag = await _tagService.GetTagAsync(guildToSearch.Id, tagCreationData.Name);
+            await _tagService.CreateTagAsync(UserGuild.Id, SocketUser.Id, tagCreationData.Name, tagCreationData.Content);
+            var createdTag = await _tagService.GetTagAsync(UserGuild.Id, tagCreationData.Name);
 
             var tagSummary = CreateFromSummary(createdTag);