Comments

backend/FwLite/FwLiteShared.Tests/Sync/SyncServiceTests.cs

@@ -0,0 +1,175 @@
+using System.Diagnostics.CodeAnalysis;
+using FwLiteShared.Sync;
+using LcmCrdt.Changes.Comments;
+using MiniLcm.Models;
+using SIL.Harmony;
+using SIL.Harmony.Changes;
+using SIL.Harmony.Core;
+
+namespace FwLiteShared.Tests.Sync;
+
+public class SyncServiceTests
+{
+    [Fact]
+    public void GetUnreadCommentsFromSyncResults_ReturnsCreatedUserComments()
+    {
+        var threadId = Guid.NewGuid();
+        var comment = new UserComment
+        {
+            Id = Guid.NewGuid(),
+            CommentThreadId = threadId,
+            Text = "synced comment"
+        };
+        var commentChange = new CreateUserCommentChange(comment);
+        var commitId = Guid.NewGuid();
+        var commit = new FakeCommit(commitId, new HybridDateTime(DateTimeOffset.UtcNow, 0))
+        {
+            ChangeEntities =
+            [
+                new ChangeEntity<IChange>
+                {
+                    Change = commentChange,
+                    CommitId = commitId,
+                    EntityId = commentChange.EntityId,
+                    Index = 0
+                },
+                new ChangeEntity<IChange>
+                {
+                    Change = new EditUserCommentChange(comment.Id, "edited", DateTimeOffset.UtcNow),
+                    CommitId = commitId,
+                    EntityId = comment.Id,
+                    Index = 1
+                }
+            ]
+        };
+
+        var results = new SyncResults([commit], [], true);
+
+        var unreadComments = SyncService.GetUnreadCommentsFromSyncResults(results, currentUserId: "current-user").ToArray();
+
+        unreadComments.Should().ContainSingle()
+            .Which.Should().Be((comment.Id, threadId));
+    }
+
+    [Fact]
+    public void GetUnreadCommentsFromSyncResults_ExcludesCommentsAuthoredByCurrentUser()
+    {
+        var threadId = Guid.NewGuid();
+        var mine = new CreateUserCommentChange(new UserComment
+        {
+            Id = Guid.NewGuid(),
+            CommentThreadId = threadId,
+            Text = "authored by me on another device",
+            AuthorId = "current-user"
+        });
+        var theirs = new CreateUserCommentChange(new UserComment
+        {
+            Id = Guid.NewGuid(),
+            CommentThreadId = threadId,
+            Text = "authored by someone else",
+            AuthorId = "other-user"
+        });
+        var commitId = Guid.NewGuid();
+        var commit = new FakeCommit(commitId, new HybridDateTime(DateTimeOffset.UtcNow, 0))
+        {
+            ChangeEntities =
+            [
+                new ChangeEntity<IChange> { Change = mine, CommitId = commitId, EntityId = mine.EntityId, Index = 0 },
+                new ChangeEntity<IChange> { Change = theirs, CommitId = commitId, EntityId = theirs.EntityId, Index = 1 }
+            ]
+        };
+
+        var results = new SyncResults([commit], [], true);
+
+        var unreadComments = SyncService.GetUnreadCommentsFromSyncResults(results, currentUserId: "current-user").ToArray();
+
+        unreadComments.Should().ContainSingle("comments authored by other users are unread, the current user's own are not")
+            .Which.Should().Be((theirs.EntityId, threadId));
+    }
+
+    [Fact]
+    public void GetUnreadCommentsFromSyncResults_WithoutCurrentUser_IncludesCommentWithNullAuthor()
+    {
+        var threadId = Guid.NewGuid();
+        var comment = new UserComment
+        {
+            Id = Guid.NewGuid(),
+            CommentThreadId = threadId,
+            Text = "synced comment with no author"
+        };
+        var change = new CreateUserCommentChange(comment);
+        var commitId = Guid.NewGuid();
+        var commit = new FakeCommit(commitId, new HybridDateTime(DateTimeOffset.UtcNow, 0))
+        {
+            ChangeEntities =
+            [
+                new ChangeEntity<IChange> { Change = change, CommitId = commitId, EntityId = change.EntityId, Index = 0 }
+            ]
+        };
+
+        var results = new SyncResults([commit], [], true);
+
+        var unreadComments = SyncService.GetUnreadCommentsFromSyncResults(results, currentUserId: null).ToArray();
+
+        unreadComments.Should().ContainSingle("with no current user, even an author-less synced comment is unread")
+            .Which.Should().Be((comment.Id, threadId));
+    }
+
+    [Fact]
+    public void GetDeletedCommentsFromSyncResults_ReturnsDeletedCommentsAndThreads()
+    {
+        var threadId = Guid.NewGuid();
+        var commentId = Guid.NewGuid();
+        var deletedThreadId = Guid.NewGuid();
+        var commitId = Guid.NewGuid();
+        var commit = new FakeCommit(commitId, new HybridDateTime(DateTimeOffset.UtcNow, 0))
+        {
+            ChangeEntities =
+            [
+                new ChangeEntity<IChange>
+                {
+                    Change = new DeleteChange<UserComment>(commentId),
+                    CommitId = commitId,
+                    EntityId = commentId,
+                    Index = 0
+                },
+                new ChangeEntity<IChange>
+                {
+                    Change = new DeleteChange<CommentThread>(deletedThreadId),
+                    CommitId = commitId,
+                    EntityId = deletedThreadId,
+                    Index = 1
+                },
+                new ChangeEntity<IChange>
+                {
+                    Change = new CreateUserCommentChange(new UserComment
+                    {
+                        Id = Guid.NewGuid(),
+                        CommentThreadId = threadId,
+                        Text = "still here"
+                    }),
+                    CommitId = commitId,
+                    EntityId = Guid.NewGuid(),
+                    Index = 2
+                }
+            ]
+        };
+
+        var results = new SyncResults([commit], [], true);
+
+        var (deletedCommentIds, deletedThreadIds) = SyncService.GetDeletedCommentsFromSyncResults(results);
+
+        deletedCommentIds.Should().ContainSingle().Which.Should().Be(commentId);
+        deletedThreadIds.Should().ContainSingle().Which.Should().Be(deletedThreadId);
+    }
+
+    private class FakeCommit : Commit
+    {
+        [SetsRequiredMembers]
+        public FakeCommit(Guid id, HybridDateTime hybridDateTime) : base(id, "", NullParentHash, hybridDateTime)
+        {
+            HybridDateTime = hybridDateTime;
+            SetParentHash(NullParentHash);
+        }
+    }
+}

backend/FwLite/FwLiteShared/Services/MiniLcmJsInvokable.cs

@@ -21,14 +21,14 @@ MiniLcmApiUserFacingWrappers userFacingWrappers
 {
     private readonly IMiniLcmApi _wrappedApi = userFacingWrappers.Apply(api, project, notificationWrapperFactory);
 
-    public record MiniLcmFeatures(bool? History, bool? Write, bool? OpenWithFlex, bool? Feedback, bool? Sync, bool? Audio, bool? CustomViews);
+    public record MiniLcmFeatures(bool? History, bool? Write, bool? OpenWithFlex, bool? Feedback, bool? Sync, bool? Audio, bool? CustomViews, bool? Comments);
     private bool SupportsSync => project.DataFormat == ProjectDataFormat.Harmony && api is CrdtMiniLcmApi;
     [JSInvokable]
     public MiniLcmFeatures SupportedFeatures()
     {
         var isCrdtProject = project.DataFormat == ProjectDataFormat.Harmony;
         var isFwDataProject = project.DataFormat == ProjectDataFormat.FwData;
-        return new(History: isCrdtProject, Write: CanWrite, OpenWithFlex: isFwDataProject, Feedback: true, Sync: SupportsSync, Audio: true, CustomViews: isCrdtProject);
+        return new(History: isCrdtProject, Write: CanWrite, OpenWithFlex: isFwDataProject, Feedback: true, Sync: SupportsSync, Audio: true, CustomViews: isCrdtProject, Comments: isCrdtProject);
     }
 
     private bool CanWrite =>
@@ -270,6 +270,114 @@ public async Task DeleteCustomView(Guid id)
         OnDataChanged();
     }
 
+    [JSInvokable]
+    public ValueTask<CommentThread[]> GetCommentThreads(SubjectType subjectType, Guid subjectId, bool includeComments = false)
+    {
+        return _wrappedApi.GetCommentThreads(subjectType, subjectId, includeComments).ToArrayAsync();
+    }
+
+    [JSInvokable]
+    [TsFunction(Type = "Promise<ICommentThread | null>")]
+    public Task<CommentThread?> GetCommentThread(Guid id)
+    {
+        return _wrappedApi.GetCommentThread(id);
+    }
+
+    [JSInvokable]
+    public ValueTask<UserComment[]> GetUserComments(Guid threadId)
+    {
+        return _wrappedApi.GetUserComments(threadId).ToArrayAsync();
+    }
+
+    [JSInvokable]
+    [TsFunction(Type = "Promise<IUserComment | null>")]
+    public Task<UserComment?> GetUserComment(Guid id)
+    {
+        return _wrappedApi.GetUserComment(id);
+    }
+
+    [JSInvokable]
+    public ValueTask<UserComment[]> GetUnreadComments(Guid? threadId = null)
+    {
+        return _wrappedApi.GetUnreadComments(threadId).ToArrayAsync();
+    }
+
+    [JSInvokable]
+    public ValueTask<UserComment[]> GetUnreadCommentsForSubject(SubjectType subjectType, Guid subjectId)
+    {
+        return _wrappedApi.GetUnreadCommentsForSubject(subjectType, subjectId).ToArrayAsync();
+    }
+
+    [JSInvokable]
+    public Task<int> CountUnreadComments(Guid? threadId = null)
+    {
+        return _wrappedApi.CountUnreadComments(threadId);
+    }
+
+    [JSInvokable]
+    public async Task<CommentThread> CreateCommentThread(CommentThread thread, UserComment firstComment)
+    {
+        var createdThread = await _wrappedApi.CreateCommentThread(thread, firstComment);
+        OnDataChanged();
+        return createdThread;
+    }
+
+    [JSInvokable]
+    public async Task<UserComment> AddUserComment(Guid threadId, UserComment comment)
+    {
+        var createdComment = await _wrappedApi.AddUserComment(threadId, comment);
+        OnDataChanged();
+        return createdComment;
+    }
+
+    [JSInvokable]
+    public async Task<UserComment> EditUserComment(Guid commentId, string text)
+    {
+        var updatedComment = await _wrappedApi.EditUserComment(commentId, text);
+        OnDataChanged();
+        return updatedComment;
+    }
+
+    [JSInvokable]
+    public async Task<CommentThread> SetCommentThreadStatus(Guid threadId, ThreadStatus status)
+    {
+        var updatedThread = await _wrappedApi.SetCommentThreadStatus(threadId, status);
+        OnDataChanged();
+        return updatedThread;
+    }
+
+    [JSInvokable]
+    public async Task DeleteUserComment(Guid commentId)
+    {
+        await _wrappedApi.DeleteUserComment(commentId);
+        OnDataChanged();
+    }
+
+    [JSInvokable]
+    public async Task DeleteCommentThread(Guid threadId)
+    {
+        await _wrappedApi.DeleteCommentThread(threadId);
+        OnDataChanged();
+    }
+
+    [JSInvokable]
+    public Task MarkCommentRead(Guid commentId)
+    {
+        return _wrappedApi.MarkCommentRead(commentId);
+    }
+
+    [JSInvokable]
+    public Task MarkCommentThreadRead(Guid threadId)
+    {
+        return _wrappedApi.MarkCommentThreadRead(threadId);
+    }
+
+    [JSInvokable]
+    public Task MarkAllCommentsRead()
+    {
+        return _wrappedApi.MarkAllCommentsRead();
+    }
+
     [JSInvokable]
     public async Task<Entry> CreateEntry(Entry entry, CreateEntryOptions options)
     {

backend/FwLite/FwLiteShared/Sync/SyncService.cs

@@ -4,6 +4,7 @@
 using FwLiteShared.Services;
 using LexCore.Sync;
 using LcmCrdt;
+using LcmCrdt.Changes.Comments;
 using LcmCrdt.Data;
 using LcmCrdt.MediaServer;
 using LcmCrdt.RemoteSync;
@@ -28,7 +29,8 @@ public class SyncService(
     LcmMediaService lcmMediaService,
     IOptions<AuthConfig> authOptions,
     ILogger<SyncService> logger,
-    SyncRepository syncRepository)
+    SyncRepository syncRepository,
+    LocalCommentReadStatusService commentReadStatusService)
 {
     public async Task<SyncResults> SafeExecuteSync(bool skipNotifications = false)
     {
@@ -105,6 +107,7 @@ public async Task<SyncResults> ExecuteSync(bool skipNotifications = false)
             }
             logger.LogInformation("Synced project {ProjectName} with server", project.Name);
             UpdateSyncStatus(SyncStatus.Success);
+            await ApplySyncedCommentReadStatus(syncResults, project.LastUserId);
             await syncRepository.UpdateSyncDate(syncDate);
             // Best-effort: if the push listener failed to start at project-open (e.g. user was offline), this
             // restarts it now that we know auth + network are healthy. If it's already running, the cache
@@ -233,6 +236,37 @@ private async Task SendNotifications(SyncResults syncResults)
         }
     }
 
+    private async Task ApplySyncedCommentReadStatus(SyncResults syncResults, string? currentUserId)
+    {
+        await commentReadStatusService.MarkCommentsUnread(GetUnreadCommentsFromSyncResults(syncResults, currentUserId));
+        var (deletedCommentIds, deletedThreadIds) = GetDeletedCommentsFromSyncResults(syncResults);
+        await commentReadStatusService.RemoveUnreadComments(deletedCommentIds);
+        foreach (var threadId in deletedThreadIds)
+        {
+            await commentReadStatusService.MarkThreadRead(threadId);
+        }
+    }
+
+    public static IEnumerable<(Guid CommentId, Guid CommentThreadId)> GetUnreadCommentsFromSyncResults(SyncResults syncResults, string? currentUserId)
+    {
+        return syncResults.MissingFromLocal
+            .SelectMany(c => c.ChangeEntities, (_, change) => change.Change)
+            .OfType<CreateUserCommentChange>()
+            //with no current user (not signed in) nothing is "ours", so every synced comment is unread
+            .Where(change => currentUserId is null || change.AuthorId != currentUserId)
+            .Select(change => (CommentId: change.EntityId, change.CommentThreadId));
+    }
+
+    public static (IEnumerable<Guid> CommentIds, IEnumerable<Guid> ThreadIds) GetDeletedCommentsFromSyncResults(
+        SyncResults syncResults)
+    {
+        var changes = syncResults.MissingFromLocal
+            .SelectMany(c => c.ChangeEntities, (_, change) => change.Change);
+        var commentIds = changes.OfType<DeleteChange<UserComment>>().Select(change => change.EntityId);
+        var threadIds = changes.OfType<DeleteChange<CommentThread>>().Select(change => change.EntityId);
+        return (commentIds, threadIds);
+    }
+
     private async IAsyncEnumerable<Guid?> GetEntryId(IObjectWithId? entity)
     {
         switch (entity)

backend/FwLite/FwLiteShared/TypeGen/ReinforcedFwLiteTypingConfig.cs

@@ -118,6 +118,8 @@ private static void ConfigureMiniLcmTypes(ConfigurationBuilder builder)
         builder.ExportAsEnum<WritingSystemType>();
         builder.ExportAsEnum<ReadFileResult>().UseString();
         builder.ExportAsEnum<UploadFileResult>().UseString();
+        builder.ExportAsEnum<ThreadStatus>().UseString();
+        builder.ExportAsEnum<SubjectType>().UseString();
         builder.ExportAsInterface<MiniLcmJsInvokable>()
             .FlattenHierarchy()
             .WithPublicProperties()