Add backend statistics endpoints for domain sense count and progress proportion

Co-authored-by: imnasnainaec <6411521+imnasnainaec@users.noreply.github.com>

Author: Copilot

Backend.Tests/Controllers/StatisticsControllerTests.cs

@@ -132,5 +132,37 @@ public async Task TestGetSemanticDomainUserCounts()
             var result = await _statsController.GetSemanticDomainUserCounts(_projId);
             Assert.That(result, Is.InstanceOf<OkObjectResult>());
         }
+
+        [Test]
+        public async Task TestGetDomainSenseCountNoPermission()
+        {
+            _statsController.ControllerContext.HttpContext = PermissionServiceMock.UnauthorizedHttpContext();
+
+            var result = await _statsController.GetDomainSenseCount(_projId, "1");
+            Assert.That(result, Is.InstanceOf<ForbidResult>());
+        }
+
+        [Test]
+        public async Task TestGetDomainSenseCount()
+        {
+            var result = await _statsController.GetDomainSenseCount(_projId, "1");
+            Assert.That(result, Is.InstanceOf<OkObjectResult>());
+        }
+
+        [Test]
+        public async Task TestGetDomainProgressProportionNoPermission()
+        {
+            _statsController.ControllerContext.HttpContext = PermissionServiceMock.UnauthorizedHttpContext();
+
+            var result = await _statsController.GetDomainProgressProportion(_projId, "1", "en");
+            Assert.That(result, Is.InstanceOf<ForbidResult>());
+        }
+
+        [Test]
+        public async Task TestGetDomainProgressProportion()
+        {
+            var result = await _statsController.GetDomainProgressProportion(_projId, "1", "en");
+            Assert.That(result, Is.InstanceOf<OkObjectResult>());
+        }
     }
 }

Backend.Tests/Mocks/StatisticsServiceMock.cs

@@ -28,5 +28,13 @@ public Task<List<SemanticDomainUserCount>> GetSemanticDomainUserCounts(string pr
         {
             return Task.FromResult(new List<SemanticDomainUserCount>());
         }
+        public Task<int> GetDomainSenseCount(string projectId, string domainId)
+        {
+            return Task.FromResult(0);
+        }
+        public Task<double> GetDomainProgressProportion(string projectId, string domainId, string lang)
+        {
+            return Task.FromResult(0.0);
+        }
     }
 }

Backend/Controllers/StatisticsController.cs

@@ -118,5 +118,39 @@ public async Task<IActionResult> GetSemanticDomainUserCounts(string projectId)
 
             return Ok(await _statService.GetSemanticDomainUserCounts(projectId));
         }
+
+        /// <summary> Get the count of senses in a specific semantic domain </summary>
+        /// <returns> An integer count </returns>
+        [HttpGet("GetDomainSenseCount", Name = "GetDomainSenseCount")]
+        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(int))]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        public async Task<IActionResult> GetDomainSenseCount(string projectId, string domainId)
+        {
+            using var activity = OtelService.StartActivityWithTag(otelTagName, "getting domain sense count");
+
+            if (!await _permissionService.HasProjectPermission(HttpContext, Permission.Statistics, projectId))
+            {
+                return Forbid();
+            }
+
+            return Ok(await _statService.GetDomainSenseCount(projectId, domainId));
+        }
+
+        /// <summary> Get the proportion of descendant domains that have at least one entry </summary>
+        /// <returns> A double value between 0 and 1 </returns>
+        [HttpGet("GetDomainProgressProportion", Name = "GetDomainProgressProportion")]
+        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(double))]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        public async Task<IActionResult> GetDomainProgressProportion(string projectId, string domainId, string lang)
+        {
+            using var activity = OtelService.StartActivityWithTag(otelTagName, "getting domain progress proportion");
+
+            if (!await _permissionService.HasProjectPermission(HttpContext, Permission.Statistics, projectId))
+            {
+                return Forbid();
+            }
+
+            return Ok(await _statService.GetDomainProgressProportion(projectId, domainId, lang));
+        }
     }
 }

Backend/Interfaces/IStatisticsService.cs

@@ -12,6 +12,8 @@ public interface IStatisticsService
         Task<ChartRootData> GetProgressEstimationLineChartRoot(string projectId, List<DateTime> schedule);
         Task<ChartRootData> GetLineChartRootData(string projectId);
         Task<List<SemanticDomainUserCount>> GetSemanticDomainUserCounts(string projectId);
+        Task<int> GetDomainSenseCount(string projectId, string domainId);
+        Task<double> GetDomainProgressProportion(string projectId, string domainId, string lang);
     }
 
 }

Backend/Services/StatisticsService.cs

@@ -355,5 +355,90 @@ public async Task<List<SemanticDomainUserCount>> GetSemanticDomainUserCounts(str
             // return descending order by senseCount
             return resUserMap.Values.ToList().OrderByDescending(t => t.WordCount).ToList();
         }
+
+        /// <summary>
+        /// Get the count of senses in a specific semantic domain
+        /// </summary>
+        /// <param name="projectId"> The project id </param>
+        /// <param name="domainId"> The semantic domain id </param>
+        /// <returns> The count of senses with the specified domain </returns>
+        public async Task<int> GetDomainSenseCount(string projectId, string domainId)
+        {
+            using var activity = OtelService.StartActivityWithTag(otelTagName, "getting domain sense count");
+
+            var wordList = await _wordRepo.GetFrontier(projectId);
+            var count = 0;
+
+            foreach (var word in wordList)
+            {
+                foreach (var sense in word.Senses)
+                {
+                    if (sense.SemanticDomains.Any(sd => sd.Id == domainId))
+                    {
+                        count++;
+                    }
+                }
+            }
+
+            return count;
+        }
+
+        /// <summary>
+        /// Get the proportion of descendant domains that have at least one entry
+        /// </summary>
+        /// <param name="projectId"> The project id </param>
+        /// <param name="domainId"> The semantic domain id </param>
+        /// <param name="lang"> The language code </param>
+        /// <returns> A proportion value between 0 and 1 </returns>
+        public async Task<double> GetDomainProgressProportion(string projectId, string domainId, string lang)
+        {
+            using var activity = OtelService.StartActivityWithTag(otelTagName, "getting domain progress proportion");
+
+            var domainTreeNodeList = await _domainRepo.GetAllSemanticDomainTreeNodes(lang);
+            if (domainTreeNodeList is null || domainTreeNodeList.Count == 0)
+            {
+                return 0.0;
+            }
+
+            // Get all descendant domain IDs
+            var descendantIds = new List<string>();
+            foreach (var node in domainTreeNodeList)
+            {
+                if (node.Id.StartsWith(domainId, StringComparison.Ordinal) && node.Id != domainId)
+                {
+                    // Check if it's a direct or indirect child (not just a string prefix match)
+                    var relativePart = node.Id.Substring(domainId.Length);
+                    if (relativePart.StartsWith('.'))
+                    {
+                        descendantIds.Add(node.Id);
+                    }
+                }
+            }
+
+            if (descendantIds.Count == 0)
+            {
+                return 0.0;
+            }
+
+            // Get word list and count which descendants have at least one entry
+            var wordList = await _wordRepo.GetFrontier(projectId);
+            var domainsWithEntries = new HashSet<string>();
+
+            foreach (var word in wordList)
+            {
+                foreach (var sense in word.Senses)
+                {
+                    foreach (var sd in sense.SemanticDomains)
+                    {
+                        if (descendantIds.Contains(sd.Id))
+                        {
+                            domainsWithEntries.Add(sd.Id);
+                        }
+                    }
+                }
+            }
+
+            return (double)domainsWithEntries.Count / descendantIds.Count;
+        }
     }
 }