public async Task UpdateDataStageAsync(Guid releaseId, Guid releaseStatusId, ReleasePublishingStatusDataStage stage,
                                               ReleasePublishingStatusLogMessage logMessage = null)
        {
            await UpdateRowAsync(releaseId, releaseStatusId, row =>
            {
                row.State.Data = stage;

                if (stage == ReleasePublishingStatusDataStage.Complete)
                {
                    // In case this was a retry, reinstate publishing if possible
                    var(publishing, overall) = GetStatesForReinstatingAfterPossibleRetry(row);
                    row.State.Publishing     = publishing;
                    row.State.Overall        = overall;
                }

                row.AppendLogMessage(logMessage);
                return(row);
            });

            if (stage == ReleasePublishingStatusDataStage.Failed)
            {
                await CancelReleasesWithContentDependency(releaseId, releaseStatusId);
            }

            if (stage == ReleasePublishingStatusDataStage.Complete)
            {
                // In case this was a retry, reinstate publishing of any other releases that were cancelled if possible
                await ReinstateReleasesWithContentDependency(releaseId, releaseStatusId);
            }
        }
 private async Task UpdateStage(GenerateReleaseContentMessage message, ReleasePublishingStatusContentStage stage,
                                ReleasePublishingStatusLogMessage logMessage = null)
 {
     foreach (var(releaseId, releaseStatusId) in message.Releases)
     {
         await _releasePublishingStatusService.UpdateContentStageAsync(releaseId, releaseStatusId, stage, logMessage);
     }
 }
 public async Task UpdateFilesStageAsync(Guid releaseId, Guid releaseStatusId, ReleasePublishingStatusFilesStage stage,
                                         ReleasePublishingStatusLogMessage logMessage = null)
 {
     await UpdateRowAsync(releaseId, releaseStatusId, row =>
     {
         row.State.Files = stage;
         row.AppendLogMessage(logMessage);
         return(row);
     });
 }
        public async Task UpdateStagesAsync(Guid releaseId, Guid releaseStatusId, ReleasePublishingStatusContentStage?content = null,
                                            ReleasePublishingStatusDataStage?data             = null, ReleasePublishingStatusFilesStage?files = null,
                                            ReleasePublishingStatusPublishingStage?publishing = null, ReleasePublishingStatusOverallStage?overall = null,
                                            ReleasePublishingStatusLogMessage logMessage      = null)
        {
            await UpdateRowAsync(releaseId, releaseStatusId, row =>
            {
                if (content.HasValue)
                {
                    row.State.Content = content.Value;
                }

                if (data.HasValue)
                {
                    row.State.Data = data.Value;
                }

                if (files.HasValue)
                {
                    row.State.Files = files.Value;
                }

                if (publishing.HasValue)
                {
                    row.State.Publishing = publishing.Value;
                }

                if (overall.HasValue)
                {
                    row.State.Overall = overall.Value;
                }

                row.AppendLogMessage(logMessage);
                return(row);
            });
        }
 private async Task UpdateStage(Guid releaseId, Guid releaseStatusId, ReleasePublishingStatusFilesStage stage,
                                ReleasePublishingStatusLogMessage logMessage = null)
 {
     await _releasePublishingStatusService.UpdateFilesStageAsync(releaseId, releaseStatusId, stage, logMessage);
 }