update resource changes to use either Edit or Create change where rel…

…evant. Update db model snapshot test

add remote resources support.
add method to upload all pending local resources, and call from SyncWithResourceUpload helper method

src/SIL.Harmony.Core/EntityNotFoundException.cs

@@ -0,0 +1,3 @@
+namespace SIL.Harmony.Core;
+
+public class EntityNotFoundException(string message) : Exception(message);

src/SIL.Harmony.Core/IResourceService.cs

@@ -0,0 +1,27 @@
+namespace SIL.Harmony.Core;
+
+/// <summary>
+/// interface to facilitate downloading of resources, typically implemented in application code
+/// the remote Id is opaque to the CRDT lib and could be a URL or some other identifier provided by the backend
+/// the local path returned for the application code to use as required, it could be a URL if needed also.
+/// </summary>
+public interface IResourceService
+{
+    /// <summary>
+    /// instructs application code to download a resource from the remote server
+    /// the service is responsible for downloading the resource and returning the local path
+    /// </summary>
+    /// <param name="remoteId">ID used to identify the remote resource, could be a URL</param>
+    /// <param name="localResourceCachePath">path defined by the CRDT config where the resource should be stored</param>
+    /// <returns>download result containing the path to the downloaded file, this is stored in the local db and not synced</returns>
+    Task<DownloadResult> DownloadResource(string remoteId, string localResourceCachePath);
+    /// <summary>
+    /// upload a resource to the remote server
+    /// </summary>
+    /// <param name="localPath">full path to the resource on the local machine</param>
+    /// <returns>an upload result with the remote id, the id will be stored and transmitted to other clients so they can also download the resource</returns>
+    Task<UploadResult> UploadResource(string localPath);
+}
+
+public record DownloadResult(string LocalPath);
+public record UploadResult(string RemoteId);

src/SIL.Harmony.Tests/DbContextTests.VerifyModel.verified.txt

@@ -81,6 +81,40 @@
       Relational:TableName: Snapshots
       Relational:ViewName: 
       Relational:ViewSchema: 
+  EntityType: LocalResource
+    Properties: 
+      Id (Guid) Required PK AfterSave:Throw ValueGenerated.OnAdd
+      LocalPath (string) Required
+    Keys: 
+      Id PK
+    Annotations: 
+      DiscriminatorProperty: 
+      Relational:FunctionName: 
+      Relational:Schema: 
+      Relational:SqlQuery: 
+      Relational:TableName: LocalResource
+      Relational:ViewName: 
+      Relational:ViewSchema: 
+  EntityType: RemoteResource
+    Properties: 
+      Id (Guid) Required PK AfterSave:Throw ValueGenerated.OnAdd
+      DeletedAt (DateTimeOffset?)
+      RemoteId (string)
+      SnapshotId (no field, Guid?) Shadow FK Index
+    Keys: 
+      Id PK
+    Foreign keys: 
+      RemoteResource {'SnapshotId'} -> ObjectSnapshot {'Id'} Unique SetNull
+    Indexes: 
+      SnapshotId Unique
+    Annotations: 
+      DiscriminatorProperty: 
+      Relational:FunctionName: 
+      Relational:Schema: 
+      Relational:SqlQuery: 
+      Relational:TableName: RemoteResource
+      Relational:ViewName: 
+      Relational:ViewSchema: 
   EntityType: Definition
     Properties: 
       Id (Guid) Required PK AfterSave:Throw ValueGenerated.OnAdd

src/SIL.Harmony.Tests/ResourceTests/RemoteResourcesTests.cs

@@ -0,0 +1,137 @@
+using System.Runtime.CompilerServices;
+using SIL.Harmony.Resource;
+
+namespace SIL.Harmony.Tests.ResourceTests;
+
+public class RemoteResourcesTests : DataModelTestBase
+{
+    private RemoteServiceMock _remoteServiceMock = new();
+
+    public RemoteResourcesTests()
+    {
+    }
+
+    private string CreateFile(string contents, [CallerMemberName] string fileName = "")
+    {
+        var filePath = Path.GetFullPath(fileName + ".txt");
+        File.WriteAllText(filePath, contents);
+        return filePath;
+    }
+
+    private async Task<(Guid resourceId, string remoteId)> SetupRemoteResource(string fileContents)
+    {
+        var remoteId = _remoteServiceMock.CreateRemoteResource(fileContents);
+        var resourceId = Guid.NewGuid();
+        await DataModel.AddChange(_localClientId, new CreateRemoteResourceChange(resourceId, remoteId));
+        return (resourceId, remoteId);
+    }
+
+    private async Task<(Guid resourceId, string localPath)> SetupLocalFile(string contents, [CallerMemberName] string fileName = "")
+    {
+        var file = CreateFile(contents, fileName);
+        //because resource service is null the file is not uploaded
+        var resourceId = await DataModel.AddLocalResource(file, _localClientId, resourceService: null);
+        return (resourceId, file);
+    }
+
+    [Fact]
+    public async Task CreatingAResourceResultsInPendingLocalResources()
+    {
+        var (_, file) = await SetupLocalFile("contents");
+
+        //act
+        var pending = await DataModel.ListResourcesPendingUpload();
+
+
+        pending.Should().ContainSingle().Which.LocalPath.Should().Be(file);
+    }
+
+    [Fact]
+    public async Task ResourcesNotLocalShouldShowUpAsNotDownloaded()
+    {
+        var (resourceId, remoteId) = await SetupRemoteResource("test");
+
+        //act
+        var pending = await DataModel.ListResourcesPendingDownload();
+
+
+        var remoteResource = pending.Should().ContainSingle().Subject;
+        remoteResource.RemoteId.Should().Be(remoteId);
+        remoteResource.Id.Should().Be(resourceId);
+    }
+
+    [Fact]
+    public async Task CanUploadFileToRemote()
+    {
+        var fileContents = "resource";
+        var localFile = CreateFile(fileContents);
+
+        //act
+        var resourceId =
+            await DataModel.AddLocalResource(localFile, _localClientId, resourceService: _remoteServiceMock);
+
+
+        var resource = await DataModel.GetLatest<RemoteResource>(resourceId);
+        ArgumentNullException.ThrowIfNull(resource);
+        ArgumentNullException.ThrowIfNull(resource.RemoteId);
+        _remoteServiceMock.ReadFile(resource.RemoteId).Should().Be(fileContents);
+        var pendingUpload = await DataModel.ListResourcesPendingUpload();
+        pendingUpload.Should().BeEmpty();
+    }
+
+    [Fact]
+    public async Task WillUploadMultiplePendingLocalFilesAtOnce()
+    {
+        await SetupLocalFile("file1", "file1");
+        await SetupLocalFile("file2", "file2");
+
+        //act
+        await DataModel.UploadPendingResources(_localClientId, _remoteServiceMock);
+
+
+        _remoteServiceMock.ListFiles()
+            .Select(Path.GetFileName)
+            .Should()
+            .Contain(["file1.txt", "file2.txt"]);
+    }
+
+    [Fact]
+    public async Task CanDownloadFileFromRemote()
+    {
+        var fileContents = "resource";
+        var (resourceId, _) = await SetupRemoteResource(fileContents);
+
+        //act
+        var localResource = await DataModel.DownloadResource(resourceId, _remoteServiceMock);
+
+
+        localResource.Id.Should().Be(resourceId);
+        var actualFileContents = await File.ReadAllTextAsync(localResource.LocalPath);
+        actualFileContents.Should().Be(fileContents);
+        var pendingDownloads = await DataModel.ListResourcesPendingDownload();
+        pendingDownloads.Should().BeEmpty();
+    }
+
+    [Fact]
+    public async Task CanGetALocalResourceGivenAnId()
+    {
+        var file = CreateFile("resource");
+        //because resource service is null the file is not uploaded
+        var resourceId = await DataModel.AddLocalResource(file, _localClientId, resourceService: null);
+
+        //act
+        var localResource = await DataModel.GetLocalResource(resourceId);
+
+
+        localResource.Should().NotBeNull();
+        localResource!.LocalPath.Should().Be(file);
+    }
+
+    [Fact]
+    public async Task LocalResourceIsNullIfNotDownloaded()
+    {
+        var (resourceId, _) = await SetupRemoteResource("test");
+        var localResource = await DataModel.GetLocalResource(resourceId);
+        localResource.Should().BeNull();
+    }
+}

src/SIL.Harmony.Tests/ResourceTests/RemoteServiceMock.cs

@@ -0,0 +1,45 @@
+using SIL.Harmony.Core;
+
+namespace SIL.Harmony.Tests.ResourceTests;
+
+public class RemoteServiceMock : IResourceService
+{
+    public static readonly string RemotePath = Directory.CreateTempSubdirectory("RemoteServiceMock").FullName;
+
+    /// <summary>
+    /// directly creates a remote resource
+    /// </summary>
+    /// <returns>the remote id</returns>
+    public string CreateRemoteResource(string contents)
+    {
+        var filePath = Path.Combine(RemotePath, Guid.NewGuid().ToString("N") + ".txt");
+        File.WriteAllText(filePath, contents);
+        return filePath;
+    }
+
+    public Task<DownloadResult> DownloadResource(string remoteId, string localResourceCachePath)
+    {
+        var fileName = Path.GetFileName(remoteId);
+        var localPath = Path.Combine(localResourceCachePath, fileName);
+        Directory.CreateDirectory(localResourceCachePath);
+        File.Copy(remoteId, localPath);
+        return Task.FromResult(new DownloadResult(localPath));
+    }
+
+    public Task<UploadResult> UploadResource(string localPath)
+    {
+        var remoteId = Path.Combine(RemotePath, Path.GetFileName(localPath));
+        File.Copy(localPath, remoteId);
+        return Task.FromResult(new UploadResult(remoteId));
+    }
+
+    public string ReadFile(string remoteId)
+    {
+        return File.ReadAllText(remoteId);
+    }
+
+    public IEnumerable<string> ListFiles()
+    {
+        return Directory.GetFiles(RemotePath);
+    }
+}

src/SIL.Harmony/Changes/EditChange.cs

@@ -1,4 +1,4 @@
-namespace SIL.Harmony.Changes;
+namespace SIL.Harmony.Changes;
 
 public abstract class EditChange<T>(Guid entityId) : Change<T>(entityId)
     where T : class

src/SIL.Harmony/CrdtConfig.cs

@@ -1,11 +1,12 @@
-using System.Text.Json;
+using System.Text.Json;
 using System.Text.Json.Serialization.Metadata;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using SIL.Harmony.Adapters;
 using SIL.Harmony.Changes;
 using SIL.Harmony.Db;
 using SIL.Harmony.Entities;
+using SIL.Harmony.Resource;
 
 namespace SIL.Harmony;
 
@@ -67,6 +68,25 @@ private void JsonTypeModifier(JsonTypeInfo typeInfo)
             }
         }
     }
+
+    public bool RemoteResourcesEnabled { get; private set; }
+    public string LocalResourceCachePath { get; set; } = Path.GetFullPath("./localResourceCache");
+    public void AddRemoteResourceEntity(string? cachePath = null)
+    {
+        RemoteResourcesEnabled = true;
+        LocalResourceCachePath = cachePath ?? LocalResourceCachePath;
+        ObjectTypeListBuilder.Add<RemoteResource>();
+        ChangeTypeListBuilder.Add<RemoteResourceUploadedChange>();
+        ChangeTypeListBuilder.Add<CreateRemoteResourceChange>();
+        ChangeTypeListBuilder.Add<CreateRemoteResourcePendingUploadChange>();
+        ChangeTypeListBuilder.Add<DeleteChange<RemoteResource>>();
+        ObjectTypeListBuilder.AddDbModelConfig(builder =>
+        {
+            var entity = builder.Entity<LocalResource>();
+            entity.HasKey(lr => lr.Id);
+            entity.Property(lr => lr.LocalPath);
+        });
+    }
 }
 
 public class ChangeTypeListBuilder