Merge pull request 'Updated links for Xivapi sources' (#54 ) from xivapi-link-changes into master

Reviewed-on: #54
Updated links for Xivapi sources
2026-01-05 12:03:09 +00:00 · 2026-01-05 12:01:53 +00:00 · 2026-01-04 05:14:37 +00:00 · 2026-01-04 05:14:22 +00:00 · 2026-01-04 05:12:00 +00:00 · 2025-12-31 17:32:00 +00:00
20 changed files with 3198 additions and 174 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -351,3 +351,6 @@ MigrationBackup/

 # docker run data
 Docker/run/data/
+
+#idea files
+*.idea
--- a/2
+++ b/2
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Chat.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Chat.cs
@@ -41,8 +41,10 @@ public partial class LightlessHub

        var groupInfos = await DbContext.Groups
            .AsNoTracking()
-            .Where(g => g.OwnerUID == userUid
+            .Where(g => g.ChatEnabled
+                        && (g.OwnerUID == userUid
                        || DbContext.GroupPairs.Any(p => p.GroupGID == g.GID && p.GroupUserUID == userUid))
+                        )
            .ToListAsync()
            .ConfigureAwait(false);

@@ -162,6 +164,13 @@ public partial class LightlessHub
                    throw new HubException("Unsupported chat channel.");
                }

+                if (!group.ChatEnabled)
+                {
+                    TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID, channel), "removing chat presence", channel);
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "This Syncshell chat is disabled.").ConfigureAwait(false);
+                    return;
+                }
+
                var isMember = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal)
                    || await DbContext.GroupPairs
                        .AsNoTracking()
@@ -207,6 +216,23 @@ public partial class LightlessHub

        var channel = request.Channel.WithNormalizedCustomKey();

+        if (channel.Type == ChatChannelType.Group)
+        {
+            var groupId = channel.CustomKey ?? string.Empty;
+            var chatEnabled = !string.IsNullOrEmpty(groupId) && await DbContext.Groups
+                .AsNoTracking()
+                .Where(g => g.GID == groupId)
+                .Select(g => g.ChatEnabled)
+                .SingleOrDefaultAsync(RequestAbortedToken)
+                .ConfigureAwait(false);
+
+            if (!chatEnabled)
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "This Syncshell chat is disabled.").ConfigureAwait(false);
+                return;
+            }
+        }
+
        if (await HandleIfChatBannedAsync(UserUID).ConfigureAwait(false))
        {
            throw new HubException("Chat access has been revoked.");
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs
@@ -40,5 +40,6 @@ namespace LightlessSyncServer.Hubs
        public Task Client_GposeLobbyPushPoseData(UserData userData, PoseData poseData) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
        public Task Client_GposeLobbyPushWorldData(UserData userData, WorldData worldData) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
        public Task Client_ChatReceive(ChatMessageDto message) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
+        public Task Client_SendLocationToClient(LocationDto locationDto, DateTimeOffset expireAt) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
    }
 }
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs
@@ -1,6 +1,7 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
+using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.Dto.Group;
 using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Models;
@@ -11,10 +12,8 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using Newtonsoft.Json.Linq;
 using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
-using System.Reflection;
+using System.Collections.Concurrent;
 using System.Security.Cryptography;

 namespace LightlessSyncServer.Hubs;
@@ -29,29 +28,78 @@ public partial class LightlessHub
        var (userHasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
        if (!userHasRights) return;

-        var (userExists, groupPair) = await TryValidateUserInGroup(dto.Group.GID, dto.User.UID).ConfigureAwait(false);
-        if (!userExists) return;
+        var targetUid = dto.User.UID?.Trim();
+        if (string.IsNullOrWhiteSpace(targetUid)) return;

-        if (groupPair.IsModerator || string.Equals(group.OwnerUID, dto.User.UID, StringComparison.Ordinal)) return;
+        if (string.Equals(group.OwnerUID, targetUid, StringComparison.Ordinal))
+            return;

-        var alias = string.IsNullOrEmpty(groupPair.GroupUser.Alias) ? "-" : groupPair.GroupUser.Alias;
-        var ban = new GroupBan()
+        var groupPair = await DbContext.GroupPairs
+            .Include(p => p.GroupUser)
+            .SingleOrDefaultAsync(p => p.GroupGID == dto.Group.GID && p.GroupUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair?.IsModerator == true)
+            return;
+
+        var now = DateTime.UtcNow;
+
+        var existingBan = await DbContext.Set<GroupBan>().SingleOrDefaultAsync(b => b.GroupGID == dto.Group.GID && b.BannedUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+        var userExists = await DbContext.Users.AsNoTracking().AnyAsync(u => u.UID == targetUid || u.Alias == targetUid, RequestAbortedToken).ConfigureAwait(false);
+
+        if (!userExists && existingBan == null)
+            return;
+
+        const string marker = " (Alias at time of ban:";
+        string suffix;
+
+        if (existingBan?.BannedReason is { } existingReason)
+        {
+            var idx = existingReason.IndexOf(marker, StringComparison.Ordinal);
+            suffix = idx >= 0 ? existingReason.Substring(startIndex: idx) : string.Empty;
+        }
+        else
+        {
+            var alias = groupPair?.GroupUser?.Alias;
+            alias = string.IsNullOrWhiteSpace(alias) ? "-" : alias;
+            suffix = $" (Alias at time of ban: {alias})";
+        }
+
+        var baseReason = (reason ?? string.Empty).Trim();
+        var finalReason = string.IsNullOrEmpty(suffix) ? baseReason : (baseReason + suffix);
+
+        if (existingBan != null)
+        {
+            existingBan.BannedByUID = UserUID;
+            existingBan.BannedReason = finalReason;
+
+            DbContext.Update(existingBan);
+        }
+        else
+        {
+            var ban = new GroupBan
            {
                BannedByUID = UserUID,
-            BannedReason = $"{reason} (Alias at time of ban: {alias})",
-            BannedOn = DateTime.UtcNow,
-            BannedUserUID = dto.User.UID,
+                BannedReason = finalReason,
+                BannedOn = now,
+                BannedUserUID = targetUid,
                GroupGID = dto.Group.GID,
            };

            DbContext.Add(ban);
-        await DbContext.SaveChangesAsync().ConfigureAwait(false);
+        }

+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair != null)
+        {
            await GroupRemoveUser(dto).ConfigureAwait(false);
+        }

        _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
    }

+    private static readonly ConcurrentDictionary<string, DateTime> GroupChatToggleCooldowns = new(StringComparer.Ordinal);
+
    [Authorize(Policy = "Identified")]
    public async Task GroupChangeGroupPermissionState(GroupPermissionDto dto)
    {
@@ -60,15 +108,73 @@ public partial class LightlessHub
        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
        if (!hasRights) return;

-        group.InvitesEnabled = !dto.Permissions.HasFlag(GroupPermissions.DisableInvites);
-        group.PreferDisableSounds = dto.Permissions.HasFlag(GroupPermissions.PreferDisableSounds);
-        group.PreferDisableAnimations = dto.Permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
-        group.PreferDisableVFX = dto.Permissions.HasFlag(GroupPermissions.PreferDisableVFX);
+        var permissions = dto.Permissions;
+        var isOwner = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal);
+        var chatEnabled = group.ChatEnabled;
+        var chatChanged = false;
+
+        if (!isOwner)
+        {
+            permissions.SetDisableChat(!group.ChatEnabled);
+        }
+        else
+        {
+            var requestedChatEnabled = !permissions.IsDisableChat();
+            if (requestedChatEnabled != group.ChatEnabled)
+            {
+                var now = DateTime.UtcNow;
+                if (GroupChatToggleCooldowns.TryGetValue(group.GID, out var lockedUntil) && lockedUntil > now)
+                {
+                    var remaining = lockedUntil - now;
+                    var minutes = Math.Max(1, (int)Math.Ceiling(remaining.TotalMinutes));
+                    await Clients.Caller.Client_ReceiveServerMessage(
+                        MessageSeverity.Warning,
+                        $"Syncshell chat can be toggled again in {minutes} minute{(minutes == 1 ? string.Empty : "s")}."
+                    ).ConfigureAwait(false);
+                    permissions.SetDisableChat(!group.ChatEnabled);
+                }
+                else
+                {
+                    chatEnabled = requestedChatEnabled;
+                    group.ChatEnabled = chatEnabled;
+                    GroupChatToggleCooldowns[group.GID] = now.AddMinutes(5);
+                    chatChanged = true;
+                }
+            }
+        }
+
+        group.InvitesEnabled = !permissions.HasFlag(GroupPermissions.DisableInvites);
+        group.PreferDisableSounds = permissions.HasFlag(GroupPermissions.PreferDisableSounds);
+        group.PreferDisableAnimations = permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
+        group.PreferDisableVFX = permissions.HasFlag(GroupPermissions.PreferDisableVFX);

        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);

        var groupPairs = DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToList();
-        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, dto.Permissions)).ConfigureAwait(false);
+        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, permissions)).ConfigureAwait(false);
+
+        if (isOwner && chatChanged && !chatEnabled)
+        {
+            var groupDisplayName = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;
+            var descriptor = new ChatChannelDescriptor
+            {
+                Type = ChatChannelType.Group,
+                WorldId = 0,
+                ZoneId = 0,
+                CustomKey = group.GID
+            };
+
+            foreach (var uid in groupPairs)
+            {
+                TryInvokeChatService(() => _chatChannelService.RemovePresence(uid, descriptor), "removing group chat presence", descriptor, uid);
+            }
+
+            await Clients.Users(groupPairs)
+                .Client_ReceiveServerMessage(
+                    MessageSeverity.Information,
+                    $"Syncshell chat for '{groupDisplayName}' has been disabled.")
+                .ConfigureAwait(false);
+        }
    }

    [Authorize(Policy = "Identified")]
@@ -235,6 +341,7 @@ public partial class LightlessHub
            PreferDisableAnimations = defaultPermissions.DisableGroupAnimations,
            PreferDisableSounds = defaultPermissions.DisableGroupSounds,
            PreferDisableVFX = defaultPermissions.DisableGroupVFX,
+            ChatEnabled = true,
            CreatedDate = currentTime,
        };

@@ -340,9 +447,9 @@ public partial class LightlessHub

        var banEntries = await DbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);

-        List<BannedGroupUserDto> bannedGroupUsers = banEntries.Select(b =>
+        List<BannedGroupUserDto> bannedGroupUsers = [.. banEntries.Select(b =>
            new BannedGroupUserDto(group.ToGroupData(), b.BannedUser.ToUserData(), b.BannedReason, b.BannedOn,
-                b.BannedByUID)).ToList();
+                b.BannedByUID))];

        _logger.LogCallInfo(LightlessHubLogger.Args(dto, bannedGroupUsers.Count));

@@ -864,12 +971,6 @@ public partial class LightlessHub
        {
            groupProfileDb.Group ??= group;

-                if (groupProfileDb?.ProfileDisabled ?? false)
-                {
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
-                    return;
-                }
-
            groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
        }

@@ -1049,11 +1150,11 @@ public partial class LightlessHub
            return false;
        }

-        var (isOwner, _) = await TryValidateOwner(dto.GID).ConfigureAwait(false);
-        if (!isOwner)
+        var (isOwnerOrMod, _) = await TryValidateGroupModeratorOrOwner(dto.GID).ConfigureAwait(false);
+        if (!isOwnerOrMod)
        {
            _logger.LogCallWarning(LightlessHubLogger.Args("Unauthorized syncshell broadcast change", "User", UserUID, "GID", dto.GID));
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner of the syncshell to broadcast it.");
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner or moderator of the syncshell to broadcast it.");
            return false;
        }

--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs
@@ -12,8 +12,6 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
 using StackExchange.Redis;
 using System.Text;
 using System.Text.Json;
@@ -1171,12 +1169,6 @@ public partial class LightlessHub
                return;
            }

-            if (profileData.ProfileDisabled)
-            {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
-                return;
-            }
-
            profileData.UpdateProfileFromDto(dto, profileResult.Base64Image, bannerResult.Base64Image);
        }
        else
@@ -1239,6 +1231,120 @@ public partial class LightlessHub
        return true;
    }
    
+    [Authorize(Policy = "Identified")]
+    public async Task UpdateLocation(LocationDto dto, bool offline = false)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
+        if (string.IsNullOrEmpty(dto.User.UID))
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with no userinfo :",UserUID, dto));
+            return;
+        }
+
+        if (!string.Equals(UserUID, dto.User.UID, StringComparison.Ordinal))
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with another UID :",UserUID, dto));
+            return;
+        }
+        var key = $"Location:{UserUID}";
+        
+        if (offline)
+        {
+            var allUsers = await GetSharingUsers().ConfigureAwait(false);   
+            await _redis.RemoveAsync(key, CommandFlags.FireAndForget).ConfigureAwait(false);
+            await Clients.Users(allUsers.Keys).Client_SendLocationToClient(dto, DateTimeOffset.MinValue).ConfigureAwait(false);
+        }
+        else
+        {
+            var currentLocation = await _redis.GetAsync<LocationDto>(key).ConfigureAwait(false);
+            if (currentLocation != dto)
+            {
+                var allUsers = await GetSharingUsers().ConfigureAwait(false);   
+                await _redis.AddAsync(key, dto).ConfigureAwait(false);
+                var sendTasks = allUsers.Select(pair => Clients.User(pair.Key).Client_SendLocationToClient(dto, pair.Value));
+                await Task.WhenAll(sendTasks).ConfigureAwait(false);
+            }
+        }
+    }
+    
+    private async Task<Dictionary<string, DateTimeOffset>> GetSharingUsers()
+    {
+        return await DbContext.Permissions.AsNoTracking()
+            .Where(x => x.UserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
+            .ToDictionaryAsync(x => x.OtherUserUID, x => x.ShareLocationUntil, RequestAbortedToken)
+            .ConfigureAwait(false);
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task<(List<LocationWithTimeDto>, List<SharingStatusDto>)> RequestAllLocationInfo()
+    {
+        _logger.LogCallInfo();
+        var locationWithTime = await GetLocationWithTime().ConfigureAwait(false);
+        var sharingStatus = await GetSharingStatus().ConfigureAwait(false);
+        return (locationWithTime, sharingStatus);
+    }
+
+    private async Task<List<LocationWithTimeDto>> GetLocationWithTime()
+    {
+        var dictionary = await DbContext.Permissions.AsNoTracking()
+            .Where(x => x.OtherUserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
+            .ToDictionaryAsync(x => x.UserUID, x => x.ShareLocationUntil, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+        if (dictionary.Count == 0)
+        {
+            return [];
+        }
+
+        var redisKeys = dictionary.Keys.Select(uid => $"Location:{uid}").ToHashSet(StringComparer.Ordinal);
+        var data = await _redis.GetAllAsync<LocationDto>(redisKeys).ConfigureAwait(false);
+        var result = new List<LocationWithTimeDto>();
+
+        foreach (var (userUid, expireAt) in dictionary)
+        {
+            var redisKey = $"Location:{userUid}";
+
+            if (data.TryGetValue(redisKey, out var locationDto) && locationDto is not null)
+            {
+                result.Add(new LocationWithTimeDto(locationDto, expireAt));
+            }
+        }
+        return result;
+    }
+
+    private async Task<List<SharingStatusDto>> GetSharingStatus()
+    {
+        return await DbContext.Permissions.AsNoTracking()
+            .Where(x => x.UserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
+            .Select(x => new SharingStatusDto(new UserData(x.OtherUserUID), x.ShareLocationUntil))
+            .ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+    }
+
+
+
+    [Authorize(Policy = "Identified")]
+    public async Task<bool> ToggleLocationSharing(LocationSharingToggleDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
+        try
+        {
+            await DbContext.Permissions.Where(x => x.UserUID == UserUID && dto.users.Contains(x.OtherUserUID))
+                .ExecuteUpdateAsync(setter =>
+                        setter.SetProperty(x => x.ShareLocationUntil, dto.duration.ToUniversalTime()),
+                    cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+
+            //update user's location for target users
+            var currentLocation = await _redis.GetAsync<LocationDto>($"Location:{UserUID}").ConfigureAwait(false);
+            await Clients.Users(dto.users).Client_SendLocationToClient(currentLocation, dto.duration.ToUniversalTime())
+                .ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "ToggleLocationSharing error:");
+            return false;
+        }
+        return true;
+    }
+
    [GeneratedRegex(@"^([a-z0-9_ '+&,\.\-\{\}]+\/)+([a-z0-9_ '+&,\.\-\{\}]+\.[a-z]{3,4})$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ECMAScript)]
    private static partial Regex GamePathRegex();

--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs
@@ -16,6 +16,8 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
+using LightlessSync.API.Dto.CharaData;
+using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Services.Interfaces;

 namespace LightlessSyncServer.Hubs;
@@ -218,6 +220,8 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub

                _lightlessCensus.ClearStatistics(UserUID);
                
+                await UpdateLocation(new LocationDto(new UserData(UserUID), new LocationInfo()), offline: true).ConfigureAwait(false);
+
                await SendOfflineToAllPairedUsers().ConfigureAwait(false);

                DbContext.RemoveRange(DbContext.Files.Where(f => !f.Uploaded && f.UploaderUID == UserUID));
--- a/LightlessSyncServer/LightlessSyncServer/Services/LightlessCensus.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/LightlessCensus.cs
@@ -72,7 +72,7 @@ public class LightlessCensus : IHostedService

        Dictionary<ushort, short> worldDcs = new();

-        var dcs = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/WorldDCGroupType.csv", cancellationToken).ConfigureAwait(false);
+        var dcs = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/WorldDCGroupType.csv", cancellationToken).ConfigureAwait(false);
        // dc: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/WorldDCGroupType.csv
        // id, name, region

@@ -92,7 +92,7 @@ public class LightlessCensus : IHostedService
            _dcs[id] = name;
        }

-        var worlds = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/World.csv", cancellationToken).ConfigureAwait(false);
+        var worlds = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/World.csv", cancellationToken).ConfigureAwait(false);
        // world: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/World.csv
        // id, internalname, name, region, usertype, datacenter, ispublic

@@ -114,7 +114,7 @@ public class LightlessCensus : IHostedService
            _logger.LogInformation("World: ID: {id}, Name: {name}, DC: {dc}", id, name, dc);
        }

-        var races = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Race.csv", cancellationToken).ConfigureAwait(false);
+        var races = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/Race.csv", cancellationToken).ConfigureAwait(false);
        // race: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Race.csv
        // id, masc name, fem name, other crap I don't care about

@@ -134,7 +134,7 @@ public class LightlessCensus : IHostedService
            _logger.LogInformation("Race: ID: {id}, Name: {name}", id, name);
        }

-        var tribe = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Tribe.csv", cancellationToken).ConfigureAwait(false);
+        var tribe = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/Tribe.csv", cancellationToken).ConfigureAwait(false);
        // tribe: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Tribe.csv
        // id masc name, fem name, other crap I don't care about

--- a/LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs
@@ -2,15 +2,19 @@
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Models;
 using Microsoft.EntityFrameworkCore;
+using StackExchange.Redis.Extensions.Core.Abstractions;

 namespace LightlessSyncServer.Services
 {
-    public class PruneService(LightlessDbContext dbContext) : IPruneService
+    public class PruneService(LightlessDbContext dbContext, IRedisDatabase redis) : IPruneService
    {
        private readonly LightlessDbContext _dbContext = dbContext;
+        private readonly IRedisDatabase _redis = redis;

        public async Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct)
        {
+            var onlineUids = await GetOnlineUidsAsync().ConfigureAwait(false);
+
            var allGroupUsers = await _dbContext.GroupPairs
                .Include(p => p.GroupUser)
                .Include(p => p.Group)
@@ -20,17 +24,14 @@ namespace LightlessSyncServer.Services
            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();
+            var usersToPrune = GetPruneUserList(allGroupUsers, onlineUids, inactivitySpan, now);
+            return usersToPrune.Count;
        }

        public async Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct)
        {
+            var onlineUids = await GetOnlineUidsAsync().ConfigureAwait(false);
+
            var allGroupUsers = await _dbContext.GroupPairs
                .Include(p => p.GroupUser)
                .Include(p => p.Group)
@@ -40,12 +41,7 @@ namespace LightlessSyncServer.Services
            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();
+            var usersToPrune = GetPruneUserList(allGroupUsers, onlineUids, inactivitySpan, now);

            _dbContext.GroupPairs.RemoveRange(usersToPrune);
            await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
@@ -53,8 +49,52 @@ namespace LightlessSyncServer.Services
            return usersToPrune;
        }

-        private static TimeSpan GetInactivitySpan(int days) => days == 0
-                ? TimeSpan.FromMinutes(15)
-                : TimeSpan.FromDays(days);
+        private static List<GroupPair> GetPruneUserList(
+            List<GroupPair> allGroupUsers,
+            HashSet<string> onlineUids,
+            TimeSpan inactivitySpan,
+            DateTime now)
+        {
+            return
+            [
+                .. allGroupUsers.Where(p =>
+                    !p.IsPinned &&
+                    !p.IsModerator &&
+                    !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
+                    !onlineUids.Contains(p.GroupUserUID) &&
+                    p.GroupUser.LastLoggedIn < now - inactivitySpan),
+            ];
+        }
+
+        private async Task<HashSet<string>> GetOnlineUidsAsync()
+        {
+            var keys = await _redis.SearchKeysAsync("UID:*").ConfigureAwait(false);
+
+            var set = new HashSet<string>(StringComparer.Ordinal);
+
+            foreach (var k in keys)
+            {
+                if (string.IsNullOrEmpty(k)) continue;
+
+                const string prefix = "UID:";
+                if (k.StartsWith(prefix, StringComparison.Ordinal))
+                {
+                    var uid = k.Substring(prefix.Length);
+                    if (!string.IsNullOrEmpty(uid))
+                        set.Add(uid);
+                }
+                else
+                {
+                    var idx = k.IndexOf(':', StringComparison.Ordinal);
+                    if (idx >= 0 && idx < k.Length - 1)
+                        set.Add(k[(idx + 1)..]);
+                }
+            }
+
+            return set;
+        }
+
+        private static TimeSpan GetInactivitySpan(int days) =>
+            days == 0 ? TimeSpan.FromHours(2) : TimeSpan.FromDays(days);
    }
 }
--- a/LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs
@@ -118,6 +118,7 @@ public static class Extensions
        permissions.SetPreferDisableSounds(group.PreferDisableSounds);
        permissions.SetPreferDisableVFX(group.PreferDisableVFX);
        permissions.SetDisableInvites(!group.InvitesEnabled);
+        permissions.SetDisableChat(!group.ChatEnabled);
        return permissions;
    }

--- a/LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs
@@ -24,7 +24,7 @@ namespace LightlessSyncServer.Worker
                        var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<LightlessHub>>();

                        var groups = await db.Groups
-                            .Where(g => g.AutoPruneEnabled && g.AutoPruneDays > 0)
+                            .Where(g => g.AutoPruneEnabled)
                            .ToListAsync(stoppingToken).ConfigureAwait(false);

                        foreach (var group in groups)
--- a/LightlessSyncServer/LightlessSyncShared/Data/LightlessDbContext.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Data/LightlessDbContext.cs
@@ -80,6 +80,9 @@ public class LightlessDbContext : DbContext
        .WithOne(p => p.Group)
        .HasForeignKey<GroupProfile>(p => p.GroupGID)
        .IsRequired(false);
+        mb.Entity<Group>()
+        .Property(g => g.ChatEnabled)
+        .HasDefaultValue(true);
        mb.Entity<GroupPair>().ToTable("group_pairs");
        mb.Entity<GroupPair>().HasKey(u => new { u.GroupGID, u.GroupUserUID });
        mb.Entity<GroupPair>().HasIndex(c => c.GroupUserUID);
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.Designer.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.Designer.cs
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class DisableChatGroups : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "chat_enabled",
+                table: "groups",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "chat_enabled",
+                table: "groups");
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.Designer.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.Designer.cs
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.cs
@@ -0,0 +1,30 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class ShareLocation : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "share_location_until",
+                table: "user_permission_sets",
+                type: "timestamp with time zone",
+                nullable: false,
+                defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "share_location_until",
+                table: "user_permission_sets");
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs
@@ -438,6 +438,12 @@ namespace LightlessSyncServer.Migrations
                        .HasColumnType("boolean")
                        .HasColumnName("auto_prune_enabled");

+                    b.Property<bool>("ChatEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true)
+                        .HasColumnName("chat_enabled");
+
                    b.Property<DateTime>("CreatedDate")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("timestamp with time zone")
@@ -935,6 +941,10 @@ namespace LightlessSyncServer.Migrations
                        .HasColumnType("boolean")
                        .HasColumnName("is_paused");

+                    b.Property<DateTimeOffset>("ShareLocationUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("share_location_until");
+
                    b.Property<bool>("Sticky")
                        .HasColumnType("boolean")
                        .HasColumnName("sticky");
--- a/LightlessSyncServer/LightlessSyncShared/Models/Group.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Models/Group.cs
@@ -19,5 +19,6 @@ public class Group
    public bool PreferDisableSounds { get; set; }
    public bool PreferDisableAnimations { get; set; }
    public bool PreferDisableVFX { get; set; }
+    public bool ChatEnabled { get; set; } = true;
    public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
 }
--- a/LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs
@@ -15,4 +15,5 @@ public class UserPermissionSet
    public bool DisableAnimations { get; set; } = false;
    public bool DisableVFX { get; set; } = false;
    public bool DisableSounds { get; set; } = false;
+    public DateTimeOffset ShareLocationUntil { get; set; } = DateTimeOffset.MinValue;
 }
--- a/LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs
+++ b/LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs
@@ -116,11 +116,12 @@ public sealed class CachedFileProvider : IDisposable
 			var tempFileName = destinationFilePath + ".dl";
 			File.Copy(coldStorageFilePath.FullName, tempFileName, true);
 			File.Move(tempFileName, destinationFilePath, true);
-            coldStorageFilePath.LastAccessTimeUtc = DateTime.UtcNow;
-            var destinationFile = new FileInfo(destinationFilePath);
-            destinationFile.LastAccessTimeUtc = DateTime.UtcNow;
-            destinationFile.CreationTimeUtc = DateTime.UtcNow;
-            destinationFile.LastWriteTimeUtc = DateTime.UtcNow;
+
+			File.SetLastAccessTimeUtc(coldStorageFilePath.FullName, DateTime.UtcNow);
+			File.SetLastAccessTimeUtc(destinationFilePath, DateTime.UtcNow);
+			File.SetCreationTimeUtc(destinationFilePath, DateTime.UtcNow);
+			File.SetLastWriteTimeUtc(destinationFilePath, DateTime.UtcNow);
+
 			_metrics.IncGauge(MetricsAPI.GaugeFilesTotal);
 			_metrics.IncGauge(MetricsAPI.GaugeFilesTotalSize, new FileInfo(destinationFilePath).Length);
 			return true;
@@ -173,7 +174,14 @@ public sealed class CachedFileProvider : IDisposable
 		var fi = FilePathUtil.GetFileInfoForHash(_hotStoragePath, hash);
 		if (fi == null) return null;

-        fi.LastAccessTimeUtc = DateTime.UtcNow;
+		try
+		{
+			File.SetLastAccessTimeUtc(fi.FullName, DateTime.UtcNow);
+		}
+		catch (Exception ex)
+		{
+			_logger.LogWarning(ex, "Failed to update LastAccessTimeUtc for file {hash}", hash);
+		}

 		_fileStatisticsService.LogFile(hash, fi.Length);
Author	SHA1	Message	Date
celine	e8c56bb3bc	Merge pull request 'Updated links for Xivapi sources' (#54 ) from xivapi-link-changes into master Reviewed-on: #54	2026-01-05 12:03:09 +00:00
celine	8e0dcc6792	Updated links for Xivapi sources	2026-01-05 12:01:53 +00:00
cake	ac4174f6e0	Fix moderator status on broadcast (#51 ) Co-authored-by: cake <admin@cakeandbanana.nl> Reviewed-on: #51 Co-authored-by: cake <cake@noreply.git.lightless-sync.org> Co-committed-by: cake <cake@noreply.git.lightless-sync.org>	2026-01-04 05:14:37 +00:00
cake	9fffaf7df2	fix-prune (#50 ) Co-authored-by: Tsubasahane <wozaiha@gmail.com> Co-authored-by: cake <admin@cakeandbanana.nl> Reviewed-on: #50 Co-authored-by: cake <cake@noreply.git.lightless-sync.org> Co-committed-by: cake <cake@noreply.git.lightless-sync.org>	2026-01-04 05:14:22 +00:00
cake	ca0c548373	AddBan changes for ban admin panel rework (#52 ) Co-authored-by: cake <admin@cakeandbanana.nl> Reviewed-on: #52 Co-authored-by: cake <cake@noreply.git.lightless-sync.org> Co-committed-by: cake <cake@noreply.git.lightless-sync.org>	2026-01-04 05:12:00 +00:00
Tsubasa	1716750347	Location Sharing (#49 ) Authored-by: Tsubasahane <wozaiha@gmail.com> Reviewed-on: #49 Co-authored-by: Tsubasa <tsubasa@noreply.git.lightless-sync.org> Co-committed-by: Tsubasa <tsubasa@noreply.git.lightless-sync.org>	2025-12-31 17:32:00 +00:00
defnotken	d39a922482	Merge pull request 'Trying a different method of setting access time.' (#48 ) from cache-test-fix into master Reviewed-on: #48	2025-12-23 17:14:08 +00:00
defnotken	6216664e18	Merge branch 'master' into cache-test-fix	2025-12-23 17:12:45 +00:00
defnotken	54992234d5	Merge pull request 'disable-chat-groups' (#45 ) from disable-chat-groups into master Reviewed-on: #45	2025-12-23 16:55:33 +00:00
defnotken	90e81fb955	Merge branch 'master' into disable-chat-groups	2025-12-23 16:55:21 +00:00
defnotken	4012b33f98	Trying a different method of setting access time.	2025-12-23 10:36:38 -06:00
defnotken	33fb6ba2eb	Merge pull request 'Done same for user' (#47 ) from fix-profile-hide into master Reviewed-on: #47	2025-12-22 20:31:36 +00:00
cake	d1526fa49e	Done same for user	2025-12-22 21:20:32 +01:00
defnotken	5b5f8edc3b	Merge pull request 'Removed code that would prevent changes on disabled profile.' (#46 ) from fix-profile-hide into master Reviewed-on: #46 Reviewed-by: defnotken <defnotken@noreply.git.lightless-sync.org>	2025-12-22 14:53:52 +00:00
cake	8515364ffd	Removed code that would prevent changes on disabled profile.	2025-12-22 15:46:52 +01:00
defnotken	4ec6169ebd	fix context	2025-12-21 21:02:59 -06:00
defnotken	ec26abaeb5	Revert "Merge pull request 'revert ce9b94a534c1239b4b89c4ccf05354c477da49d9' (#44 ) from defnotken-patch-1 into master" This reverts commit `76bdbe28da`, reversing changes made to `ce9b94a534`.	2025-12-21 21:00:53 -06:00
defnotken	3350f2ebf6	Merge branch 'master' into disable-chat-groups	2025-12-22 02:57:55 +00:00
defnotken	670e0e01f1	Merge branch 'disable-chat-groups' of https://git.lightless-sync.org/Lightless-Sync/LightlessServer into disable-chat-groups	2025-12-21 20:48:22 -06:00
defnotken	12d51dc689	Generate migration	2025-12-21 20:48:07 -06:00
defnotken	860bc955a4	Generate migration	2025-12-21 20:43:24 -06:00
defnotken	76bdbe28da	Merge pull request 'revert ce9b94a534c1239b4b89c4ccf05354c477da49d9' (#44 ) from defnotken-patch-1 into master Reviewed-on: #44	2025-12-22 02:27:14 +00:00
defnotken	f4753505aa	revert `ce9b94a534` revert Merge pull request 'add capability to disable chat feature for groups/syncshells' (#43) from disable-chat-groups into master Reviewed-on: #43	2025-12-22 02:25:40 +00:00
defnotken	ce9b94a534	Merge pull request 'add capability to disable chat feature for groups/syncshells' (#43 ) from disable-chat-groups into master Reviewed-on: #43	2025-12-22 02:18:00 +00:00
Abelfreyja	e58210e770	add capability to disable chat feature for groups/syncshells	2025-12-22 10:24:34 +09:00
defnotken	6d49389bd4	Merge pull request 'bump-api' (#42 ) from bump-api into master Reviewed-on: #42	2025-12-19 15:38:53 +00:00
defnotken	9a964b4933	Merge branch 'bump-api' of https://git.lightless-sync.org/Lightless-Sync/LightlessServer into bump-api	2025-12-19 09:37:49 -06:00
defnotken	2ca0fe0697	bumping tha api	2025-12-19 09:37:15 -06:00
defnotken	10bcf5dd1f	Merge pull request 'migration-fix' (#41 ) from migration-fix into master Reviewed-on: #41	2025-12-19 12:04:12 +00:00
cake	7cd463d4b7	bump api server	2025-12-19 07:12:09 +01:00