[DEV-14516]: RetrySubmission

CODEOWNERS

@@ -0,0 +1 @@
+* @IndicoDataSolutions/pr-be-indicodata-ai

IndicoV2.Abstractions/Submissions/ISubmissionsClient.cs

@@ -107,6 +107,14 @@ public interface ISubmissionsClient
         /// <returns>Id of the submission updated.</returns>
         Task<ISubmission> MarkSubmissionAsRetrieved(int submissionId, bool retrieved = true, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Retries failed submissions. Submissions must be in a failed state and cannot be requested before the cool-off period (typically 180ms).
+        /// </summary>
+        /// <param name="submissionIds">The submission ids to retry.</param>
+        /// <param name="cancellationToken"><c><see cref="CancellationToken"/></c> for handling cancellation of asynchronous operations.</param>
+        /// <returns><c><see cref="IEnumerable{T}"/></c> of <c><see cref="ISubmission"/></c></returns>
+        Task<IEnumerable<ISubmission>> RetrySubmissionsAsync(IEnumerable<int> submissionIds, CancellationToken cancellationToken = default);
+
         /// <summary>
         /// Uses the legacy C# client for older frameworks.
         /// </summary>

IndicoV2.IntegrationTests/Submissions/SubmissionClientTests.cs

@@ -412,5 +412,95 @@ public async Task MarkSubmissionAsRetrieved_ShouldUpdateSubmission()
             updated_sub.Retrieved.Should().BeTrue();
 
         }
+
+        [Test]
+        public async Task RetrySubmissionsAsync_ShouldThrowArgumentException_WhenSubmissionIdsIsNull()
+        {
+            // Arrange
+            IEnumerable<int> submissionIds = null;
+
+            // Act & Assert
+            Func<Task> act = async () => await _submissionsClient.RetrySubmissionsAsync(submissionIds);
+            var exceptionAssertions = await act.Should().ThrowAsync<ArgumentException>();
+            exceptionAssertions.Which.Message.Should().Contain("You must specify submission ids");
+            exceptionAssertions.Which.ParamName.Should().Be("submissionIds");
+        }
+
+        [Test]
+        public async Task RetrySubmissionsAsync_ShouldThrowArgumentException_WhenSubmissionIdsIsEmpty()
+        {
+            // Arrange
+            var submissionIds = new List<int>();
+
+            // Act & Assert
+            Func<Task> act = async () => await _submissionsClient.RetrySubmissionsAsync(submissionIds);
+            var exceptionAssertions = await act.Should().ThrowAsync<ArgumentException>();
+            exceptionAssertions.Which.Message.Should().Contain("You must specify submission ids");
+            exceptionAssertions.Which.ParamName.Should().Be("submissionIds");
+        }
+
+        [Test]
+        public async Task RetrySubmissionsAsync_ShouldReturnSubmissions_WithRetryInformation()
+        {
+            // Arrange
+            var filters = new SubmissionFilter
+            {
+                Status = SubmissionStatus.FAILED
+            };
+            var failedSubmissions = await _submissionsClient.ListAsync(null, new List<int> { _workflowId }, filters, 0, 10);
+
+            if (!failedSubmissions.Data.Any())
+            {
+                Assert.Inconclusive("No failed submissions available for retry test. This test requires a submission in FAILED status.");
+                return;
+            }
+
+            var failedSubmissionId = failedSubmissions.Data.First().Id;
+
+            // Act
+            var retriedSubmissions = await _submissionsClient.RetrySubmissionsAsync(new List<int> { failedSubmissionId });
+
+            // Assert
+            retriedSubmissions.Should().NotBeNull();
+            retriedSubmissions.Should().HaveCount(1);
+            var retriedSubmission = retriedSubmissions.First();
+            retriedSubmission.Should().NotBeNull();
+            retriedSubmission.Id.Should().BeGreaterThan(0);
+            retriedSubmission.Status.Should().BeOfType<SubmissionStatus>();
+            retriedSubmission.Retries.Should().NotBeNull();
+        }
+
+        [Test]
+        public async Task RetrySubmissionsAsync_ShouldHandleMultipleSubmissionIds()
+        {
+            // Arrange
+            var filters = new SubmissionFilter
+            {
+                Status = SubmissionStatus.FAILED
+            };
+            var failedSubmissions = await _submissionsClient.ListAsync(null, new List<int> { _workflowId }, filters, 0, 10);
+
+            if (failedSubmissions.Data.Count() < 2)
+            {
+                Assert.Inconclusive("Less than 2 failed submissions available for retry test. This test requires at least 2 submissions in FAILED status.");
+                return;
+            }
+
+            var failedSubmissionIds = failedSubmissions.Data.Take(2).Select(s => s.Id).ToList();
+
+            // Act
+            var retriedSubmissions = await _submissionsClient.RetrySubmissionsAsync(failedSubmissionIds);
+
+            // Assert
+            retriedSubmissions.Should().NotBeNull();
+            retriedSubmissions.Should().HaveCount(2);
+            foreach (var retriedSubmission in retriedSubmissions)
+            {
+                retriedSubmission.Should().NotBeNull();
+                retriedSubmission.Id.Should().BeGreaterThan(0);
+                retriedSubmission.Status.Should().BeOfType<SubmissionStatus>();
+                retriedSubmission.Retries.Should().NotBeNull();
+            }
+        }
     }
 }

IndicoV2.StrawberryShake/Submissions/SubmissionSsClient.cs

@@ -39,7 +39,7 @@
             .SubmissionIds
             .Select(id => id.Value);
 
         public async Task<IListSubmissions_Submissions> List(IReadOnlyList<int?> ids, IReadOnlyList<int?> workflowIds, SubmissionFilter? filter, int? limit, int? after, CancellationToken cancellationToken) => (
             await ExecuteAsync(async () => await _services.GetRequiredService<ListSubmissionsQuery>().ExecuteAsync(ids, workflowIds, filter, limit, null, null, after, cancellationToken))).Submissions;
 
         public async Task<int?> MarkRetrieved(int submissionId, bool retrieved = true, CancellationToken cancellationToken = default) => (await ExecuteAsync(async () => await _services.GetRequiredService<UpdateSubmissionMutation>().ExecuteAsync(submissionId, retrieved, cancellationToken))).UpdateSubmission.Id;
@@ -50,6 +50,9 @@
         public async Task<string> GenerateSubmissionResult(int submissionId, CancellationToken cancellationToken) => (
             await ExecuteAsync(async () => await _services.GetRequiredService<CreateSubmissionResultsMutation>().ExecuteAsync(submissionId, cancellationToken))).SubmissionResults.JobId;
 
+        public async Task<IReadOnlyList<IRetrySubmissions_RetrySubmissions>> Retry(IReadOnlyList<int> submissionIds, CancellationToken cancellationToken = default) => (
+            await ExecuteAsync(async () => await _services.GetRequiredService<RetrySubmissionsMutation>().ExecuteAsync(submissionIds.Select(id => (int?)id).ToList(), cancellationToken))).RetrySubmissions;
+
         private string RemovePropsCausingErrors(string metaString)
         {
             var acceptableMetaProps = new[] { "name", "path", "upload_type" };

IndicoV2.StrawberryShake/Submissions/Submissions.graphql

@@ -204,3 +204,18 @@ mutation CreateSubmissionResults($submissionId: Int!) {
     jobId
   }
 }
+
+mutation RetrySubmissions($submissionIds: [Int]!) {
+  retrySubmissions(submissionIds: $submissionIds) {
+    id
+    status
+    errors
+    retries {
+      id
+      submissionId
+      previousErrors
+      previousStatus
+      retryErrors
+    }
+  }
+}

IndicoV2/Submissions/SubmissionsClient.cs

@@ -140,6 +140,45 @@
             return GetSubmissionToSubmission(result);
         }
 
+        public async Task<IEnumerable<ISubmission>> RetrySubmissionsAsync(IEnumerable<int> submissionIds, CancellationToken cancellationToken = default)
+        {
+            var submissionIdsList = submissionIds?.ToList() ?? throw new ArgumentException("You must specify submission ids", nameof(submissionIds));
+            if (submissionIdsList.Count == 0)
+                throw new ArgumentException("You must specify submission ids", nameof(submissionIds));
+
+            var result = await _strawberryShakeClient.Submissions().Retry(submissionIdsList, cancellationToken);
+            return result?.Select(r =>
+            {
+                if (!Enum.IsDefined(typeof(StrawberryShake.SubmissionStatus), r.Status))
+                {
+                    throw new NotSupportedException($"Cannot read submission status: {r.Status}");
+                }
+
+                return new Submission
+                {
+                    Id = r.Id ?? 0,
+                    Status = (Models.SubmissionStatus)r.Status,
+                    Errors = r.Errors ?? null,
+                    Retries = r.Retries?.Select(retry =>
+                    {
+                        if (!Enum.IsDefined(typeof(StrawberryShake.SubmissionStatus), retry.PreviousStatus))
+                        {
+                            throw new NotSupportedException($"Cannot read submission retry previous status: {retry.PreviousStatus}");
+                        }
+
+                        return new SubmissionRetry
+                        {
+                            Id = retry.Id ?? 0,
+                            SubmissionId = retry.SubmissionId ?? 0,
+                            PreviousErrors = retry.PreviousErrors,
+                            PreviousStatus = (Models.SubmissionStatus)retry.PreviousStatus,
+                            RetryErrors = retry.RetryErrors
+                        };
+                    }).ToArray() ?? Array.Empty<SubmissionRetry>()
+                };
+            }).ToList() ?? new List<ISubmission>();
+        }
+
         private ISubmission ToSubmissionFromSs(IListSubmissions_Submissions_Submissions submission) => new SubmissionSs(submission);
 
         private ISubmission GetSubmissionToSubmission(IGetSubmission_Submission result) => new Submission