public FundingStructureService(
ICacheProvider cacheProvider,
ISpecificationsService specificationsService,
ICalculationsApiClient calculationsApiClient,
IGraphApiClient graphApiClient,
Common.ApiClient.Policies.IPoliciesApiClient policiesApiClient,
IValidator <UpdateFundingStructureLastModifiedRequest> validator,
ISpecificationsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(specificationsService, nameof(specificationsService));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(calculationsApiClient, nameof(calculationsApiClient));
Guard.ArgumentNotNull(graphApiClient, nameof(graphApiClient));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(validator, nameof(validator));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProvider, nameof(resiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(resiliencePolicies?.CalcsApiClient, nameof(resiliencePolicies.CalcsApiClient));
_specificationsService = specificationsService;
_policiesApiClient = policiesApiClient;
_calculationsApiClient = calculationsApiClient;
_graphApiClient = graphApiClient;
_cacheProvider = cacheProvider;
_validator = validator;
_policiesResilience = resiliencePolicies.PoliciesApiClient;
_cacheResilience = resiliencePolicies.CacheProvider;
_calculationsResilience = resiliencePolicies.CalcsApiClient;
}
public AssignSpecificationProviderVersionModelValidator(
ISpecificationsRepository specificationsRepository,
IProvidersApiClient providersApiClient,
ISpecificationsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ProvidersApiClient, nameof(resiliencePolicies.ProvidersApiClient));
_specificationsRepository = specificationsRepository;
_providersApiClient = providersApiClient;
_providersApiClientPolicy = resiliencePolicies.ProvidersApiClient;
RuleFor(model => model.SpecificationId)
.NotEmpty()
.WithMessage("Null or Empty SpecificationId provided")
.CustomAsync(async(name, context, cancellationToken) =>
{
AssignSpecificationProviderVersionModel model = context.ParentContext.InstanceToValidate as AssignSpecificationProviderVersionModel;
if (!string.IsNullOrWhiteSpace(model.SpecificationId))
{
Specification specification = await _specificationsRepository.GetSpecificationById(model.SpecificationId);
if (specification == null)
{
context.AddFailure(nameof(model.SpecificationId), $"Specification not found for SpecificationId - {model.SpecificationId}");
}
else if (specification.Current.ProviderSource != ProviderSource.FDZ)
{
context.AddFailure($"Specification ProviderSource is not set to FDZ");
}
}
});
RuleFor(model => model.ProviderVersionId)
.NotEmpty()
.WithMessage("Null or Empty ProviderVersionId provided")
.CustomAsync(async(name, context, cancellationToken) =>
{
AssignSpecificationProviderVersionModel model = context.ParentContext.InstanceToValidate as AssignSpecificationProviderVersionModel;
if (!string.IsNullOrWhiteSpace(model.ProviderVersionId))
{
HttpStatusCode providerVersionStatusCode = await _providersApiClientPolicy.ExecuteAsync(() => _providersApiClient.DoesProviderVersionExist(model.ProviderVersionId));
if (providerVersionStatusCode == HttpStatusCode.NotFound)
{
context.AddFailure(nameof(model.ProviderVersionId), $"Provider version id specified does not exist");
}
}
});
}
public SpecificationTemplateVersionChangedHandler(IJobManagement jobs,
ICalculationsApiClient calculations,
ISpecificationsResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(jobs, nameof(jobs));
Guard.ArgumentNotNull(calculations, nameof(calculations));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(resiliencePolicies?.CalcsApiClient, nameof(resiliencePolicies.CalcsApiClient));
_jobs = jobs;
_calculations = calculations;
_logger = logger;
_calculationsPolicy = resiliencePolicies.CalcsApiClient;
}
public QueueCreateSpecificationJobAction(IPoliciesApiClient policies,
IJobManagement jobManagement,
ISpecificationsResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(policies, nameof(policies));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
_policies = policies;
_jobManagement = jobManagement;
_logger = logger;
_policyResiliencePolicy = resiliencePolicies.PoliciesApiClient;
}
public SpecificationIndexingService(IJobManagement jobs,
ILogger logger,
ISpecificationIndexer indexer,
ISpecificationsRepository specifications,
ISpecificationsResiliencePolicies resiliencePolicies) : base(jobs, logger)
{
Guard.ArgumentNotNull(jobs, nameof(jobs));
Guard.ArgumentNotNull(indexer, nameof(indexer));
Guard.ArgumentNotNull(specifications, nameof(specifications));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsRepository, nameof(resiliencePolicies.SpecificationsRepository));
_jobs = jobs;
_indexer = indexer;
_specifications = specifications;
_specificationsPolicy = resiliencePolicies.SpecificationsRepository;
}
public QueueEditSpecificationJobActions(
IJobManagement jobManagement,
IDatasetsApiClient datasets,
ISpecificationsResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(datasets, nameof(datasets));
_jobManagement = jobManagement;
_logger = logger;
_datasets = datasets;
_datasetsPolicy = resiliencePolicies.DatasetsApiClient;
}
public void SetUp()
{
_jobManagement = Substitute.For <IJobManagement>();
_datasetsApiClient = Substitute.For <IDatasetsApiClient>();
_specificationsResiliencePolicies = new SpecificationsResiliencePolicies
{
DatasetsApiClient = Policy.NoOpAsync()
};
_logger = Substitute.For <ILogger>();
_userId = NewRandomString();
_userName = NewRandomString();
_user = NewReference(_ => _.WithId(_userId).WithName(_userName));
_correlationId = NewRandomString();
_action = new QueueEditSpecificationJobActions(_jobManagement, _datasetsApiClient, _specificationsResiliencePolicies, _logger);
_jobManagement.QueueJob(Arg.Any <JobCreateModel>())
.Returns(new Job()); //default instance as we assert was called but have null checks in the test now
}
public SpecificationIndexer(IMapper mapper,
ISpecificationsResiliencePolicies resiliencePolicies,
IDatasetsApiClient datasets,
ISearchRepository <SpecificationIndex> specificationSearch,
IProducerConsumerFactory producerConsumerFactory,
ILogger logger)
{
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsSearchRepository, nameof(resiliencePolicies.SpecificationsSearchRepository));
Guard.ArgumentNotNull(datasets, nameof(datasets));
Guard.ArgumentNotNull(specificationSearch, nameof(specificationSearch));
Guard.ArgumentNotNull(producerConsumerFactory, nameof(producerConsumerFactory));
Guard.ArgumentNotNull(logger, nameof(logger));
_mapper = mapper;
_datasetsPolicy = resiliencePolicies.DatasetsApiClient;
_specificationsSearchPolicy = resiliencePolicies.SpecificationsSearchRepository;
_datasets = datasets;
_producerConsumerFactory = producerConsumerFactory;
_logger = logger;
_specificationSearch = specificationSearch;
}
public SpecificationCreateModelValidator(ISpecificationsRepository specificationsRepository,
IProvidersApiClient providersApiClient,
IPoliciesApiClient policiesApiClient,
ISpecificationsResiliencePolicies resiliencePolicies)
{
Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
Guard.ArgumentNotNull(policiesApiClient, nameof(policiesApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.PoliciesApiClient, nameof(resiliencePolicies.PoliciesApiClient));
_specificationsRepository = specificationsRepository;
_providersApiClient = providersApiClient;
_policiesApiClient = policiesApiClient;
_policiesApiClientPolicy = resiliencePolicies.PoliciesApiClient;
RuleFor(model => model.FundingPeriodId)
.NotEmpty()
.WithMessage("Null or empty academic year id provided")
.Custom((name, context) =>
{
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
if (!string.IsNullOrWhiteSpace(specModel.FundingPeriodId))
{
ApiResponse <PolicyModels.FundingPeriod> fundingPeriodResponse =
_policiesApiClientPolicy.ExecuteAsync(() => _policiesApiClient.GetFundingPeriodById(specModel.FundingPeriodId)).GetAwaiter().GetResult();
if (fundingPeriodResponse?.StatusCode != HttpStatusCode.OK || fundingPeriodResponse?.Content == null)
{
context.AddFailure("Funding period not found");
}
}
});
RuleFor(model => model.ProviderVersionId)
.Custom((name, context) => {
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
ApiResponse <PolicyModels.FundingConfig.FundingConfiguration> fundingConfigResponse =
_policiesApiClientPolicy.ExecuteAsync(() => _policiesApiClient.GetFundingConfiguration(specModel.FundingStreamIds.FirstOrDefault(), specModel.FundingPeriodId)).GetAwaiter().GetResult();
if (fundingConfigResponse?.StatusCode != HttpStatusCode.OK || fundingConfigResponse?.Content == null)
{
context.AddFailure("Funding config not found");
return;
}
switch (fundingConfigResponse.Content.ProviderSource)
{
case ProviderSource.CFS:
{
if (string.IsNullOrWhiteSpace(specModel.ProviderVersionId))
{
context.AddFailure($"Null or empty provider version id");
}
if (_providersApiClient.DoesProviderVersionExist(specModel.ProviderVersionId).Result == System.Net.HttpStatusCode.NotFound)
{
context.AddFailure($"Provider version id selected does not exist");
}
if (specModel.CoreProviderVersionUpdates != CoreProviderVersionUpdates.Manual)
{
context.AddFailure($"CoreProviderVersionUpdates - {specModel.CoreProviderVersionUpdates} is not valid for provider source - {fundingConfigResponse.Content.ProviderSource}");
}
break;
}
case ProviderSource.FDZ:
{
if (!specModel.ProviderSnapshotId.HasValue)
{
context.AddFailure($"Null or empty provider snapshot id");
}
break;
}
}
});
RuleFor(model => model.FundingStreamIds)
.NotNull()
.NotEmpty()
.WithMessage("You must select at least one funding stream")
.Custom((name, context) => {
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
foreach (string fundingStreamId in specModel.FundingStreamIds)
{
if (string.IsNullOrWhiteSpace(fundingStreamId))
{
context.AddFailure($"A null or empty string funding stream ID was provided");
}
}
});
RuleFor(model => model.Name)
.NotEmpty()
.WithMessage("You must give a unique specification name")
.Custom((name, context) => {
SpecificationCreateModel specModel = context.ParentContext.InstanceToValidate as SpecificationCreateModel;
Specification specification = _specificationsRepository.GetSpecificationByQuery(m => m.Content.Name.ToLower() == specModel.Name.Trim().ToLower()).Result;
if (specification != null)
{
context.AddFailure($"You must give a unique specification name");
}
});
}
