clean up logging

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs

@@ -264,7 +264,7 @@ public partial class LightlessHub
         var self = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
 
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
-            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
+            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal)))
             .ConfigureAwait(false);
         
         _logger.LogCallInfo(LightlessHubLogger.Args(gid));
@@ -454,14 +454,9 @@ public partial class LightlessHub
         await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
 
         var groupInfos = await DbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
-        var totalUserCount = await DbContext.GroupPairs
-            .AsNoTracking()
-            .CountAsync(u => u.GroupGID == group.GID, RequestAbortedToken)
-            .ConfigureAwait(false);
-
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(group.ToGroupData(), group.Owner.ToUserData(),
             group.ToEnum(), preferredPermissions.ToEnum(), newPair.ToEnum(),
-            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal), totalUserCount)).ConfigureAwait(false);
+            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal))).ConfigureAwait(false);
 
         var self = DbContext.Users.Single(u => u.UID == UserUID);
 
@@ -683,38 +678,30 @@ public partial class LightlessHub
     {
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, days, execute));
 
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
-            .ConfigureAwait(false);
         if (!hasRights) return -1;
 
-        if (!execute)
+        var allGroupUsers = await DbContext.GroupPairs.Include(p => p.GroupUser).Include(p => p.Group)
-        {
-            var count = await _pruneService.CountPrunableUsersAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
-            return count;
-        }
-
-        var allGroupUsers = await DbContext.GroupPairs
-            .Include(p => p.GroupUser)
-            .Include(p => p.Group)
             .Where(g => g.GroupGID == dto.Group.GID)
-            .ToListAsync(RequestAbortedToken).ConfigureAwait(false);
+            .ToListAsync().ConfigureAwait(false);
+        var usersToPrune = allGroupUsers.Where(p => !p.IsPinned && !p.IsModerator
+            && !string.Equals(p.GroupUserUID, UserUID, StringComparison.Ordinal)
+            && !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal)
+            && p.GroupUser.LastLoggedIn.AddDays(days) < DateTime.UtcNow);
 
-        var prunedPairs = await _pruneService.ExecutePruneAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+        if (!execute) return usersToPrune.Count();
 
-        var remainingUserIds = allGroupUsers
+        DbContext.GroupPairs.RemoveRange(usersToPrune);
-            .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
-            .Select(p => p.GroupUserUID)
-            .Distinct(StringComparer.Ordinal)
-            .ToList();
 
-        foreach (var pair in prunedPairs)
+        foreach (var pair in usersToPrune)
         {
-            await Clients.Users(remainingUserIds)
+            await Clients.Users(allGroupUsers.Where(p => !usersToPrune.Contains(p)).Select(g => g.GroupUserUID))
-                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData()))
+                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData())).ConfigureAwait(false);
-                .ConfigureAwait(false);
         }
 
-        return prunedPairs.Count;
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        return usersToPrune.Count();
     }
 
     [Authorize(Policy = "Identified")]
@@ -852,9 +839,8 @@ public partial class LightlessHub
             {
                 GroupGID = dto.Group.GID,
                 Group = group,
-                    ProfileDisabled = dto.IsDisabled ?? false,
+                ProfileDisabled = false,
                 IsNSFW = dto.IsNsfw ?? false,
-                    
             };
 
             groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
@@ -924,44 +910,6 @@ public partial class LightlessHub
         await Clients.Users(groupPairs).Client_GroupPairChangeUserInfo(new GroupPairUserInfoDto(dto.Group, dto.User, userPair.ToEnum())).ConfigureAwait(false);
     }
 
-    [Authorize(Policy = "Identified")]
-    public async Task<GroupPruneSettingsDto> GroupGetPruneSettings(GroupDto dto)
-    {
-        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
-
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.GID)
-            .ConfigureAwait(false);
-        if (!hasRights || group == null)
-            return null;
-
-        return new GroupPruneSettingsDto(
-            Group: group.ToGroupData(),
-            AutoPruneEnabled: group.AutoPruneEnabled,
-            AutoPruneDays: group.AutoPruneDays
-        );
-    }
-
-    [Authorize(Policy = "Identified")]
-    public async Task GroupSetPruneSettings(GroupPruneSettingsDto dto)
-    {
-        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
-
-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
-            .ConfigureAwait(false);
-        if (!hasRights || group == null)
-            return;
-
-        // if days == 0, auto prune is OFF
-        var days = dto.AutoPruneDays;
-        var enabled = dto.AutoPruneEnabled && days > 0;
-
-        group.AutoPruneEnabled = enabled;
-        group.AutoPruneDays = enabled ? days : 0;
-
-        await DbContext.SaveChangesAsync(RequestAbortedToken)
-            .ConfigureAwait(false);
-    }
-
     [Authorize(Policy = "Identified")]
     public async Task<List<GroupFullInfoDto>> GroupsGetAll()
     {
@@ -984,8 +932,6 @@ public partial class LightlessHub
                     .Where(x => x.GroupGID == gp.GroupGID && (x.IsPinned || x.IsModerator))
                     .Select(x => new { x.GroupUserUID, EnumValue = x.ToEnum() })
                     .ToList(),
-                UserCount = DbContext.GroupPairs
-                    .Count(x => x.GroupGID == gp.GroupGID),
             })
             .AsNoTracking()
             .ToListAsync()
@@ -998,6 +944,7 @@ public partial class LightlessHub
             var groupInfoDict = r.GroupInfos
                 .ToDictionary(x => x.GroupUserUID, x => x.EnumValue, StringComparer.Ordinal);
 
+
             _logger.LogCallInfo(LightlessHubLogger.Args(r));
 
             return new GroupFullInfoDto(
@@ -1006,8 +953,7 @@ public partial class LightlessHub
                 r.GroupPair.Group.ToEnum(),
                 r.PreferredPermission.ToEnum(),
                 r.GroupPair.ToEnum(),
-            groupInfoDict,
+                groupInfoDict
-            r.UserCount
             );
         }),];
         return List;

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs

@@ -1,6 +1,7 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Dto;
+using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.SignalR;
 using LightlessSyncServer.Services;
 using LightlessSyncServer.Configuration;
@@ -16,7 +17,8 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
-using LightlessSyncServer.Services.Interfaces;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace LightlessSyncServer.Hubs;
 
@@ -27,7 +29,6 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
     private readonly LightlessMetrics _lightlessMetrics;
     private readonly SystemInfoService _systemInfoService;
     private readonly PairService _pairService;
-    private readonly IPruneService _pruneService;
     private readonly IHttpContextAccessor _contextAccessor;
     private readonly LightlessHubLogger _logger;
     private readonly string _shardName;
@@ -54,7 +55,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         IConfigurationService<ServerConfiguration> configuration, IHttpContextAccessor contextAccessor,
         IRedisDatabase redisDb, OnlineSyncedPairCacheService onlineSyncedPairCacheService, LightlessCensus lightlessCensus,
         GPoseLobbyDistributionService gPoseLobbyDistributionService, IBroadcastConfiguration broadcastConfiguration, PairService pairService,
-        ChatChannelService chatChannelService, IPruneService pruneService)
+        ChatChannelService chatChannelService)
     {
         _lightlessMetrics = lightlessMetrics;
         _systemInfoService = systemInfoService;
@@ -76,7 +77,6 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
         _broadcastConfiguration = broadcastConfiguration;
         _pairService = pairService;
         _chatChannelService = chatChannelService;
-        _pruneService = pruneService;
     }
 
     protected override void Dispose(bool disposing)

LightlessSyncServer/LightlessSyncServer/Services/Interfaces/IPruneService.cs

@@ -1,10 +0,0 @@
-using LightlessSyncShared.Models;
-
-namespace LightlessSyncServer.Services.Interfaces
-{
-    public interface IPruneService
-    {
-        Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct);
-        Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct);
-    }
-}

LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs

@@ -1,60 +0,0 @@
-using LightlessSyncServer.Services.Interfaces;
-using LightlessSyncShared.Data;
-using LightlessSyncShared.Models;
-using Microsoft.EntityFrameworkCore;
-
-namespace LightlessSyncServer.Services
-{
-    public class PruneService(LightlessDbContext dbContext) : IPruneService
-    {
-        private readonly LightlessDbContext _dbContext = dbContext;
-
-        public async Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct)
-        {
-            var allGroupUsers = await _dbContext.GroupPairs
-                .Include(p => p.GroupUser)
-                .Include(p => p.Group)
-                .Where(g => g.GroupGID == groupGid)
-                .ToListAsync(ct).ConfigureAwait(false);
-
-            var inactivitySpan = GetInactivitySpan(days);
-            var now = DateTime.UtcNow;
-
-            var usersToPrune = allGroupUsers.Where(p =>
-                !p.IsPinned &&
-                !p.IsModerator &&
-                !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
-                p.GroupUser.LastLoggedIn < now - inactivitySpan);
-
-            return usersToPrune.Count();
-        }
-
-        public async Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct)
-        {
-            var allGroupUsers = await _dbContext.GroupPairs
-                .Include(p => p.GroupUser)
-                .Include(p => p.Group)
-                .Where(g => g.GroupGID == groupGid)
-                .ToListAsync(ct).ConfigureAwait(false);
-
-            var inactivitySpan = GetInactivitySpan(days);
-            var now = DateTime.UtcNow;
-
-            var usersToPrune = allGroupUsers.Where(p =>
-                !p.IsPinned &&
-                !p.IsModerator &&
-                !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
-                p.GroupUser.LastLoggedIn < now - inactivitySpan)
-                .ToList();
-
-            _dbContext.GroupPairs.RemoveRange(usersToPrune);
-            await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
-
-            return usersToPrune;
-        }
-
-        private static TimeSpan GetInactivitySpan(int days) => days == 0
-                ? TimeSpan.FromMinutes(15)
-                : TimeSpan.FromDays(days);
-    }
-}

LightlessSyncServer/LightlessSyncServer/Services/SystemInfoService.cs

@@ -72,11 +72,9 @@ public sealed class SystemInfoService : BackgroundService
                     await _hubContext.Clients.All.Client_UpdateSystemInfo(SystemInfoDto).ConfigureAwait(false);
 
                     using var db = await _dbContextFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
-                    var groupsWithAutoPrune = db.Groups.AsNoTracking().Count(g => g.AutoPruneEnabled && g.AutoPruneDays > 0);
 
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeAuthorizedConnections, onlineUsers);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeLightFinderConnections, countLightFinderUsers);
-                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroupAutoPrunesEnabled, groupsWithAutoPrune);
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairs, db.ClientPairs.AsNoTracking().Count());
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairsPaused, db.Permissions.AsNoTracking().Count(p => p.IsPaused));
                     _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroups, db.Groups.AsNoTracking().Count());

LightlessSyncServer/LightlessSyncServer/Startup.cs

@@ -1,13 +1,9 @@
 using AspNetCoreRateLimit;
-using LightlessSync.API.Data;
-using LightlessSync.API.Dto.Group;
 using LightlessSync.API.SignalR;
-using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Controllers;
+using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Hubs;
 using LightlessSyncServer.Services;
-using LightlessSyncServer.Services.Interfaces;
-using LightlessSyncServer.Worker;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.RequirementHandlers;
@@ -22,7 +18,6 @@ using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.IdentityModel.Tokens;
 using Prometheus;
 using StackExchange.Redis;
@@ -114,12 +109,9 @@ public class Startup
             services.AddHostedService(provider => provider.GetService<CharaDataCleanupService>());
             services.AddHostedService<ClientPairPermissionsCleanupService>();
             services.AddScoped<PairService>();
-            services.AddScoped<IPruneService, PruneService>();
         }
 
         services.AddSingleton<GPoseLobbyDistributionService>();
-
-        services.AddHostedService<AutoPruneWorker>();
         services.AddHostedService(provider => provider.GetService<GPoseLobbyDistributionService>());
     }
 
@@ -128,8 +120,6 @@ public class Startup
         services.AddSingleton<IUserIdProvider, IdBasedUserIdProvider>();
         services.AddSingleton<ConcurrencyFilter>();
 
-        var msgpackOptions = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4Block).WithResolver(ContractlessStandardResolver.Instance);
-
         var signalRServiceBuilder = services.AddSignalR(hubOptions =>
         {
             hubOptions.MaximumReceiveMessageSize = long.MaxValue;
@@ -141,10 +131,21 @@ public class Startup
             hubOptions.AddFilter<ConcurrencyFilter>();
         }).AddMessagePackProtocol(opt =>
         {
-            opt.SerializerOptions = msgpackOptions;
+            var resolver = CompositeResolver.Create(StandardResolverAllowPrivate.Instance,
+                BuiltinResolver.Instance,
+                AttributeFormatterResolver.Instance,
+                // replace enum resolver
+                DynamicEnumAsStringResolver.Instance,
+                DynamicGenericResolver.Instance,
+                DynamicUnionResolver.Instance,
+                DynamicObjectResolver.Instance,
+                PrimitiveObjectResolver.Instance,
+                // final fallback(last priority)
+                StandardResolver.Instance);
 
-            var dummy = new GroupPruneSettingsDto(new GroupData("TEST-GID", null), true, 14);
+            opt.SerializerOptions = MessagePackSerializerOptions.Standard
-            MessagePackSerializer.Serialize(dummy, msgpackOptions);
+                .WithCompression(MessagePackCompression.Lz4Block)
+                .WithResolver(resolver);
         });
 
 
@@ -165,7 +166,7 @@ public class Startup
             KeyPrefix = "",
             Hosts = new RedisHost[]
             {
-                new(){ Host = address, Port = port },
+                new RedisHost(){ Host = address, Port = port },
             },
             AllowAdmin = true,
             ConnectTimeout = options.ConnectTimeout,
@@ -291,12 +292,11 @@ public class Startup
             MetricsAPI.CounterUserPairCacheMiss,
             MetricsAPI.CounterUserPairCacheNewEntries,
             MetricsAPI.CounterUserPairCacheUpdatedEntries,
-        },
+        }, new List<string>
-        [
+        {
             MetricsAPI.GaugeAuthorizedConnections,
             MetricsAPI.GaugeLightFinderConnections,
             MetricsAPI.GaugeLightFinderGroups,
-            MetricsAPI.GaugeGroupAutoPrunesEnabled,
             MetricsAPI.GaugeConnections,
             MetricsAPI.GaugePairs,
             MetricsAPI.GaugePairsPaused,
@@ -312,7 +312,7 @@ public class Startup
             MetricsAPI.GaugeGposeLobbyUsers,
             MetricsAPI.GaugeHubConcurrency,
             MetricsAPI.GaugeHubQueuedConcurrency,
-        ]));
+        }));
     }
 
     private static void ConfigureServicesBasedOnShardType(IServiceCollection services, IConfigurationSection lightlessConfig, bool isMainServer)

LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs

@@ -22,7 +22,6 @@ public static class Extensions
         if (dto.Tags != null) profile.Tags = dto.Tags;
         if (dto.Description != null) profile.Description = dto.Description;
         if (dto.IsNsfw.HasValue) profile.IsNSFW = dto.IsNsfw.Value;
-        if (dto.IsDisabled.HasValue) profile.ProfileDisabled = dto.IsDisabled.Value;
     }
 
     public static void UpdateProfileFromDto(this UserProfileData profile, UserProfileDto dto, string? base64PictureString = null, string? base64BannerString = null)

LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs

@@ -1,68 +0,0 @@
-using LightlessSync.API.Dto.Group;
-using LightlessSyncServer.Hubs;
-using LightlessSyncServer.Services.Interfaces;
-using LightlessSyncServer.Utils;
-using LightlessSyncShared.Data;
-using Microsoft.AspNetCore.SignalR;
-using Microsoft.EntityFrameworkCore;
-
-namespace LightlessSyncServer.Worker
-{
-    public class AutoPruneWorker(IServiceProvider services, ILogger<AutoPruneWorker> logger) : BackgroundService
-    {
-        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-        {
-            while (!stoppingToken.IsCancellationRequested)
-            {
-                try
-                {
-                    var scope = services.CreateAsyncScope();
-                    await using (scope.ConfigureAwait(false))
-                    {
-                        var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
-                        var pruneService = scope.ServiceProvider.GetRequiredService<IPruneService>();
-                        var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<LightlessHub>>();
-
-                        var groups = await db.Groups
-                            .Where(g => g.AutoPruneEnabled && g.AutoPruneDays > 0)
-                            .ToListAsync(stoppingToken).ConfigureAwait(false);
-
-                        foreach (var group in groups)
-                        {
-                            var allGroupUsers = await db.GroupPairs
-                                .Include(p => p.GroupUser)
-                                .Include(p => p.Group)
-                                .Where(p => p.GroupGID == group.GID)
-                                .ToListAsync(stoppingToken).ConfigureAwait(false);
-
-                            var prunedPairs = await pruneService.ExecutePruneAsync(group.GID, group.AutoPruneDays, stoppingToken).ConfigureAwait(false);
-
-                            if (prunedPairs.Count == 0)
-                                continue;
-
-                            var remainingUserIds = allGroupUsers
-                                .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
-                                .Select(p => p.GroupUserUID)
-                                .Distinct(StringComparer.Ordinal)
-                                .ToList();
-
-                            foreach (var pair in prunedPairs)
-                            {
-                                await hubContext.Clients.Users(remainingUserIds).SendAsync("Client_GroupPairLeft", new GroupPairDto(group.ToGroupData(), pair.GroupUser.ToUserData()), stoppingToken).ConfigureAwait(false);
-                            }
-
-                            logger.LogInformation("Auto-pruned {Count} users from group {GroupId}", prunedPairs.Count, group.GID);
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    logger.LogError(ex, "Error in auto-prune worker");
-                }
-
-                //Run task each hour to check for pruning
-                await Task.Delay(TimeSpan.FromHours(1), stoppingToken).ConfigureAwait(false);
-            }
-        }
-    }
-}

LightlessSyncServer/LightlessSyncServer/appsettings.json

@@ -7,7 +7,6 @@
       "Default": "Information",
       "Microsoft": "Warning",
       "Microsoft.Hosting.Lifetime": "Information",
-      "Microsoft.EntityFrameworkCore.Database.Command": "Warning",
       "LightlessSyncServer.Authentication": "Warning",
       "System.IO.IOException": "Warning"
     },

LightlessSyncServer/LightlessSyncServices/Discord/MareWizardModule.Vanity.cs

@@ -94,7 +94,7 @@ public partial class LightlessWizardModule
         bool canAddVanityId = !db.Users.Any(u => u.UID == modal.DesiredVanityUID || u.Alias == modal.DesiredVanityUID);
         var forbiddenWords = new[] { "null", "nil" };
 
-        Regex rgx = new(@"^[_\-a-zA-Z0-9\?]{3,15}$", RegexOptions.ECMAScript);
+        Regex rgx = new(@"^[_\-a-zA-Z0-9]{3,15}$", RegexOptions.ECMAScript);
         if (!rgx.Match(desiredVanityUid).Success)
         {
             eb.WithColor(Color.Red);

LightlessSyncServer/LightlessSyncShared/Metrics/MetricsAPI.cs

@@ -11,7 +11,6 @@ public class MetricsAPI
     public const string CounterUsersRegisteredDeleted = "lightless_users_registered_deleted";
     public const string GaugeLightFinderConnections = "lightless_lightfinder_connections";
     public const string GaugeLightFinderGroups = "lightless_lightfinder_groups";
-    public const string GaugeGroupAutoPrunesEnabled = "lightless_group_autoprunes_enabled";
     public const string GaugePairs = "lightless_pairs";
     public const string GaugePairsPaused = "lightless_pairs_paused";
     public const string GaugeFilesTotal = "lightless_files";

LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.cs

@@ -1,40 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace LightlessSyncServer.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddAutoPruneInGroup : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "auto_prune_days",
-                table: "groups",
-                type: "integer",
-                nullable: false,
-                defaultValue: 0);
-
-            migrationBuilder.AddColumn<bool>(
-                name: "auto_prune_enabled",
-                table: "groups",
-                type: "boolean",
-                nullable: false,
-                defaultValue: false);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "auto_prune_days",
-                table: "groups");
-
-            migrationBuilder.DropColumn(
-                name: "auto_prune_enabled",
-                table: "groups");
-        }
-    }
-}

LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs

@@ -430,14 +430,6 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("character varying(50)")
                         .HasColumnName("alias");
 
-                    b.Property<int>("AutoPruneDays")
-                        .HasColumnType("integer")
-                        .HasColumnName("auto_prune_days");
-
-                    b.Property<bool>("AutoPruneEnabled")
-                        .HasColumnType("boolean")
-                        .HasColumnName("auto_prune_enabled");
-
                     b.Property<DateTime>("CreatedDate")
                         .ValueGeneratedOnAdd()
                         .HasColumnType("timestamp with time zone")

LightlessSyncServer/LightlessSyncShared/Models/Group.cs

@@ -12,8 +12,6 @@ public class Group
     [MaxLength(50)]
     public string Alias { get; set; }
     public GroupProfile? Profile { get; set; }
-    public bool AutoPruneEnabled { get; set; } = false;
-    public int AutoPruneDays { get; set; } = 0;
     public bool InvitesEnabled { get; set; }
     public string HashedPassword { get; set; }
     public bool PreferDisableSounds { get; set; }