Bib 809 machine translation scoring

src/Aquifer.API/Endpoints/Resources/Content/Publish/Endpoint.cs

@@ -1,5 +1,6 @@
 using Aquifer.API.Common;
 using Aquifer.API.Services;
+using Aquifer.Common.Messages.Models;
 using Aquifer.Common.Messages.Publishers;
 using Aquifer.Data;
 using Aquifer.Data.Entities;
@@ -9,7 +10,13 @@
 
 namespace Aquifer.API.Endpoints.Resources.Content.Publish;
 
-public class Endpoint(AquiferDbContext dbContext, IUserService userService, ITranslationMessagePublisher translationMessagePublisher, IResourceHistoryService historyService) : Endpoint<Request>
+public class Endpoint(
+    AquiferDbContext dbContext, 
+    IUserService userService, 
+    ITranslationMessagePublisher translationMessagePublisher, 
+    IResourceHistoryService historyService,
+    IScoreResourceContentVersionSimilarityMessagePublisher scoreResourceContentVersionSimilarityMessagePublisher,
+    ILogger<Endpoint> logger) : Endpoint<Request>
 {
     public override void Configure()
     {
@@ -24,6 +31,7 @@ public override async Task HandleAsync(Request request, CancellationToken ct)
             ThrowError(Helpers.InvalidUserIdResponse);
         }
 
+        List<ScoreResourceContentVersionSimilarityMessage> similarityScoreMessages = [];
         var contentIds = request.ContentId is not null ? [(int)request.ContentId] : request.ContentIds!;
 
         foreach (var contentId in contentIds)
@@ -86,10 +94,35 @@ await Helpers.CreateNewDraft(dbContext,
 
                 await historyService.AddStatusHistoryAsync(mostRecentContentVersion, ResourceContentStatus.Complete, user.Id, ct);
             }
+
+            var machineTranslation = await dbContext
+                .ResourceContentVersionMachineTranslations
+                .AsTracking()
+                .FirstOrDefaultAsync(x => x.Id == mostRecentContentVersion.Id, ct);
+
+            if (machineTranslation is not null)
+            {
+                similarityScoreMessages.Add(
+                    new ScoreResourceContentVersionSimilarityMessage(
+                        machineTranslation.Id,
+                        mostRecentContentVersion.Id,
+                        ResourceContentVersionSimilarityComparisonTypes.MachineTranslationToResourceContentVersion)
+                );
+            }
+            else
+            {
+                logger.LogInformation($"No machine translation found for published content version {mostRecentContentVersion.Id}.");
+            }
         }
 
         await dbContext.SaveChangesAsync(ct);
 
+        foreach (var similarityScoreMessage in similarityScoreMessages)
+        {
+            await scoreResourceContentVersionSimilarityMessagePublisher
+                    .PublishScoreResourceContentVersionSimilarityMessageAsync(similarityScoreMessage, ct);
+        }
+
         await SendNoContentAsync(ct);
     }
 }

src/Aquifer.API/Program.cs

@@ -47,6 +47,7 @@
     .AddSingleton<IResourceContentRequestTrackingMessagePublisher, ResourceContentRequestTrackingMessagePublisher>()
     .AddSingleton<INotificationMessagePublisher, NotificationMessagePublisher>()
     .AddSingleton<ITranslationMessagePublisher, TranslationMessagePublisher>()
+    .AddSingleton<IScoreResourceContentVersionSimilarityMessagePublisher, ScoreResourceContentVersionSimilarityMessagePublisher>()
     .AddAzureClient(builder.Environment.IsDevelopment())
     .AddFastEndpoints()
     .AddResponseCaching()

src/Aquifer.Common/Messages/Models/ResourceContentVersionSimilarityComparisonTypes.cs

@@ -0,0 +1,9 @@
+namespace Aquifer.Common.Messages.Models;
+
+public enum ResourceContentVersionSimilarityComparisonTypes
+{
+    MachineTranslationToResourceContentVersion,
+    MachineTranslationToSnapshot,
+    ResourceContentVersionToSnapshot,
+    SnapshotToSnapshot,
+}

src/Aquifer.Common/Messages/Models/ScoreResourceContentVersionSimilarityMessage.cs

@@ -0,0 +1,7 @@
+namespace Aquifer.Common.Messages.Models;
+
+public sealed record ScoreResourceContentVersionSimilarityMessage(
+    int BaseVersionId,
+    int CompareVersionId,
+    ResourceContentVersionSimilarityComparisonTypes ComparisonType
+);

src/Aquifer.Common/Messages/Publishers/ScoreResourceContentSimilarityMessagePublisher.cs

@@ -0,0 +1,19 @@
+using Aquifer.Common.Messages.Models;
+
+namespace Aquifer.Common.Messages.Publishers;
+
+public interface IScoreResourceContentVersionSimilarityMessagePublisher
+{
+    Task PublishScoreResourceContentVersionSimilarityMessageAsync(ScoreResourceContentVersionSimilarityMessage message, CancellationToken ct);
+}
+
+public sealed class ScoreResourceContentVersionSimilarityMessagePublisher(
+    IQueueClientFactory _queueClientFactory) : IScoreResourceContentVersionSimilarityMessagePublisher
+{
+    public async Task PublishScoreResourceContentVersionSimilarityMessageAsync(ScoreResourceContentVersionSimilarityMessage message,
+        CancellationToken ct)
+    {
+        var queueClient = await _queueClientFactory.GetQueueClientAsync(Queues.GenerateResourceContentSimilarityScore, ct);
+        await queueClient.SendMessageAsync(message, cancellationToken: ct);
+    }
+}

src/Aquifer.Common/Messages/Queues.cs

@@ -17,6 +17,8 @@ public static class Queues
     public const string TranslateLanguageResources = "translate-language-resources";
     public const string TranslateProjectResources = "translate-project-resources";
     public const string TranslateResource = "translate-resource";
+
+    public const string GenerateResourceContentSimilarityScore = "generate-resource-content-similarity-score";
 
     public static string GetPoisonQueueName(string queueName)
     {

src/Aquifer.Common/Utilities/StringSimilarityUtilities.cs

@@ -0,0 +1,117 @@
+using System.Diagnostics;
+
+namespace Aquifer.Common.Utilities;
+
+public static class StringSimilarityUtilities
+{
+    public static (double similarity, double executionTime) ComputeLevenshteinSimilarity(string textA, string textB, int limit = 15000)
+    {
+        var stopwatch = Stopwatch.StartNew();
+
+        var textASubstrings = GetSubstrings(textA, limit);
+        var textBSubstrings = GetSubstrings(textB, limit);
+        var distance = ComputeTotalStringDistance(textASubstrings, textBSubstrings);
+
+        var similarity = 1 - ((double)distance / Math.Max(textA.Length, textB.Length));
+
+        stopwatch.Stop();
+        var executionTime = stopwatch.Elapsed.TotalMilliseconds;
+
+        return (similarity, executionTime);
+    }
+
+    public static int LevenshteinDistance(string textA, string textB)
+    {
+        var aLength = textA.Length;
+        var bLength = textB.Length;
+        var matrix = new int[bLength + 1];
+
+        for (var j = 0; j <= bLength; j++)
+        {
+            matrix[j] = j;
+        }
+
+        for (var i = 1; i <= aLength; i++)
+        {
+            var prev = matrix[0];
+            matrix[0] = i;
+            for (var j = 1; j <= bLength; j++)
+            {
+                var cost = (textA[i - 1] == textB[j - 1]) ? 0 : 1;
+                var temp = matrix[j];
+                matrix[j] = Math.Min(
+                    Math.Min(
+                        prev + cost, 
+                        matrix[j] + 1
+                    ), 
+                    matrix[j - 1] + 1
+                );
+                prev = temp;
+            }
+        }
+
+        return matrix[bLength];
+    }
+
+    public static List<string> GetSubstrings(string text, int limit)
+    {
+        var result = new List<string>();
+
+        while (text.Length > limit)
+        {
+            string? substring;
+
+            if (text.LastIndexOf(' ', limit) == -1)
+            { 
+                substring = text[..limit];
+                text = text[limit..];
+            }
+            else
+            {
+                substring = text[..text.LastIndexOf(' ', limit)];
+                text = text[(text.LastIndexOf(' ', limit) + 1)..];
+            }
+
+            result.Add(substring);
+        }
+        result.Add(text);
+
+        return result;
+    }
+
+    public static int ComputeTotalStringDistance(List<string> listA, List<string> listB)
+    {
+        var totalDistance = 0;
+        List<string> longestList;
+        List<string> shortestList;
+
+        if (listA.Count > listB.Count)
+        {
+            longestList = listA;
+            shortestList = listB;
+        }
+        else
+        {
+            longestList = listB;
+            shortestList = listA;
+        }
+
+        // We have to account for lists that are not the same length.
+        // Levenshtein distance is cumulative, so the distance of a string
+        // compared to an empty string is the character count of that non-empty string 
+        // i.e. "123" and "" is a distance of 3
+        for (var i = 0; i < longestList.Count; i++)
+        {
+            if (i >= shortestList.Count)
+            {
+                totalDistance += LevenshteinDistance(longestList[i], string.Empty);
+            }
+            else
+            {
+                totalDistance += LevenshteinDistance(longestList[i], shortestList[i]);
+            }
+        }
+
+        return totalDistance;
+    }
+}