Location Share but with expireAt

.gitignore

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

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

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;
@@ -1233,6 +1231,94 @@ 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>> RequestAllLocationInfo()
+    {
+        _logger.LogCallInfo();
+        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;
+    }
+
+
+
+    [Authorize(Policy = "Identified")]
+    public async Task ToggleLocationSharing(LocationSharingToggleDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
+        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);
+    }
+
     [GeneratedRegex(@"^([a-z0-9_ '+&,\.\-\{\}]+\/)+([a-z0-9_ '+&,\.\-\{\}]+\.[a-z]{3,4})$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ECMAScript)]
     private static partial Regex GamePathRegex();
 

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));

LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs

@@ -151,6 +151,7 @@ public static class Extensions
         perm.SetDisableVFX(permissions.DisableVFX);
         if (setSticky)
             perm.SetSticky(permissions.Sticky);
+        perm.SetShareLocation(permissions.ShareLocationUntil > DateTimeOffset.UtcNow);
         return perm;
     }
 }

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;
 }