public async Task <(bool Success, IActionResult ActionResult)> UploadProviderVersion(string providerVersionId, ProviderVersionViewModel providerVersionModel)
{
Guard.IsNullOrWhiteSpace(providerVersionId, nameof(providerVersionId));
Guard.ArgumentNotNull(providerVersionModel, nameof(providerVersionModel));
IActionResult validationResult = await UploadProviderVersionValidate(providerVersionModel, providerVersionId);
if (validationResult != null)
{
return(false, validationResult);
}
ProviderVersion providerVersion = _mapper.Map <ProviderVersion>(providerVersionModel);
providerVersion.Id = $"providerVersion-{providerVersionId}";
await UploadProviderVersionBlob(providerVersionId, providerVersion);
providerVersion.Providers = null;
ProviderVersionMetadata providerVersionMetadata = providerVersion;
HttpStatusCode result = await _providerVersionMetadataRepositoryPolicy.ExecuteAsync(() => _providerVersionMetadataRepository.CreateProviderVersion(providerVersionMetadata));
if (result.IsSuccess())
{
await _providersSearchPolicy.ExecuteAsync(() => _searchRepository.RunIndexer());
}
return(true, null);
}
public async Task ExistsMatchesAnyByFundingStreamVersionTypeAndName(string queriedName,
int queriedVersion,
string queriedType,
string queriedFundingStream,
bool expectedExists)
{
string type = nameof(type);
string name = nameof(name);
string fundingStream = nameof(fundingStream);
int version = 99;
ProviderVersion providerVersionOne = NewProviderVersion();
ProviderVersion providerVersionTwo = NewProviderVersion(_ => _.WithName(name)
.WithFundingStream(fundingStream)
.WithVersion(version)
.WithType(type));
GivenTheCosmosContents(providerVersionOne,
providerVersionTwo);
bool actualExists = await WhenTheProviderVersionExistsIsChecked(queriedName, queriedType, queriedFundingStream, queriedVersion);
actualExists
.Should()
.Be(expectedExists);
}
private async Task UploadProviderVersionBlob(string providerVersionId, ProviderVersion providerVersion)
{
ICloudBlob blob = _blobClient.GetBlockBlobReference(providerVersionId.ToLowerInvariant() + ".json");
await using MemoryStream stream = new MemoryStream(providerVersion.AsJsonBytes());
await _blobRepositoryPolicy.ExecuteAsync(() => blob.UploadFromStreamAsync(stream));
}
/// <summary>
/// Load the best matching provider for the specified type param
/// By default, the most recent Tridion version is used
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IProvider LoadProvider <T>() where T : class
{
ProviderVersion version = ConfigurationHelper.ProviderVersion;
if (version == ProviderVersion.Undefined)
{
version = ProviderAssemblyNames.DefaultProviderVersion;
}
string classIdentifier = ProviderAssemblyNames.GetProviderClassName(version);
return((IProvider)ClassLoader.Load <T>(classIdentifier));
}
public void AddProviderVersion(ProviderVersion providerVersion)
{
Guard.ArgumentNotNull(providerVersion, nameof(providerVersion));
Guard.IsNullOrWhiteSpace(providerVersion.ProviderVersionId, nameof(providerVersion.ProviderVersionId));
_providerVersions[providerVersion.ProviderVersionId] = providerVersion;
if (!_providers.ContainsKey(providerVersion.ProviderVersionId))
{
_providers[providerVersion.ProviderVersionId] = new Dictionary <string, Provider>();
}
providerVersion.Providers = _providers[providerVersion.ProviderVersionId].Values;
}
public static string GetProviderClassName(ProviderVersion version)
{
return Dictionary[version];
}
public static string GetProviderClassName(ProviderVersion version)
{
return(Dictionary[version]);
}
public void GivenTheFollowingProviderVersionExistsInTheProvidersService(Table table)
{
ProviderVersion providerVersion = table.CreateInstance <ProviderVersion>();
_providersStepContext.EmulatedClient.AddProviderVersion(providerVersion);
}
public override async Task Process(Message message)
{
Guard.ArgumentNotNull(message, nameof(message));
string specificationId = message.GetUserProperty <string>(SpecificationId);
string scopedProviderSummariesCountCacheKey = $"{CacheKeys.ScopedProviderSummariesCount}{specificationId}";
string cacheKeyScopedListCacheKey = $"{CacheKeys.ScopedProviderSummariesPrefix}{specificationId}";
SpecificationSummary specificationSummary = await GetSpecificationSummary(specificationId);
string providerVersionId = specificationSummary?.ProviderVersionId;
if (string.IsNullOrWhiteSpace(providerVersionId))
{
return;
}
ProviderVersion providerVersion = await _providerVersionService.GetProvidersByVersion(providerVersionId);
if (providerVersion == null)
{
return;
}
IEnumerable <Provider> sourceProviders = providerVersion.Providers;
if (specificationSummary.ProviderSource == ProviderSource.CFS)
{
HashSet <string> scopedProviderIds = (await GetScopedProviderIdsBySpecification(specificationId)).ToHashSet();
sourceProviders = sourceProviders.Where(_ => scopedProviderIds.Contains(_.ProviderId));
}
IEnumerable <ProviderSummary> providerSummaries = sourceProviders
.Select(x => new ProviderSummary
{
Name = x.Name,
Id = x.ProviderId,
ProviderProfileIdType = x.ProviderProfileIdType,
UKPRN = x.UKPRN,
URN = x.URN,
Authority = x.Authority,
UPIN = x.UPIN,
ProviderSubType = x.ProviderSubType,
EstablishmentNumber = x.EstablishmentNumber,
ProviderType = x.ProviderType,
DateOpened = x.DateOpened,
DateClosed = x.DateClosed,
LACode = x.LACode,
CrmAccountId = x.CrmAccountId,
LegalName = x.LegalName,
NavVendorNo = x.NavVendorNo,
DfeEstablishmentNumber = x.DfeEstablishmentNumber,
Status = x.Status,
PhaseOfEducation = x.PhaseOfEducation,
ReasonEstablishmentClosed = x.ReasonEstablishmentClosed,
ReasonEstablishmentOpened = x.ReasonEstablishmentOpened,
Successor = x.Successor,
TrustStatus = x.TrustStatus,
TrustName = x.TrustName,
TrustCode = x.TrustCode,
Town = x.Town,
Postcode = x.Postcode,
CompaniesHouseNumber = x.CompaniesHouseNumber,
GroupIdNumber = x.GroupIdNumber,
RscRegionName = x.RscRegionName,
RscRegionCode = x.RscRegionCode,
GovernmentOfficeRegionName = x.GovernmentOfficeRegionName,
GovernmentOfficeRegionCode = x.GovernmentOfficeRegionCode,
DistrictCode = x.DistrictCode,
DistrictName = x.DistrictName,
WardName = x.WardName,
WardCode = x.WardCode,
CensusWardCode = x.CensusWardCode,
CensusWardName = x.CensusWardName,
MiddleSuperOutputAreaCode = x.MiddleSuperOutputAreaCode,
MiddleSuperOutputAreaName = x.MiddleSuperOutputAreaName,
LowerSuperOutputAreaCode = x.LowerSuperOutputAreaCode,
LowerSuperOutputAreaName = x.LowerSuperOutputAreaName,
ParliamentaryConstituencyCode = x.ParliamentaryConstituencyCode,
ParliamentaryConstituencyName = x.ParliamentaryConstituencyName,
CountryCode = x.CountryCode,
CountryName = x.CountryName,
LocalGovernmentGroupTypeCode = x.LocalGovernmentGroupTypeCode,
LocalGovernmentGroupTypeName = x.LocalGovernmentGroupTypeName,
Street = x.Street,
Locality = x.Locality,
Address3 = x.Address3,
PaymentOrganisationIdentifier = x.PaymentOrganisationIdentifier,
PaymentOrganisationName = x.PaymentOrganisationName
});
await _cachePolicy.ExecuteAsync(() => _cacheProvider.KeyDeleteAsync <ProviderSummary>(cacheKeyScopedListCacheKey));
// Batch to get around redis timeouts
foreach (IEnumerable <ProviderSummary> batch in providerSummaries.ToBatches(1000))
{
// Create list is an upsert into the redis list
await _cachePolicy.ExecuteAsync(() => _cacheProvider.CreateListAsync(batch, cacheKeyScopedListCacheKey));
await _cachePolicy.ExecuteAsync(() => _cacheProvider.SetExpiry <ProviderSummary>(cacheKeyScopedListCacheKey, DateTime.UtcNow.AddDays(7)));
}
await _cachePolicy.ExecuteAsync(() =>
_cacheProvider.SetAsync(scopedProviderSummariesCountCacheKey,
providerSummaries.Count().ToString(), TimeSpan.FromDays(7), true));
string filesystemCacheKey = $"{CacheKeys.ScopedProviderSummariesFilesystemKeyPrefix}{specificationId}";
await _cachePolicy.ExecuteAsync(() => _cacheProvider.KeyDeleteAsync <string>(filesystemCacheKey));
}
