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"); } }); }