protected async Task UndoPublishedFunding(CancellationToken cancellationToken,
dynamic context,
IEnumerable <PublishedFunding> publishedFunding)
{
PublishedFundingUndoTaskContext taskContext = GetTaskContext(context);
List <PublishedFunding> publishedFundingToDelete = new List <PublishedFunding>();
List <PublishedFunding> publishedFundingToUpdate = new List <PublishedFunding>();
foreach (PublishedFunding document in publishedFunding)
{
PublishedFundingVersion previousVersion = await GetPreviousPublishedFundingVersion(document.Current, taskContext);
if (previousVersion == null)
{
publishedFundingToDelete.Add(document);
}
else
{
document.Current = previousVersion;
publishedFundingToUpdate.Add(document);
}
}
Task[] updateTasks = new[]
{
UpdateDocuments(publishedFundingToUpdate, _ => _.ParitionKey),
DeleteDocuments(publishedFundingToDelete, _ => _.ParitionKey, IsHardDelete)
};
await TaskHelper.WhenAllAndThrow(updateTasks);
}
private static void EnsureContextInitialised(PublishedFundingUndoTaskContext taskContext)
{
(bool isInitiliased, IEnumerable <string> errors)initialisationCheck = taskContext.EnsureIsInitialised();
if (!initialisationCheck.isInitiliased)
{
throw new InvalidOperationException(initialisationCheck.errors.Join("\n"));
}
}
public Task Run(PublishedFundingUndoTaskContext taskContext)
{
DsgRollBackParameters parameters = taskContext.Parameters as DsgRollBackParameters;
Guard.ArgumentNotNull(parameters, nameof(parameters));
taskContext.PublishedFundingDetails =
taskContext.PublishedProviderDetails =
taskContext.PublishedProviderVersionDetails =
taskContext.PublishedFundingVersionDetails = new UndoTaskDetails
{
FundingPeriodId = parameters.FundingPeriodId,
FundingStreamId = "DSG",
Version = parameters.Version.DecimalValue
};
return(Task.CompletedTask);
}
public async Task Run(PublishedFundingUndoTaskContext taskContext)
{
Guard.ArgumentNotNull(taskContext, nameof(taskContext));
string correlationId = taskContext.Parameters.ForCorrelationId;
LogInformation($"Initialising task context for correlationId: {correlationId}");
Task[] initialisations = new[]
{
InitialisePublishedProviderDetails(correlationId, taskContext),
InitialisePublishedProviderVersionDetails(correlationId, taskContext),
InitialisePublishFundingDetails(correlationId, taskContext),
InitialisePublishFundingVersionDetails(correlationId, taskContext),
};
await TaskHelper.WhenAllAndThrow(initialisations);
EnsureContextInitialised(taskContext);
}
protected async Task UndoPublishedProviders(CancellationToken cancellationToken,
dynamic context,
IEnumerable <PublishedProvider> publishedProviders)
{
PublishedFundingUndoTaskContext taskContext = GetTaskContext(context);
List <PublishedProvider> publishedProvidersToDelete = new List <PublishedProvider>();
List <PublishedProvider> publishedProviderToUpdate = new List <PublishedProvider>();
foreach (PublishedProvider publishedProvider in publishedProviders)
{
string providerId = publishedProvider.Current.ProviderId;
PublishedProviderVersion previousVersion = await GetPreviousPublishedProviderVersion(providerId,
taskContext);
if (previousVersion == null)
{
publishedProvidersToDelete.Add(publishedProvider);
}
else
{
PublishedProviderVersion previousReleasedVersion = await GetPreviousPublishedProviderVersion(providerId,
taskContext,
PublishedProviderStatus.Released);
publishedProvider.Current = previousVersion;
publishedProvider.Released = previousReleasedVersion;
publishedProviderToUpdate.Add(publishedProvider);
}
}
Task[] cosmosUpdates = new[]
{
DeleteDocuments(publishedProvidersToDelete, _ => _.PartitionKey, IsHardDelete),
UpdateDocuments(publishedProviderToUpdate, _ => _.PartitionKey)
};
await TaskHelper.WhenAllAndThrow(cosmosUpdates);
}
public async Task Run(PublishedFundingUndoTaskContext taskContext)
{
LogStartingTask();
Guard.ArgumentNotNull(taskContext?.PublishedFundingVersionDetails, nameof(taskContext.PublishedFundingVersionDetails));
UndoTaskDetails details = taskContext.PublishedFundingVersionDetails;
ICosmosDbFeedIterator <PublishedFundingVersion> feed = GetPublishedFundingVersionsFeed(details);
FeedContext <PublishedFundingVersion> feedContext = new FeedContext <PublishedFundingVersion>(taskContext, feed);
IProducerConsumer producerConsumer = ProducerConsumerFactory.CreateProducerConsumer(ProducePublishedFundingVersions,
UndoPublishedFundingVersions,
200,
4,
Logger);
await producerConsumer.Run(feedContext);
await NotifyJobProgress(taskContext);
LogCompletedTask();
}
protected override Task NotifyProgress(PublishedFundingUndoTaskContext taskContext) => Task.CompletedTask;
protected override async Task <PublishedProviderVersion> GetPreviousPublishedProviderVersion(string providerId,
PublishedFundingUndoTaskContext taskContext,
PublishedProviderStatus?status = null)
{
LogInformation($"Querying latest earlier published provider version for '{taskContext.Parameters}'");
UndoTaskDetails taskDetails = taskContext.PublishedProviderVersionDetails;
return(await Cosmos.GetLatestEarlierPublishedProviderVersionFromVersion(taskDetails.FundingStreamId,
taskDetails.FundingPeriodId,
taskDetails.Version,
providerId,
status));
}
private async Task InitialisePublishedProviderVersionDetails(string correlationId, PublishedFundingUndoTaskContext context)
{
context.PublishedProviderVersionDetails = await Cosmos.GetCorrelationIdDetailsForPublishedProviderVersions(correlationId);
}
protected override async Task <PublishedFundingVersion> GetPreviousPublishedFundingVersion(PublishedFundingVersion currentVersion,
PublishedFundingUndoTaskContext taskContext)
{
LogInformation($"Querying latest earlier published funding version for '{taskContext.Parameters}'");
UndoTaskDetails details = taskContext.PublishedFundingVersionDetails;
return(await Cosmos.GetLatestEarlierPublishedFundingVersionFromVersion(details.FundingStreamId,
details.FundingPeriodId,
details.Version,
currentVersion.OrganisationGroupTypeIdentifier,
currentVersion.OrganisationGroupIdentifierValue,
currentVersion.GroupingReason));
}
public FeedContext(PublishedFundingUndoTaskContext taskContext,
ICosmosDbFeedIterator <TDocument> feed)
{
TaskContext = taskContext;
Feed = feed;
}
