public void AssemblePublishedProviderCreateVersionRequests_GivenPublishedProviders_ReturnsCreateVersionRequestWithPublishStatus(
PublishedProviderStatus currentStatus, PublishedProviderStatus givenPublishedProviderStatus, PublishStatus expectedPublishStatus)
{
//Arrange
IEnumerable <PublishedProvider> publishedProviders = new[]
{
new PublishedProvider
{
Current = new PublishedProviderVersion
{
Status = currentStatus
}
}
};
PublishedProviderVersioningService service = CreateVersioningService();
//Act
IEnumerable <PublishedProviderCreateVersionRequest> results = service.AssemblePublishedProviderCreateVersionRequests(
publishedProviders, new Reference("id1", "Joe Bloggs"), givenPublishedProviderStatus);
//Assert
results
.Should()
.HaveCount(1);
results.First().NewVersion.PublishStatus.Should().Be(expectedPublishStatus);
}
public async Task <int> UpdatePublishedProviderStatus(IEnumerable <PublishedProvider> publishedProviders, Reference author,
PublishedProviderStatus publishedProviderStatus, string jobId = null, string correlationId = null, bool force = false)
{
Guard.ArgumentNotNull(publishedProviders, nameof(publishedProviders));
Guard.ArgumentNotNull(author, nameof(author));
IEnumerable <PublishedProviderCreateVersionRequest> publishedProviderCreateVersionRequests = _publishedProviderVersioningService.AssemblePublishedProviderCreateVersionRequests(
publishedProviders.ToList(),
author, publishedProviderStatus, jobId, correlationId, force);
if (!publishedProviderCreateVersionRequests.IsNullOrEmpty())
{
bool shouldNotifyProgress = !jobId.IsNullOrWhitespace();
if (shouldNotifyProgress)
{
await CreatePublishedProviderVersionsInBatches(publishedProviderStatus,
publishedProviderCreateVersionRequests.ToList(), jobId);
}
else
{
await CreateLatestPublishedProviderVersions(publishedProviderStatus,
publishedProviderCreateVersionRequests);
}
return(publishedProviderCreateVersionRequests.Count());
}
else
{
return(0);
}
}
public async Task GetPublishedProvidersFundingDataForCsvReport()
{
string publishedProviderId0 = NewRandomString();
string publishedProviderId1 = NewRandomString();
string publishedProviderId2 = NewRandomString();
string[] publishedProviderIds = AsArray(publishedProviderId0, publishedProviderId1, publishedProviderId2);
PublishedProviderStatus status0 = NewRandomStatus();
PublishedProviderStatus status1 = NewRandomStatus();
PublishedProviderStatus[] statuses = AsArray(status0, status1);
string specificationId = NewRandomString();
List <dynamic> results = new List <dynamic>()
{
CreatePublishedProviderFundingCsvData(specificationId, publishedProviderId0, status0.ToString()),
CreatePublishedProviderFundingCsvData(specificationId, publishedProviderId1, status1.ToString()),
CreatePublishedProviderFundingCsvData(specificationId, publishedProviderId2, status0.ToString())
};
GivenTheDynamicResultsForTheQuery(QueryMatch(specificationId, publishedProviderIds, statuses), results);
IEnumerable <PublishedProviderFundingCsvData> fundings = await WhenThePublishedProviderFundingDataForCsvReportIsQueried(publishedProviderIds, specificationId, statuses);
fundings
.Count()
.Should()
.Be(3);
Func <CosmosDbQuery, bool> QueryMatch(string s,
string[] strings,
PublishedProviderStatus[] publishedProviderStatuses) =>
_ => _.QueryText == @"
SELECT
c.content.current.specificationId,
c.content.current.fundingStreamId,
c.content.current.fundingPeriodId,
c.content.current.status,
c.content.current.provider.providerId,
c.content.current.provider.ukprn,
c.content.current.provider.urn,
c.content.current.provider.upin,
c.content.current.provider.name,
c.content.current.totalFunding
FROM publishedProvider c
WHERE c.documentType = 'PublishedProvider'
AND c.deleted = false
AND c.content.current.specificationId = @specificationId AND c.content.current.publishedProviderId IN (@publishedProviderId_0,@publishedProviderId_1,@publishedProviderId_2) AND c.content.current.status IN (@status_0,@status_1)" &&
HasParameter(_, "@specificationId", s) &&
HasParameter(_, "@publishedProviderId_0", publishedProviderId0) &&
HasParameter(_, "@publishedProviderId_1", publishedProviderId1) &&
HasParameter(_, "@publishedProviderId_2", publishedProviderId2) &&
HasParameter(_, "@status_0", status0.ToString()) &&
HasParameter(_, "@status_1", status1.ToString());
}
public async Task GetPublishedProvidesFunding()
{
string publishedProviderId0 = NewRandomString();
string publishedProviderId1 = NewRandomString();
string publishedProviderId2 = NewRandomString();
string[] publishedProviderIds = AsArray(publishedProviderId0, publishedProviderId1, publishedProviderId2);
PublishedProviderStatus status0 = NewRandomStatus();
PublishedProviderStatus status1 = NewRandomStatus();
PublishedProviderStatus[] statuses = AsArray(status0, status1);
string specificationId = NewRandomString();
List <dynamic> results = new List <dynamic>()
{
CreatePublishedProviderFundingResult(specificationId, publishedProviderId0),
CreatePublishedProviderFundingResult(specificationId, publishedProviderId1),
CreatePublishedProviderFundingResult(specificationId, publishedProviderId2)
};
GivenTheDynamicResultsForTheQuery(QueryMatch(specificationId, publishedProviderIds, statuses), results);
IEnumerable <PublishedProviderFunding> fundings = await WhenThePublishedProviderFundingIsQueried(publishedProviderIds, specificationId, statuses);
fundings
.Count()
.Should()
.Be(3);
Func <CosmosDbQuery, bool> QueryMatch(string s,
string[] strings,
PublishedProviderStatus[] publishedProviderStatuses) =>
_ => _.QueryText == @"
SELECT
c.content.current.specificationId,
c.content.current.publishedProviderId,
c.content.current.fundingStreamId,
c.content.current.totalFunding,
c.content.current.provider.providerType,
c.content.current.provider.providerSubType,
c.content.current.provider.laCode
FROM publishedProvider c
WHERE c.documentType = 'PublishedProvider'
AND c.content.current.specificationId = @specificationId
AND ARRAY_CONTAINS(@publishedProviderIds, c.content.current.publishedProviderId)
AND ARRAY_CONTAINS(@statuses, c.content.current.status)
AND (IS_NULL(c.content.current.errors) OR ARRAY_LENGTH(c.content.current.errors) = 0)
AND c.deleted = false" &&
HasParameter(_, "@specificationId", s) &&
HasArrayParameter(_, "@publishedProviderIds", publishedProviderIds) &&
HasArrayParameter(_, "@statuses", statuses.Select(status => status.ToString()));
}
private async Task <IEnumerable <PublishedProvider> > CreateVersions(IEnumerable <PublishedProviderCreateVersionRequest> publishedProviderCreateVersionRequests,
PublishedProviderStatus publishedProviderStatus = default)
{
IEnumerable <PublishedProvider> updatedPublishedProviders = null;
try
{
updatedPublishedProviders = await _publishedProviderVersioningService.CreateVersions(publishedProviderCreateVersionRequests);
}
catch (Exception ex)
{
string errorMessage = $"Failed to create versions when updating status:' {publishedProviderStatus}' on published providers.";
_logger.Error(ex, errorMessage);
throw new RetriableException(errorMessage, ex);
}
return(updatedPublishedProviders);
}
private async Task CreatePublishedProviderVersionsInBatches(PublishedProviderStatus publishedProviderStatus,
List <PublishedProviderCreateVersionRequest> publishedProviderCreateVersionRequests,
string jobId)
{
int batchSize = _settings.BatchSize;
int currentCount = 0;
int total = publishedProviderCreateVersionRequests.Count;
while (currentCount < total)
{
IEnumerable <PublishedProviderCreateVersionRequest> batch = publishedProviderCreateVersionRequests
.Skip(currentCount)
.Take(batchSize);
await CreateLatestPublishedProviderVersions(publishedProviderStatus, batch);
currentCount += batchSize;
await _jobTracker.NotifyProgress(Math.Min(currentCount, total), jobId);
}
}
private async Task CreateLatestPublishedProviderVersions(PublishedProviderStatus publishedProviderStatus,
IEnumerable <PublishedProviderCreateVersionRequest> publishedProviderCreateVersionRequests)
{
IEnumerable <PublishedProvider> updatedPublishedProviders = await CreateVersions(publishedProviderCreateVersionRequests, publishedProviderStatus);
if (!updatedPublishedProviders.Any())
{
return;
}
ConcurrentBag <HttpStatusCode> results = new ConcurrentBag <HttpStatusCode>();
try
{
await _publishedFundingBulkRepository.UpsertPublishedProviders(
updatedPublishedProviders,
(Task <HttpStatusCode> task) =>
{
HttpStatusCode httpStatusCode = task.Result;
results.Add(httpStatusCode);
});
if (results.Any(_ => !_.IsSuccess()))
{
throw new Exception();
}
await SaveVersions(updatedPublishedProviders, publishedProviderStatus);
}
catch (Exception ex)
{
string errorMessage = $"Failed to create published Providers when updating status:' {publishedProviderStatus}' on published providers.";
_logger.Error(ex, errorMessage);
throw new RetriableException(errorMessage, ex);
}
}
public IEnumerable <PublishedProviderCreateVersionRequest> AssemblePublishedProviderCreateVersionRequests(IEnumerable <PublishedProvider> publishedProviders,
Reference author, PublishedProviderStatus publishedProviderStatus, string jobId = null, string correlationId = null, bool force = false)
{
Guard.ArgumentNotNull(publishedProviders, nameof(publishedProviders));
Guard.ArgumentNotNull(author, nameof(author));
IList <PublishedProviderCreateVersionRequest> publishedProviderCreateVersionRequests =
new List <PublishedProviderCreateVersionRequest>();
foreach (PublishedProvider publishedProvider in publishedProviders)
{
Guard.ArgumentNotNull(publishedProvider.Current, nameof(publishedProvider.Current));
// always update if it's a refresh
if (!force && publishedProviderStatus != PublishedProviderStatus.Draft &&
publishedProviderStatus != PublishedProviderStatus.Updated &&
publishedProvider.Current.Status == publishedProviderStatus)
{
continue;
}
PublishedProviderVersion newVersion = publishedProvider.Current.Clone() as PublishedProviderVersion;
newVersion.Author = author;
newVersion.Status = publishedProviderStatus;
newVersion.JobId = jobId;
newVersion.CorrelationId = correlationId;
int minorVersion = publishedProvider.Current.MinorVersion;
int majorVersion = publishedProvider.Current.MajorVersion;
if ((publishedProvider.Current.Status == PublishedProviderStatus.Approved ||
publishedProvider.Current.Status == PublishedProviderStatus.Released) &&
publishedProviderStatus == PublishedProviderStatus.Updated)
{
Interlocked.Increment(ref minorVersion);
newVersion.MinorVersion = minorVersion;
}
else if (publishedProviderStatus == PublishedProviderStatus.Released)
{
Interlocked.Increment(ref majorVersion);
newVersion.MajorVersion = majorVersion;
newVersion.MinorVersion = 0;
publishedProvider.Released = newVersion;
}
switch (publishedProviderStatus)
{
case PublishedProviderStatus.Approved:
case PublishedProviderStatus.Released:
newVersion.PublishStatus = PublishStatus.Approved;
break;
case PublishedProviderStatus.Updated:
newVersion.PublishStatus = PublishStatus.Updated;
break;
default:
newVersion.PublishStatus = PublishStatus.Draft;
break;
}
publishedProviderCreateVersionRequests.Add(new PublishedProviderCreateVersionRequest
{
PublishedProvider = publishedProvider,
NewVersion = newVersion
});
}
return(publishedProviderCreateVersionRequests);
}
public PublishedProviderVersionBuilder WithPublishedProviderStatus(PublishedProviderStatus status)
{
_status = status;
return(this);
}
private async Task SaveVersions(IEnumerable <PublishedProvider> updatedPublishedProviders, PublishedProviderStatus publishedProviderStatus)
{
try
{
await _publishedProviderVersioningService.SaveVersions(updatedPublishedProviders);
}
catch (Exception ex)
{
string errorMessage = $"Failed to save versions when updating status:' {publishedProviderStatus}' on published providers.";
_logger.Error(ex, errorMessage);
throw new RetriableException(errorMessage, ex);
}
}
public async Task OverridesProfilePeriodsOnPublishedProviderVersionAndGeneratesNewVersion(PublishedProviderStatus currentStatus,
PublishedProviderStatus expectedRequestedStatus)
{
string fundingLineOne = NewRandomString();
ProfilePeriod profilePeriod1 = NewProfilePeriod(_ => _.WithDistributionPeriodId("FY-2021"));
ProfilePeriod profilePeriod2 = NewProfilePeriod(_ => _.WithDistributionPeriodId("FY-2022"));
ApplyCustomProfileRequest request = NewApplyCustomProfileRequest(_ => _
.WithFundingLineCode(fundingLineOne)
.WithProfilePeriods(profilePeriod1, profilePeriod2));
PublishedProvider publishedProvider = NewPublishedProvider(_ => _.WithCurrent(
NewPublishedProviderVersion(ppv =>
ppv.WithPublishedProviderStatus(currentStatus)
.WithFundingLines(NewFundingLine(fl =>
fl.WithFundingLineCode(fundingLineOne)
.WithDistributionPeriods(NewDistributionPeriod(dp =>
dp.WithDistributionPeriodId("FY-2021")
.WithProfilePeriods(profilePeriod1)),
NewDistributionPeriod(dp =>
dp.WithDistributionPeriodId("FY-2022")
.WithProfilePeriods(profilePeriod2))))
))));
Reference author = NewAuthor();
GivenTheValidationResultForTheRequest(NewValidationResult(), request);
AndThePublishedProvider(request.PublishedProviderId, publishedProvider);
IActionResult result = await WhenTheCustomProfileIsApplied(request, author);
result
.Should()
.BeOfType <NoContentResult>();
IEnumerable <ProfilePeriod> profilePeriods = request.ProfilePeriods;
FundingLine fundingLine = publishedProvider.Current.FundingLines.Single(fl => fl.FundingLineCode == fundingLineOne);
AndTheCustomProfilePeriodsWereUsedOn(fundingLine, profilePeriods);
AndANewProviderVersionWasCreatedFor(publishedProvider, expectedRequestedStatus, author);
AndProfilingAuditUpdatedForFundingLines(publishedProvider, new[] { fundingLineOne }, author);
}
private void AndANewProviderVersionWasCreatedFor(PublishedProvider publishedProvider, PublishedProviderStatus newStatus, Reference author)
{
_publishedProviderVersionCreation.Verify(_ => _.UpdatePublishedProviderStatus(new [] { publishedProvider },
author,
newStatus,
null,
null,
true),
Times.Once);
}
