expose vanity and colors and update from bot

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs

@@ -1,4 +1,4 @@
-using LightlessSyncShared.Models;
+using LightlessSyncShared.Models;
 using Microsoft.EntityFrameworkCore;
 using LightlessSyncServer.Utils;
 using LightlessSyncShared.Utils;
@@ -325,7 +325,10 @@ public partial class LightlessHub
                          OwnPermissions = ownperm,
                          OtherPermissions = otherperm,
                          OtherUserIsAdmin = u.IsAdmin,
-                         OtherUserIsModerator = u.IsModerator
+                         OtherUserIsModerator = u.IsModerator,
+                         OtherUserHasVanity = u.HasVanity,
+                         OtherUserTextColorHex = u.TextColorHex,
+                         OtherUserTextGlowColorHex = u.TextGlowColorHex
                      };
 
         var resultList = await result.AsNoTracking().ToListAsync().ConfigureAwait(false);
@@ -333,14 +336,18 @@ public partial class LightlessHub
         if (!resultList.Any()) return null;
 
         var groups = resultList.Select(g => g.GID).ToList();
-        return new UserInfo(resultList[0].OtherUserAlias,
+        return new UserInfo(
+            resultList[0].OtherUserAlias,
             resultList.SingleOrDefault(p => string.IsNullOrEmpty(p.GID))?.Synced ?? false,
             resultList.Max(p => p.Synced),
             resultList.Select(p => string.IsNullOrEmpty(p.GID) ? Constants.IndividualKeyword : p.GID).ToList(),
             resultList[0].OwnPermissions,
             resultList[0].OtherPermissions,
             resultList[0].OtherUserIsAdmin,
-            resultList[0].OtherUserIsModerator);
+            resultList[0].OtherUserIsModerator,
+            resultList[0].OtherUserHasVanity ?? false,
+            resultList[0].OtherUserTextColorHex ?? string.Empty,
+            resultList[0].OtherUserTextGlowColorHex ?? string.Empty);
     }
 
     private async Task<Dictionary<string, UserInfo>> GetAllPairInfo(string uid)
@@ -414,21 +421,27 @@ public partial class LightlessHub
                          OwnPermissions = ownperm,
                          OtherPermissions = otherperm,
                          OtherUserIsAdmin = u.IsAdmin,
-                         OtherUserIsModerator = u.IsModerator
+                         OtherUserIsModerator = u.IsModerator,
+                         OtherUserHasVanity = u.HasVanity,
+                         OtherUserTextColorHex = u.TextColorHex,
+                         OtherUserTextGlowColorHex = u.TextGlowColorHex
                      };
 
         var resultList = await result.AsNoTracking().ToListAsync().ConfigureAwait(false);
         return resultList.GroupBy(g => g.OtherUserUID, StringComparer.Ordinal).ToDictionary(g => g.Key, g =>
         {
-            return new UserInfo(g.First().OtherUserAlias,
+            return new UserInfo(
+                g.First().OtherUserAlias,
                 g.SingleOrDefault(p => string.IsNullOrEmpty(p.GID))?.Synced ?? false,
                 g.Max(p => p.Synced),
                 g.Select(p => string.IsNullOrEmpty(p.GID) ? Constants.IndividualKeyword : p.GID).ToList(),
                 g.First().OwnPermissions,
                 g.First().OtherPermissions,
                 g.First().OtherUserIsAdmin,
-                g.First().OtherUserIsModerator
+                g.First().OtherUserIsModerator,
-                );
+                g.First().OtherUserHasVanity ?? false,
+                g.First().OtherUserTextColorHex ?? string.Empty,
+                g.First().OtherUserTextGlowColorHex ?? string.Empty);
         }, StringComparer.Ordinal);
     }
 
@@ -501,6 +514,9 @@ public partial class LightlessHub
         UserPermissionSet? OwnPermissions,
         UserPermissionSet? OtherPermissions,
         bool IsAdmin,
-        bool IsModerator
+        bool IsModerator,
+        bool HasVanity,
+        string? TextColorHex,
+        string? TextGlowColorHex
     );
 }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs

@@ -1,4 +1,4 @@
-using LightlessSync.API.Data;
+using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
 using LightlessSync.API.Dto.Group;
@@ -493,7 +493,7 @@ public partial class LightlessHub
         var pairs = await GetAllPairInfo(UserUID).ConfigureAwait(false);
         return pairs.Select(p =>
         {
-            return new UserFullPairDto(new UserData(p.Key, p.Value.Alias, p.Value.IsAdmin, p.Value.IsModerator),
+            return new UserFullPairDto(new UserData(p.Key, p.Value.Alias, p.Value.IsAdmin, p.Value.IsModerator, p.Value.HasVanity, p.Value.TextColorHex, p.Value.TextGlowColorHex),
                 p.Value.ToIndividualPairStatus(),
                 p.Value.GIDs.Where(g => !string.Equals(g, Constants.IndividualKeyword, StringComparison.OrdinalIgnoreCase)).ToList(),
                 p.Value.OwnPermissions.ToUserPermissions(setSticky: true),

LightlessSyncServer/LightlessSyncServices/Discord/DiscordBot.cs

@@ -1,4 +1,4 @@
-using Discord;
+using Discord;
 using Discord.Interactions;
 using Discord.Rest;
 using Discord.WebSocket;
@@ -384,13 +384,50 @@ internal class DiscordBot : IHostedService
 
         _logger.LogInformation($"Checking Group: {group.GID} [{group.Alias}], owned by {group.OwnerUID} ({groupPrimaryUser}), User in Roles: {string.Join(", ", discordUser?.RoleIds ?? new List<ulong>())}");
 
-        if (lodestoneUser == null || discordUser == null || !discordUser.RoleIds.Any(allowedRoleIds.Keys.Contains))
+        var hasAllowedRole = lodestoneUser != null && discordUser != null && discordUser.RoleIds.Any(allowedRoleIds.Keys.Contains);
+
+        if (!hasAllowedRole)
         {
             await _botServices.LogToChannel($"VANITY GID REMOVAL: <@{lodestoneUser?.DiscordId ?? 0}> ({lodestoneUser?.User?.UID}) - GID: {group.GID}, Vanity: {group.Alias}").ConfigureAwait(false);
 
             _logger.LogInformation($"User {lodestoneUser?.User?.UID ?? "unknown"} not in allowed roles, deleting group alias for {group.GID}");
             group.Alias = null;
             db.Update(group);
+
+            if (lodestoneUser?.User != null)
+            {
+                lodestoneUser.User.HasVanity = false;
+                db.Update(lodestoneUser.User);
+
+                var secondaryUsers = await db.Auth.Include(u => u.User)
+                    .Where(u => u.PrimaryUserUID == lodestoneUser.User.UID).ToListAsync().ConfigureAwait(false);
+
+                foreach (var secondaryUser in secondaryUsers)
+                {
+                    secondaryUser.User.HasVanity = false;
+                    db.Update(secondaryUser.User);
+                }
+            }
+
+            await db.SaveChangesAsync(token).ConfigureAwait(false);
+        }
+        else if (lodestoneUser?.User != null && lodestoneUser.User.HasVanity != true)
+        {
+            lodestoneUser.User.HasVanity = true;
+            db.Update(lodestoneUser.User);
+
+            var secondaryUsers = await db.Auth.Include(u => u.User)
+                .Where(u => u.PrimaryUserUID == lodestoneUser.User.UID).ToListAsync().ConfigureAwait(false);
+
+            foreach (var secondaryUser in secondaryUsers)
+            {
+                if (secondaryUser.User.HasVanity != true)
+                {
+                    secondaryUser.User.HasVanity = true;
+                    db.Update(secondaryUser.User);
+                }
+            }
+
             await db.SaveChangesAsync(token).ConfigureAwait(false);
         }
     }
@@ -400,22 +437,55 @@ internal class DiscordBot : IHostedService
         var discordUser = await restGuild.GetUserAsync(lodestoneAuth.DiscordId).ConfigureAwait(false);
         _logger.LogInformation($"Checking User: {lodestoneAuth.DiscordId}, {lodestoneAuth.User.UID} ({lodestoneAuth.User.Alias}), User in Roles: {string.Join(", ", discordUser?.RoleIds ?? new List<ulong>())}");
 
-        if (discordUser == null || !discordUser.RoleIds.Any(u => allowedRoleIds.Keys.Contains(u)))
+        var hasAllowedRole = discordUser != null && discordUser.RoleIds.Any(u => allowedRoleIds.Keys.Contains(u));
+
+        if (!hasAllowedRole)
         {
             _logger.LogInformation($"User {lodestoneAuth.User.UID} not in allowed roles, deleting alias");
             await _botServices.LogToChannel($"VANITY UID REMOVAL: <@{lodestoneAuth.DiscordId}> - UID: {lodestoneAuth.User.UID}, Vanity: {lodestoneAuth.User.Alias}").ConfigureAwait(false);
             lodestoneAuth.User.Alias = null;
+            lodestoneAuth.User.HasVanity = false;
             var secondaryUsers = await db.Auth.Include(u => u.User).Where(u => u.PrimaryUserUID == lodestoneAuth.User.UID).ToListAsync().ConfigureAwait(false);
             foreach (var secondaryUser in secondaryUsers)
             {
                 _logger.LogInformation($"Secondary User {secondaryUser.User.UID} not in allowed roles, deleting alias");
 
                 secondaryUser.User.Alias = null;
+                secondaryUser.User.HasVanity = false;
                 db.Update(secondaryUser.User);
             }
             db.Update(lodestoneAuth.User);
             await db.SaveChangesAsync(token).ConfigureAwait(false);
         }
+        else
+        {
+            var secondaryUsers = await db.Auth.Include(u => u.User)
+                .Where(u => u.PrimaryUserUID == lodestoneAuth.User.UID).ToListAsync().ConfigureAwait(false);
+
+            var hasChanges = false;
+
+            if (lodestoneAuth.User.HasVanity != true)
+            {
+                lodestoneAuth.User.HasVanity = true;
+                db.Update(lodestoneAuth.User);
+                hasChanges = true;
+            }
+
+            foreach (var secondaryUser in secondaryUsers)
+            {
+                if (secondaryUser.User.HasVanity != true)
+                {
+                    secondaryUser.User.HasVanity = true;
+                    db.Update(secondaryUser.User);
+                    hasChanges = true;
+                }
+            }
+
+            if (hasChanges)
+            {
+                await db.SaveChangesAsync(token).ConfigureAwait(false);
+            }
+        }
     }
 
     private async Task UpdateStatusAsync(CancellationToken token)

LightlessSyncServer/LightlessSyncServices/Discord/MareWizardModule.Vanity.cs

@@ -1,4 +1,4 @@
-using Discord.Interactions;
+using Discord.Interactions;
 using Discord;
 using Microsoft.EntityFrameworkCore;
 using System.Text.RegularExpressions;
@@ -123,6 +123,20 @@ public partial class LightlessWizardModule
         {
             var user = await db.Users.SingleAsync(u => u.UID == uid).ConfigureAwait(false);
             user.Alias = desiredVanityUid;
+            user.HasVanity = true;
+
+            var secondaryUsers = await db.Auth.Include(u => u.User)
+                .Where(u => u.PrimaryUserUID == user.UID).ToListAsync().ConfigureAwait(false);
+
+            foreach (var secondaryUser in secondaryUsers)
+            {
+                if (secondaryUser.User.HasVanity != true)
+                {
+                    secondaryUser.User.HasVanity = true;
+                    db.Update(secondaryUser.User);
+                }
+            }
+
             db.Update(user);
             await db.SaveChangesAsync().ConfigureAwait(false);
             eb.WithColor(Color.Green);
@@ -199,6 +213,25 @@ public partial class LightlessWizardModule
         {
             var group = await db.Groups.SingleAsync(u => u.GID == gid).ConfigureAwait(false);
             group.Alias = desiredVanityGid;
+
+            var ownerAuth = await db.Auth.SingleOrDefaultAsync(u => u.UserUID == group.OwnerUID).ConfigureAwait(false);
+            var ownerUid = string.IsNullOrEmpty(ownerAuth?.PrimaryUserUID) ? group.OwnerUID : ownerAuth.PrimaryUserUID;
+            var ownerUser = await db.Users.SingleAsync(u => u.UID == ownerUid).ConfigureAwait(false);
+            ownerUser.HasVanity = true;
+            db.Update(ownerUser);
+
+            var secondaryUsers = await db.Auth.Include(u => u.User)
+                .Where(u => u.PrimaryUserUID == ownerUser.UID).ToListAsync().ConfigureAwait(false);
+
+            foreach (var secondaryUser in secondaryUsers)
+            {
+                if (secondaryUser.User.HasVanity != true)
+                {
+                    secondaryUser.User.HasVanity = true;
+                    db.Update(secondaryUser.User);
+                }
+            }
+
             db.Update(group);
             await db.SaveChangesAsync().ConfigureAwait(false);
             eb.WithColor(Color.Green);