Add database collection to track semantic domain sense counts per project

Backend.Tests/Controllers/AudioControllerTests.cs

@@ -37,7 +37,9 @@ public void Setup()
             _projRepo = new ProjectRepositoryMock();
             _wordRepo = new WordRepositoryMock();
             _permissionService = new PermissionServiceMock();
-            _wordService = new WordService(_wordRepo);
+            var countRepo = new SemanticDomainCountRepositoryMock();
+            var countService = new SemanticDomainCountService(countRepo, _wordRepo);
+            _wordService = new WordService(_wordRepo, countService);
             _audioController = new AudioController(_wordRepo, _wordService, _permissionService);
 
             _projId = _projRepo.Create(new Project { Name = "AudioControllerTests" }).Result!.Id;

Backend.Tests/Controllers/LiftControllerTests.cs

@@ -49,7 +49,9 @@ public void Setup()
             _speakerRepo = new SpeakerRepositoryMock();
             _wordRepo = new WordRepositoryMock();
             _liftService = new LiftService(new SemanticDomainRepositoryMock(), _speakerRepo);
-            _wordService = new WordService(_wordRepo);
+            var countRepo = new SemanticDomainCountRepositoryMock();
+            var countService = new SemanticDomainCountService(countRepo, _wordRepo);
+            _wordService = new WordService(_wordRepo, countService);
             _liftController = new LiftController(_wordRepo, _projRepo, new PermissionServiceMock(), _liftService,
                 new HubContextMock<ExportHub>(), new MockLogger());
 

Backend.Tests/Controllers/MergeControllerTests.cs

@@ -34,7 +34,9 @@ public void Setup()
             _mergeBlacklistRepo = new MergeBlacklistRepositoryMock();
             _mergeGraylistRepo = new MergeGraylistRepositoryMock();
             _wordRepo = new WordRepositoryMock();
-            _wordService = new WordService(_wordRepo);
+            var countRepo = new SemanticDomainCountRepositoryMock();
+            var countService = new SemanticDomainCountService(countRepo, _wordRepo);
+            _wordService = new WordService(_wordRepo, countService);
             _mergeService = new MergeService(_mergeBlacklistRepo, _mergeGraylistRepo, _wordRepo, _wordService);
             _mergeController = new MergeController(
                 _mergeService, new HubContextMock<MergeHub>(), new PermissionServiceMock());

Backend.Tests/Controllers/WordControllerTests.cs

@@ -32,7 +32,9 @@ public void Dispose()
         public void Setup()
         {
             _wordRepo = new WordRepositoryMock();
-            _wordService = new WordService(_wordRepo);
+            var countRepo = new SemanticDomainCountRepositoryMock();
+            var countService = new SemanticDomainCountService(countRepo, _wordRepo);
+            _wordService = new WordService(_wordRepo, countService);
             _permissionService = new PermissionServiceMock();
             _wordController = new WordController(_wordRepo, _wordService, _permissionService);
         }

Backend.Tests/Mocks/SemanticDomainCountRepositoryMock.cs

@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BackendFramework.Interfaces;
+using BackendFramework.Models;
+
+namespace Backend.Tests.Mocks
+{
+    public sealed class SemanticDomainCountRepositoryMock : ISemanticDomainCountRepository
+    {
+        private readonly List<ProjectSemanticDomainCount> _counts;
+
+        public SemanticDomainCountRepositoryMock()
+        {
+            _counts = new List<ProjectSemanticDomainCount>();
+        }
+
+        public Task<ProjectSemanticDomainCount?> GetCount(string projectId, string domainId)
+        {
+            var count = _counts.FirstOrDefault(c => c.ProjectId == projectId && c.DomainId == domainId);
+            return Task.FromResult(count);
+        }
+
+        public Task<List<ProjectSemanticDomainCount>> GetAllCounts(string projectId)
+        {
+            var counts = _counts.Where(c => c.ProjectId == projectId).ToList();
+            return Task.FromResult(counts);
+        }
+
+        public Task<ProjectSemanticDomainCount> Create(ProjectSemanticDomainCount count)
+        {
+            count.Id = Util.RandString();
+            _counts.Add(count);
+            return Task.FromResult(count);
+        }
+
+        public Task<bool> Increment(string projectId, string domainId, int amount = 1)
+        {
+            var count = _counts.FirstOrDefault(c => c.ProjectId == projectId && c.DomainId == domainId);
+            if (count is null)
+            {
+                count = new ProjectSemanticDomainCount(projectId, domainId, amount)
+                {
+                    Id = Util.RandString()
+                };
+                _counts.Add(count);
+            }
+            else
+            {
+                count.Count += amount;
+            }
+            return Task.FromResult(true);
+        }
+
+        public Task<bool> DeleteAllCounts(string projectId)
+        {
+            var removed = _counts.RemoveAll(c => c.ProjectId == projectId);
+            return Task.FromResult(removed > 0);
+        }
+    }
+}

Backend.Tests/Services/MergeServiceTests.cs

@@ -25,7 +25,9 @@ public void Setup()
             _mergeBlacklistRepo = new MergeBlacklistRepositoryMock();
             _mergeGraylistRepo = new MergeGraylistRepositoryMock();
             _wordRepo = new WordRepositoryMock();
-            _wordService = new WordService(_wordRepo);
+            var countRepo = new SemanticDomainCountRepositoryMock();
+            var countService = new SemanticDomainCountService(countRepo, _wordRepo);
+            _wordService = new WordService(_wordRepo, countService);
             _mergeService = new MergeService(_mergeBlacklistRepo, _mergeGraylistRepo, _wordRepo, _wordService);
         }
 

Backend.Tests/Services/SemanticDomainCountServiceTests.cs

@@ -0,0 +1,218 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Backend.Tests.Mocks;
+using BackendFramework.Interfaces;
+using BackendFramework.Models;
+using BackendFramework.Services;
+using NUnit.Framework;
+
+namespace Backend.Tests.Services
+{
+    internal sealed class SemanticDomainCountServiceTests
+    {
+        private ISemanticDomainCountRepository _countRepo = null!;
+        private IWordRepository _wordRepo = null!;
+        private ISemanticDomainCountService _countService = null!;
+
+        private const string ProjId = "CountServiceTestProjId";
+        private const string DomainId1 = "1.1";
+        private const string DomainId2 = "2.1";
+
+        [SetUp]
+        public void Setup()
+        {
+            _countRepo = new SemanticDomainCountRepositoryMock();
+            _wordRepo = new WordRepositoryMock();
+            _countService = new SemanticDomainCountService(_countRepo, _wordRepo);
+        }
+
+        [Test]
+        public async Task TestUpdateCountsForWord()
+        {
+            var word = new Word
+            {
+                ProjectId = ProjId,
+                Senses = new List<Sense>
+                {
+                    new()
+                    {
+                        SemanticDomains = new List<SemanticDomain>
+                        {
+                            new() { Id = DomainId1 },
+                            new() { Id = DomainId2 }
+                        }
+                    }
+                }
+            };
+
+            await _countService.UpdateCountsForWord(word);
+
+            var count1 = await _countRepo.GetCount(ProjId, DomainId1);
+            var count2 = await _countRepo.GetCount(ProjId, DomainId2);
+
+            Assert.That(count1, Is.Not.Null);
+            Assert.That(count1!.Count, Is.EqualTo(1));
+            Assert.That(count2, Is.Not.Null);
+            Assert.That(count2!.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public async Task TestUpdateCountsForWords()
+        {
+            var words = new List<Word>
+            {
+                new()
+                {
+                    ProjectId = ProjId,
+                    Senses = new List<Sense>
+                    {
+                        new()
+                        {
+                            SemanticDomains = new List<SemanticDomain>
+                            {
+                                new() { Id = DomainId1 }
+                            }
+                        }
+                    }
+                },
+                new()
+                {
+                    ProjectId = ProjId,
+                    Senses = new List<Sense>
+                    {
+                        new()
+                        {
+                            SemanticDomains = new List<SemanticDomain>
+                            {
+                                new() { Id = DomainId1 },
+                                new() { Id = DomainId2 }
+                            }
+                        }
+                    }
+                }
+            };
+
+            await _countService.UpdateCountsForWords(words);
+
+            var count1 = await _countRepo.GetCount(ProjId, DomainId1);
+            var count2 = await _countRepo.GetCount(ProjId, DomainId2);
+
+            Assert.That(count1, Is.Not.Null);
+            Assert.That(count1!.Count, Is.EqualTo(2));
+            Assert.That(count2, Is.Not.Null);
+            Assert.That(count2!.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public async Task TestUpdateCountsAfterWordUpdate()
+        {
+            var oldWord = new Word
+            {
+                ProjectId = ProjId,
+                Senses = new List<Sense>
+                {
+                    new()
+                    {
+                        SemanticDomains = new List<SemanticDomain>
+                        {
+                            new() { Id = DomainId1 },
+                            new() { Id = DomainId2 }
+                        }
+                    }
+                }
+            };
+
+            var newWord = new Word
+            {
+                ProjectId = ProjId,
+                Senses = new List<Sense>
+                {
+                    new()
+                    {
+                        SemanticDomains = new List<SemanticDomain>
+                        {
+                            new() { Id = DomainId1 }
+                        }
+                    }
+                }
+            };
+
+            // Start with counts from old word
+            await _countService.UpdateCountsForWord(oldWord);
+
+            // Update counts
+            await _countService.UpdateCountsAfterWordUpdate(oldWord, newWord);
+
+            var count1 = await _countRepo.GetCount(ProjId, DomainId1);
+            var count2 = await _countRepo.GetCount(ProjId, DomainId2);
+
+            Assert.That(count1, Is.Not.Null);
+            Assert.That(count1!.Count, Is.EqualTo(1)); // Unchanged
+            Assert.That(count2, Is.Not.Null);
+            Assert.That(count2!.Count, Is.EqualTo(0)); // Decremented by 1
+        }
+
+        [Test]
+        public async Task TestMigrateCounts()
+        {
+            // Create some frontier words
+            var word1 = new Word
+            {
+                ProjectId = ProjId,
+                Senses = new List<Sense>
+                {
+                    new()
+                    {
+                        SemanticDomains = new List<SemanticDomain>
+                        {
+                            new() { Id = DomainId1 }
+                        }
+                    }
+                }
+            };
+
+            var word2 = new Word
+            {
+                ProjectId = ProjId,
+                Senses = new List<Sense>
+                {
+                    new()
+                    {
+                        SemanticDomains = new List<SemanticDomain>
+                        {
+                            new() { Id = DomainId1 },
+                            new() { Id = DomainId2 }
+                        }
+                    }
+                }
+            };
+
+            await _wordRepo.Create(word1);
+            await _wordRepo.Create(word2);
+
+            // Migrate counts
+            await _countService.MigrateCounts(ProjId);
+
+            var count1 = await _countRepo.GetCount(ProjId, DomainId1);
+            var count2 = await _countRepo.GetCount(ProjId, DomainId2);
+
+            Assert.That(count1, Is.Not.Null);
+            Assert.That(count1!.Count, Is.EqualTo(2));
+            Assert.That(count2, Is.Not.Null);
+            Assert.That(count2!.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public async Task TestMigrateClearsOldCounts()
+        {
+            // Add an old count
+            await _countRepo.Create(new ProjectSemanticDomainCount(ProjId, DomainId1, 99));
+
+            // Migrate with no words
+            await _countService.MigrateCounts(ProjId);
+
+            var counts = await _countRepo.GetAllCounts(ProjId);
+            Assert.That(counts, Is.Empty);
+        }
+    }
+}

Backend.Tests/Services/WordServiceTests.cs

@@ -11,6 +11,7 @@ namespace Backend.Tests.Services
     internal sealed class WordServiceTests
     {
         private IWordRepository _wordRepo = null!;
+        private ISemanticDomainCountService _countService = null!;
         private IWordService _wordService = null!;
 
         private const string ProjId = "WordServiceTestProjId";
@@ -21,7 +22,9 @@ internal sealed class WordServiceTests
         public void Setup()
         {
             _wordRepo = new WordRepositoryMock();
-            _wordService = new WordService(_wordRepo);
+            var countRepo = new SemanticDomainCountRepositoryMock();
+            _countService = new SemanticDomainCountService(countRepo, _wordRepo);
+            _wordService = new WordService(_wordRepo, _countService);
         }
 
         [Test]

Backend/Interfaces/ISemanticDomainCountRepository.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BackendFramework.Models;
+
+namespace BackendFramework.Interfaces
+{
+    public interface ISemanticDomainCountRepository
+    {
+        Task<ProjectSemanticDomainCount?> GetCount(string projectId, string domainId);
+        Task<List<ProjectSemanticDomainCount>> GetAllCounts(string projectId);
+        Task<ProjectSemanticDomainCount> Create(ProjectSemanticDomainCount count);
+        Task<bool> Increment(string projectId, string domainId, int amount = 1);
+        Task<bool> DeleteAllCounts(string projectId);
+    }
+}

Backend/Interfaces/ISemanticDomainCountService.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BackendFramework.Models;
+
+namespace BackendFramework.Interfaces
+{
+    public interface ISemanticDomainCountService
+    {
+        Task UpdateCountsForWord(Word word);
+        Task UpdateCountsForWords(List<Word> words);
+        Task UpdateCountsAfterWordUpdate(Word oldWord, Word newWord);
+        Task MigrateCounts(string projectId);
+    }
+}