Resolve alias if used

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>

.gitignore

@@ -351,4 +351,6 @@ MigrationBackup/
 
 # docker run data
 Docker/run/data/
-*.idea
+
+#idea files
+*.idea

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs

@@ -40,6 +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) => 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");
     }
 }

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs

@@ -585,11 +585,6 @@ public partial class LightlessHub
 
         return await result.Distinct().AsNoTracking().ToListAsync().ConfigureAwait(false);
     }
-    
-    private async Task CleanVisibilityCacheFromRedis()
-    {
-        await _redis.RemoveAsync($"Visibility:{UserUID}", CommandFlags.FireAndForget).ConfigureAwait(false);
-    }
 
     public record UserInfo(
         string Alias,

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs

@@ -28,25 +28,72 @@ 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)
         {
-            BannedByUID = UserUID,
-            BannedReason = $"{reason} (Alias at time of ban: {alias})",
-            BannedOn = DateTime.UtcNow,
-            BannedUserUID = dto.User.UID,
-            GroupGID = dto.Group.GID,
-        };
+            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})";
+        }
 
-        DbContext.Add(ban);
-        await DbContext.SaveChangesAsync().ConfigureAwait(false);
+        var baseReason = (reason ?? string.Empty).Trim();
+        var finalReason = string.IsNullOrEmpty(suffix) ? baseReason : (baseReason + suffix);
 
-        await GroupRemoveUser(dto).ConfigureAwait(false);
+        if (existingBan != null)
+        {
+            existingBan.BannedByUID = UserUID;
+            existingBan.BannedReason = finalReason;
+
+            DbContext.Update(existingBan);
+        }
+        else
+        {
+            var ban = new GroupBan
+            {
+                BannedByUID = UserUID,
+                BannedReason = finalReason,
+                BannedOn = now,
+                BannedUserUID = targetUid,
+                GroupGID = dto.Group.GID,
+            };
+
+            DbContext.Add(ban);
+        }
+
+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair != null)
+        {
+            await GroupRemoveUser(dto).ConfigureAwait(false);
+        }
 
         _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
     }
@@ -326,7 +373,7 @@ public partial class LightlessHub
         await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
             newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
             .ConfigureAwait(false);
-        
+
         _logger.LogCallInfo(LightlessHubLogger.Args(gid));
 
         return new GroupJoinDto(newGroup.ToGroupData(), passwd, initialPrefPermissions.ToEnum());
@@ -400,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));
 
@@ -504,7 +551,6 @@ public partial class LightlessHub
             preferredPermissions.DisableVFX = dto.GroupUserPreferredPermissions.IsDisableVFX();
             preferredPermissions.DisableAnimations = dto.GroupUserPreferredPermissions.IsDisableAnimations();
             preferredPermissions.IsPaused = false;
-            preferredPermissions.ShareLocation = dto.GroupUserPreferredPermissions.IsSharingLocation();
             DbContext.Update(preferredPermissions);
         }
 
@@ -550,8 +596,7 @@ public partial class LightlessHub
                         DisableSounds = preferredPermissions.DisableSounds,
                         DisableVFX = preferredPermissions.DisableVFX,
                         IsPaused = preferredPermissions.IsPaused,
-                        Sticky = false,
-                        ShareLocation = preferredPermissions.ShareLocation,
+                        Sticky = false
                     };
 
                     await DbContext.Permissions.AddAsync(ownPermissionsToOther).ConfigureAwait(false);
@@ -563,7 +608,6 @@ public partial class LightlessHub
                     existingPermissionsOnDb.DisableVFX = preferredPermissions.DisableVFX;
                     existingPermissionsOnDb.IsPaused = false;
                     existingPermissionsOnDb.Sticky = false;
-                    existingPermissionsOnDb.ShareLocation = preferredPermissions.ShareLocation;
 
                     DbContext.Update(existingPermissionsOnDb);
 
@@ -579,7 +623,6 @@ public partial class LightlessHub
                 ownPermissionsToOther.DisableVFX = preferredPermissions.DisableVFX;
                 ownPermissionsToOther.DisableSounds = preferredPermissions.DisableSounds;
                 ownPermissionsToOther.IsPaused = false;
-                ownPermissionsToOther.ShareLocation = preferredPermissions.ShareLocation;
 
                 DbContext.Update(ownPermissionsToOther);
             }
@@ -601,8 +644,7 @@ public partial class LightlessHub
                         DisableSounds = otherPreferred.DisableSounds,
                         DisableVFX = otherPreferred.DisableVFX,
                         IsPaused = otherPreferred.IsPaused,
-                        Sticky = false,
-                        ShareLocation = otherPreferred.ShareLocation,
+                        Sticky = false
                     };
 
                     await DbContext.AddAsync(otherExistingPermsOnDb).ConfigureAwait(false);
@@ -614,7 +656,6 @@ public partial class LightlessHub
                     otherExistingPermsOnDb.DisableSounds = otherPreferred.DisableSounds;
                     otherExistingPermsOnDb.DisableVFX = otherPreferred.DisableVFX;
                     otherExistingPermsOnDb.IsPaused = otherPreferred.IsPaused;
-                    otherExistingPermsOnDb.ShareLocation = otherPreferred.ShareLocation;
 
                     DbContext.Update(otherExistingPermsOnDb);
                 }
@@ -628,7 +669,6 @@ public partial class LightlessHub
                 otherPermissionToSelf.DisableSounds = otherPreferred.DisableSounds;
                 otherPermissionToSelf.DisableVFX = otherPreferred.DisableVFX;
                 otherPermissionToSelf.IsPaused = otherPreferred.IsPaused;
-                otherPermissionToSelf.ShareLocation = otherPreferred.ShareLocation;
 
                 DbContext.Update(otherPermissionToSelf);
             }
@@ -838,7 +878,7 @@ public partial class LightlessHub
         }
 
         var data = await DbContext.GroupProfiles
-            .Include(gp => gp.Group) 
+            .Include(gp => gp.Group)
             .FirstOrDefaultAsync(
                 g => g.Group.GID == dto.Group.GID || g.Group.Alias == dto.Group.AliasOrGID,
                 cancellationToken
@@ -869,85 +909,85 @@ public partial class LightlessHub
     [Authorize(Policy = "Identified")]
     public async Task GroupSetProfile(GroupProfileDto dto)
     {
-            _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
 
-            var cancellationToken = RequestAbortedToken;
+        var cancellationToken = RequestAbortedToken;
 
-            if (dto.Group == null) return;
+        if (dto.Group == null) return;
 
-            var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
-            if (!hasRights) return;
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
+        if (!hasRights) return;
 
-            var groupProfileDb = await DbContext.GroupProfiles
-                .Include(g => g.Group)
-                .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID, cancellationToken)
+        var groupProfileDb = await DbContext.GroupProfiles
+            .Include(g => g.Group)
+            .FirstOrDefaultAsync(g => g.GroupGID == dto.Group.GID, cancellationToken)
+            .ConfigureAwait(false);
+
+        ImageCheckService.ImageLoadResult profileResult = new();
+        ImageCheckService.ImageLoadResult bannerResult = new();
+
+        //Avatar image validation
+        if (!string.IsNullOrEmpty(dto.PictureBase64))
+        {
+            profileResult = await ImageCheckService.ValidateImageAsync(dto.PictureBase64, banner: false, RequestAbortedToken).ConfigureAwait(false);
+
+            if (!profileResult.Success)
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, profileResult.ErrorMessage).ConfigureAwait(false);
+                return;
+            }
+        }
+
+        //Banner image validation
+        if (!string.IsNullOrEmpty(dto.BannerBase64))
+        {
+            bannerResult = await ImageCheckService.ValidateImageAsync(dto.BannerBase64, banner: true, RequestAbortedToken).ConfigureAwait(false);
+
+            if (!bannerResult.Success)
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, bannerResult.ErrorMessage).ConfigureAwait(false);
+                return;
+            }
+        }
+
+        var sanitizedProfileImage = profileResult?.Base64Image;
+        var sanitizedBannerImage = bannerResult?.Base64Image;
+
+        if (groupProfileDb == null)
+        {
+            groupProfileDb = new GroupProfile
+            {
+                GroupGID = dto.Group.GID,
+                Group = group,
+                ProfileDisabled = dto.IsDisabled ?? false,
+                IsNSFW = dto.IsNsfw ?? false,
+
+            };
+
+            groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
+            await DbContext.GroupProfiles.AddAsync(groupProfileDb, cancellationToken).ConfigureAwait(false);
+        }
+        else
+        {
+            groupProfileDb.Group ??= group;
+
+            groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
+        }
+
+        var userIds = await DbContext.GroupPairs
+            .Where(p => p.GroupGID == groupProfileDb.GroupGID)
+            .Select(p => p.GroupUserUID)
+            .ToListAsync(cancellationToken)
+            .ConfigureAwait(false);
+
+        if (userIds.Count > 0)
+        {
+            var profileDto = groupProfileDb.ToDTO();
+            await Clients.Users(userIds).Client_GroupSendProfile(profileDto)
                 .ConfigureAwait(false);
+        }
 
-            ImageCheckService.ImageLoadResult profileResult = new();
-            ImageCheckService.ImageLoadResult bannerResult = new();
-
-            //Avatar image validation
-            if (!string.IsNullOrEmpty(dto.PictureBase64))
-            {
-                profileResult = await ImageCheckService.ValidateImageAsync(dto.PictureBase64, banner: false, RequestAbortedToken).ConfigureAwait(false);
-
-                if (!profileResult.Success)
-                {
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, profileResult.ErrorMessage).ConfigureAwait(false);
-                    return;
-                }
-            }
-
-            //Banner image validation
-            if (!string.IsNullOrEmpty(dto.BannerBase64))
-            {
-                bannerResult = await ImageCheckService.ValidateImageAsync(dto.BannerBase64, banner: true, RequestAbortedToken).ConfigureAwait(false);
-
-                if (!bannerResult.Success)
-                {
-                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, bannerResult.ErrorMessage).ConfigureAwait(false);
-                    return;
-                }
-            }
-
-            var sanitizedProfileImage = profileResult?.Base64Image;
-            var sanitizedBannerImage = bannerResult?.Base64Image;
-
-            if (groupProfileDb == null)
-            {
-                groupProfileDb = new GroupProfile
-                {
-                    GroupGID = dto.Group.GID,
-                    Group = group,
-                    ProfileDisabled = dto.IsDisabled ?? false,
-                    IsNSFW = dto.IsNsfw ?? false,
-                    
-                };
-
-                groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
-                await DbContext.GroupProfiles.AddAsync(groupProfileDb, cancellationToken).ConfigureAwait(false);
-            }
-            else
-            {
-                groupProfileDb.Group ??= group;
-
-                groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
-            }
-
-            var userIds = await DbContext.GroupPairs
-                .Where(p => p.GroupGID == groupProfileDb.GroupGID)
-                .Select(p => p.GroupUserUID)
-                .ToListAsync(cancellationToken)
-                .ConfigureAwait(false);
-
-            if (userIds.Count > 0)
-            {
-                var profileDto = groupProfileDb.ToDTO();
-                await Clients.Users(userIds).Client_GroupSendProfile(profileDto)
-                    .ConfigureAwait(false);
-            }
-
-            await DbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+        await DbContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
     }
 
     [Authorize(Policy = "Identified")]

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Permissions.cs

@@ -66,7 +66,6 @@ public partial class LightlessHub
             prevPermissions.DisableSounds = newPerm.IsDisableSounds();
             prevPermissions.DisableVFX = newPerm.IsDisableVFX();
             prevPermissions.Sticky = newPerm.IsSticky() || setSticky;
-            prevPermissions.ShareLocation = newPerm.IsSharingLocation();
             DbContext.Update(prevPermissions);
 
             // send updated data to pair
@@ -113,7 +112,6 @@ public partial class LightlessHub
             groupPreferredPermissions.DisableAnimations = group.Value.IsDisableAnimations();
             groupPreferredPermissions.IsPaused = group.Value.IsPaused();
             groupPreferredPermissions.DisableVFX = group.Value.IsDisableVFX();
-            groupPreferredPermissions.ShareLocation = group.Value.IsSharingLocation();
 
             var nonStickyPairs = allUsers.Where(u => !u.Value.OwnPermissions.Sticky).ToList();
             var affectedGroupPairs = nonStickyPairs.Where(u => u.Value.GIDs.Contains(group.Key, StringComparer.Ordinal)).ToList();
@@ -128,7 +126,6 @@ public partial class LightlessHub
                 perm.DisableAnimations = groupPreferredPermissions.DisableAnimations;
                 perm.IsPaused = groupPreferredPermissions.IsPaused;
                 perm.DisableVFX = groupPreferredPermissions.DisableVFX;
-                perm.ShareLocation = groupPreferredPermissions.ShareLocation;
             }
 
             UserPermissions permissions = UserPermissions.NoneSet;
@@ -136,7 +133,6 @@ public partial class LightlessHub
             permissions.SetDisableAnimations(groupPreferredPermissions.DisableAnimations);
             permissions.SetDisableSounds(groupPreferredPermissions.DisableSounds);
             permissions.SetDisableVFX(groupPreferredPermissions.DisableVFX);
-            permissions.SetShareLocation(groupPreferredPermissions.ShareLocation);
 
             await Clients.Users(affectedGroupPairs
                 .Select(k => k.Key))

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;
@@ -86,8 +84,7 @@ public partial class LightlessHub
                 DisableSounds = ownDefaultPermissions.DisableIndividualSounds,
                 DisableVFX = ownDefaultPermissions.DisableIndividualVFX,
                 IsPaused = false,
-                Sticky = true,
-                ShareLocation = false,
+                Sticky = true
             };
 
             var existingDbPerms = await DbContext.Permissions.SingleOrDefaultAsync(u => u.UserUID == UserUID && u.OtherUserUID == otherUser.UID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
@@ -102,7 +99,6 @@ public partial class LightlessHub
                 existingDbPerms.DisableVFX = permissions.DisableVFX;
                 existingDbPerms.IsPaused = false;
                 existingDbPerms.Sticky = true;
-                existingDbPerms.ShareLocation = permissions.ShareLocation;
 
                 DbContext.Permissions.Update(existingDbPerms);
             }
@@ -1235,82 +1231,118 @@ 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))
+        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))
+        if (!string.Equals(UserUID, dto.User.UID, StringComparison.Ordinal))
         {
             _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with another UID :",UserUID, dto));
             return;
         }
-        
-        var visibilityCacheKey = $"Visibility:{UserUID}";
-        
-        var allUsers = await _redis.GetAsync<List<string>>(visibilityCacheKey).ConfigureAwait(false);
-        if (allUsers == null)
-        {
-            var permissibleGroupGIDsQuery = DbContext.GroupPairPreferredPermissions.AsNoTracking()
-                .Where(gpp => gpp.UserUID == dto.user.UID && !gpp.IsPaused && gpp.ShareLocation == true)
-                .Select(gpp => gpp.GroupGID);
-
-            var groupUserUIDsQuery = DbContext.GroupPairs.AsNoTracking()
-                .Where(gp => permissibleGroupGIDsQuery.Contains(gp.GroupGID))
-                .Select(gp => gp.GroupUserUID);
-
-            var directlySharedUserUIDsQuery = DbContext.Permissions.AsNoTracking()
-                .Where(p => p.UserUID == dto.user.UID && !p.IsPaused && p.ShareLocation == true)
-                .Select(p => p.OtherUserUID);
-
-            allUsers = await directlySharedUserUIDsQuery
-                .Union(groupUserUIDsQuery)
-                .Distinct()
-                .ToListAsync().ConfigureAwait(false);
-            
-            await _redis.AddAsync(
-                visibilityCacheKey, 
-                allUsers, 
-                TimeSpan.FromMinutes(30), 
-                StackExchange.Redis.When.Always, 
-                StackExchange.Redis.CommandFlags.FireAndForget
-            ).ConfigureAwait(false);
-        }
-        
         var key = $"Location:{UserUID}";
         
         if (offline)
         {
-            await _redis.RemoveAsync(key, StackExchange.Redis.CommandFlags.FireAndForget).ConfigureAwait(false);
-            await Clients.Users(allUsers).Client_SendLocationToClient(dto).ConfigureAwait(false);
+            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);
-            
-            await _redis.AddAsync(key, dto).ConfigureAwait(false);
-            if (allUsers.Count != 0 && currentLocation != dto)
+            if (currentLocation != dto)
             {
-                await Clients.Users(allUsers).Client_SendLocationToClient(dto).ConfigureAwait(false);
+                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<LocationDto>> RequestAllLocationInfo()
+    public async Task<(List<LocationWithTimeDto>, List<SharingStatusDto>)> RequestAllLocationInfo()
     {
         _logger.LogCallInfo();
-        var uids = DbContext.Permissions.AsNoTracking().Where(x => x.OtherUserUID == UserUID && x.ShareLocation == true)
-            .Select(x => x.UserUID).ToList();
-        var data =await _redis.GetAllAsync<LocationDto>(uids.Select(x => $"Location:{x}").ToHashSet(StringComparer.Ordinal))
+        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);
-        return data.Where(x => x.Value is not null).Select(x => x.Value).ToList();
+        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)]

LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs

@@ -219,11 +219,10 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
                 await RemoveUserFromRedis().ConfigureAwait(false);
 
                 _lightlessCensus.ClearStatistics(UserUID);
-
-                await SendOfflineToAllPairedUsers().ConfigureAwait(false);
                 
                 await UpdateLocation(new LocationDto(new UserData(UserUID), new LocationInfo()), offline: true).ConfigureAwait(false);
-                await CleanVisibilityCacheFromRedis().ConfigureAwait(false);
+
+                await SendOfflineToAllPairedUsers().ConfigureAwait(false);
 
                 DbContext.RemoveRange(DbContext.Files.Where(f => !f.Uploaded && f.UploaderUID == UserUID));
                 await DbContext.SaveChangesAsync().ConfigureAwait(false);

LightlessSyncServer/LightlessSyncServer/Services/PairService.cs

@@ -67,7 +67,6 @@ public class PairService
                     DisableVFX = defaultPerms.DisableIndividualVFX,
                     IsPaused = false,
                     Sticky = true,
-                    ShareLocation = false,
                 });
                 modified = true;
             }
@@ -89,7 +88,6 @@ public class PairService
                     DisableVFX = defaultPerms.DisableIndividualVFX,
                     IsPaused = false,
                     Sticky = true,
-                    ShareLocation = false,
                 });
                 modified = true;
             }

LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs

@@ -129,7 +129,6 @@ public static class Extensions
         permissions.SetDisableSounds(groupPair.DisableSounds);
         permissions.SetPaused(groupPair.IsPaused);
         permissions.SetDisableVFX(groupPair.DisableVFX);
-        permissions.SetShareLocation(groupPair.ShareLocation);
         return permissions;
     }
 
@@ -150,7 +149,6 @@ public static class Extensions
         perm.SetDisableAnimations(permissions.DisableAnimations);
         perm.SetDisableSounds(permissions.DisableSounds);
         perm.SetDisableVFX(permissions.DisableVFX);
-        perm.SetShareLocation(permissions.ShareLocation);
         if (setSticky)
             perm.SetSticky(permissions.Sticky);
         return perm;

LightlessSyncServer/LightlessSyncShared/Migrations/20251227120132_LocationSharing.cs

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

LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.Designer.cs

@@ -12,8 +12,8 @@ using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 namespace LightlessSyncServer.Migrations
 {
     [DbContext(typeof(LightlessDbContext))]
-    [Migration("20251227120132_LocationSharing")]
-    partial class LocationSharing
+    [Migration("20251229015535_ShareLocation")]
+    partial class ShareLocation
     {
         /// <inheritdoc />
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
@@ -587,10 +587,6 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("is_paused");
 
-                    b.Property<bool>("ShareLocation")
-                        .HasColumnType("boolean")
-                        .HasColumnName("share_location");
-
                     b.HasKey("UserUID", "GroupGID")
                         .HasName("pk_group_pair_preferred_permissions");
 
@@ -948,9 +944,9 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("is_paused");
 
-                    b.Property<bool>("ShareLocation")
-                        .HasColumnType("boolean")
-                        .HasColumnName("share_location");
+                    b.Property<DateTimeOffset>("ShareLocationUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("share_location_until");
 
                     b.Property<bool>("Sticky")
                         .HasColumnType("boolean")

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");
+        }
+    }
+}

LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs

@@ -584,10 +584,6 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("is_paused");
 
-                    b.Property<bool>("ShareLocation")
-                        .HasColumnType("boolean")
-                        .HasColumnName("share_location");
-
                     b.HasKey("UserUID", "GroupGID")
                         .HasName("pk_group_pair_preferred_permissions");
 
@@ -945,9 +941,9 @@ namespace LightlessSyncServer.Migrations
                         .HasColumnType("boolean")
                         .HasColumnName("is_paused");
 
-                    b.Property<bool>("ShareLocation")
-                        .HasColumnType("boolean")
-                        .HasColumnName("share_location");
+                    b.Property<DateTimeOffset>("ShareLocationUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("share_location_until");
 
                     b.Property<bool>("Sticky")
                         .HasColumnType("boolean")

LightlessSyncServer/LightlessSyncShared/Models/GroupPairPreferredPermission.cs

@@ -10,5 +10,4 @@ public class GroupPairPreferredPermission
     public bool DisableAnimations { get; set; }
     public bool DisableSounds { get; set; }
     public bool DisableVFX { get; set; }
-    public bool ShareLocation  { get; set; }
 }

LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs

@@ -15,5 +15,5 @@ public class UserPermissionSet
     public bool DisableAnimations { get; set; } = false;
     public bool DisableVFX { get; set; } = false;
     public bool DisableSounds { get; set; } = false;
-    public bool ShareLocation  { get; set; } = false;
+    public DateTimeOffset ShareLocationUntil { get; set; } = DateTimeOffset.MinValue;
 }