Bugfix/blueprint push2 (#60)

sei-tspencer · web-flow · commit 43e4d5d38da5 · 2025-07-28T10:31:56.000-04:00
Change Official and Team submissions to be created when the move changes, instead of creating them all at once.
diff --git a/Cite.Api/Cite.Api.csproj b/Cite.Api/Cite.Api.csproj
@@ -1,6 +1,6 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk.Web">
   <PropertyGroup>
-    <Version>1.8.2</Version>
+    <Version>1.8.3</Version>
     <TargetFramework>net8.0</TargetFramework>
     <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
     <NoWarn>CS1591</NoWarn>
diff --git a/Cite.Api/Services/EvaluationService.cs b/Cite.Api/Services/EvaluationService.cs
@@ -403,7 +403,6 @@ public async Task<Evaluation> UploadJsonAsync(FileForm form, CancellationToken c
                 }
             }
             // okay to update this evaluation
-            await _context.Database.BeginTransactionAsync(ct);
             evaluation.CreatedBy = evaluationToUpdate.CreatedBy;
             evaluation.DateCreated = evaluationToUpdate.DateCreated;
             evaluation.ModifiedBy = _user.GetId();
@@ -418,7 +417,6 @@ public async Task<Evaluation> UploadJsonAsync(FileForm form, CancellationToken c
             await _context.SaveChangesAsync(ct);
             _logger.LogDebug("Verifying required submissions exist");
             await VerifyOfficialAndTeamSubmissions(evaluationToUpdate, ct);
-            await _context.Database.CommitTransactionAsync(ct);
             evaluation = await GetAsync(evaluationToUpdate.Id, ct);
 
             return evaluation;
@@ -507,41 +505,40 @@ private async Task VerifyOfficialAndTeamSubmissions(EvaluationEntity evaluation,
             // get a list of moves for the evaluation
             var moves = await _moveService.GetByEvaluationAsync(evaluation.Id, ct);
             // verify submissions exist for all moves
-            foreach (var move in moves)
+            // make sure all official and team submissions exist
+            var moveNumber = evaluation.CurrentMoveNumber;
+            if (!submissionList.Any(s => s.UserId == null && s.TeamId == null && s.MoveNumber == moveNumber))
             {
-                // make sure all official and team submissions exist
-                if (!submissionList.Any(s => s.UserId == null && s.TeamId == null && s.MoveNumber == move.MoveNumber))
+                var submission = new Submission()
+                {
+                    Id = Guid.NewGuid(),
+                    EvaluationId = evaluation.Id,
+                    TeamId = null,
+                    UserId = null,
+                    ScoringModelId = evaluation.ScoringModelId,
+                    MoveNumber = moveNumber,
+                    DateCreated = DateTime.UtcNow
+                };
+                _logger.LogDebug("Make Official submission for move " + moveNumber.ToString());
+                await _submissionService.CreateNewSubmission(_context, submission, ct);
+            }
+            // team submissions
+            foreach (var team in evaluationTeamList)
+            {
+                if (!submissionList.Any(s => s.UserId == null && s.TeamId == team.Id && s.MoveNumber == moveNumber))
                 {
                     var submission = new Submission() {
                         Id = Guid.NewGuid(),
                         EvaluationId = evaluation.Id,
-                        TeamId = null,
+                        TeamId = team.Id,
                         UserId = null,
                         ScoringModelId = evaluation.ScoringModelId,
-                        MoveNumber = move.MoveNumber,
+                        MoveNumber = moveNumber,
                         DateCreated = DateTime.UtcNow
                     };
-                    _logger.LogInformation("Make Official submission for move " + move.MoveNumber.ToString());
+                    _logger.LogDebug("Make Team submission for move " + moveNumber + "  team=" + submission.TeamId.ToString());
                     await _submissionService.CreateNewSubmission(_context, submission, ct);
                 }
-                // team submissions
-                foreach (var team in evaluationTeamList)
-                {
-                    if (!submissionList.Any(s => s.UserId == null && s.TeamId == team.Id && s.MoveNumber == move.MoveNumber))
-                    {
-                        var submission = new Submission() {
-                            Id = Guid.NewGuid(),
-                            EvaluationId = evaluation.Id,
-                            TeamId = team.Id,
-                            UserId = null,
-                            ScoringModelId = evaluation.ScoringModelId,
-                            MoveNumber = move.MoveNumber,
-                            DateCreated = DateTime.UtcNow
-                        };
-                        _logger.LogInformation("Make Team submission for move " + move.MoveNumber + "  team=" + submission.TeamId.ToString());
-                        await _submissionService.CreateNewSubmission(_context, submission, ct);
-                    }
-                }
             }
 
         }
diff --git a/Cite.Api/Services/SubmissionService.cs b/Cite.Api/Services/SubmissionService.cs
@@ -643,6 +643,7 @@ private async Task<SubmissionEntity> createRequestedSubmissionAndOthers(ViewMode
                         (s.UserId == submission.UserId)))
                         {
                             submission.MoveNumber = move.MoveNumber;
+                            _logger.LogDebug("Creating new submission from createRequestedSubmissionAndOthers");
                             await CreateNewSubmission(_context, submission, ct);
                         }
                     }
@@ -667,23 +668,24 @@ public async Task<SubmissionEntity> CreateNewSubmission(CiteContext citeContext,
             submissionEntity.Status = Data.Enumerations.ItemStatus.Active;
             submissionEntity.Evaluation = null;
             submissionEntity.ScoringModel = null;
-            citeContext.Submissions.Add(submissionEntity);
             // catch race condition if we try to add the same submission twice
             try
             {
-                await citeContext.SaveChangesAsync(ct);
                 var scoringModelEntity = await citeContext.ScoringModels
                     .Include(sm => sm.ScoringCategories)
                     .ThenInclude(sc => sc.ScoringOptions)
                     .FirstAsync(sm => sm.Id == submissionEntity.ScoringModelId);
-                await CreateSubmissionCategories(submissionEntity, scoringModelEntity, ct);
-                _logger.LogInformation("Created submission for move " + submission.MoveNumber.ToString());
+                CreateSubmissionCategories(submissionEntity, scoringModelEntity, ct);
+                citeContext.Submissions.Add(submissionEntity);
+                await citeContext.SaveChangesAsync(ct);
+                _logger.LogDebug("Created submission for move " + submission.MoveNumber.ToString());
 
                 return submissionEntity;
             }
-            catch (System.Exception)
+            catch (System.Exception ex)
             {
-                _logger.LogWarning("!!! Tried to create a duplicate submission");
+                var message = "!!! Error creating submission. " + ex.Message + " ===> " + ex.InnerException?.Message;
+                _logger.LogWarning(message);
                 return null;
             }
         }
@@ -914,33 +916,37 @@ public async Task<bool> DeleteAsync(Guid id, CancellationToken ct)
             return await GetAsync(submissionId, ct);
         }
 
-        private async Task<IEnumerable<SubmissionCategoryEntity>> CreateSubmissionCategories(
+        private IEnumerable<SubmissionCategoryEntity> CreateSubmissionCategories(
             SubmissionEntity submissionEntity, ScoringModelEntity scoringModelEntity, CancellationToken ct)
         {
             foreach (var scoringCategoryEntity in scoringModelEntity.ScoringCategories)
             {
-                var submissionCategoryEntity = new SubmissionCategoryEntity();
-                submissionCategoryEntity.ScoringCategoryId = scoringCategoryEntity.Id;
-                submissionCategoryEntity.SubmissionId = submissionEntity.Id;
-                submissionCategoryEntity.Score = 0;
-                _context.SubmissionCategories.Add(submissionCategoryEntity);
-                await _context.SaveChangesAsync(ct);
-                await CreateSubmissionOptions(submissionCategoryEntity, scoringCategoryEntity, ct);
+                var submissionCategoryEntity = new SubmissionCategoryEntity()
+                {
+                    Id = Guid.NewGuid(),
+                    ScoringCategoryId = scoringCategoryEntity.Id,
+                    SubmissionId = submissionEntity.Id,
+                    Score = 0,
+                };
+                CreateSubmissionOptions(submissionCategoryEntity, scoringCategoryEntity, ct);
+                submissionEntity.SubmissionCategories.Add(submissionCategoryEntity);
             }
             return submissionEntity.SubmissionCategories;
         }
 
-        private async Task<IEnumerable<SubmissionOptionEntity>> CreateSubmissionOptions(
+        private IEnumerable<SubmissionOptionEntity> CreateSubmissionOptions(
             SubmissionCategoryEntity submissionCategoryEntity, ScoringCategoryEntity scoringCategoryEntity, CancellationToken ct)
         {
             foreach (var scoringOptionEntity in scoringCategoryEntity.ScoringOptions)
             {
-                var submissionOptionEntity = new SubmissionOptionEntity();
-                submissionOptionEntity.ScoringOptionId = scoringOptionEntity.Id;
-                submissionOptionEntity.SubmissionCategoryId = submissionCategoryEntity.Id;
-                submissionOptionEntity.IsSelected = false;
-                _context.SubmissionOptions.Add(submissionOptionEntity);
-                await _context.SaveChangesAsync(ct);
+                var submissionOptionEntity = new SubmissionOptionEntity()
+                {
+                    Id = Guid.NewGuid(),
+                    ScoringOptionId = scoringOptionEntity.Id,
+                    SubmissionCategoryId = submissionCategoryEntity.Id,
+                    IsSelected = false
+                };
+                submissionCategoryEntity.SubmissionOptions.Add(submissionOptionEntity);
             }
             return submissionCategoryEntity.SubmissionOptions;
         }

Original file line number	Diff line number	Diff line change
`@@ -643,6 +643,7 @@ private async Task<SubmissionEntity> createRequestedSubmissionAndOthers(ViewMode`
`643`	`643`	`(s.UserId == submission.UserId)))`
`644`	`644`	`{`
`645`	`645`	`submission.MoveNumber = move.MoveNumber;`
	`646`	`+ _logger.LogDebug("Creating new submission from createRequestedSubmissionAndOthers");`
`646`	`647`	`await CreateNewSubmission(_context, submission, ct);`
`647`	`648`	`}`
`648`	`649`	`}`
`@@ -667,23 +668,24 @@ public async Task<SubmissionEntity> CreateNewSubmission(CiteContext citeContext,`
`667`	`668`	`submissionEntity.Status = Data.Enumerations.ItemStatus.Active;`
`668`	`669`	`submissionEntity.Evaluation = null;`
`669`	`670`	`submissionEntity.ScoringModel = null;`
`670`		`- citeContext.Submissions.Add(submissionEntity);`
`671`	`671`	`// catch race condition if we try to add the same submission twice`
`672`	`672`	`try`
`673`	`673`	`{`
`674`		`- await citeContext.SaveChangesAsync(ct);`
`675`	`674`	`var scoringModelEntity = await citeContext.ScoringModels`
`676`	`675`	`.Include(sm => sm.ScoringCategories)`
`677`	`676`	`.ThenInclude(sc => sc.ScoringOptions)`
`678`	`677`	`.FirstAsync(sm => sm.Id == submissionEntity.ScoringModelId);`
`679`		`- await CreateSubmissionCategories(submissionEntity, scoringModelEntity, ct);`
`680`		`- _logger.LogInformation("Created submission for move " + submission.MoveNumber.ToString());`
	`678`	`+ CreateSubmissionCategories(submissionEntity, scoringModelEntity, ct);`
	`679`	`+ citeContext.Submissions.Add(submissionEntity);`
	`680`	`+ await citeContext.SaveChangesAsync(ct);`
	`681`	`+ _logger.LogDebug("Created submission for move " + submission.MoveNumber.ToString());`
`681`	`682`
`682`	`683`	`return submissionEntity;`
`683`	`684`	`}`
`684`		`- catch (System.Exception)`
	`685`	`+ catch (System.Exception ex)`
`685`	`686`	`{`
`686`		`- _logger.LogWarning("!!! Tried to create a duplicate submission");`
	`687`	`+ var message = "!!! Error creating submission. " + ex.Message + " ===> " + ex.InnerException?.Message;`
	`688`	`+ _logger.LogWarning(message);`
`687`	`689`	`return null;`
`688`	`690`	`}`
`689`	`691`	`}`
`@@ -914,33 +916,37 @@ public async Task<bool> DeleteAsync(Guid id, CancellationToken ct)`
`914`	`916`	`return await GetAsync(submissionId, ct);`
`915`	`917`	`}`
`916`	`918`
`917`		`- private async Task<IEnumerable<SubmissionCategoryEntity>> CreateSubmissionCategories(`
	`919`	`+ private IEnumerable<SubmissionCategoryEntity> CreateSubmissionCategories(`
`918`	`920`	`SubmissionEntity submissionEntity, ScoringModelEntity scoringModelEntity, CancellationToken ct)`
`919`	`921`	`{`
`920`	`922`	`foreach (var scoringCategoryEntity in scoringModelEntity.ScoringCategories)`
`921`	`923`	`{`
`922`		`- var submissionCategoryEntity = new SubmissionCategoryEntity();`
`923`		`- submissionCategoryEntity.ScoringCategoryId = scoringCategoryEntity.Id;`
`924`		`- submissionCategoryEntity.SubmissionId = submissionEntity.Id;`
`925`		`- submissionCategoryEntity.Score = 0;`
`926`		`- _context.SubmissionCategories.Add(submissionCategoryEntity);`
`927`		`- await _context.SaveChangesAsync(ct);`
`928`		`- await CreateSubmissionOptions(submissionCategoryEntity, scoringCategoryEntity, ct);`
	`924`	`+ var submissionCategoryEntity = new SubmissionCategoryEntity()`
	`925`	`+ {`
	`926`	`+ Id = Guid.NewGuid(),`
	`927`	`+ ScoringCategoryId = scoringCategoryEntity.Id,`
	`928`	`+ SubmissionId = submissionEntity.Id,`
	`929`	`+ Score = 0,`
	`930`	`+ };`
	`931`	`+ CreateSubmissionOptions(submissionCategoryEntity, scoringCategoryEntity, ct);`
	`932`	`+ submissionEntity.SubmissionCategories.Add(submissionCategoryEntity);`
`929`	`933`	`}`
`930`	`934`	`return submissionEntity.SubmissionCategories;`
`931`	`935`	`}`
`932`	`936`
`933`		`- private async Task<IEnumerable<SubmissionOptionEntity>> CreateSubmissionOptions(`
	`937`	`+ private IEnumerable<SubmissionOptionEntity> CreateSubmissionOptions(`
`934`	`938`	`SubmissionCategoryEntity submissionCategoryEntity, ScoringCategoryEntity scoringCategoryEntity, CancellationToken ct)`
`935`	`939`	`{`
`936`	`940`	`foreach (var scoringOptionEntity in scoringCategoryEntity.ScoringOptions)`
`937`	`941`	`{`
`938`		`- var submissionOptionEntity = new SubmissionOptionEntity();`
`939`		`- submissionOptionEntity.ScoringOptionId = scoringOptionEntity.Id;`
`940`		`- submissionOptionEntity.SubmissionCategoryId = submissionCategoryEntity.Id;`
`941`		`- submissionOptionEntity.IsSelected = false;`
`942`		`- _context.SubmissionOptions.Add(submissionOptionEntity);`
`943`		`- await _context.SaveChangesAsync(ct);`
	`942`	`+ var submissionOptionEntity = new SubmissionOptionEntity()`
	`943`	`+ {`
	`944`	`+ Id = Guid.NewGuid(),`
	`945`	`+ ScoringOptionId = scoringOptionEntity.Id,`
	`946`	`+ SubmissionCategoryId = submissionCategoryEntity.Id,`
	`947`	`+ IsSelected = false`
	`948`	`+ };`
	`949`	`+ submissionCategoryEntity.SubmissionOptions.Add(submissionOptionEntity);`
`944`	`950`	`}`
`945`	`951`	`return submissionCategoryEntity.SubmissionOptions;`
`946`	`952`	`}`