public static void EnsureValid(this BlobStorageOptions options)
{
if (options == null)
{
CoreOptionsExtensions.ThrowMissingConfiguration(nameof(BaGetOptions.Storage));
}
if (string.IsNullOrEmpty(options.AccountName))
{
CoreOptionsExtensions.ThrowMissingConfiguration(
nameof(BaGetOptions.Storage),
nameof(BlobStorageOptions.AccountName));
}
if (string.IsNullOrEmpty(options.AccessKey))
{
CoreOptionsExtensions.ThrowMissingConfiguration(
nameof(BaGetOptions.Storage),
nameof(BlobStorageOptions.AccessKey));
}
if (string.IsNullOrEmpty(options.Container))
{
CoreOptionsExtensions.ThrowMissingConfiguration(
nameof(BaGetOptions.Storage),
nameof(BlobStorageOptions.Container));
}
}
public override IBlobProviderSelector GetBlobProviderSelector()
{
return(new BuiltInBlobProviderSelector(
Providers.Instance.BlobProviders,
null,
Options.Create(BlobStorageOptions.GetLegacyConfiguration())));
}
protected override void SetupNewDatabase(DbContextOptions <IPOContext> dbContextOptions)
{
using (var context = new IPOContext(dbContextOptions, _plantProvider, _eventDispatcher, _currentUserProvider))
{
var invitation = new Invitation(
TestPlant,
"TestProject",
"TestInvitation",
"TestDescriptioN",
DisciplineType.DP,
new DateTime(),
new DateTime(),
null,
new List <McPkg> {
new McPkg(TestPlant, "TestProject", "commno", "mcno", "d", "1|2")
},
null);
var attachmentA = new Attachment(TestPlant, "fileA.txt");
var attachmentB = new Attachment(TestPlant, "fileB.txt");
invitation.AddAttachment(attachmentA);
invitation.AddAttachment(attachmentB);
context.Invitations.Add(invitation);
context.SaveChangesAsync().Wait();
}
var blobStorageOptions = new BlobStorageOptions();
_blobStorageOptionsMonitorMock = new Mock <IOptionsMonitor <BlobStorageOptions> >();
_blobStorageOptionsMonitorMock
.Setup(x => x.CurrentValue)
.Returns(blobStorageOptions);
}
public override IBlobStorageMetaDataProvider GetBlobMetaDataProvider(DataProvider dataProvider)
{
//TODO: get services and options from outside
return(new MsSqlBlobMetaDataProvider(Providers.Instance.BlobProviders,
Options.Create(DataOptions.GetLegacyConfiguration()),
Options.Create(BlobStorageOptions.GetLegacyConfiguration()),
Options.Create(ConnectionStringOptions.GetLegacyConnectionStrings())));
}
/// <summary>
/// Initializes an instance of the BuiltInBlobProviderSelector
/// </summary>
public BuiltInBlobProviderSelector(
IBlobProviderStore blobProviderStore,
IExternalBlobProviderFactory externalBlobProviderFactory,
IOptions <BlobStorageOptions> blobStorageConfig)
{
BlobProviders = blobProviderStore;
ExternalFactory = externalBlobProviderFactory;
BlobStorageConfig = blobStorageConfig?.Value ?? new BlobStorageOptions();
}
public BlobStorage(IBlobProviderStore providers,
IBlobProviderSelector selector,
IBlobStorageMetaDataProvider metaProvider,
IOptions <BlobStorageOptions> blobStorageOptions)
{
ProviderSelector = selector;
Providers = providers;
DataProvider = metaProvider;
BlobStorageConfig = blobStorageOptions?.Value ?? new BlobStorageOptions();
}
/// <summary>
/// Create new instance.
/// </summary>
public SpacesBlobStorageService(IOptions <BlobStorageOptions> options, ILogger <SpacesBlobStorageService> logger)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_awsCredentials = new BasicAWSCredentials(_options.AccessKey, _options.SecretKey);
_clientConfig = new()
{
ServiceURL = _options.ServiceUri.AbsoluteUri
};
}
public AdminApiController(PowerBIPoCContext context, IDataProtectionProvider dataProtectionProvider, ILogger <UserManager <Admin> > logger
, IHostingEnvironment env, IMailService mailService, IOptions <ProjectNameOptions> currentProjectOptions, IOptions <BlobStorageOptions> blobStorageOptions, IImageProcessor imageProcessor)
{
_context = context;
_dataProtectionProvider = dataProtectionProvider;
_logger = logger;
_mailService = mailService;
_currentProject = currentProjectOptions.Value.Value;
_imageProcessor = imageProcessor;
_blobStorageOptions = blobStorageOptions.Value;
this.env = env;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Cria um objeto com os valores atribuidos nas configurações
// e coloca o objeto acessivel globalmente na aplicação
var blobStorage = new BlobStorageOptions();
Configuration.Bind(nameof(BlobStorageOptions), blobStorage);
services.AddSingleton(blobStorage);
services.AddScoped <IBlobStorageService, BlobStorageService>();
services.AddAutoMapper(typeof(Startup));
services.AddControllers();
}
/// <summary>
/// Create new instance.
/// </summary>
public SpacesBlobStorageService(IOptions <BlobStorageOptions> options,
ILogger <SpacesBlobStorageService> logger)
{
_options = options?.Value ?? throw new ArgumentNullException(nameof(options));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
// Create client once.
client = new AmazonS3Client(new BasicAWSCredentials(_options.AccessKey, _options.SecretKey),
new AmazonS3Config
{
ServiceURL = _options.ServiceUri.AbsoluteUri
});
}
public void Setup()
{
_blobStorageOptions = new BlobStorageOptions {
ContainerName = NewRandomString(),
ConnectionString = NewRandomString()
};
_cloudBlob = new Mock <ICloudBlob>();
_cloudBlockBlob = new Mock <CloudBlockBlob>(new object[] { new Uri(NewRandomUrl()) });
_cloudBlobContainer = new Mock <CloudBlobContainer>(new object[] { new Uri(NewRandomUrl()) });
_blobContainerRepository = new BlobContainerRepositoryTest(_blobStorageOptions, _cloudBlobContainer.Object);
}
public FileService(CaffStoreDbContext context, IConfiguration configuration)
{
_context = context;
var blobStorageOptions = new BlobStorageOptions();
configuration.Bind(nameof(BlobStorageOptions), blobStorageOptions);
_sasTokenLifetimeSeconds = blobStorageOptions.SasTokenLifetimeSeconds;
_sharedKeyCredential = new StorageSharedKeyCredential(blobStorageOptions.StorageAccountName, blobStorageOptions.StorageAccountKey);
var blobServiceClient = new BlobServiceClient(blobStorageOptions.StorageAccountUri, _sharedKeyCredential);
_caffBlobContainerClient = blobServiceClient.GetBlobContainerClient(blobStorageOptions.CaffContainerName);
_previewBlobContainerClient = blobServiceClient.GetBlobContainerClient(blobStorageOptions.PreviewContainerName);
}
public void Setup()
{
_validatorMock = new Mock <IInvitationValidator>();
_validatorMock
.Setup(x => x.IpoExistsAsync(1, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(true));
_validatorMock.Setup(x => x.AttachmentWithFileNameExistsAsync(1, "existingfile.txt", It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(true));
var blobStorageOptions = new BlobStorageOptions()
{
BlobContainer = "TestContainer",
MaxSizeMb = 1,
BlockedFileSuffixes = new[] { ".exe" }
};
_monitor = Mock.Of <IOptionsMonitor <BlobStorageOptions> >(x => x.CurrentValue == blobStorageOptions);
_dut = new UploadAttachmentCommandValidator(_validatorMock.Object, _monitor);
}
public void Setup()
{
_invitation = new Invitation(
_plant,
_projectName,
"TestInvitation",
"Description",
DisciplineType.DP,
new DateTime(),
new DateTime(),
null,
new List <McPkg> {
new McPkg(_plant, _projectName, "Comm", "Mc", "d", "1|2")
},
null);
_attachment = new Attachment(_plant, "ExistingFile.txt");
_attachment.SetProtectedIdForTesting(2);
_invitation.AddAttachment(_attachment);
_invitationRepositoryMock = new Mock <IInvitationRepository>();
_invitationRepositoryMock
.Setup(x => x.GetByIdAsync(1))
.Returns(Task.FromResult(_invitation));
_unitOfWorkMock = new Mock <IUnitOfWork>();
_blobStorageMock = new Mock <IBlobStorage>();
var blobStorageOptions = new BlobStorageOptions()
{
BlobContainer = "TestContainer"
};
_monitorMock = Mock.Of <IOptionsMonitor <BlobStorageOptions> >(x => x.CurrentValue == blobStorageOptions);
_command = new DeleteAttachmentCommand(1, 2, "AAAAAAAAAAA=");
_dut = new DeleteAttachmentCommandHandler(
_invitationRepositoryMock.Object,
_unitOfWorkMock.Object,
_blobStorageMock.Object,
_monitorMock);
}
public void GetAttachmentDownloadUri_ReturnCorrectUri()
{
TimeService.SetProvider(new ManualTimeProvider(new DateTime(2020, 1, 1, 12, 0, 0, 0, DateTimeKind.Utc)));
var attachment = new Attachment("PCS$TESTPLANT", "testfile.txt");
var blobStorageMock = new Mock <IBlobStorage>();
blobStorageMock.Setup(x => x.GetDownloadSasUri(It.IsAny <string>(), It.IsAny <DateTimeOffset>(), It.IsAny <DateTimeOffset>()))
.Returns((string path, DateTimeOffset start, DateTimeOffset end) => new Uri($"{path}?{start.UtcDateTime:yyyy-MM-ddTHH:mm:ssZ}&{end.UtcDateTime:yyyy-MM-ddTHH:mm:ssZ}"));
var blobStorageOptions = new BlobStorageOptions
{
BlobClockSkewMinutes = 5,
BlobContainer = @"https://blobcontainer",
BlockedFileSuffixes = new[] { ".txt" },
ConnectionString = "connectionstring",
MaxSizeMb = 1
};
var uri = attachment.GetAttachmentDownloadUri(blobStorageMock.Object, blobStorageOptions);
Assert.AreEqual($"https://blobcontainer/{attachment.BlobPath}?2020-01-01T11:55:00Z&2020-01-01T12:05:00Z", uri.ToString());
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IPublishedFundingQueryBuilder, PublishedFundingQueryBuilder>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddFeatureToggling(Configuration);
// Register v3 services
builder
.AddSingleton <IFundingFeedService, FundingFeedService>();
builder
.AddSingleton <IFundingFeedItemByIdService, FundingFeedItemByIdService>();
builder
.AddSingleton <IFileSystemCache, FileSystemCache>()
.AddSingleton <IFileSystemAccess, FileSystemAccess>()
.AddSingleton <IFileSystemCacheSettings, FileSystemCacheSettings>();
builder.AddSingleton <IFeedItemPreloader, FeedItemPreLoader>()
.AddSingleton <IFeedItemPreloaderSettings>(ctx =>
{
FeedItemPreLoaderSettings settings = new FeedItemPreLoaderSettings();
Configuration.Bind("feeditempreloadersettings", settings);
return(settings);
});
builder.AddSingleton <IExternalApiFileSystemCacheSettings>(ctx =>
{
ExternalApiFileSystemCacheSettings settings = new ExternalApiFileSystemCacheSettings();
Configuration.Bind("externalapifilesystemcachesettings", settings);
return(settings);
});
builder.AddSingleton <IExternalEngineOptions>(ctx =>
{
ExternalEngineOptions settings = new ExternalEngineOptions();
Configuration.Bind("externalengineoptions", settings);
return(settings);
});
builder.AddSingleton <IPublishedFundingRetrievalService>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedfunding";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
IBlobClient blobClient = new BlobClient(blobContainerRepository);
IExternalApiResiliencePolicies resiliencePolicies = ctx.GetService <IExternalApiResiliencePolicies>();
ILogger logger = ctx.GetService <ILogger>();
IFileSystemCache fileSystemCache = ctx.GetService <IFileSystemCache>();
IExternalApiFileSystemCacheSettings settings = ctx.GetService <IExternalApiFileSystemCacheSettings>();
return(new PublishedFundingRetrievalService(blobClient, resiliencePolicies, fileSystemCache, logger, settings));
});
builder.AddSingleton <IPublishedFundingRepository, PublishedFundingRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.ContainerName = "publishedfunding";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calssDbSettings);
IPublishedFundingQueryBuilder publishedFundingQueryBuilder = ctx.GetService <IPublishedFundingQueryBuilder>();
return(new PublishedFundingRepository(calcsCosmosRepostory, publishedFundingQueryBuilder));
});
// Register dependencies
builder
.AddSingleton <IFundingFeedSearchService, FundingFeedSearchService>()
.AddSingleton <IHealthChecker, FundingFeedSearchService>();
builder
.AddSingleton <IFundingStreamService, FundingStreamService>();
builder
.AddSingleton <IPublishedProviderRetrievalService, PublishedProviderRetrievalService>();
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <PublishedFundingIndex>, SearchRepository <PublishedFundingIndex> >();
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.External");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.External");
builder.AddLogging("CalculateFunding.Api.External");
builder.AddTelemetry();
builder.AddHttpContextAccessor();
builder.AddPolicySettings(Configuration);
builder.AddSingleton <IPublishingResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies()
{
FundingFeedSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
PublishedFundingBlobRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
ProvidersApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddSingleton <IExternalApiResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ExternalApiResiliencePolicies()
{
PublishedProviderBlobRepositoryPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingBlobRepositoryPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
PoliciesApiClientPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
MapperConfiguration externalConfig = new MapperConfiguration(c =>
{
c.AddProfile <ExternalServiceMappingProfile>();
});
builder.AddSingleton(externalConfig.CreateMapper());
builder.AddAuthenticatedHealthCheckMiddleware();
builder.AddTransient <ContentTypeCheckMiddleware>();
builder.AddPoliciesInterServiceClient(Configuration);
builder.AddProvidersInterServiceClient(Configuration);
builder.AddSingleton <IProviderFundingVersionService>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedproviderversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
IBlobClient blobClient = new BlobClient(blobContainerRepository);
IExternalApiResiliencePolicies publishingResiliencePolicies = ctx.GetService <IExternalApiResiliencePolicies>();
ILogger logger = ctx.GetService <ILogger>();
IFileSystemCache fileSystemCache = ctx.GetService <IFileSystemCache>();
IExternalApiFileSystemCacheSettings settings = ctx.GetService <IExternalApiFileSystemCacheSettings>();
IPublishedFundingRepository publishedFundingRepository = ctx.GetService <IPublishedFundingRepository>();
return(new ProviderFundingVersionService(blobClient, publishedFundingRepository, logger, publishingResiliencePolicies, fileSystemCache, settings));
});
}
public static IServiceProvider BuildServiceProvider(string collectionName)
{
IServiceCollection builder = new ServiceCollection();
builder.AddApplicationInsightsTelemetryClient(Configuration, ServiceName);
builder.AddLogging(serviceName: ServiceName);
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddPolicySettings(Configuration);
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <IJobTracker, JobTracker>();
builder.AddJobsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddServiceBus(Configuration);
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddSingleton <ICosmosRepository>(ctx =>
{
CosmosDbSettings cosmosDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", cosmosDbSettings);
cosmosDbSettings.ContainerName = collectionName;
return(new CosmosRepository(cosmosDbSettings));
});
builder.AddSingleton <IPublishingResiliencePolicies>(ctx =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers
.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies
{
JobsApiClient = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingRepository = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedIndexSearchResiliencePolicy = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
BlobClient = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>(ctx =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers
.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies
{
JobsApiClient = ResiliencePolicyHelpers
.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IPublishedFundingUndoCosmosRepository, PublishedFundingUndoCosmosRepository>();
builder.AddSingleton <IPublishedFundingUndoBlobStoreRepository>(ctx =>
{
BlobStorageOptions settings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", settings);
settings.ContainerName = "publishedproviderversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(settings);
return(new PublishedFundingUndoBlobStoreRepository(new CommonBlobClient(blobContainerRepository),
ctx.GetService <IPublishingResiliencePolicies>(),
ctx.GetService <ILogger>()));
});
builder.AddSingleton <IPublishedFundingUndoJobCreation, PublishedFundingUndoJobCreation>();
builder.AddSingleton <IPublishedFundingUndoTaskFactoryLocator, PublishedFundingUndoTaskFactoryLocator>();
builder.AddSingleton <IDsgRollBackCosmosDocumentsJob, DsgRollBackCosmosDocumentsJob>();
builder.AddSingleton <IPublishedFundingUndoTaskFactory, DsgRollBackTaskFactory>();
builder.AddSingleton <IRollBackDsg, RollBackDsg>();
return(builder.BuildServiceProvider());
}
public SourceFileRepository(BlobStorageOptions blobStorageOptions) : base(blobStorageOptions)
{
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <CalcsAddRelationshipToBuildProject>();
builder.AddSingleton <OnCalcsCreateDraftEvent>();
builder.AddSingleton <OnCalcsInstructAllocationResultsFailure>();
builder.AddSingleton <OnCalcsInstructAllocationResults>();
builder.AddSingleton <OnCalculationAggregationsJobCompleted>();
builder.AddSingleton <OnDataDefinitionChanges>();
builder.AddSingleton <OnEditCalculationSpecificationEvent>();
builder.AddSingleton <OnEditSpecificationEvent>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <ICalculationService, CalculationService>();
builder.AddSingleton <ICalculationsSearchService, CalculationSearchService>();
builder.AddSingleton <ICalculationCodeReferenceUpdate, CalculationCodeReferenceUpdate>();
builder.AddSingleton <ITokenChecker, TokenChecker>();
builder.AddSingleton <IValidator <Calculation>, CalculationModelValidator>();
builder.AddSingleton <IPreviewService, PreviewService>();
builder.AddSingleton <ICompilerFactory, CompilerFactory>();
builder.AddSingleton <IDatasetRepository, DatasetRepository>();
builder.AddSingleton <IJobService, JobService>();
builder
.AddSingleton <CSharpCompiler>()
.AddSingleton <VisualBasicCompiler>()
.AddSingleton <VisualBasicSourceFileGenerator>();
builder.AddSingleton <ISourceFileGeneratorProvider, SourceFileGeneratorProvider>();
builder.AddSingleton <IValidator <PreviewRequest>, PreviewRequestModelValidator>();
builder.AddSingleton <IProviderResultsRepository, ProviderResultsRepository>();
builder.AddSingleton <ISpecificationRepository, SpecificationRepository>();
builder.AddSingleton <IBuildProjectsService, BuildProjectsService>();
builder.AddSingleton <IBuildProjectsRepository, BuildProjectsRepository>();
builder.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder.AddSingleton <ISourceCodeService, SourceCodeService>();
builder.AddSingleton <IJobHelperService, JobHelperService>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>(ctx =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("CommonStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
return(new SourceFileRepository(blobStorageOptions));
});
builder.AddSingleton <IVersionRepository <CalculationVersion>, VersionRepository <CalculationVersion> >((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.CollectionName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new VersionRepository <CalculationVersion>(resultsRepostory));
});
if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
{
builder.AddCosmosDb(config, "calcs");
}
else
{
builder.AddCosmosDb(config);
}
builder.AddFeatureToggling(config);
builder.AddSearch(config);
builder.AddServiceBus(config);
builder.AddResultsInterServiceClient(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddDatasetsInterServiceClient(config);
builder.AddJobsInterServiceClient(config);
builder.AddCaching(config);
builder.AddEngineSettings(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.Calcs");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Calcs");
builder.AddLogging("CalculateFunding.Functions.Calcs");
builder.AddTelemetry();
PolicySettings policySettings = builder.GetPolicySettings(config);
ResiliencePolicies resiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <ICalcsResiliencePolicies>(resiliencePolicies);
builder.AddSingleton <IJobHelperResiliencePolicies>(resiliencePolicies);
return(builder.BuildServiceProvider());
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <OnCreateAllocationLineResultStatusUpdates>();
builder.AddSingleton <OnCreateAllocationLineResultStatusUpdatesFailure>();
builder.AddSingleton <OnCreateInstructAllocationLineResultStatusUpdates>();
builder.AddSingleton <OnCreateInstructAllocationLineResultStatusUpdatesFailure>();
builder.AddSingleton <OnFetchProviderProfileEvent>();
builder.AddSingleton <OnFetchProviderProfileFailure>();
builder.AddSingleton <OnMigrateFeedIndexIdEvent>();
builder.AddSingleton <OnMigrateResultVersionsEvent>();
builder.AddSingleton <OnProviderResultsPublishedEvent>();
builder.AddSingleton <OnProviderResultsPublishedFailure>();
builder.AddSingleton <OnProviderResultsSpecificationCleanup>();
builder.AddSingleton <OnReIndexAllocationNotificationFeeds>();
builder.AddSingleton <OnReIndexCalculationResults>();
builder.AddSingleton <OnCalculationResultsCsvGeneration>();
builder.AddSingleton <OnCalculationResultsCsvGenerationTimer>();
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>();
builder.AddSingleton <IResultsService, ResultsService>();
builder.AddSingleton <IPublishedResultsService, PublishedResultsService>();
builder.AddSingleton <IResultsSearchService, ResultsSearchService>();
builder.AddSingleton <ICalculationProviderResultsSearchService, CalculationProviderResultsSearchService>();
builder.AddSingleton <IProviderImportMappingService, ProviderImportMappingService>();
builder.AddSingleton <IAllocationNotificationsFeedsSearchService, AllocationNotificationsFeedsSearchService>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder.AddSingleton <IValidator <MasterProviderModel>, MasterProviderModelValidator>();
builder.AddSingleton <IProviderVariationAssemblerService, ProviderVariationAssemblerService>();
builder.AddSingleton <IProviderVariationsService, ProviderVariationsService>();
builder.AddSingleton <IProviderService, ProviderService>();
builder.AddSingleton <IJobHelperService, JobHelperService>();
builder.AddSingleton <IProviderCalculationResultsReIndexerService, ProviderCalculationResultsReIndexerService>();
builder.AddSingleton <IProviderVariationsStorageRepository, ProviderVariationsStorageRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("CommonStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "providervariations";
return(new ProviderVariationsStorageRepository(blobStorageOptions));
});
MapperConfiguration resultsConfig = new MapperConfiguration(c =>
{
c.AddProfile <DatasetsMappingProfile>();
c.AddProfile <ResultServiceMappingProfile>();
c.AddProfile <ProviderMappingProfile>();
});
builder
.AddSingleton(resultsConfig.CreateMapper());
builder.AddCaching(config);
builder.AddSingleton <ICalculationResultsRepository, CalculationResultsRepository>((ctx) =>
{
CosmosDbSettings calssDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calssDbSettings);
calssDbSettings.CollectionName = "calculationresults";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calssDbSettings);
return(new CalculationResultsRepository(calcsCosmosRepostory));
});
builder.AddSingleton <IProviderSourceDatasetRepository, ProviderSourceDatasetRepository>((ctx) =>
{
CosmosDbSettings provDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", provDbSettings);
provDbSettings.CollectionName = "providerdatasets";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(provDbSettings);
return(new ProviderSourceDatasetRepository(calcsCosmosRepostory));
});
builder.AddSingleton <IPublishedProviderResultsRepository, PublishedProviderResultsRepository>((ctx) =>
{
CosmosDbSettings resultsDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", resultsDbSettings);
resultsDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository resultsRepostory = new CosmosRepository(resultsDbSettings);
return(new PublishedProviderResultsRepository(resultsRepostory));
});
builder.AddSingleton <IProviderChangesRepository, ProviderChangesRepository>((ctx) =>
{
CosmosDbSettings cosmosSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", cosmosSettings);
cosmosSettings.CollectionName = "publishedproviderchanges";
CosmosRepository resultsRepostory = new CosmosRepository(cosmosSettings);
ILogger logger = ctx.GetService <ILogger>();
return(new ProviderChangesRepository(resultsRepostory, logger));
});
builder
.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <IPublishedProviderResultsAssemblerService, PublishedProviderResultsAssemblerService>();
builder.AddSingleton <IPublishedProviderResultsSettings, PublishedProviderResultsSettings>((ctx) =>
{
PublishedProviderResultsSettings settings = new PublishedProviderResultsSettings();
config.Bind("PublishedProviderResultsSettings", settings);
return(settings);
});
builder.AddSingleton <IVersionRepository <PublishedAllocationLineResultVersion>, VersionRepository <PublishedAllocationLineResultVersion> >((ctx) =>
{
CosmosDbSettings versioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", versioningDbSettings);
versioningDbSettings.CollectionName = "publishedproviderresults";
CosmosRepository resultsRepostory = new CosmosRepository(versioningDbSettings);
return(new VersionRepository <PublishedAllocationLineResultVersion>(resultsRepostory));
});
builder
.AddSingleton <IBlobClient, AzureStorage.BlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
config.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "calculationresultscsv";
return(new AzureStorage.BlobClient(storageSettings));
});
builder.AddSearch(config);
builder.AddServiceBus(config);
builder.AddCaching(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.Results");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Results");
builder.AddLogging("CalculateFunding.Functions.Results");
builder.AddTelemetry();
builder.AddCalcsInterServiceClient(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddJobsInterServiceClient(config);
builder.AddResultsInterServiceClient(config);
builder.AddFeatureToggling(config);
builder.AddSingleton <IPublishedAllocationLineLogicalResultVersionService, PublishedAllocationLineLogicalResultVersionService>();
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder.AddSingleton <IAzureBearerTokenProxy, AzureBearerTokenProxy>();
builder.AddHttpClient(HttpClientKeys.Profiling,
c =>
{
ApiClientConfigurationOptions opts = new ApiClientConfigurationOptions();
config.Bind("providerProfilingClient", opts);
SetDefaultApiClientConfigurationOptions(c, opts, builder);
})
.ConfigurePrimaryHttpMessageHandler(() => new ApiClientHandler())
.AddTransientHttpErrorPolicy(c => c.WaitAndRetryAsync(retryTimeSpans))
.AddTransientHttpErrorPolicy(c => c.CircuitBreakerAsync(numberOfExceptionsBeforeCircuitBreaker, circuitBreakerFailurePeriod));
builder.AddSingleton <IProfilingApiClient>((ctx) =>
{
IFeatureToggle featureToggle = ctx.GetService <IFeatureToggle>();
bool enableMockProvider = featureToggle.IsProviderProfilingServiceDisabled();
if (enableMockProvider)
{
return(new MockProviderProfilingRepository());
}
else
{
IHttpClientFactory httpClientFactory = ctx.GetService <IHttpClientFactory>();
ILogger logger = ctx.GetService <ILogger>();
ICancellationTokenProvider cancellationTokenProvider = ctx.GetService <ICancellationTokenProvider>();
IAzureBearerTokenProxy azureBearerTokenProxy = ctx.GetService <IAzureBearerTokenProxy>();
ICacheProvider cacheProvider = ctx.GetService <ICacheProvider>();
AzureBearerTokenOptions azureBearerTokenOptions = new AzureBearerTokenOptions();
config.Bind("providerProfilingAzureBearerTokenOptions", azureBearerTokenOptions);
AzureBearerTokenProvider bearerTokenProvider = new AzureBearerTokenProvider(azureBearerTokenProxy, cacheProvider, azureBearerTokenOptions);
return(new ProfilingApiClient(httpClientFactory, HttpClientKeys.Profiling, logger, bearerTokenProvider, cancellationTokenProvider));
}
});
PolicySettings policySettings = builder.GetPolicySettings(config);
ResiliencePolicies resultsResiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <IResultsResiliencePolicies>(resultsResiliencePolicies);
builder.AddSingleton <IJobHelperResiliencePolicies>(resultsResiliencePolicies);
return(builder.BuildServiceProvider());
}
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 static Uri GetAttachmentDownloadUri(this Attachment attachment, IBlobStorage blobStorage, BlobStorageOptions blobStorageOptions)
{
var fullBlobPath = string.Join('/', blobStorageOptions.BlobContainer, attachment.BlobPath);
var now = TimeService.UtcNow;
var uri = blobStorage.GetDownloadSasUri(
fullBlobPath,
new DateTimeOffset(now.AddMinutes(blobStorageOptions.BlobClockSkewMinutes * -1)),
new DateTimeOffset(now.AddMinutes(blobStorageOptions.BlobClockSkewMinutes)));
return(uri);
}
public void RegisterComponents(IServiceCollection builder)
{
builder.AddScoped <ICalculationEngineService, CalculationEngineService>();
builder.AddScoped <ICalculationEngine, CalculationEngine>();
builder.AddScoped <IAllocationFactory, AllocationFactory>();
builder.AddScoped <IJobManagement, JobManagement>();
builder.AddSingleton <IProviderSourceDatasetVersionKeyProvider, ProviderSourceDatasetVersionKeyProvider>();
builder.AddSingleton <IFileSystemAccess, FileSystemAccess>();
builder.AddSingleton <IAssemblyService, AssemblyService>();
builder.AddSingleton <ICalculationAggregationService, CalculationAggregationService>();
builder.AddScoped <ICalculationEnginePreviewService, CalculationEnginePreviewService>();
builder.AddSingleton <IFileSystemCacheSettings, FileSystemCacheSettings>();
builder.AddSingleton <IFileSystemCache, FileSystemCache>();
builder.AddSingleton <IProviderSourceDatasetsRepository, ProviderSourceDatasetsRepository>((ctx) =>
{
CosmosDbSettings providerSourceDatasetsCosmosSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", providerSourceDatasetsCosmosSettings);
providerSourceDatasetsCosmosSettings.ContainerName = "providerdatasets";
CosmosRepository calcsCosmosRepository = new CosmosRepository(providerSourceDatasetsCosmosSettings, new CosmosClientOptions()
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = 8,
MaxTcpConnectionsPerEndpoint = 4,
ConsistencyLevel = ConsistencyLevel.Eventual,
AllowBulkExecution = true,
});
ICalculatorResiliencePolicies calculatorResiliencePolicies = ctx.GetService <ICalculatorResiliencePolicies>();
return(new ProviderSourceDatasetsRepository(calcsCosmosRepository, calculatorResiliencePolicies));
});
builder.AddSingleton <IProviderResultCalculationsHashProvider, ProviderResultCalculationsHashProvider>();
builder.AddSingleton <IProviderResultsRepository, ProviderResultsRepository>((ctx) =>
{
CosmosDbSettings calcResultsDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calcResultsDbSettings);
calcResultsDbSettings.ContainerName = "calculationresults";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calcResultsDbSettings, new CosmosClientOptions()
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = 8,
MaxTcpConnectionsPerEndpoint = 2,
// MaxRetryWaitTimeOnRateLimitedRequests = new TimeSpan(0, 0, 30),
AllowBulkExecution = true,
});
ILogger logger = ctx.GetService <ILogger>();
IProviderResultCalculationsHashProvider calculationsHashProvider = ctx.GetService <IProviderResultCalculationsHashProvider>();
ICalculatorResiliencePolicies calculatorResiliencePolicies = ctx.GetService <ICalculatorResiliencePolicies>();
IResultsApiClient resultsApiClient = ctx.GetService <IResultsApiClient>();
IJobManagement jobManagement = ctx.GetService <IJobManagement>();
return(new ProviderResultsRepository(
calcsCosmosRepostory,
logger,
calculationsHashProvider,
calculatorResiliencePolicies,
resultsApiClient,
jobManagement));
});
builder
.AddSingleton <IBlobContainerRepository, BlobContainerRepository>();
builder
.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder
.AddSingleton <IDatasetAggregationsRepository, DatasetAggregationsRepository>();
builder
.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
MapperConfiguration calculationsConfig = new MapperConfiguration(c =>
{
c.AddProfile <CalculationsMappingProfile>();
c.AddProfile <CalcEngineMappingProfile>();
});
builder
.AddSingleton(calculationsConfig.CreateMapper());
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddCalculationsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddSpecificationsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddJobsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPoliciesInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddResultsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddDatasetsInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddProvidersInterServiceClient(Configuration, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddEngineSettings(Configuration);
builder.AddServiceBus(Configuration, "calcengine");
builder.AddCaching(Configuration);
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.CalcEngine");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.CalcEngine");
builder.AddLogging("CalculateFunding.Api.CalcEngine");
builder.AddTelemetry();
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <ProviderCalculationResultsIndex>, SearchRepository <ProviderCalculationResultsIndex> >();
builder.AddFeatureToggling(Configuration);
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(Configuration);
CalculatorResiliencePolicies calcResiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <ICalculatorResiliencePolicies>(calcResiliencePolicies);
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) => new JobManagementResiliencePolicies()
{
JobsApiClient = calcResiliencePolicies.JobsApiClient
});
builder.AddSingleton <IValidator <ICalculatorResiliencePolicies>, CalculatorResiliencePoliciesValidator>();
builder.AddSingleton <ICalculationEngineServiceValidator, CalculationEngineServiceValidator>();
builder.AddSingleton <ISpecificationAssemblyProvider, SpecificationAssemblyProvider>();
builder.AddSingleton <IBlobClient>(ctx =>
{
BlobStorageOptions options = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", options);
options.ContainerName = "source";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(options);
return(new BlobClient(blobContainerRepository));
});
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "CalcEngine Microservice API", version: "v1");
}
}
private void RegisterComponents(IServiceCollection builder)
{
builder.AddSingleton <IBatchProfilingOptions, BatchProfilingOptions>();
builder.AddSingleton <IBatchProfilingService, BatchProfilingService>();
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder.AddSingleton <IReProfilingResponseMapper, ReProfilingResponseMapper>();
builder.AddSingleton <IBatchUploadQueryService, BatchUploadQueryService>();
builder.AddSingleton <IUniqueIdentifierProvider, UniqueIdentifierProvider>();
builder.AddSingleton <IBatchUploadValidationService, BatchUploadValidationService>();
builder.AddSingleton <IBatchUploadReaderFactory, BatchUploadReaderFactory>();
builder.AddSingleton <IValidator <BatchUploadValidationRequest>, BatchUploadValidationRequestValidation>();
builder.AddSingleton <IPublishedProviderUpdateDateService, PublishedProviderUpdateDateService>();
ISqlSettings sqlSettings = new SqlSettings();
Configuration.Bind("saSql", sqlSettings);
builder.AddSingleton(sqlSettings);
builder.AddSingleton <IBatchUploadService, BatchUploadService>();
builder.AddScoped <IDataTableImporter, DataTableImporter>();
builder.AddScoped <ISqlImportContextBuilder, SqlImportContextBuilder>();
builder.AddSingleton <ISqlPolicyFactory, SqlPolicyFactory>();
builder.AddScoped <ISqlConnectionFactory, SqlConnectionFactory>();
builder.AddScoped <ISqlImportContextBuilder, SqlImportContextBuilder>();
builder.AddScoped <ISqlImporter, SqlImporter>();
builder.AddScoped <ISqlImportService, SqlImportService>();
builder.AddScoped <ISqlNameGenerator, SqlNameGenerator>();
builder.AddScoped <ISqlSchemaGenerator, SqlSchemaGenerator>();
builder.AddScoped <IQaSchemaService, QaSchemaService>();
builder.AddScoped <IQaRepository, QaRepository>();
builder.AddSingleton <ITemplateMetadataResolver>(ctx =>
{
TemplateMetadataResolver resolver = new TemplateMetadataResolver();
ILogger logger = ctx.GetService <ILogger>();
TemplateMetadataSchema10.TemplateMetadataGenerator schema10Generator = new TemplateMetadataSchema10.TemplateMetadataGenerator(logger);
resolver.Register("1.0", schema10Generator);
TemplateMetadataSchema11.TemplateMetadataGenerator schema11Generator = new TemplateMetadataSchema11.TemplateMetadataGenerator(logger);
resolver.Register("1.1", schema11Generator);
return(resolver);
});
builder.AddSingleton <ICosmosRepository, CosmosRepository>();
CosmosDbSettings settings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
builder.AddSingleton(settings);
builder.AddSingleton <IPublishedFundingContentsGeneratorResolver>(ctx =>
{
PublishedFundingContentsGeneratorResolver resolver = new PublishedFundingContentsGeneratorResolver();
resolver.Register("1.0", new Generators.Schema10.PublishedFundingContentsGenerator());
resolver.Register("1.1", new Generators.Schema11.PublishedFundingContentsGenerator());
return(resolver);
});
builder.AddSingleton <IPublishedFundingIdGeneratorResolver>(ctx =>
{
PublishedFundingIdGeneratorResolver resolver = new PublishedFundingIdGeneratorResolver();
IPublishedFundingIdGenerator v10Generator = new Generators.Schema10.PublishedFundingIdGenerator();
resolver.Register("1.0", v10Generator);
resolver.Register("1.1", v10Generator);
return(resolver);
});
builder.AddSingleton <IProfilePatternPreview, ProfilePatternPreview>();
builder.AddSingleton <IReProfilingRequestBuilder, ReProfilingRequestBuilder>();
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder
.AddSingleton <IHealthChecker, ControllerResolverHealthCheck>();
builder.AddSingleton <IProfileHistoryService, ProfileHistoryService>();
builder.AddSingleton <IDateTimeProvider, DateTimeProvider>();
builder
.AddSingleton <IPublishedProviderVersionService, PublishedProviderVersionService>()
.AddSingleton <IHealthChecker, PublishedProviderVersionService>();
builder.AddSingleton <ISpecificationFundingStatusService, SpecificationFundingStatusService>();
builder
.AddSingleton <IPublishedSearchService, PublishedSearchService>()
.AddSingleton <IHealthChecker, PublishedSearchService>();
builder.AddSingleton <IPoliciesService, PoliciesService>();
builder.AddSingleton <IPublishedProviderStatusService, PublishedProviderStatusService>();
builder.AddScoped <IProfileTotalsService, ProfileTotalsService>();
builder.AddSingleton <IFundingConfigurationService, FundingConfigurationService>();
builder.AddScoped <IFundingStreamPaymentDatesQuery, FundingStreamPaymentDatesQuery>();
builder.AddScoped <IFundingStreamPaymentDatesIngestion, FundingStreamPaymentDatesIngestion>();
builder.AddSingleton <ICsvUtils, CsvUtils>();
builder.AddScoped <ICustomProfileService, CustomProfilingService>();
builder.AddScoped <IValidator <ApplyCustomProfileRequest>, ApplyCustomProfileRequestValidator>();
builder.AddSingleton <IPublishedProviderStatusUpdateService, PublishedProviderStatusUpdateService>();
builder.AddSingleton <IPublishedProviderVersioningService, PublishedProviderVersioningService>();
builder.AddSingleton <IJobTracker, JobTracker>();
builder.AddSingleton <IJobManagement, JobManagement>();
builder.AddSingleton <IVersionRepository <PublishedProviderVersion>, VersionRepository <PublishedProviderVersion> >((ctx) =>
{
CosmosDbSettings settings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
CosmosRepository cosmos = new CosmosRepository(settings);
return(new VersionRepository <PublishedProviderVersion>(cosmos, new NewVersionBuilderFactory <PublishedProviderVersion>()));
});
builder.AddSingleton <IVersionBulkRepository <PublishedProviderVersion>, VersionBulkRepository <PublishedProviderVersion> >((ctx) =>
{
CosmosDbSettings settings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
CosmosRepository cosmos = new CosmosRepository(settings);
return(new VersionBulkRepository <PublishedProviderVersion>(cosmos, new NewVersionBuilderFactory <PublishedProviderVersion>()));
});
builder
.AddSingleton <IPublishedProviderStatusUpdateSettings>(_ =>
{
PublishedProviderStatusUpdateSettings settings = new PublishedProviderStatusUpdateSettings();
Configuration.Bind("PublishedProviderStatusUpdateSettings", settings);
return(settings);
}
);
builder.AddHttpClient(HttpClientKeys.Profiling,
c =>
{
ApiOptions apiOptions = new ApiOptions();
Configuration.Bind("providerProfilingClient", apiOptions);
Services.Core.Extensions.ServiceCollectionExtensions.SetDefaultApiClientConfigurationOptions(c, apiOptions, builder);
})
.ConfigurePrimaryHttpMessageHandler(() => new ApiClientHandler())
.AddTransientHttpErrorPolicy(c => c.WaitAndRetryAsync(new[] { TimeSpan.FromMilliseconds(500), TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5) }))
.AddTransientHttpErrorPolicy(c => c.CircuitBreakerAsync(100, TimeSpan.FromSeconds(30)));
builder.AddSingleton <IFundingStreamPaymentDatesRepository>((ctx) =>
{
CosmosDbSettings cosmosSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", cosmosSettings);
cosmosSettings.ContainerName = "profiling";
return(new FundingStreamPaymentDatesRepository(new CosmosRepository(cosmosSettings)));
});
builder
.AddSingleton <IPublishedFundingQueryBuilder, PublishedFundingQueryBuilder>();
builder.AddSingleton <IPublishedFundingRepository, PublishedFundingRepository>((ctx) =>
{
CosmosDbSettings settings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
CosmosRepository calcsCosmosRepository = new CosmosRepository(settings);
IPublishedFundingQueryBuilder publishedFundingQueryBuilder = ctx.GetService <IPublishedFundingQueryBuilder>();
return(new PublishedFundingRepository(calcsCosmosRepository, publishedFundingQueryBuilder));
});
builder
.AddSingleton <IPublishingEngineOptions>(_ => new PublishingEngineOptions(Configuration));
builder.AddSingleton <IPublishedFundingBulkRepository, PublishedFundingBulkRepository>((ctx) =>
{
CosmosDbSettings settings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
IPublishingEngineOptions publishingEngineOptions = ctx.GetService <IPublishingEngineOptions>();
CosmosRepository calcsCosmosRepository = new CosmosRepository(settings, publishingEngineOptions.AllowBatching ? new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Direct,
RequestTimeout = new TimeSpan(0, 0, 15),
MaxRequestsPerTcpConnection = publishingEngineOptions.MaxRequestsPerTcpConnectionPublishedFundingCosmosBulkOptions,
MaxTcpConnectionsPerEndpoint = 4,
ConsistencyLevel = ConsistencyLevel.Eventual,
AllowBulkExecution = true
} : null);
IPublishingResiliencePolicies publishingResiliencePolicies = ctx.GetService <IPublishingResiliencePolicies>();
return(new PublishedFundingBulkRepository(publishingResiliencePolicies, publishingEngineOptions, calcsCosmosRepository));
});
builder
.AddSingleton <IBlobClient, BlobClient>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedproviderversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
return(new BlobClient(blobContainerRepository));
});
builder.AddCaching(Configuration);
builder.AddSearch(Configuration);
builder
.AddSingleton <ISearchRepository <PublishedProviderIndex>, SearchRepository <PublishedProviderIndex> >();
builder
.AddSingleton <ISearchRepository <PublishedFundingIndex>, SearchRepository <PublishedFundingIndex> >();
builder
.AddSingleton <IPublishedProviderProfilingService, PublishedProviderProfilingService>()
.AddSingleton <IPublishedProviderErrorDetection, PublishedProviderErrorDetection>()
.AddSingleton <IErrorDetectionStrategyLocator, ErrorDetectionStrategyLocator>()
.AddSingleton <IDetectPublishedProviderErrors, FundingLineValueProfileMismatchErrorDetector>()
.AddSingleton <IProfilingService, ProfilingService>()
.AddSingleton <IHealthChecker, ProfilingService>()
.AddSingleton <IPublishedProviderVersioningService, PublishedProviderVersioningService>();
builder.AddApplicationInsightsTelemetry();
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Publishing");
builder.AddApplicationInsightsServiceName(Configuration, "CalculateFunding.Api.Publishing");
builder.AddLogging("CalculateFunding.Api.Publishing");
builder.AddTelemetry();
builder.AddServiceBus(Configuration, "publishing");
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddPolicySettings(Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
builder.AddHttpCachingMvc();
builder.AddQueryProviderAndExtractorForViewModelMvc <PublishedProviderFundingStructure, PublishedProviderFundingStructureTimedEtagProvider, PublishedProviderFundingStructureTimedEtagExtractor>(false);
builder.AddPublishingServices(Configuration);
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddProvidersInterServiceClient(Configuration);
builder.AddCalculationsInterServiceClient(Configuration);
builder.AddProfilingInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddPoliciesInterServiceClient(Configuration);
builder.AddFundingDataServiceInterServiceClient(Configuration);
builder.AddFeatureToggling(Configuration);
builder.AddScoped <IPublishedFundingUndoJobService, PublishedFundingUndoJobService>();
builder.AddScoped <IPublishedFundingUndoJobCreation, PublishedFundingUndoJobCreation>();
builder.AddScoped <IPublishedFundingUndoTaskFactoryLocator, PublishedFundingUndoTaskFactoryLocator>();
builder.AddSingleton <IPublishedFundingUndoTaskFactory, SoftDeletePublishedFundingUndoTaskFactory>();
builder.AddSingleton <IPublishedFundingUndoTaskFactory, HardDeletePublishedFundingUndoTaskFactory>();
builder.AddSingleton <IPublishedFundingUndoCosmosRepository>(ctx =>
{
CosmosDbSettings settings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", settings);
settings.ContainerName = "publishedfunding";
return(new PublishedFundingUndoCosmosRepository(ctx.GetService <IPublishingResiliencePolicies>(),
new CosmosRepository(settings)));
});
builder.AddSingleton <IPublishedFundingUndoBlobStoreRepository>(ctx =>
{
BlobStorageOptions settings = new BlobStorageOptions();
Configuration.Bind("AzureStorageSettings", settings);
settings.ContainerName = "publishedproviderversions";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(settings);
return(new PublishedFundingUndoBlobStoreRepository(new BlobClient(blobContainerRepository),
ctx.GetService <IPublishingResiliencePolicies>(),
ctx.GetService <ILogger>()));
});
builder.AddSingleton <IProducerConsumerFactory, ProducerConsumerFactory>();
builder
.AddSingleton <LocalIBlobClient, LocalBlobClient>((ctx) =>
{
AzureStorageSettings storageSettings = new AzureStorageSettings();
Configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedfunding";
return(new LocalBlobClient(storageSettings));
});
MapperConfiguration resultsConfig = new MapperConfiguration(c =>
{
c.AddProfile <PublishingServiceMappingProfile>();
});
builder.AddSingleton(resultsConfig.CreateMapper());
builder.AddSingleton <IPublishingResiliencePolicies>(ctx =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies
{
SpecificationsRepositoryPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProvidersApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
CalculationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedFundingRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(),
PublishedProviderVersionRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
BlobClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PoliciesApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
ProfilingApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
PublishedIndexSearchResiliencePolicy = PublishedIndexSearchResiliencePolicy.GeneratePublishedIndexSearch(),
PublishedProviderSearchRepository = PublishedIndexSearchResiliencePolicy.GeneratePublishedIndexSearch(),
SpecificationsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
FundingStreamPaymentDatesRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new JobManagementResiliencePolicies()
{
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
});
});
builder.AddSingleton <IPublishedProviderFundingCountProcessor, PublishedProviderFundingCountProcessor>();
builder.AddSingleton <IPublishedProviderFundingCsvDataProcessor, PublishedProviderFundingCsvDataProcessor>();
if (Configuration.IsSwaggerEnabled())
{
builder.ConfigureSwaggerServices(title: "Publishing Microservice API");
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
_ = services.Configure <RecaptchaOptions>(Configuration.GetSection("Recaptcha"))
.Configure <LetsEncryptOptions>(Configuration.GetSection("LetsEncrypt"))
.Configure <BlobStorageOptions>(Configuration.GetSection("AzureBlobStorage"));
blobStorageOptions = Configuration.GetSection("AzureBlobStorage").Get <BlobStorageOptions>();
_ = services.Configure <PasswordHasherOptions>(options => options.CompatibilityMode = PasswordHasherCompatibilityMode.IdentityV2);
_ = services
.AddIdentity <JoinIdentityUser, string>(options => options.Password.ConfigureValidation())
.AddDefaultTokenProviders()
.AddUserStore <MyUserStore>()
.AddRoleStore <MyUserStore>();
_ = services.ConfigureApplicationCookie(AuthenticationConfigurator.SetCookieOptions());
_ = services.AddLogging();
_ = services.AddHttpContextAccessor();
services.TryAddSingleton <IActionContextAccessor, ActionContextAccessor>();
_ = services.AddHttpClient();
_ = services.AddRouting(options => options.LowercaseUrls = true);
var mvc = services
.AddMvc(options =>
{
if (!environment.IsEnvironment("IntegrationTest"))
{
options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute());
}
options.Filters.Add(new SetIsProductionFilterAttribute());
options.Filters.Add(new TypeFilterAttribute(typeof(SetUserDataFilterAttribute)));
//TODO need to fix this
options.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes = true;
})
.AddControllersAsServices()
.AddViewComponentsAsServices();
_ = services.AddAntiforgery(options => options.HeaderName = "X-CSRF-TOKEN-HEADERNAME");
var dataProtection = services.AddDataProtection();
if (blobStorageOptions.BlobStorageConfigured)
{
dataProtection.PersistKeysToAzureBlobStorage(
blobStorageOptions.BlobStorageConnectionString,
"data-protection-keys", "joinrpg-portal-protection-keys");
}
if (environment.IsDevelopment())
{
//That's make local debug more easy
_ = mvc.AddRazorRuntimeCompilation();
}
_ = services.AddAuthorization();
_ = services.AddTransient <IAuthorizationPolicyProvider, AuthPolicyProvider>();
services
.AddAuthentication()
.ConfigureJoinExternalLogins(Configuration.GetSection("Authentication"));
_ = services.AddSwaggerGen(Swagger.ConfigureSwagger);
_ = services.AddApplicationInsightsTelemetry();
_ = services.AddHealthChecks()
.AddSqlServer(Configuration["ConnectionStrings:DefaultConnection"], tags: new[] { "ready" })
.AddCheck <HealthCheckLoadProjects>("Project load", tags: new[] { "ready" })
.AddCheck <HealthCheckBlobStorage>("Blob connect");
services.Configure <ForwardedHeadersOptions>(options =>
{
options.ForwardedHeaders = ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedFor;
options.KnownProxies.Clear();
options.KnownNetworks.Clear();
options.ForwardLimit = 1;
// Allow nearest proxy server to set X-Forwarded-?? header
// Do not white-list servers (It's hard to know them specifically proxy server in cloud)
// It will allow IP-spoofing, if Kestrel is directly exposed to end user
// But it should never happen anyway (we always should be under at least one proxy)
});
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <OnCalcsGenerateAllocationResults>();
builder.AddSingleton <OnCalculationGenerateFailure>();
builder.AddSingleton <ICalculationEngineService, CalculationEngineService>();
builder.AddSingleton <ICalculationEngine, CalculationEngine>();
builder.AddSingleton <IAllocationFactory, AllocationFactory>();
builder.AddSingleton <IJobHelperService, JobHelperService>();
builder.AddSingleton <IProviderSourceDatasetsRepository, ProviderSourceDatasetsRepository>((ctx) =>
{
CosmosDbSettings providerSourceDatasetsCosmosSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", providerSourceDatasetsCosmosSettings);
providerSourceDatasetsCosmosSettings.CollectionName = "providerdatasets";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(providerSourceDatasetsCosmosSettings);
EngineSettings engineSettings = ctx.GetService <EngineSettings>();
return(new ProviderSourceDatasetsRepository(calcsCosmosRepostory, engineSettings));
});
builder.AddSingleton <Services.Calculator.Interfaces.IProviderResultsRepository, Services.CalcEngine.ProviderResultsRepository>((ctx) =>
{
CosmosDbSettings calcResultsDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcResultsDbSettings);
calcResultsDbSettings.CollectionName = "calculationresults";
CosmosRepository calcsCosmosRepostory = new CosmosRepository(calcResultsDbSettings);
ISearchRepository <CalculationProviderResultsIndex> calculationProviderResultsSearchRepository = ctx.GetService <ISearchRepository <CalculationProviderResultsIndex> >();
ISearchRepository <ProviderCalculationResultsIndex> providerCalculationResultsSearchRepository = ctx.GetService <ISearchRepository <ProviderCalculationResultsIndex> >();
ISpecificationsRepository specificationsRepository = ctx.GetService <ISpecificationsRepository>();
ILogger logger = ctx.GetService <ILogger>();
IFeatureToggle featureToggle = ctx.GetService <IFeatureToggle>();
EngineSettings engineSettings = ctx.GetService <EngineSettings>();
return(new Services.CalcEngine.ProviderResultsRepository(
calcsCosmosRepostory,
calculationProviderResultsSearchRepository,
specificationsRepository,
logger,
providerCalculationResultsSearchRepository,
featureToggle,
engineSettings));
});
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("CommonStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
return(new SourceFileRepository(blobStorageOptions));
});
builder
.AddSingleton <ISpecificationsRepository, SpecificationsRepository>();
builder
.AddSingleton <Services.Calculator.Interfaces.ICalculationsRepository, Services.Calculator.CalculationsRepository>();
builder
.AddSingleton <IDatasetAggregationsRepository, DatasetAggregationsRepository>();
builder
.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder
.AddSingleton <ISourceCodeService, SourceCodeService>();
builder.AddCalcsInterServiceClient(config);
builder.AddSpecificationsInterServiceClient(config);
builder.AddJobsInterServiceClient(config);
builder.AddDatasetsInterServiceClient(config);
builder.AddEngineSettings(config);
builder.AddServiceBus(config);
builder.AddCaching(config);
builder.AddApplicationInsights(config, "CalculateFunding.Functions.CalcEngine");
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.CalcEngine");
builder.AddLogging("CalculateFunding.Functions.CalcEngine", config);
builder.AddTelemetry();
builder.AddSearch(config);
builder.AddFeatureToggling(config);
PolicySettings policySettings = builder.GetPolicySettings(config);
CalculatorResiliencePolicies calcResiliencePolicies = CreateResiliencePolicies(policySettings);
builder.AddSingleton <ICalculatorResiliencePolicies>(calcResiliencePolicies);
builder.AddSingleton <IJobHelperResiliencePolicies>(calcResiliencePolicies);
builder.AddSingleton <IValidator <ICalculatorResiliencePolicies>, CalculatorResiliencePoliciesValidator>();
return(builder.BuildServiceProvider());
}
public ProviderVariationsStorageRepository(BlobStorageOptions blobStorageOptions) : base(blobStorageOptions)
{
}
private static IServiceProvider Register(IServiceCollection builder, IConfigurationRoot config)
{
builder.AddSingleton <IUserProfileProvider, UserProfileProvider>();
builder.AddFeatureManagement();
builder.AddSingleton <IConfiguration>(ctx => config);
// 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 <CalcsAddRelationshipToBuildProject>();
builder.AddScoped <OnCalcsInstructAllocationResultsFailure>();
builder.AddScoped <OnCalcsInstructAllocationResults>();
builder.AddScoped <OnCalculationAggregationsJobCompleted>();
builder.AddScoped <OnDataDefinitionChanges>();
builder.AddScoped <OnApplyTemplateCalculations>();
builder.AddScoped <OnApplyTemplateCalculationsFailure>();
builder.AddScoped <OnReIndexSpecificationCalculationRelationships>();
builder.AddScoped <OnReIndexSpecificationCalculationRelationshipsFailure>();
builder.AddScoped <OnDeleteCalculations>();
builder.AddScoped <OnDeleteCalculationsFailure>();
builder.AddScoped <OnUpdateCodeContextCache>();
builder.AddScoped <OnUpdateCodeContextCacheFailure>();
builder.AddScoped <OnApproveAllCalculations>();
builder.AddScoped <OnApproveAllCalculationsFailure>();
}
builder.AddSingleton <IFundingLineRoundingSettings, FundingLineRoundingSettings>();
builder.AddScoped <IApplyTemplateCalculationsService, ApplyTemplateCalculationsService>();
builder.AddSingleton <ICalculationsRepository, CalculationsRepository>((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new CalculationsRepository(resultsRepostory));
});
builder.AddScoped <ICalculationService, CalculationService>()
.AddScoped <IInstructionAllocationJobCreation, InstructionAllocationJobCreation>()
.AddScoped <ICreateCalculationService, CreateCalculationService>();
builder.AddSingleton <ICalculationNameInUseCheck, CalculationNameInUseCheck>();
builder.AddSingleton <ICalculationsSearchService, CalculationSearchService>();
builder.AddSingleton <ICalculationCodeReferenceUpdate, CalculationCodeReferenceUpdate>();
builder.AddSingleton <IValidator <Calculation>, CalculationModelValidator>();
builder.AddScoped <IPreviewService, PreviewService>();
builder.AddSingleton <ICompilerFactory, CompilerFactory>();
//builder.AddSingleton<IDatasetRepository, DatasetRepository>();
builder.AddScoped <IJobService, JobService>();
builder.AddScoped <IApproveAllCalculationsJobAction, ApproveAllCalculationsJobAction>();
builder
.AddSingleton <CSharpCompiler>()
.AddSingleton <VisualBasicCompiler>()
.AddSingleton <VisualBasicSourceFileGenerator>();
builder.AddSingleton <ISourceFileGeneratorProvider, SourceFileGeneratorProvider>();
builder.AddSingleton <IValidator <PreviewRequest>, PreviewRequestModelValidator>();
builder.AddScoped <IBuildProjectsService, BuildProjectsService>();
builder.AddSingleton <IBuildProjectsRepository, BuildProjectsRepository>((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new BuildProjectsRepository(resultsRepostory));
});
builder.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder.AddSingleton <ICancellationTokenProvider, InactiveCancellationTokenProvider>();
builder.AddSingleton <ISourceCodeService, SourceCodeService>();
builder.AddScoped <IDeadletterService, DeadletterService>();
builder.AddScoped <IJobManagement, JobManagement>();
MapperConfiguration calculationsConfig = new MapperConfiguration(c =>
{
c.AddProfile <CalculationsMappingProfile>();
});
builder
.AddSingleton(calculationsConfig.CreateMapper());
builder.AddScoped <IReIndexGraphRepository, ReIndexGraphRepository>();
builder.AddScoped <ISpecificationCalculationAnalysis, SpecificationCalculationAnalysis>();
builder.AddScoped <IReIndexSpecificationCalculationRelationships, ReIndexSpecificationCalculationRelationships>();
builder.AddScoped <ICalculationAnalysis, CalculationAnalysis>();
builder
.AddScoped <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddScoped <ICalculationEngineRunningChecker, CalculationEngineRunningChecker>();
builder.AddScoped <IValidator <CalculationCreateModel>, CalculationCreateModelValidator>();
builder.AddScoped <IApproveAllCalculationsService, ApproveAllCalculationsService>();
builder
.AddScoped <IDatasetReferenceService, DatasetReferenceService>();
builder
.AddScoped <IValidator <CalculationEditModel>, CalculationEditModelValidator>();
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>(ctx =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
config.Bind("AzureStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(blobStorageOptions);
return(new SourceFileRepository(blobContainerRepository));
});
builder.AddSingleton <IVersionRepository <CalculationVersion>, VersionRepository <CalculationVersion> >((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
config.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.ContainerName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new VersionRepository <CalculationVersion>(resultsRepostory, new NewVersionBuilderFactory <CalculationVersion>()));
});
builder.AddFeatureToggling(config);
builder.AddSearch(config);
builder
.AddSingleton <ISearchRepository <CalculationIndex>, SearchRepository <CalculationIndex> >();
builder
.AddSingleton <ISearchRepository <ProviderCalculationResultsIndex>, SearchRepository <ProviderCalculationResultsIndex> >();
builder.AddServiceBus(config, "calcs");
builder.AddScoped <ICalculationsFeatureFlag, CalculationsFeatureFlag>();
builder.AddScoped <IGraphRepository, GraphRepository>();
builder.AddScoped <IUserProfileProvider, UserProfileProvider>();
builder.AddProvidersInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddSpecificationsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddDatasetsInterServiceClient(config);
builder.AddJobsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddGraphInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddPoliciesInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddResultsInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCalcEngineInterServiceClient(config, handlerLifetime: Timeout.InfiniteTimeSpan);
builder.AddCaching(config);
builder.AddEngineSettings(config);
builder.AddApplicationInsightsTelemetryClient(config, "CalculateFunding.Functions.Calcs");
builder.AddApplicationInsightsServiceName(config, "CalculateFunding.Functions.Calcs");
builder.AddLogging("CalculateFunding.Functions.Calcs");
builder.AddTelemetry();
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(config);
AsyncBulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
ResiliencePolicies resiliencePolicies = CreateResiliencePolicies(totalNetworkRequestsPolicy);
builder.AddSingleton <ICalcsResiliencePolicies>(resiliencePolicies);
builder.AddSingleton <IJobManagementResiliencePolicies>((ctx) => new JobManagementResiliencePolicies()
{
JobsApiClient = resiliencePolicies.JobsApiClient,
});
builder.AddScoped <ICodeContextCache, CodeContextCache>()
.AddScoped <ICodeContextBuilder, CodeContextBuilder>();
return(builder.BuildServiceProvider());
}
private static void RegisterSpecificationServiceComponents(IServiceCollection serviceCollection, IConfiguration configuration)
{
serviceCollection.AddSingleton(ctx => configuration);
serviceCollection.AddScoped <ISpecificationPublishingService, SpecificationPublishingService>();
serviceCollection.AddSingleton <IProviderFundingPublishingService, ProviderFundingPublishingService>();
serviceCollection.AddSingleton <IHealthChecker, ProviderFundingPublishingService>();
serviceCollection.AddSingleton <ISpecificationIdServiceRequestValidator, PublishSpecificationValidator>();
serviceCollection.AddSingleton <IPublishedProviderIdsServiceRequestValidator, PublishedProviderIdsValidator>();
serviceCollection.AddSingleton <IPublishedProviderFundingService, PublishedProviderFundingService>();
serviceCollection.AddSingleton <ISpecificationService, SpecificationService>();
serviceCollection.AddSingleton <ICalculationsService, CalculationsService>();
serviceCollection.AddSingleton <IProviderService, ProviderService>();
serviceCollection.AddSingleton <IPublishedProviderIndexerService, PublishedProviderIndexerService>();
serviceCollection.AddSingleton <IPublishProviderExclusionCheck, PublishedProviderExclusionCheck>();
serviceCollection.AddSingleton <IFundingLineValueOverride, FundingLineValueOverride>();
serviceCollection.AddSingleton <IPublishedFundingDateService, PublishedFundingDateService>();
serviceCollection.AddSingleton <IPublishedFundingDataService, PublishedFundingDataService>();
serviceCollection.AddSingleton <IPublishedProviderContentPersistanceService, PublishedProviderContentPersistanceService>();
serviceCollection.AddSingleton <ICreateRefreshFundingJobs, RefreshFundingJobCreation>();
serviceCollection.AddSingleton <ICreateApproveAllFundingJobs, ApproveAllFundingJobCreation>();
serviceCollection.AddSingleton <ICreateApproveBatchFundingJobs, ApproveBatchFundingJobCreation>();
serviceCollection.AddSingleton <ICreateAllPublishProviderFundingJobs, AllPublishProviderFundingJobCreation>();
serviceCollection.AddSingleton <ICreatePublishIntegrityJob, PublishIntegrityCheckJobCreation>();
serviceCollection.AddSingleton <ICreateBatchPublishProviderFundingJobs, BatchPublishProviderFundingJobCreation>();
serviceCollection.AddSingleton <ICreateDeleteSpecificationJobs, DeleteSpecificationJobCreation>();
serviceCollection.AddSingleton <ICreateDeletePublishedProvidersJobs, DeletePublishedProvidersJobCreation>();
serviceCollection.AddSingleton <IPublishedFundingStatusUpdateService, PublishedFundingStatusUpdateService>();
serviceCollection.AddSingleton <IDeleteSpecifications, DeleteSpecificationService>();
serviceCollection.AddSingleton <IDeletePublishedProvidersService, DeletePublishedProvidersService>();
serviceCollection.AddSingleton <IDeleteFundingSearchDocumentsService, DeleteFundingSearchDocumentsService>();
serviceCollection.AddSingleton <IDeselectSpecificationForFundingService, DeselectSpecificationForFundingService>();
serviceCollection.AddSingleton <IDeletePublishedFundingBlobDocumentsService, DeletePublishedFundingBlobDocumentsService>();
serviceCollection.AddSingleton <IPublishedProviderFundingStructureService, PublishedProviderFundingStructureService>();
PolicySettings policySettings = ServiceCollectionExtensions.GetPolicySettings(configuration);
OrganisationGroupResiliencePolicies organisationResiliencePolicies = CreateResiliencePolicies(policySettings);
serviceCollection.AddSingleton <IOrganisationGroupResiliencePolicies>(organisationResiliencePolicies);
serviceCollection.AddSingleton <IOrganisationGroupTargetProviderLookup, OrganisationGroupTargetProviderLookup>();
serviceCollection.AddSingleton <IOrganisationGroupGenerator, OrganisationGroupGenerator>();
serviceCollection.AddSingleton <IJobsRunning, JobsRunning>();
serviceCollection.AddSingleton <ICalculationPrerequisiteCheckerService, CalculationPrerequisiteCheckerService>();
serviceCollection.AddScoped <IPrerequisiteCheckerLocator, PrerequisiteCheckerLocator>();
serviceCollection.AddScoped <IPrerequisiteChecker, RefreshPrerequisiteChecker>();
serviceCollection.AddScoped <IPrerequisiteChecker, PublishAllPrerequisiteChecker>();
serviceCollection.AddScoped <IPrerequisiteChecker, PublishBatchPrerequisiteChecker>();
serviceCollection.AddScoped <IPrerequisiteChecker, ApproveAllProvidersPrerequisiteChecker>();
serviceCollection.AddScoped <IPrerequisiteChecker, ApproveBatchProvidersPrerequisiteChecker>();
serviceCollection.AddSingleton <IPublishedFundingChangeDetectorService, PublishedFundingChangeDetectorService>();
serviceCollection.AddSingleton <IPublishedFundingGenerator, PublishedFundingGenerator>();
SearchRepositorySettings searchSettings = new SearchRepositorySettings
{
SearchServiceName = configuration.GetValue <string>("SearchServiceName"),
SearchKey = configuration.GetValue <string>("SearchServiceKey")
};
serviceCollection.AddSingleton(searchSettings);
serviceCollection.AddSingleton <ISearchRepository <PublishedFundingIndex>, SearchRepository <PublishedFundingIndex> >();
serviceCollection.AddSingleton <IPublishedFundingContentsPersistanceService>((ctx) =>
{
BlobStorageOptions storageSettings = new BlobStorageOptions();
configuration.Bind("AzureStorageSettings", storageSettings);
storageSettings.ContainerName = "publishedfunding";
IBlobContainerRepository blobContainerRepository = new BlobContainerRepository(storageSettings);
IBlobClient blobClient = new BlobClient(blobContainerRepository);
IPublishedFundingContentsGeneratorResolver publishedFundingContentsGeneratorResolver = ctx.GetService <IPublishedFundingContentsGeneratorResolver>();
ISearchRepository <PublishedFundingIndex> searchRepository = ctx.GetService <ISearchRepository <PublishedFundingIndex> >();
IPublishingResiliencePolicies publishingResiliencePolicies = ctx.GetService <IPublishingResiliencePolicies>();
return(new PublishedFundingContentsPersistanceService(publishedFundingContentsGeneratorResolver,
blobClient,
publishingResiliencePolicies,
ctx.GetService <IPublishingEngineOptions>()));
});
}
public void RegisterComponents(IServiceCollection builder)
{
builder
.AddSingleton <ICalculationsRepository, CalculationsRepository>();
builder
.AddSingleton <ICalculationService, CalculationService>()
.AddSingleton <IHealthChecker, CalculationService>();
builder
.AddSingleton <ICalculationCodeReferenceUpdate, CalculationCodeReferenceUpdate>()
.AddSingleton <ITokenChecker, TokenChecker>();
builder
.AddSingleton <ICalculationsSearchService, CalculationSearchService>()
.AddSingleton <IHealthChecker, CalculationSearchService>();
builder
.AddSingleton <IValidator <Calculation>, CalculationModelValidator>();
builder
.AddSingleton <IPreviewService, PreviewService>()
.AddSingleton <IHealthChecker, PreviewService>();
builder
.AddSingleton <ICompilerFactory, CompilerFactory>();
builder
.AddSingleton <CSharpCompiler>()
.AddSingleton <VisualBasicCompiler>()
.AddSingleton <VisualBasicSourceFileGenerator>();
builder
.AddSingleton <ISourceFileGeneratorProvider, SourceFileGeneratorProvider>();
builder
.AddSingleton <IValidator <PreviewRequest>, PreviewRequestModelValidator>();
builder
.AddSingleton <IProviderResultsRepository, ProviderResultsRepository>()
.AddSingleton <IHealthChecker, ProviderResultsRepository>();
builder
.AddSingleton <ISpecificationRepository, SpecificationRepository>();
builder
.AddSingleton <IBuildProjectsService, BuildProjectsService>()
.AddSingleton <IHealthChecker, BuildProjectsService>();
builder
.AddSingleton <IBuildProjectsRepository, BuildProjectsRepository>()
.AddSingleton <IHealthChecker, BuildProjectsRepository>();
builder
.AddSingleton <ICodeMetadataGeneratorService, ReflectionCodeMetadataGenerator>();
builder
.AddSingleton <IDatasetRepository, DatasetRepository>();
builder.AddSingleton <ISourceCodeService, SourceCodeService>();
builder
.AddSingleton <IDatasetDefinitionFieldChangesProcessor, DatasetDefinitionFieldChangesProcessor>();
builder.AddSingleton <ISourceFileRepository, SourceFileRepository>((ctx) =>
{
BlobStorageOptions blobStorageOptions = new BlobStorageOptions();
Configuration.Bind("CommonStorageSettings", blobStorageOptions);
blobStorageOptions.ContainerName = "source";
return(new SourceFileRepository(blobStorageOptions));
});
builder.AddSingleton <IVersionRepository <CalculationVersion>, VersionRepository <CalculationVersion> >((ctx) =>
{
CosmosDbSettings calcsVersioningDbSettings = new CosmosDbSettings();
Configuration.Bind("CosmosDbSettings", calcsVersioningDbSettings);
calcsVersioningDbSettings.CollectionName = "calcs";
CosmosRepository resultsRepostory = new CosmosRepository(calcsVersioningDbSettings);
return(new VersionRepository <CalculationVersion>(resultsRepostory));
});
builder
.AddSingleton <ICancellationTokenProvider, HttpContextCancellationProvider>();
builder.AddUserProviderFromRequest();
builder.AddCosmosDb(Configuration);
builder.AddSearch(Configuration);
builder.AddServiceBus(Configuration);
builder.AddResultsInterServiceClient(Configuration);
builder.AddSpecificationsInterServiceClient(Configuration);
builder.AddDatasetsInterServiceClient(Configuration);
builder.AddJobsInterServiceClient(Configuration);
builder.AddCaching(Configuration);
builder.AddApplicationInsights(Configuration, "CalculateFunding.Api.Calcs");
builder.AddApplicationInsightsTelemetryClient(Configuration, "CalculateFunding.Api.Calcs");
builder.AddLogging("CalculateFunding.Api.Calcs");
builder.AddTelemetry();
builder.AddEngineSettings(Configuration);
builder.AddFeatureToggling(Configuration);
builder.AddPolicySettings(Configuration);
builder.AddSingleton <ICalcsResiliencePolicies>((ctx) =>
{
PolicySettings policySettings = ctx.GetService <PolicySettings>();
BulkheadPolicy totalNetworkRequestsPolicy = ResiliencePolicyHelpers.GenerateTotalNetworkRequestsPolicy(policySettings);
return(new ResiliencePolicies
{
CalculationsRepository = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
CalculationsSearchRepository = SearchResiliencePolicyHelper.GenerateSearchPolicy(totalNetworkRequestsPolicy),
CacheProviderPolicy = ResiliencePolicyHelpers.GenerateRedisPolicy(totalNetworkRequestsPolicy),
CalculationsVersionsRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
SpecificationsRepositoryPolicy = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
BuildProjectRepositoryPolicy = CosmosResiliencePolicyHelper.GenerateCosmosPolicy(totalNetworkRequestsPolicy),
MessagePolicy = ResiliencePolicyHelpers.GenerateMessagingPolicy(totalNetworkRequestsPolicy),
JobsApiClient = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
SourceFilesRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy),
DatasetsRepository = ResiliencePolicyHelpers.GenerateRestRepositoryPolicy(totalNetworkRequestsPolicy)
});
});
builder.AddApiKeyMiddlewareSettings((IConfigurationRoot)Configuration);
builder.AddHttpContextAccessor();
builder.AddHealthCheckMiddleware();
}
