public FundingTemplateService(
ILogger logger,
IFundingTemplateRepository fundingTemplateRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IFundingTemplateValidationService fundingTemplateValidationService,
ICacheProvider cacheProvider,
ITemplateMetadataResolver templateMetadataResolver,
ITemplateBuilderService templateBuilderService,
IMapper mapper)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fundingTemplateRepository, nameof(fundingTemplateRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.CacheProvider, nameof(policyResiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(policyResiliencePolicies?.FundingTemplateRepository, nameof(policyResiliencePolicies.FundingTemplateRepository));
Guard.ArgumentNotNull(fundingTemplateValidationService, nameof(fundingTemplateValidationService));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(templateMetadataResolver, nameof(templateMetadataResolver));
Guard.ArgumentNotNull(templateBuilderService, nameof(templateBuilderService));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_logger = logger;
_fundingTemplateRepository = fundingTemplateRepository;
_fundingTemplateRepositoryPolicy = policyResiliencePolicies.FundingTemplateRepository;
_fundingTemplateValidationService = fundingTemplateValidationService;
_cacheProvider = cacheProvider;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_templateMetadataResolver = templateMetadataResolver;
_templateBuilderService = templateBuilderService;
_mapper = mapper;
}
public TestResultsService(ITestResultsRepository testResultsRepository,
ISearchRepository <TestScenarioResultIndex> searchRepository,
IMapper mapper,
ILogger logger,
ITelemetry telemetry,
ITestRunnerResiliencePolicies policies,
IProvidersApiClient providersApiClient,
IJobManagement jobManagement) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(testResultsRepository, nameof(testResultsRepository));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(telemetry, nameof(telemetry));
Guard.ArgumentNotNull(policies?.TestResultsRepository, nameof(policies.TestResultsRepository));
Guard.ArgumentNotNull(policies?.TestResultsSearchRepository, nameof(policies.TestResultsSearchRepository));
Guard.ArgumentNotNull(providersApiClient, nameof(providersApiClient));
_testResultsRepository = testResultsRepository;
_searchRepository = searchRepository;
_mapper = mapper;
_logger = logger;
_telemetry = telemetry;
_testResultsPolicy = policies.TestResultsRepository;
_testResultsSearchPolicy = policies.TestResultsSearchRepository;
_providersApiClient = providersApiClient;
}
public FundingStreamPermissionService(
IUserRepository userRepository,
ISpecificationsApiClient specificationsApiClient,
IVersionRepository <FundingStreamPermissionVersion> fundingStreamPermissionVersionRepository,
ICacheProvider cacheProvider,
IMapper mapper,
ILogger logger,
IUsersResiliencePolicies policies)
{
Guard.ArgumentNotNull(userRepository, nameof(userRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(fundingStreamPermissionVersionRepository, nameof(fundingStreamPermissionVersionRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(policies?.UserRepositoryPolicy, nameof(policies.UserRepositoryPolicy));
Guard.ArgumentNotNull(policies?.SpecificationApiClient, nameof(policies.SpecificationApiClient));
Guard.ArgumentNotNull(policies?.FundingStreamPermissionVersionRepositoryPolicy, nameof(policies.FundingStreamPermissionVersionRepositoryPolicy));
Guard.ArgumentNotNull(policies?.CacheProviderPolicy, nameof(policies.CacheProviderPolicy));
_userRepository = userRepository;
_specificationsApiClient = specificationsApiClient;
_fundingStreamPermissionVersionRepository = fundingStreamPermissionVersionRepository;
_cacheProvider = cacheProvider;
_mapper = mapper;
_logger = logger;
_userRepositoryPolicy = policies.UserRepositoryPolicy;
_specificationsApiClientPolicy = policies.SpecificationApiClient;
_fundingStreamPermissionVersionRepositoryPolicy = policies.FundingStreamPermissionVersionRepositoryPolicy;
_cacheProviderPolicy = policies.CacheProviderPolicy;
}
public ApproveAllCalculationsService(
ICalculationsRepository calculationsRepository,
ICalcsResiliencePolicies resiliencePolicies,
ISpecificationsApiClient specificationsApiClient,
IResultsApiClient resultsApiClient,
ISearchRepository <CalculationIndex> searchRepository,
ICacheProvider cacheProvider,
ILogger logger,
IJobManagement jobManagement) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resultsApiClient, nameof(resultsApiClient));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsApiClient, nameof(resiliencePolicies.ResultsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
_calculationsRepository = calculationsRepository;
_logger = logger;
_calculationRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_specificationsApiClient = specificationsApiClient;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_resultsApiClient = resultsApiClient;
_resultsApiClientPolicy = resiliencePolicies.ResultsApiClient;
_searchRepository = searchRepository;
_cacheProvider = cacheProvider;
_cachePolicy = resiliencePolicies.CacheProviderPolicy;
}
public ProviderCalculationResultsReIndexerService(
ILogger logger,
ISearchRepository <ProviderCalculationResultsIndex> providerCalculationResultsSearchRepository,
ISpecificationsApiClient specificationsApiClient,
ICalculationResultsRepository resultsRepository,
IResultsResiliencePolicies resiliencePolicies,
IFeatureToggle featureToggle,
IMessengerService messengerService)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(providerCalculationResultsSearchRepository, nameof(providerCalculationResultsSearchRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsRepository, nameof(resiliencePolicies.ResultsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsSearchRepository, nameof(resiliencePolicies.ResultsSearchRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
_logger = logger;
_providerCalculationResultsSearchRepository = providerCalculationResultsSearchRepository;
_specificationsApiClient = specificationsApiClient;
_resultsRepository = resultsRepository;
_resultsRepositoryPolicy = resiliencePolicies.ResultsRepository;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository;
_featureToggle = featureToggle;
_messengerService = messengerService;
}
public DatasetDefinitionFieldChangesProcessor(
IFeatureToggle featureToggle,
IDatasetsApiClient datasetsApiClient,
ICalcsResiliencePolicies resiliencePolicies,
ILogger logger,
ICalculationService calculationService,
ICalculationsRepository calculationsRepository,
IMapper mapper)
{
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(calculationService, nameof(calculationService));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_featureToggle = featureToggle;
_datasetsApiClient = datasetsApiClient;
_datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient;
_logger = logger;
_calculationService = calculationService;
_calculationsRepository = calculationsRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_mapper = mapper;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public DefinitionSpecificationRelationshipService(IDatasetRepository datasetRepository,
ILogger logger,
ISpecificationsApiClient specificationsApiClient,
IValidator <CreateDefinitionSpecificationRelationshipModel> relationshipModelValidator,
IMessengerService messengerService,
ICalcsRepository calcsRepository,
ICacheProvider cacheProvider,
IDatasetsResiliencePolicies datasetsResiliencePolicies,
IJobManagement jobManagement,
IDateTimeProvider dateTimeProvider)
{
Guard.ArgumentNotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.ArgumentNotNull(datasetRepository, nameof(datasetRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(relationshipModelValidator, nameof(relationshipModelValidator));
Guard.ArgumentNotNull(messengerService, nameof(messengerService));
Guard.ArgumentNotNull(calcsRepository, nameof(calcsRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(datasetsResiliencePolicies?.SpecificationsApiClient, nameof(datasetsResiliencePolicies.SpecificationsApiClient));
_datasetRepository = datasetRepository;
_logger = logger;
_specificationsApiClient = specificationsApiClient;
_relationshipModelValidator = relationshipModelValidator;
_messengerService = messengerService;
_calcsRepository = calcsRepository;
_cacheProvider = cacheProvider;
_jobManagement = jobManagement;
_dateTimeProvider = dateTimeProvider;
_specificationsApiClientPolicy = datasetsResiliencePolicies.SpecificationsApiClient;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public CalculationResultsService(
IPublishingResiliencePolicies resiliencePolicies,
ICalculationResultsRepository calculationResultsRepository)
{
Guard.ArgumentNotNull(calculationResultsRepository, nameof(calculationResultsRepository));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies.CalculationResultsRepository, nameof(resiliencePolicies.CalculationResultsRepository));
_calculationResultsRepository = calculationResultsRepository;
_resultsRepositoryPolicy = resiliencePolicies.CalculationResultsRepository;
}
public FundingSchemaService(
ILogger logger,
IFundingSchemaRepository fundingSchemaRepository,
IPolicyResiliencePolicies policyResiliencePolicies)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fundingSchemaRepository, nameof(fundingSchemaRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.FundingSchemaRepository, nameof(policyResiliencePolicies.FundingSchemaRepository));
_logger = logger;
_fundingSchemaRepository = fundingSchemaRepository;
_fundingSchemaRepositoryPolicy = policyResiliencePolicies.FundingSchemaRepository;
}
public PublishedFundingBulkRepository(
IPublishingResiliencePolicies resiliencePolicies,
IPublishingEngineOptions publishingEngineOptions,
ICosmosRepository cosmosRepository)
{
Guard.ArgumentNotNull(cosmosRepository, nameof(cosmosRepository));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies.PublishedFundingRepository, nameof(resiliencePolicies.PublishedFundingRepository));
Guard.ArgumentNotNull(publishingEngineOptions, nameof(publishingEngineOptions));
_repository = cosmosRepository;
_publishingEngineOptions = publishingEngineOptions;
_publishedFundingRepositoryPolicy = resiliencePolicies.PublishedFundingRepository;
}
public FundingFeedItemByIdService(IPublishedFundingRetrievalService publishedFundingRetrievalService,
ISearchRepository <PublishedFundingIndex> fundingSearchRepository,
IPublishingResiliencePolicies resiliencePolicies,
ILogger logger)
{
Guard.ArgumentNotNull(publishedFundingRetrievalService, nameof(publishedFundingRetrievalService));
Guard.ArgumentNotNull(fundingSearchRepository, nameof(fundingSearchRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(resiliencePolicies?.FundingFeedSearchRepository, nameof(resiliencePolicies.FundingFeedSearchRepository));
_publishedFundingRetrievalService = publishedFundingRetrievalService;
_fundingSearchRepository = fundingSearchRepository;
_fundingSearchRepositoryPolicy = resiliencePolicies.FundingFeedSearchRepository;
_logger = logger;
}
public FundingTemplateValidationService(
IFundingSchemaRepository fundingSchemaRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IPolicyRepository policyRepository)
{
Guard.ArgumentNotNull(fundingSchemaRepository, nameof(fundingSchemaRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.FundingSchemaRepository, nameof(policyResiliencePolicies.FundingSchemaRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
_fundingSchemaRepository = fundingSchemaRepository;
_fundingSchemaRepositoryPolicy = policyResiliencePolicies.FundingSchemaRepository;
_policyRepository = policyRepository;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
}
public ResultsService(ILogger logger,
IFeatureToggle featureToggle,
ICalculationResultsRepository resultsRepository,
IProviderSourceDatasetRepository providerSourceDatasetRepository,
ISearchRepository <ProviderCalculationResultsIndex> calculationProviderResultsSearchRepository,
ISpecificationsApiClient specificationsApiClient,
ICalculationsApiClient calculationsApiClient,
IResultsResiliencePolicies resiliencePolicies,
ICalculationsRepository calculationRepository,
IMapper mapper,
IJobManagement jobManagement,
IBlobClient blobClient) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository));
Guard.ArgumentNotNull(providerSourceDatasetRepository, nameof(providerSourceDatasetRepository));
Guard.ArgumentNotNull(calculationProviderResultsSearchRepository, nameof(calculationProviderResultsSearchRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(calculationsApiClient, nameof(calculationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsRepository, nameof(resiliencePolicies.ResultsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.ResultsSearchRepository, nameof(resiliencePolicies.ResultsSearchRepository));
Guard.ArgumentNotNull(resiliencePolicies?.SpecificationsApiClient, nameof(resiliencePolicies.SpecificationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsApiClient, nameof(resiliencePolicies.CalculationsApiClient));
Guard.ArgumentNotNull(resiliencePolicies?.CalculationsRepository, nameof(resiliencePolicies.CalculationsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, nameof(resiliencePolicies.BlobClient));
Guard.ArgumentNotNull(calculationRepository, nameof(calculationRepository));
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(blobClient, nameof(blobClient));
_logger = logger;
_mapper = mapper;
_resultsRepository = resultsRepository;
_providerSourceDatasetRepository = providerSourceDatasetRepository;
_calculationProviderResultsSearchRepository = calculationProviderResultsSearchRepository;
_resultsRepositoryPolicy = resiliencePolicies.ResultsRepository;
_specificationsApiClient = specificationsApiClient;
_calculationsApiClient = calculationsApiClient;
_resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository;
_specificationsApiClientPolicy = resiliencePolicies.SpecificationsApiClient;
_calculationsApiClientPolicy = resiliencePolicies.CalculationsApiClient;
_blobClientPolicy = resiliencePolicies.BlobClient;
_calculationRepository = calculationRepository;
_calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository;
_featureToggle = featureToggle;
_blobClient = blobClient;
}
public JobService(
IJobRepository jobRepository,
IMapper mapper,
IJobsResiliencePolicies resiliencePolicies,
ICacheProvider cacheProvider)
{
Guard.ArgumentNotNull(jobRepository, nameof(jobRepository));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies?.JobRepository, nameof(resiliencePolicies.JobRepository));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
_jobRepository = jobRepository;
_mapper = mapper;
_jobsRepositoryPolicy = resiliencePolicies.JobRepository;
_cacheProviderPolicy = resiliencePolicies.CacheProviderPolicy;
_cacheProvider = cacheProvider;
}
public PublishedProviderVersioningService(
ILogger logger,
IVersionRepository <PublishedProviderVersion> versionRepository,
IPublishingResiliencePolicies resiliencePolicies,
IPublishingEngineOptions publishingEngineOptions,
IVersionBulkRepository <PublishedProviderVersion> versionBulkRepository)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(versionRepository, nameof(versionRepository));
Guard.ArgumentNotNull(resiliencePolicies?.PublishedProviderVersionRepository, nameof(resiliencePolicies.PublishedProviderVersionRepository));
Guard.ArgumentNotNull(publishingEngineOptions, nameof(publishingEngineOptions));
Guard.ArgumentNotNull(versionBulkRepository, nameof(versionBulkRepository));
_logger = logger;
_versionRepository = versionRepository;
_publishingEngineOptions = publishingEngineOptions;
_versionRepositoryPolicy = resiliencePolicies.PublishedProviderVersionRepository;
_versionBulkRepository = versionBulkRepository;
}
public FundingPeriodService(ILogger logger,
ICacheProvider cacheProvider,
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IValidator <FundingPeriodsJsonModel> fundingPeriodJsonModelValidator)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.CacheProvider, nameof(policyResiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(fundingPeriodJsonModelValidator, nameof(fundingPeriodJsonModelValidator));
_logger = logger;
_cacheProvider = cacheProvider;
_policyRepository = policyRepository;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_fundingPeriodJsonModelValidator = fundingPeriodJsonModelValidator;
}
public FundingDateService(
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
ILogger logger,
IValidator <FundingDate> fundingDateValidator,
IMapper mapper)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies, nameof(policyResiliencePolicies));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fundingDateValidator, nameof(fundingDateValidator));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_policyRepository = policyRepository;
_logger = logger;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
_fundingDateValidator = fundingDateValidator;
_mapper = mapper;
}
public ScenariosService(
ILogger logger,
IScenariosRepository scenariosRepository,
ISpecificationsApiClient specificationsApiClient,
IValidator <CreateNewTestScenarioVersion> createNewTestScenarioVersionValidator,
ISearchRepository <ScenarioIndex> searchRepository,
ICacheProvider cacheProvider,
IVersionRepository <TestScenarioVersion> versionRepository,
IJobManagement jobManagement,
ICalcsRepository calcsRepository,
IScenariosResiliencePolicies scenariosResiliencePolicies)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(scenariosRepository, nameof(scenariosRepository));
Guard.ArgumentNotNull(specificationsApiClient, nameof(specificationsApiClient));
Guard.ArgumentNotNull(createNewTestScenarioVersionValidator, nameof(createNewTestScenarioVersionValidator));
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(versionRepository, nameof(versionRepository));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(calcsRepository, nameof(calcsRepository));
Guard.ArgumentNotNull(scenariosResiliencePolicies?.CalcsRepository, nameof(scenariosResiliencePolicies.CalcsRepository));
Guard.ArgumentNotNull(scenariosResiliencePolicies?.ScenariosRepository, nameof(scenariosResiliencePolicies.ScenariosRepository));
Guard.ArgumentNotNull(scenariosResiliencePolicies?.SpecificationsApiClient, nameof(scenariosResiliencePolicies.SpecificationsApiClient));
_scenariosRepository = scenariosRepository;
_logger = logger;
_specificationsApiClient = specificationsApiClient;
_createNewTestScenarioVersionValidator = createNewTestScenarioVersionValidator;
_searchRepository = searchRepository;
_cacheProvider = cacheProvider;
_cacheProvider = cacheProvider;
_versionRepository = versionRepository;
_jobManagement = jobManagement;
_calcsRepository = calcsRepository;
_calcsRepositoryPolicy = scenariosResiliencePolicies.CalcsRepository;
_scenariosRepositoryPolicy = scenariosResiliencePolicies.ScenariosRepository;
_specificationsApiClientPolicy = scenariosResiliencePolicies.SpecificationsApiClient;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public JobDefinitionsService(IJobDefinitionsRepository jobDefinitionsRepository,
ILogger logger,
IJobsResiliencePolicies resiliencePolicies,
ICacheProvider cacheProvider,
IValidator <JobDefinition> validator)
{
Guard.ArgumentNotNull(jobDefinitionsRepository, nameof(jobDefinitionsRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(resiliencePolicies?.JobDefinitionsRepository, nameof(resiliencePolicies.JobDefinitionsRepository));
Guard.ArgumentNotNull(resiliencePolicies?.CacheProviderPolicy, nameof(resiliencePolicies.CacheProviderPolicy));
Guard.ArgumentNotNull(validator, nameof(validator));
_jobDefinitionsRepository = jobDefinitionsRepository;
_logger = logger;
_jobDefinitionsRepositoryPolicy = resiliencePolicies.JobDefinitionsRepository;
_cacheProvider = cacheProvider;
_validator = validator;
_cachePolicy = resiliencePolicies.CacheProviderPolicy;
}
public PreviewService(
ILogger logger,
IBuildProjectsService buildProjectsService,
IValidator <PreviewRequest> previewRequestValidator,
ICalculationsRepository calculationsRepository,
IDatasetsApiClient datasetsApiClient,
ICacheProvider cacheProvider,
ISourceCodeService sourceCodeService,
ICalcsResiliencePolicies resiliencePolicies,
IMapper mapper,
ICalcEngineApiClient calcEngineApiClient)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(buildProjectsService, nameof(buildProjectsService));
Guard.ArgumentNotNull(previewRequestValidator, nameof(previewRequestValidator));
Guard.ArgumentNotNull(calculationsRepository, nameof(calculationsRepository));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(sourceCodeService, nameof(sourceCodeService));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(resiliencePolicies.DatasetsApiClient, nameof(resiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(resiliencePolicies.CalcEngineApiClient, nameof(resiliencePolicies.CalcEngineApiClient));
Guard.ArgumentNotNull(calcEngineApiClient, nameof(calcEngineApiClient));
_logger = logger;
_buildProjectsService = buildProjectsService;
_previewRequestValidator = previewRequestValidator;
_calculationsRepository = calculationsRepository;
_datasetsApiClient = datasetsApiClient;
_cacheProvider = cacheProvider;
_sourceCodeService = sourceCodeService;
_datasetsApiClientPolicy = resiliencePolicies.DatasetsApiClient;
_mapper = mapper;
_calcEngineApiClient = calcEngineApiClient;
_calcEngineApiClientPolicy = resiliencePolicies.CalcEngineApiClient;
_typeIdentifierGenerator = new VisualBasicTypeIdentifierGenerator();
}
public DatasetDefinitionFieldChangesProcessor(
IFeatureToggle featureToggle,
ILogger logger,
IDatasetsApiClient datasetsApiClient,
IScenariosResiliencePolicies scenariosResiliencePolicies,
IScenariosService scenariosService,
IMapper mapper)
{
Guard.ArgumentNotNull(featureToggle, nameof(featureToggle));
Guard.ArgumentNotNull(datasetsApiClient, nameof(datasetsApiClient));
Guard.ArgumentNotNull(scenariosResiliencePolicies?.DatasetsApiClient, nameof(scenariosResiliencePolicies.DatasetsApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(scenariosService, nameof(scenariosService));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_featureToggle = featureToggle;
_logger = logger;
_datasetsApiClient = datasetsApiClient;
_datasetsApiClientPolicy = scenariosResiliencePolicies.DatasetsApiClient;
_scenariosService = scenariosService;
_mapper = mapper;
}
public FundingConfigurationService(
ILogger logger,
ICacheProvider cacheProvider,
IMapper mapper,
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IValidator <FundingConfiguration> fundingConfigurationValidator)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(fundingConfigurationValidator, nameof(fundingConfigurationValidator));
Guard.ArgumentNotNull(policyResiliencePolicies?.CacheProvider, nameof(policyResiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
_logger = logger;
_cacheProvider = cacheProvider;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_mapper = mapper;
_policyRepository = policyRepository;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
_fundingConfigurationValidator = fundingConfigurationValidator;
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton <ISpecificationTemplateVersionChangedHandler, SpecificationTemplateVersionChangedHandler>();
builder.AddSingleton <IQueueCreateSpecificationJobActions, QueueCreateSpecificationJobAction>();
builder.AddSingleton <IQueueEditSpecificationJobActions, QueueEditSpecificationJobActions>();
builder.AddSingleton <IQueueDeleteSpecificationJobActions, QueueDeleteSpecificationJobAction>();
// These registrations of the functions themselves are just for the DebugQueue. Ideally we don't want these registered in production
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddScoped <OnAddRelationshipEvent>();
builder.AddScoped <OnReIndexSpecification>();
builder.AddScoped <OnDeleteSpecifications>();
builder.AddScoped <OnDeleteSpecificationsFailure>();
}
builder.AddSingleton <ISpecificationsRepository, SpecificationsRepository>((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.ContainerName = "specs";
CosmosRepository resultsRepository = new CosmosRepository(specsVersioningDbSettings);
return(new SpecificationsRepository(resultsRepository));
});
builder.AddSingleton <ISpecificationsService, SpecificationsService>();
builder.AddSingleton <IValidator <SpecificationCreateModel>, SpecificationCreateModelValidator>();
builder.AddSingleton <IValidator <SpecificationEditModel>, SpecificationEditModelValidator>();
builder.AddSingleton <IValidator <AssignDefinitionRelationshipMessage>, AssignDefinitionRelationshipMessageValidator>();
builder.AddSingleton <IValidator <AssignSpecificationProviderVersionModel>, AssignSpecificationProviderVersionModelValidator>();
builder.AddSingleton <ISpecificationsSearchService, SpecificationsSearchService>();
builder.AddSingleton <IResultsRepository, ResultsRepository>();
builder.AddSingleton <ISpecificationIndexer, SpecificationIndexer>();
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddSingleton <ISpecificationIndexingService, SpecificationIndexingService>();
builder.AddSingleton <IDeadletterService, DeadletterService>();
builder.AddSingleton <ITemplateMetadataResolver>((ctx) =>
{
TemplateMetadataResolver resolver = new TemplateMetadataResolver();
TemplateMetadataGenerator schema10Generator = new TemplateMetadataGenerator(ctx.GetService <ILogger>());
resolver.Register("1.0", schema10Generator);
return(resolver);
});
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
config.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "providerversions";
return(new BlobClient(storageSettings));
});
builder.AddSingleton <IVersionRepository <Models.Specs.SpecificationVersion>, VersionRepository <Models.Specs.SpecificationVersion> >((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.ContainerName = "specs";
CosmosRepository cosmosRepository = new CosmosRepository(specsVersioningDbSettings);
return(new VersionRepository <Models.Specs.SpecificationVersion>(cosmosRepository, new NewVersionBuilderFactory <SpecificationVersion>()));
});
builder
.AddSingleton <IJobManagement, JobManagement>();
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(config);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
builder.AddSingleton <ISpecificationsResiliencePolicies>((ctx) =>
{
Polly.AsyncPolicy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new SpecificationsResiliencePolicies()
{
PoliciesApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalcsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProvidersApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsSearchRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ResultsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) => new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
MapperConfiguration mappingConfig = new MapperConfiguration(c =>
{
c.AddProfile <SpecificationsMappingProfile>();
});
builder.AddSingleton(mappingConfig.CreateMapper());
builder.AddServiceBus(config, "specs");
builder.AddSearch(config);
builder
.AddSingleton <ISearchRepository <SpecificationIndex>, SearchRepository <SpecificationIndex> >();
builder.AddCaching(config);
builder.AddResultsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddProvidersInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPoliciesInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddJobsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCalculationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddDatasetsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPolicySettings(config);
builder.AddFeatureToggling(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Specs");
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.Specs");
builder.AddLogging("CalculateFunding.Functions.Specs");
builder.AddTelemetry();
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
return(builder.BuildServiceProvider());
}
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");
}
});
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddHttpCachingMvc();
builder.AddQueryProviderAndExtractorForViewModelMvc <
FundingStructure,
TemplateMetadataContentsTimedETagProvider,
TemplateMatadataContentsTimedETagExtractor>(false);
builder.AddSingleton <IFundingStructureService, FundingStructureService>()
.AddSingleton <IValidator <UpdateFundingStructureLastModifiedRequest>, UpdateFundingStructureLastModifiedRequestValidator>();
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddSingleton <IQueueCreateSpecificationJobActions, QueueCreateSpecificationJobAction>();
builder.AddSingleton <IQueueEditSpecificationJobActions, QueueEditSpecificationJobActions>();
builder.AddSingleton <IQueueDeleteSpecificationJobActions, QueueDeleteSpecificationJobAction>();
builder.AddSingleton <ISpecificationsRepository, SpecificationsRepository>((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.ContainerName = "specs";
CosmosRepository resultsRepostory = new CosmosRepository(specsVersioningDbSettings);
return(new SpecificationsRepository(resultsRepostory));
});
builder
.AddSingleton <ISpecificationsService, SpecificationsService>()
.AddSingleton <IHealthChecker, SpecificationsService>();
builder.AddSingleton <ISpecificationIndexer, SpecificationIndexer>();
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddSingleton <ISpecificationIndexingService, SpecificationIndexingService>();
builder
.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <IValidator <SpecificationCreateModel>, SpecificationCreateModelValidator>();
builder.AddSingleton <IValidator <SpecificationEditModel>, SpecificationEditModelValidator>();
builder.AddSingleton <IValidator <AssignDefinitionRelationshipMessage>, AssignDefinitionRelationshipMessageValidator>();
builder.AddSingleton <IValidator <AssignSpecificationProviderVersionModel>, AssignSpecificationProviderVersionModelValidator>();
builder
.AddSingleton <ISpecificationsSearchService, SpecificationsSearchService>()
.AddSingleton <IHealthChecker, SpecificationsSearchService>();
builder.AddSingleton <IResultsRepository, ResultsRepository>();
builder
.AddSingleton <ISpecificationsReportService, SpecificationsReportService>()
.AddSingleton <IHealthChecker, SpecificationsReportService>();
builder.AddSingleton <ITemplateMetadataResolver>((ctx) =>
{
TemplateMetadataResolver resolver = new TemplateMetadataResolver();
TemplateMetadataGenerator schema10Generator = new TemplateMetadataGenerator(ctx.GetService <ILogger>());
resolver.Register("1.0", schema10Generator);
return(resolver);
});
builder
.AddSingleton <LocalIBlobClient, LocalBlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "providerversions";
return(new LocalBlobClient(storageSettings));
});
builder.AddSingleton <ISpecificationTemplateVersionChangedHandler, SpecificationTemplateVersionChangedHandler>();
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "providerversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
return(new BlobClient(blobContainerRepository));
});
builder.AddSingleton <IVersionRepository <Models.Specs.SpecificationVersion>, VersionRepository <Models.Specs.SpecificationVersion> >((ctx) =>
{
CosmosDbSettings specsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", specsVersioningDbSettings);
specsVersioningDbSettings.ContainerName = "specs";
CosmosRepository resultsRepostory = new CosmosRepository(specsVersioningDbSettings);
return(new VersionRepository <Models.Specs.SpecificationVersion>(resultsRepostory, new NewVersionBuilderFactory <SpecificationVersion>()));
});
MapperConfiguration mappingConfig = new MapperConfiguration(
c =>
{
c.AddProfile <SpecificationsMappingProfile>();
}
);
builder.AddFeatureToggling(Configuration);
builder.AddSingleton(mappingConfig.CreateMapper());
builder.AddServiceBus(Configuration);
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <SpecificationIndex>, SearchRepository <SpecificationIndex> >();
builder.AddCaching(Configuration);
builder.AddResultsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddGraphInterServiceClient(Configuration);
builder.AddCalculationsInterServiceClient(Configuration);
builder.AddProvidersInterServiceClient(Configuration);
builder.AddPoliciesInterServiceClient(Configuration);
builder.AddDatasetsInterServiceClient(Configuration);
builder.AddPolicySettings(Configuration);
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
builder.AddSingleton <ISpecificationsResiliencePolicies>((ctx) =>
{
Polly.AsyncPolicy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new SpecificationsResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PoliciesApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalcsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProvidersApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsSearchRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ResultsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Apis.Specs");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Specs");
builder.AddLogging("CalculateFunding.Apis.Specs");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Specs Microservice API");
}
}
public void RegisterComponents(IServiceCollection builder)
{
builder
.AddSpecificationsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan)
.AddCalculationsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan)
.AddResultsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton <IIoCValidatorFactory, ValidatorFactory>()
.AddSingleton <IValidator <Reference>, AuthorValidator>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder
.AddSingleton <IFundingStreamService, FundingStreamService>()
.AddSingleton <IHealthChecker, FundingStreamService>()
.AddSingleton <IValidator <FundingStreamSaveModel>, FundingStreamSaveModelValidator>();
builder
.AddSingleton <IFundingPeriodService, FundingPeriodService>()
.AddSingleton <IHealthChecker, FundingPeriodService>()
.AddSingleton <IFundingPeriodValidator, FundingPeriodValidator>();
builder
.AddSingleton <IFundingSchemaService, FundingSchemaService>()
.AddSingleton <IHealthChecker, FundingSchemaService>();
builder
.AddSingleton <IFundingConfigurationService, FundingConfigurationService>()
.AddSingleton <IHealthChecker, FundingConfigurationService>();
builder
.AddSingleton <IFundingTemplateService, FundingTemplateService>()
.AddSingleton <IHealthChecker, FundingTemplateService>();
builder
.AddSingleton <IFundingTemplateValidationService, FundingTemplateValidationService>()
.AddSingleton <IHealthChecker, FundingTemplateValidationService>();
builder
.AddSingleton <IFundingDateService, FundingDateService>()
.AddSingleton <IHealthChecker, FundingDateService>();
builder
.AddSingleton <IFundingSchemaRepository, FundingSchemaRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "fundingschemas";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(blobStorageOptions);
return(new FundingSchemaRepository(blobContainerRepository));
});
builder
.AddSingleton <IFundingTemplateRepository, FundingTemplateRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "fundingtemplates";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(blobStorageOptions);
return(new FundingTemplateRepository(blobContainerRepository));
});
builder
.AddSingleton <IPolicyRepository, PolicyRepository>((ctx) =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings
{
ContainerName = "policy"
};
Configuration.Bind("CosmosDbSettings", cosmosDbSettings);
CosmosRepository cosmosRepository = new CosmosRepository(cosmosDbSettings);
return(new PolicyRepository(cosmosRepository));
});
builder.AddSingleton <IPolicyResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
Polly.AsyncPolicy redisPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy);
return(new PolicyResiliencePolicies
{
PolicyRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CacheProvider = redisPolicy,
FundingSchemaRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
FundingTemplateRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
TemplatesSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
TemplatesRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SpecificationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ResultsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalculationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IValidator <FundingConfiguration>, SaveFundingConfigurationValidator>();
builder.AddSingleton <IValidator <FundingPeriodsJsonModel>, FundingPeriodJsonModelValidator>();
builder.AddSingleton <IValidator <FundingDate>, SaveFundingDateValidator>();
RegisterTemplateBuilderComponents(builder);
builder.AddPolicySettings(Configuration);
builder.AddJobsInterServiceClient(Configuration);
MapperConfiguration fundingConfMappingConfig = new MapperConfiguration(c =>
{
c.AddProfile <FundingConfigurationMappingProfile>();
});
builder
.AddSingleton(fundingConfMappingConfig.CreateMapper());
builder.AddSearch(Configuration);
builder.AddSingleton <TemplateSearchService>()
.AddSingleton <IHealthChecker, TemplateSearchService>();
builder
.AddSingleton <ISearchRepository <TemplateIndex>, SearchRepository <TemplateIndex> >();
builder.AddCaching(Configuration);
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Policy");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Policy");
builder.AddLogging("CalculateFunding.Api.Policy");
builder.AddTelemetry();
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Policy Microservice API");
}
}
public SaveFundingConfigurationValidator(IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IFundingTemplateService fundingTemplateService)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(fundingTemplateService, nameof(fundingTemplateService));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
ResiliencePolicy policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
RuleFor(_ => _.ApprovalMode)
.Must(_ => _ != ApprovalMode.Undefined)
.WithMessage("No valid approval mode was selected");
RuleFor(model => model.FundingStreamId)
.NotEmpty()
.WithMessage("No funding stream id was provided to SaveFundingConfiguration")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingConfiguration model = context.ParentContext.InstanceToValidate as FundingConfiguration;
if (!string.IsNullOrWhiteSpace(model.FundingStreamId))
{
FundingStream fundingStream = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingStreamById(model.FundingStreamId));
if (fundingStream == null)
{
context.AddFailure("Funding stream not found");
}
}
});
RuleFor(model => model.FundingPeriodId)
.NotEmpty()
.WithMessage("No funding period id was provided to SaveFundingConfiguration")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingConfiguration model = context.ParentContext.InstanceToValidate as FundingConfiguration;
if (!string.IsNullOrWhiteSpace(model.FundingPeriodId))
{
FundingPeriod fundingPeriod = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingPeriodById(model.FundingPeriodId));
if (fundingPeriod == null)
{
context.AddFailure("Funding period not found");
}
}
});
RuleFor(model => model.DefaultTemplateVersion)
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingConfiguration model = context.ParentContext.InstanceToValidate as FundingConfiguration;
string fundingStreamId = model.FundingStreamId;
string defaultTemplateVersion = model.DefaultTemplateVersion;
string fundingPeriodId = model.FundingPeriodId;
if (!string.IsNullOrWhiteSpace(fundingStreamId) && !string.IsNullOrWhiteSpace(fundingPeriodId) && !string.IsNullOrWhiteSpace(defaultTemplateVersion))
{
if (!await fundingTemplateService.TemplateExists(fundingStreamId, fundingPeriodId, defaultTemplateVersion))
{
context.AddFailure("Default template not found");
}
}
});
RuleFor(_ => _.UpdateCoreProviderVersion)
.Must(v => v == UpdateCoreProviderVersion.Manual)
.When(_ => _.ProviderSource != CalculateFunding.Models.Providers.ProviderSource.FDZ, ApplyConditionTo.CurrentValidator)
.WithMessage(x => $"UpdateCoreProviderVersion - {x.UpdateCoreProviderVersion.ToString()} is not valid for provider source - {x.ProviderSource}");
}
public SaveFundingDateValidator(
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies
)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
ResiliencePolicy policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
RuleFor(model => model.FundingStreamId)
.NotEmpty()
.WithMessage("No funding stream id was provided to SaveFundingDate")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingDate model = context.ParentContext.InstanceToValidate as FundingDate;
if (!string.IsNullOrWhiteSpace(model.FundingStreamId))
{
FundingStream fundingStream = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingStreamById(model.FundingStreamId));
if (fundingStream == null)
{
context.AddFailure("Funding stream not found");
}
}
});
RuleFor(model => model.FundingPeriodId)
.NotEmpty()
.WithMessage("No funding period id was provided to SaveFundingDate")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingDate model = context.ParentContext.InstanceToValidate as FundingDate;
if (!string.IsNullOrWhiteSpace(model.FundingPeriodId))
{
FundingPeriod fundingPeriod = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingPeriodById(model.FundingPeriodId));
if (fundingPeriod == null)
{
context.AddFailure("Funding period not found");
}
}
});
RuleFor(model => model.Patterns)
.NotEmpty()
.WithMessage("No funding date pattern was provided to SaveFundingDate")
.Custom((name, context) =>
{
FundingDate model = context.ParentContext.InstanceToValidate as FundingDate;
if (model.Patterns == null)
{
return;
}
foreach (FundingDatePattern fundingDatePattern in model.Patterns)
{
if (fundingDatePattern.Occurrence == default ||
string.IsNullOrEmpty(fundingDatePattern.Period) ||
fundingDatePattern.PeriodYear == default ||
fundingDatePattern.PaymentDate == default)
{
context.AddFailure("FundingDatePattern information missing");
}
}
if (model.Patterns.GroupBy(x => new { x.Period, x.PeriodYear, x.Occurrence }).Any(_ => _.Count() > 1))
{
context.AddFailure("Duplicate funding data pattern");
}
});
}
