Add API for downloading media file metadata

backend/FwLite/FwLiteShared/Services/FwLiteProvider.cs

@@ -46,6 +46,7 @@ IServiceProvider services
         DotnetService.ProjectServicesProvider => typeof(ProjectServicesProvider),
         DotnetService.HistoryService => typeof(HistoryServiceJsInvokable),
         DotnetService.SyncService => typeof(SyncServiceJsInvokable),
+        DotnetService.MediaFilesService => typeof(MediaFilesServiceJsInvokable),
         DotnetService.AppLauncher => typeof(IAppLauncher),
         DotnetService.TroubleshootingService => typeof(ITroubleshootingService),
         DotnetService.TestingService => typeof(TestingService),
@@ -103,6 +104,7 @@ public enum DotnetService
     ProjectServicesProvider,
     HistoryService,
     SyncService,
+    MediaFilesService,
     AppLauncher,
     TroubleshootingService,
     TestingService,

backend/FwLite/FwLiteShared/Services/MediaFilesServiceJsInvokable.cs

@@ -0,0 +1,44 @@
+using Microsoft.JSInterop;
+using LcmCrdt.MediaServer;
+using SIL.Harmony.Resource;
+
+namespace FwLiteShared.Services;
+
+public class MediaFilesServiceJsInvokable(LcmMediaService mediaService)
+{
+    [JSInvokable]
+    public async Task<RemoteResource[]> ResourcesPendingDownload()
+    {
+        return await mediaService.ResourcesPendingDownload();
+    }
+
+    [JSInvokable]
+    public async Task<LocalResource[]> ResourcesPendingUpload()
+    {
+        return await mediaService.ResourcesPendingUpload();
+    }
+
+    [JSInvokable]
+    public async Task DownloadAllResources()
+    {
+        await mediaService.DownloadAllResources();
+    }
+
+    [JSInvokable]
+    public async Task UploadAllResources()
+    {
+        await mediaService.UploadAllResources();
+    }
+
+    [JSInvokable]
+    public async Task DownloadResources(IEnumerable<RemoteResource> resources)
+    {
+        await mediaService.DownloadResources(resources);
+    }
+
+    [JSInvokable]
+    public async Task UploadResources(IEnumerable<LocalResource> resources)
+    {
+        await mediaService.UploadResources(resources);
+    }
+}

backend/FwLite/FwLiteShared/Services/ProjectServicesProvider.cs

@@ -18,7 +18,7 @@
     IServiceProvider serviceProvider,
     LexboxProjectService lexboxProjectService,
     IEnumerable<IProjectProvider> projectProviders,
     ILogger<ProjectServicesProvider> logger
 ): IAsyncDisposable
 {
     private IProjectProvider? FwDataProjectProvider =>
@@ -69,7 +69,8 @@
                 scope.Server = server;
                 scope.SetCrdtServices(
                     ActivatorUtilities.CreateInstance<HistoryServiceJsInvokable>(scopedServices),
-                    ActivatorUtilities.CreateInstance<SyncServiceJsInvokable>(scopedServices)
+                    ActivatorUtilities.CreateInstance<SyncServiceJsInvokable>(scopedServices),
+                    ActivatorUtilities.CreateInstance<MediaFilesServiceJsInvokable>(scopedServices)
                 );
                 _projectScopes.TryAdd(scope, scope);
                 return scope;
@@ -173,10 +174,12 @@
 
     public void SetCrdtServices(
         HistoryServiceJsInvokable historyService,
-        SyncServiceJsInvokable syncService)
+        SyncServiceJsInvokable syncService,
+        MediaFilesServiceJsInvokable mediaFilesService)
     {
         HistoryService = DotNetObjectReference.Create(historyService);
         SyncService = DotNetObjectReference.Create(syncService);
+        MediaFilesService = DotNetObjectReference.Create(mediaFilesService);
     }
 
     public ValueTask CleanupAsync()
@@ -191,4 +194,5 @@
     public DotNetObjectReference<MiniLcmJsInvokable> MiniLcm { get; set; }
     public DotNetObjectReference<HistoryServiceJsInvokable>? HistoryService { get; set; }
     public DotNetObjectReference<SyncServiceJsInvokable>? SyncService { get; set; }
+    public DotNetObjectReference<MediaFilesServiceJsInvokable>? MediaFilesService { get; set; }
 }

backend/FwLite/FwLiteShared/TypeGen/ReinforcedFwLiteTypingConfig.cs

@@ -21,6 +21,7 @@
 using SIL.Harmony;
 using SIL.Harmony.Core;
 using SIL.Harmony.Db;
+using SIL.Harmony.Resource;
 using System.Runtime.CompilerServices;
 using FwLiteShared.AppUpdate;
 using FwLiteShared.Sync;
@@ -84,7 +85,9 @@ private static void ConfigureMiniLcmTypes(ConfigurationBuilder builder)
                 typeof(RichTextObjectData),
 
                 typeof(MediaFile),
-                typeof(LcmFileMetadata)
+                typeof(LcmFileMetadata),
+                typeof(RemoteResource),
+                typeof(LocalResource)
             ],
             exportBuilder => exportBuilder.WithPublicNonStaticProperties(exportBuilder =>
         {
@@ -112,6 +115,10 @@ private static void ConfigureMiniLcmTypes(ConfigurationBuilder builder)
             .FlattenHierarchy()
             .WithPublicProperties()
             .WithPublicMethods(b => b.AlwaysReturnPromise().OnlyJsInvokable());
+        builder.ExportAsInterface<MediaFilesServiceJsInvokable>()
+            // .WithPublicMethods(b => b.AlwaysReturnPromise().OnlyJsInvokable());
+            .WithPublicMethods();
+            // TODO: Does MediaFilesServiceJsInvokable need the AlwaysReturnPromise().OnlyJsInvokable() setup that MiniLcmJsInvokable needs?
         builder.ExportAsEnum<SortField>().UseString();
         builder.ExportAsInterfaces([
                 typeof(QueryOptions),

backend/FwLite/LcmCrdt/MediaServer/IMediaServerClient.cs

@@ -8,6 +8,9 @@ public interface IMediaServerClient
     [Get("/api/media/{fileId}")]
     Task<HttpResponseMessage> DownloadFile(Guid fileId);
 
+    [Get("/api/media/metadata/{fileId}")]
+    Task<HttpResponseMessage> GetFileMetadata(Guid fileId);
+
     [Post("/api/media")]
     [Multipart]
     Task<MediaUploadFileResponse> UploadFile(MultipartItem file,

backend/FwLite/LcmCrdt/MediaServer/LcmMediaService.cs

@@ -7,6 +7,7 @@
 using LcmCrdt.RemoteSync;
 using Microsoft.Extensions.Logging;
 using MiniLcm.Media;
+using System.Net.Http.Json;
 
 namespace LcmCrdt.MediaServer;
 
@@ -24,6 +25,16 @@ public async Task<HarmonyResource[]> AllResources()
         return await resourceService.AllResources();
     }
 
+    public async Task<RemoteResource[]> ResourcesPendingDownload()
+    {
+        return await resourceService.ListResourcesPendingDownload();
+    }
+
+    public async Task<LocalResource[]> ResourcesPendingUpload()
+    {
+        return await resourceService.ListResourcesPendingUpload();
+    }
+
     /// <summary>
     /// should only be used in fw-headless for files which already exist in the lexbox db
     /// </summary>
@@ -42,6 +53,56 @@ public async Task DeleteResource(Guid fileId)
         await resourceService.DeleteResource(currentProjectService.ProjectData.ClientId, fileId);
     }
 
+    public async Task<LocalResource?> DownloadResourceIfNeeded(Guid fileId)
+    {
+        var localResource = await resourceService.GetLocalResource(fileId);
+        if (localResource is null)
+        {
+            var connectionStatus = await httpClientProvider.ConnectionStatus();
+            if (connectionStatus == ConnectionStatus.Online)
+            {
+                return await resourceService.DownloadResource(fileId, this);
+            }
+        }
+        return localResource;
+    }
+
+    public async Task DownloadAllResources()
+    {
+        var connectionStatus = await httpClientProvider.ConnectionStatus();
+        if (connectionStatus == ConnectionStatus.Online)
+        {
+            var resources = await ResourcesPendingDownload();
+            foreach (var resource in resources)
+            {
+                if (resource.RemoteId is null) continue;
+                await resourceService.DownloadResource(resource.Id, this);
+            }
+        }
+        // TODO: Gracefully handle other connection statuses, e.g. "not logged in"
+    }
+
+    public async Task UploadAllResources()
+    {
+        await UploadResources(await ResourcesPendingUpload());
+    }
+
+    public async Task DownloadResources(IEnumerable<RemoteResource> resources)
+    {
+        foreach (var resource in resources)
+        {
+            await DownloadResourceIfNeeded(resource.Id);
+        }
+    }
+
+    public async Task UploadResources(IEnumerable<LocalResource> resources)
+    {
+        foreach (var resource in resources)
+        {
+            await ((IRemoteResourceService)this).UploadResource(resource.Id, resource.LocalPath);
+        }
+    }
+
     /// <summary>
     /// return a stream for the file, if it's not cached locally, it will be downloaded
     /// </summary>
@@ -50,25 +111,56 @@ public async Task DeleteResource(Guid fileId)
     /// <exception cref="FileNotFoundException"></exception>
     public async Task<ReadFileResponse> GetFileStream(Guid fileId)
     {
-        var localResource = await resourceService.GetLocalResource(fileId);
+        var localResource = await DownloadResourceIfNeeded(fileId);
         if (localResource is null)
         {
             var connectionStatus = await httpClientProvider.ConnectionStatus();
             if (connectionStatus == ConnectionStatus.Online)
             {
-                localResource = await resourceService.DownloadResource(fileId, this);
+                // Try again, maybe earlier failure was a blip
+                localResource = await DownloadResourceIfNeeded(fileId);
             }
             else
             {
                 return new ReadFileResponse(ReadFileResult.Offline);
             }
         }
-        //todo, consider trying to download the file again, maybe the cache was cleared
+        if (localResource is null || !File.Exists(localResource.LocalPath))
+        {
+            // One more attempt to download again, maybe the cache was cleared
+            localResource = await DownloadResourceIfNeeded(fileId);
+            // If still null then connection is offline or unreliable enough to consider as offline
+            if (localResource is null) return new ReadFileResponse(ReadFileResult.Offline);
+        }
+        // If still can't find local path then this is where we give up
         if (!File.Exists(localResource.LocalPath))
             throw new FileNotFoundException("Unable to find the file with Id" + fileId, localResource.LocalPath);
         return new(File.OpenRead(localResource.LocalPath), Path.GetFileName(localResource.LocalPath));
     }
 
+    public async Task<LcmFileMetadata> GetFileMetadata(Guid fileId)
+    {
+        var mediaClient = await MediaServerClient();
+        var response = await mediaClient.GetFileMetadata(fileId);
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new Exception($"Failed to retrieve metadata for file {fileId}: {response.StatusCode} {response.ReasonPhrase}");
+        }
+        var metadata = await response.Content.ReadFromJsonAsync<LcmFileMetadata>();
+        if (metadata is null)
+        {
+            // Try to get content into error message, but if buffering not enabled for this request, give up
+            var content = "";
+            try
+            {
+                content = await response.Content.ReadAsStringAsync();
+            }
+            catch { } // Oh well, we tried
+            throw new Exception($"Failed to retrieve metadata for file {fileId}: response was in incorrect format. {content}");
+        }
+        return metadata;
+    }
+
     private async Task<(Stream? stream, string? filename)> RequestMediaFile(Guid fileId)
     {
         var mediaClient = await MediaServerClient();

frontend/viewer/src/DotnetProjectView.svelte

@@ -13,6 +13,7 @@
   } from '$lib/dotnet-types/generated-types/FwLiteShared/Services/ISyncServiceJsInvokable';
   import ProjectLoader from './ProjectLoader.svelte';
   import {initProjectContext} from '$lib/project-context.svelte';
+  import type {IMediaFilesServiceJsInvokable} from '$lib/dotnet-types/generated-types/FwLiteShared/Services/IMediaFilesServiceJsInvokable';
 
   const projectServicesProvider = useProjectServicesProvider();
   const projectContext = initProjectContext();
@@ -52,11 +53,16 @@
     if (projectScope.syncService) {
       syncService = wrapInProxy(projectScope.syncService, DotnetService.SyncService);
     }
+    let mediaFilesService: IMediaFilesServiceJsInvokable | undefined = undefined;
+    if (projectScope.mediaFilesService) {
+      mediaFilesService = wrapInProxy(projectScope.mediaFilesService, DotnetService.MediaFilesService);
+    }
     const api = wrapInProxy(projectScope.miniLcm, DotnetService.MiniLcmApi);
     projectContext.setup({
       api,
       historyService,
       syncService,
+      mediaFilesService,
       projectName,
       projectCode: code,
       projectType,

frontend/viewer/src/lib/dotnet-types/generated-types/FwLiteShared/Services/DotnetService.ts

@@ -12,6 +12,7 @@ export enum DotnetService {
 	ProjectServicesProvider = "ProjectServicesProvider",
 	HistoryService = "HistoryService",
 	SyncService = "SyncService",
+	MediaFilesService = "MediaFilesService",
 	AppLauncher = "AppLauncher",
 	TroubleshootingService = "TroubleshootingService",
 	TestingService = "TestingService",

frontend/viewer/src/lib/dotnet-types/generated-types/FwLiteShared/Services/IMediaFilesServiceJsInvokable.ts

@@ -0,0 +1,18 @@
+/* eslint-disable */
+//     This code was generated by a Reinforced.Typings tool.
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+
+import type {IRemoteResource} from '../../SIL/Harmony/Resource/IRemoteResource';
+import type {ILocalResource} from '../../SIL/Harmony/Resource/ILocalResource';
+
+export interface IMediaFilesServiceJsInvokable
+{
+	resourcesPendingDownload() : Promise<IRemoteResource[]>;
+	resourcesPendingUpload() : Promise<ILocalResource[]>;
+	downloadAllResources() : Promise<void>;
+	uploadAllResources() : Promise<void>;
+	downloadResources(resources: IRemoteResource[]) : Promise<void>;
+	uploadResources(resources: ILocalResource[]) : Promise<void>;
+}
+/* eslint-enable */

frontend/viewer/src/lib/dotnet-types/generated-types/FwLiteShared/Services/IProjectScope.ts

@@ -16,5 +16,6 @@ export interface IProjectScope
 	miniLcm: DotNet.DotNetObject;
 	historyService?: DotNet.DotNetObject;
 	syncService?: DotNet.DotNetObject;
+	mediaFilesService?: DotNet.DotNetObject;
 }
 /* eslint-enable */

frontend/viewer/src/lib/dotnet-types/generated-types/SIL/Harmony/Resource/ILocalResource.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+//     This code was generated by a Reinforced.Typings tool.
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+
+export interface ILocalResource
+{
+	id: string;
+	localPath: string;
+}
+/* eslint-enable */

frontend/viewer/src/lib/project-context.svelte.ts

@@ -6,6 +6,9 @@ import type {
 import type {
   ISyncServiceJsInvokable
 } from '$lib/dotnet-types/generated-types/FwLiteShared/Services/ISyncServiceJsInvokable';
+import type {
+  IMediaFilesServiceJsInvokable
+} from '$lib/dotnet-types/generated-types/FwLiteShared/Services/IMediaFilesServiceJsInvokable';
 import {resource, type ResourceOptions, type ResourceReturn} from 'runed';
 import {SvelteMap} from 'svelte/reactivity';
 import type {IProjectData} from '$lib/dotnet-types/generated-types/LcmCrdt/IProjectData';
@@ -18,6 +21,7 @@ interface ProjectContextSetup {
   api: IMiniLcmJsInvokable;
   historyService?: IHistoryServiceJsInvokable;
   syncService?: ISyncServiceJsInvokable;
+  mediaFilesService?: IMediaFilesServiceJsInvokable;
   projectName: string;
   projectCode: string;
   projectType?: 'crdt' | 'fwdata';
@@ -43,6 +47,7 @@ export class ProjectContext {
   #projectData = $state<IProjectData>();
   #historyService: IHistoryServiceJsInvokable | undefined = $state(undefined);
   #syncService: ISyncServiceJsInvokable | undefined = $state(undefined);
+  #mediaFilesService: IMediaFilesServiceJsInvokable | undefined = $state(undefined);
   #paratext = $state(false);
   #features = resource(() => this.#api, (api) => {
     if (!api) return Promise.resolve({} satisfies IMiniLcmFeatures);
@@ -81,6 +86,9 @@ export class ProjectContext {
   public get syncService(): ISyncServiceJsInvokable | undefined {
     return this.#syncService;
   }
+  public get mediaFilesService(): IMediaFilesServiceJsInvokable | undefined {
+    return this.#mediaFilesService;
+  }
   public get inParatext(): boolean {
     return this.#paratext;
   }
@@ -93,6 +101,7 @@ export class ProjectContext {
     this.#api = args.api;
     this.#historyService = args.historyService;
     this.#syncService = args.syncService;
+    this.#mediaFilesService = args.mediaFilesService;
     this.#projectName = args.projectName;
     this.#projectCode = args.projectCode;
     this.#projectType = args.projectType;