Update LightlessAPI

This reverts commit 9971b14177.

.gitignore

@@ -350,4 +350,7 @@ MigrationBackup/
 .ionide/
 
 # docker run data
-Docker/run/data/
+Docker/run/data/
+
+#idea files
+*.idea

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

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.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;
@@ -52,6 +51,8 @@ public partial class LightlessHub
         _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 +61,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 +294,7 @@ public partial class LightlessHub
             PreferDisableAnimations = defaultPermissions.DisableGroupAnimations,
             PreferDisableSounds = defaultPermissions.DisableGroupSounds,
             PreferDisableVFX = defaultPermissions.DisableGroupVFX,
+            ChatEnabled = true,
             CreatedDate = currentTime,
         };
 

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;
@@ -1232,6 +1230,120 @@ public partial class LightlessHub
         errorMessage = string.Empty;
         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();

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;
@@ -217,6 +219,8 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
                 await RemoveUserFromRedis().ConfigureAwait(false);
 
                 _lightlessCensus.ClearStatistics(UserUID);
+                
+                await UpdateLocation(new LocationDto(new UserData(UserUID), new LocationInfo()), offline: true).ConfigureAwait(false);
 
                 await SendOfflineToAllPairedUsers().ConfigureAwait(false);
 

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

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

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

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

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

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

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

LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs

@@ -102,36 +102,37 @@ public sealed class CachedFileProvider : IDisposable
 
     private bool TryCopyFromColdStorage(string hash, string destinationFilePath)
     {
-        if (!_configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.UseColdStorage), false)) return false;
+		if (!_configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.UseColdStorage), false)) return false;
 
-        string coldStorageDir = _configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.ColdStorageDirectory), string.Empty);
-        if (string.IsNullOrEmpty(coldStorageDir)) return false;
+		string coldStorageDir = _configuration.GetValueOrDefault(nameof(StaticFilesServerConfiguration.ColdStorageDirectory), string.Empty);
+		if (string.IsNullOrEmpty(coldStorageDir)) return false;
 
-        var coldStorageFilePath = FilePathUtil.GetFileInfoForHash(coldStorageDir, hash);
-        if (coldStorageFilePath == null) return false;
+		var coldStorageFilePath = FilePathUtil.GetFileInfoForHash(coldStorageDir, hash);
+		if (coldStorageFilePath == null) return false;
 
-        try
-        {
-            _logger.LogDebug("Copying {hash} from cold storage: {path}", hash, coldStorageFilePath);
-            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;
-            _metrics.IncGauge(MetricsAPI.GaugeFilesTotal);
-            _metrics.IncGauge(MetricsAPI.GaugeFilesTotalSize, new FileInfo(destinationFilePath).Length);
-            return true;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Could not copy {coldStoragePath} from cold storage", coldStorageFilePath);
-        }
+		try
+		{
+			_logger.LogDebug("Copying {hash} from cold storage: {path}", hash, coldStorageFilePath);
+			var tempFileName = destinationFilePath + ".dl";
+			File.Copy(coldStorageFilePath.FullName, tempFileName, true);
+			File.Move(tempFileName, destinationFilePath, true);
 
-        return false;
-    }
+			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;
+		}
+		catch (Exception ex)
+		{
+			_logger.LogWarning(ex, "Could not copy {coldStoragePath} from cold storage", coldStorageFilePath);
+		}
+
+		return false;
+	}
 
     public async Task DownloadFileWhenRequired(string hash)
     {
@@ -170,15 +171,22 @@ public sealed class CachedFileProvider : IDisposable
 
     public FileInfo? GetLocalFilePath(string hash)
     {
-        var fi = FilePathUtil.GetFileInfoForHash(_hotStoragePath, hash);
-        if (fi == null) return null;
+		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);
+		_fileStatisticsService.LogFile(hash, fi.Length);
 
-        return new FileInfo(fi.FullName);
-    }
+		return new FileInfo(fi.FullName);
+	}
 
     public async Task<FileInfo?> DownloadAndGetLocalFileInfo(string hash)
     {