public PublishedProviderStatusService( ISpecificationIdServiceRequestValidator validator, ISpecificationService specificationService, IPublishedFundingRepository publishedFundingRepository, IPublishingResiliencePolicies publishingResiliencePolicies, IPublishedProviderFundingCountProcessor fundingCountProcessor, IPublishedProviderFundingCsvDataProcessor fundingCsvDataProcessor, ICsvUtils csvUtils, IBlobClient blobClient) { Guard.ArgumentNotNull(validator, nameof(validator)); Guard.ArgumentNotNull(specificationService, nameof(specificationService)); Guard.ArgumentNotNull(publishedFundingRepository, nameof(publishedFundingRepository)); Guard.ArgumentNotNull(publishingResiliencePolicies, nameof(publishingResiliencePolicies)); Guard.ArgumentNotNull(publishingResiliencePolicies.PublishedFundingRepository, nameof(publishingResiliencePolicies.PublishedFundingRepository)); Guard.ArgumentNotNull(publishingResiliencePolicies.SpecificationsRepositoryPolicy, nameof(publishingResiliencePolicies.SpecificationsRepositoryPolicy)); Guard.ArgumentNotNull(publishingResiliencePolicies.BlobClient, nameof(publishingResiliencePolicies.BlobClient)); Guard.ArgumentNotNull(fundingCountProcessor, nameof(fundingCountProcessor)); Guard.ArgumentNotNull(fundingCsvDataProcessor, nameof(fundingCsvDataProcessor)); Guard.ArgumentNotNull(csvUtils, nameof(csvUtils)); Guard.ArgumentNotNull(blobClient, nameof(blobClient)); _validator = validator; _specificationService = specificationService; _publishedFundingRepository = publishedFundingRepository; _fundingCountProcessor = fundingCountProcessor; _publishedFundingRepositoryResilience = publishingResiliencePolicies.PublishedFundingRepository; _specificationsRepositoryPolicy = publishingResiliencePolicies.SpecificationsRepositoryPolicy; _blobClientPolicy = publishingResiliencePolicies.BlobClient; _fundingCsvDataProcessor = fundingCsvDataProcessor; _csvUtils = csvUtils; _blobClient = blobClient; }
public async Task GetProviderFundingVersionsBody_GivenGetBlobReferenceCausesException_LogsAndReturnsInternalServerError() { //Arrange ILogger logger = CreateLogger(); IBlobClient blobClient = CreateBlobClient(); blobClient .BlobExistsAsync(blobName) .Returns(true); blobClient .GetBlobReferenceFromServerAsync(blobName) .Throws(new Exception()); string errorMessage = $"Failed to fetch blob '{blobName}' from azure storage"; ProviderFundingVersionService service = CreateProviderFundingVersionService(logger, blobClient); //Act IActionResult result = await service.GetProviderFundingVersion(providerFundingVersion); //Assert result .Should() .BeAssignableTo <InternalServerErrorResult>() .Which .Value .Should() .Be(errorMessage); logger .Received(1) .Error(Arg.Any <Exception>(), Arg.Is(errorMessage)); }
protected CustomFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor) { if (repositories == null) { throw new ArgumentNullException("repositories"); } if (blobClient == null) { throw new ArgumentNullException("blobClient"); } if (dataTableBinder == null) { throw new ArgumentNullException("dataTableBinder"); } if (auditor == null) { throw new ArgumentNullException("auditor"); } RepositoryContainer = repositories; CustomDataOriginRepository = repositories.Obtain <ICustomDataOriginRepository>(); CustomFieldCategoryRepository = repositories.Obtain <ICustomFieldCategoryRepository>(); CustomFieldRepository = repositories.Obtain <ICustomFieldRepository>(); CustomFieldTypeRepository = repositories.Obtain <ICustomFieldTypeRepository>(); CustomFieldValueRepository = repositories.Obtain <ICustomFieldValueRepository>(); StudentRepository = repositories.Obtain <IStudentRepository>(); ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>(); DataFileBlobContainer = blobClient.CreateContainer(DataFileBlobContainerName); DataTableBinder = dataTableBinder; Auditor = auditor; }
public async Task IsHealthOk_ReturnsAsExpected(bool blobOk, string blobMessage) { //Arrange IBlobClient blobClient = Substitute.For <IBlobClient>(); blobClient .IsHealthOk() .Returns((blobOk, blobMessage)); ProviderFundingVersionService providerFundingVersionService = CreateProviderFundingVersionService(blobClient: blobClient); ServiceHealth health = await providerFundingVersionService.IsHealthOk(); health.Name .Should() .Be(nameof(ProviderFundingVersionService)); health.Dependencies.Count.Should().Be(1); health .Dependencies .Count(x => x.HealthOk == blobOk && x.Message == blobMessage) .Should() .Be(1); }
public void SetUp() { IPublishedFundingContentsGeneratorResolver publishedFundingContentsGeneratorResolver = Substitute.For <IPublishedFundingContentsGeneratorResolver>(); IConfiguration configuration = Substitute.For <IConfiguration>(); _blobClient = Substitute.For <IBlobClient>(); _publishedFundingContentsGenerator = Substitute.For <IPublishedFundingContentsGenerator>(); _templateMetadataContents = new Common.TemplateMetadata.Models.TemplateMetadataContents { SchemaVersion = _schema }; publishedFundingContentsGeneratorResolver.GetService(Arg.Is(_schema)) .Returns(_publishedFundingContentsGenerator); _publishedFundingContentsPersistanceService = new PublishedFundingContentsPersistanceService( publishedFundingContentsGeneratorResolver, _blobClient, PublishingResilienceTestHelper.GenerateTestPolicies(), new PublishingEngineOptions(configuration)); _cloudBlob = Substitute.For <ICloudBlob>(); _publishedFundingPeriod = new PublishedFundingPeriod { Type = PublishedFundingPeriodType.AY, Period = "123" }; }
public void SetUp() { _specificationId = NewRandomString(); _validationResult = new ValidationResult(); _validator = Substitute.For <ISpecificationIdServiceRequestValidator>(); _validator.Validate(_specificationId) .Returns(_validationResult); _specificationService = Substitute.For <ISpecificationService>(); _publishedFundingRepository = Substitute.For <IPublishedFundingRepository>(); _fundingCountProcessor = Substitute.For <IPublishedProviderFundingCountProcessor>(); _fundingCsvDataProcessor = Substitute.For <IPublishedProviderFundingCsvDataProcessor>(); _csvUtils = Substitute.For <ICsvUtils>(); _blobClient = Substitute.For <IBlobClient>(); _service = new PublishedProviderStatusService(_validator, _specificationService, _publishedFundingRepository, new ResiliencePolicies { PublishedFundingRepository = Polly.Policy.NoOpAsync(), SpecificationsRepositoryPolicy = Polly.Policy.NoOpAsync(), BlobClient = Polly.Policy.NoOpAsync() }, _fundingCountProcessor, _fundingCsvDataProcessor, _csvUtils, _blobClient); }
protected BasePublishingCsvGenerator( IJobManagement jobManagement, IFileSystemAccess fileSystemAccess, IBlobClient blobClient, IPublishingResiliencePolicies policies, ICsvUtils csvUtils, ILogger logger, IFileSystemCacheSettings fileSystemCacheSettings, IPublishedProviderCsvTransformServiceLocator publishedProviderCsvTransformServiceLocator) : base(jobManagement, logger) { Guard.ArgumentNotNull(fileSystemAccess, nameof(fileSystemAccess)); Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(policies?.BlobClient, nameof(policies.BlobClient)); Guard.ArgumentNotNull(csvUtils, nameof(csvUtils)); Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(fileSystemCacheSettings, nameof(fileSystemCacheSettings)); Guard.ArgumentNotNull(publishedProviderCsvTransformServiceLocator, nameof(publishedProviderCsvTransformServiceLocator)); _fileSystemAccess = fileSystemAccess; _blobClient = blobClient; _blobClientPolicy = policies.BlobClient; _csvUtils = csvUtils; _fileSystemCacheSettings = fileSystemCacheSettings; _publishedProviderCsvTransformServiceLocator = publishedProviderCsvTransformServiceLocator; _logger = logger; }
public DefinitionsService( ILogger logger, IDatasetRepository dataSetsRepository, ISearchRepository <DatasetDefinitionIndex> datasetDefinitionSearchRepository, IDatasetsResiliencePolicies datasetsResiliencePolicies, IExcelWriter <DatasetDefinition> excelWriter, IBlobClient blobClient, IDefinitionChangesDetectionService definitionChangesDetectionService, IMessengerService messengerService) { Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(dataSetsRepository, nameof(dataSetsRepository)); Guard.ArgumentNotNull(datasetDefinitionSearchRepository, nameof(datasetDefinitionSearchRepository)); Guard.ArgumentNotNull(datasetsResiliencePolicies, nameof(datasetsResiliencePolicies)); Guard.ArgumentNotNull(excelWriter, nameof(excelWriter)); Guard.ArgumentNotNull(definitionChangesDetectionService, nameof(definitionChangesDetectionService)); Guard.ArgumentNotNull(messengerService, nameof(messengerService)); _logger = logger; _datasetsRepository = dataSetsRepository; _datasetDefinitionSearchRepository = datasetDefinitionSearchRepository; _datasetDefinitionSearchRepositoryPolicy = datasetsResiliencePolicies.DatasetDefinitionSearchRepository; _datasetsRepositoryPolicy = datasetsResiliencePolicies.DatasetRepository; _excelWriter = excelWriter; _blobClient = blobClient; _blobClientPolicy = datasetsResiliencePolicies.BlobClient; _definitionChangesDetectionService = definitionChangesDetectionService; _messengerService = messengerService; }
public BlobRepository(IServiceProvider serviceProvider, ILoggerFactory loggerFactory) { logger = loggerFactory.CreateLogger <BlobRepository <T> >(); var configuration = serviceProvider.GetRequiredService <IConfiguration>(); var storageSettings = configuration.GetConfiguredSettings <StorageDataSettings>(); var prop = storageSettings.GetType().GetProperties() .FirstOrDefault(p => { var customAttr = p.GetCustomAttribute <MappedModelAttribute>(); if (customAttr != null && customAttr.ModelType == typeof(T)) { return(true); } return(false); }); if (prop == null) { throw new Exception($"Missing backend mapping for model: {typeof(T).Name}"); } var blobStorageSettings = prop.GetValue(storageSettings) as BlobStorageSettings; if (blobStorageSettings == null) { throw new Exception($"Missing backend mapping for model: {typeof(T).Name}"); } client = new BlobClient(serviceProvider, loggerFactory, new OptionsWrapper <BlobStorageSettings>(blobStorageSettings)); }
public FundingLineCsvGenerator(IFundingLineCsvTransformServiceLocator transformServiceLocator, IPublishedFundingPredicateBuilder predicateBuilder, IBlobClient blobClient, IFileSystemAccess fileSystemAccess, IFileSystemCacheSettings fileSystemCacheSettings, IFundingLineCsvBatchProcessorServiceLocator batchProcessorServiceLocator, IPublishingResiliencePolicies policies, IJobManagement jobManagement, ILogger logger) : base(jobManagement, logger) { Guard.ArgumentNotNull(logger, nameof(logger)); Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(transformServiceLocator, nameof(transformServiceLocator)); Guard.ArgumentNotNull(predicateBuilder, nameof(predicateBuilder)); Guard.ArgumentNotNull(fileSystemAccess, nameof(fileSystemAccess)); Guard.ArgumentNotNull(fileSystemCacheSettings, nameof(fileSystemCacheSettings)); Guard.ArgumentNotNull(policies?.BlobClient, nameof(policies.BlobClient)); Guard.ArgumentNotNull(batchProcessorServiceLocator, nameof(batchProcessorServiceLocator)); _logger = logger; _batchProcessorServiceLocator = batchProcessorServiceLocator; _blobClient = blobClient; _transformServiceLocator = transformServiceLocator; _fileSystemAccess = fileSystemAccess; _fileSystemCacheSettings = fileSystemCacheSettings; _blobClientPolicy = policies.BlobClient; }
public static async Task ProvisionResources(this IBlobClient client, IHost host, CancellationToken token = default) { var configuration = host.Services.GetRequiredService <IConfiguration>(); switch (client) { case S3BlobClient _: if (Environment.GetEnvironmentVariable("MINIO_SERVER") != null) { var s3Client = host.Services.GetRequiredService <AmazonS3Client>(); var s3Options = new S3BlobClientOptions(); configuration.GetSection(nameof(S3BlobClientOptions)).Bind(s3Options); var buckets = await s3Client.ListBucketsAsync(token); if (!buckets.Buckets.Exists(bucket => bucket.BucketName == s3Options.Buckets[WellknownBuckets.ImportLegacyBucket])) { await s3Client.PutBucketAsync(s3Options.Buckets[WellknownBuckets.ImportLegacyBucket], token); } } break; case FileBlobClient _: var fileOptions = new FileBlobClientOptions(); configuration.GetSection(nameof(FileBlobClientOptions)).Bind(fileOptions); if (!Directory.Exists(fileOptions.Directory)) { Directory.CreateDirectory(fileOptions.Directory); } break; } }
protected CustomFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor) { if (repositories == null) { throw new ArgumentNullException("repositories"); } if (blobClient == null) { throw new ArgumentNullException("blobClient"); } if (dataTableBinder == null) { throw new ArgumentNullException("dataTableBinder"); } if (auditor == null) { throw new ArgumentNullException("auditor"); } RepositoryContainer = repositories; CustomDataOriginRepository = repositories.Obtain<ICustomDataOriginRepository>(); CustomFieldCategoryRepository = repositories.Obtain<ICustomFieldCategoryRepository>(); CustomFieldRepository = repositories.Obtain<ICustomFieldRepository>(); CustomFieldTypeRepository = repositories.Obtain<ICustomFieldTypeRepository>(); CustomFieldValueRepository = repositories.Obtain<ICustomFieldValueRepository>(); StudentRepository = repositories.Obtain<IStudentRepository>(); ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>(); DataFileBlobContainer = blobClient.CreateContainer(DataFileBlobContainerName); DataTableBinder = dataTableBinder; Auditor = auditor; }
public ProvidersStepContext(IProviderService service, IProvidersApiClient client, IBlobClient blobClient) { _blobClient = blobClient; Service = service; Client = client; }
public PublishedFundingRepositoryStepContext(ICosmosRepository cosmosRepo, IBlobClient blobRepo, IPublishedFundingRepository publishedFundingRepository) { CosmosRepo = cosmosRepo; _blobRepo = blobRepo; _publishedFundingRepository = publishedFundingRepository; }
public HomeController(IBlobClient blobClient, IModelCreator modelCreator, IEloCalulator eloCalulator, ITeamGenerator teamGenerator, ITrendCalculator trendCalculator) { this.blobClient = blobClient; this.modelCreator = modelCreator; this.eloCalulator = eloCalulator; this.teamGenerator = teamGenerator; this.trendCalculator = trendCalculator; }
protected ErrorRecorder(IPublishingResiliencePolicies resiliencePolicies, IBlobClient blobClient) { Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, nameof(resiliencePolicies.BlobClient)); _resiliencePolicy = resiliencePolicies.BlobClient; _blobClient = blobClient; }
public Blob(string blobName, IBlobClient blobClient, IBlobContainer container, IBlobDirectory blobDirectory) { _blobName = blobName; _exists = false; _blobContainer = container; _blobClient = blobClient; _blobDirectory = blobDirectory; }
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundAndHasNewResults_CreatesNewMessage() { //Arrange IEnumerable <SpecModel.SpecificationSummary> specificationSummaries = new[] { new SpecModel.SpecificationSummary { Id = specificationId } }; ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient(); specificationsApiClient .GetSpecificationSummaries() .Returns(new ApiResponse <IEnumerable <SpecModel.SpecificationSummary> >(HttpStatusCode.OK, specificationSummaries)); ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository(); calculationResultsRepository .CheckHasNewResultsForSpecificationIdAndTime( Arg.Is(specificationId), Arg.Any <DateTimeOffset>()) .Returns(true); ILogger logger = CreateLogger(); IJobManagement jobManagement = CreateJobManagement(); IBlobClient blobClient = CreateBlobClient(); blobClient .DoesBlobExistAsync($"{CalculationResultsReportFilePrefix}-{specificationId}", CalcsResultsContainerName) .Returns(true); ResultsService resultsService = CreateResultsService( logger, specificationsApiClient: specificationsApiClient, resultsRepository: calculationResultsRepository, jobManagement: jobManagement, blobClient: blobClient); //Act await resultsService.QueueCsvGenerationMessages(); //Assert await jobManagement .Received(1) .QueueJob( Arg.Is <JobCreateModel>(_ => _.JobDefinitionId == JobConstants.DefinitionNames.GenerateCalcCsvResultsJob && _.Properties["specification-id"] == specificationId)); logger .Received() .Information($"Found new calculation results for specification id '{specificationId}'"); }
public BlobCache(IServiceProvider serviceProvider, ILoggerFactory loggerFactory) { logger = loggerFactory.CreateLogger<BlobCache>(); appTelemetry = serviceProvider.GetRequiredService<IAppTelemetry>(); var configuration = serviceProvider.GetRequiredService<IConfiguration>(); cacheSettings = configuration.GetConfiguredSettings<CacheSettings>(); blobClient = new BlobClient(serviceProvider, loggerFactory, new OptionsWrapper<BlobStorageSettings>(cacheSettings.BlobCache)); }
public async Task Run(IDictionary <string, object> parameters) { IBlobClient client = _blobClientFactory.CreateBlobClient(); IBlobContainer container = client.GetContainerReference(_containerName); await container.CreateIfNotExistsAsync((BlobRequestOptions)parameters["options"]); IBlockBlob blob = container.GetBlockBlobReference((string)parameters["blobPath"]); await blob.UploadFromFileAsync((string)parameters["filePath"], (string)parameters["contentType"]); }
private static async Task <ApiResourceCollection> GetApiCollectionAsync(IBlobClient blobClient) { _ = blobClient ?? throw new ArgumentNullException(nameof(blobClient)); var container = blobClient.GetContainer(ApiContainer); var file = await container.GetItemAsync <ApiResourceCollection>(ApiFile); return(file.Item); }
public BatchUploadReader(IBlobClient blobClient, IPublishingResiliencePolicies resiliencePolicies) { Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient"); _blobClient = blobClient; _blobResilience = resiliencePolicies.BlobClient; }
public BatchUploadReaderFactory(IBlobClient blobClient, IPublishingResiliencePolicies resiliencePolicies) { Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies)); _blobClient = blobClient; _resiliencePolicies = resiliencePolicies; }
public BatchCreator(IConfiguration configuration, ILoggerFactory loggerFactory, IAppTelemetry appTelemetry, IBlobClient blobClient, IRangeHelper <TField> rangeHelper) { _batchSetting = configuration.GetConfiguredSettings <BatchSetting <TField> >(); _logger = loggerFactory.CreateLogger <BatchCreator <TField> >(); _appTelemetry = appTelemetry; _blobClient = blobClient; _rangeHelper = rangeHelper; _getBlobName = t => $"{_batchSetting.Name}-{t.Sequence}"; }
private void Cleanup() { IBlobClient cleanupClient = AzureBlobClientFactory.Create(); foreach (string containerName in ContainersToClean) { IBlobContainer container = cleanupClient.CreateContainer(containerName); CleanupContainer(container); } }
public PublishedProviderStepContext(IProviderService service, IProvidersApiClient client, ISearchRepository <PublishedProviderIndex> searchRepository, IBlobClient blobClient) { _searchRepository = searchRepository; _blobClient = blobClient; Service = service; Client = client; }
public ResultsService(ILogger logger, IFeatureToggle featureToggle, ICalculationResultsRepository resultsRepository, IMapper mapper, ISearchRepository <ProviderIndex> searchRepository, ITelemetry telemetry, IProviderSourceDatasetRepository providerSourceDatasetRepository, ISearchRepository <ProviderCalculationResultsIndex> calculationProviderResultsSearchRepository, ISpecificationsRepository specificationsRepository, IResultsResiliencePolicies resiliencePolicies, IProviderImportMappingService providerImportMappingService, ICacheProvider cacheProvider, IMessengerService messengerService, ICalculationsRepository calculationRepository, IValidator <MasterProviderModel> masterProviderModelValidator, IBlobClient blobClient) { Guard.ArgumentNotNull(resultsRepository, nameof(resultsRepository)); Guard.ArgumentNotNull(mapper, nameof(mapper)); Guard.ArgumentNotNull(searchRepository, nameof(searchRepository)); Guard.ArgumentNotNull(telemetry, nameof(telemetry)); Guard.ArgumentNotNull(providerSourceDatasetRepository, nameof(providerSourceDatasetRepository)); Guard.ArgumentNotNull(calculationProviderResultsSearchRepository, nameof(calculationProviderResultsSearchRepository)); Guard.ArgumentNotNull(specificationsRepository, nameof(specificationsRepository)); Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies)); Guard.ArgumentNotNull(providerImportMappingService, nameof(providerImportMappingService)); Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider)); Guard.ArgumentNotNull(messengerService, nameof(messengerService)); Guard.ArgumentNotNull(calculationRepository, nameof(calculationRepository)); Guard.ArgumentNotNull(masterProviderModelValidator, nameof(masterProviderModelValidator)); Guard.ArgumentNotNull(featureToggle, nameof(featureToggle)); Guard.ArgumentNotNull(blobClient, nameof(blobClient)); _logger = logger; _resultsRepository = resultsRepository; _mapper = mapper; _searchRepository = searchRepository; _telemetry = telemetry; _providerSourceDatasetRepository = providerSourceDatasetRepository; _calculationProviderResultsSearchRepository = calculationProviderResultsSearchRepository; _resultsRepositoryPolicy = resiliencePolicies.ResultsRepository; _specificationsRepository = specificationsRepository; _resultsSearchRepositoryPolicy = resiliencePolicies.ResultsSearchRepository; _specificationsRepositoryPolicy = resiliencePolicies.SpecificationsRepository; _providerImportMappingService = providerImportMappingService; _cacheProvider = cacheProvider; _messengerService = messengerService; _calculationRepository = calculationRepository; _masterProviderModelValidator = masterProviderModelValidator; _calculationsRepositoryPolicy = resiliencePolicies.CalculationsRepository; _featureToggle = featureToggle; _blobClient = blobClient; _blobClientPolicy = resiliencePolicies.CsvBlobPolicy; }
public BatchUploadQueryService(IBlobClient blobClient, IPublishingResiliencePolicies resiliencePolicies, ILogger logger) { Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient"); Guard.ArgumentNotNull(logger, nameof(logger)); _blobClient = blobClient; _blobResilience = resiliencePolicies.BlobClient; _logger = logger; }
public PublishedFundingUndoBlobStoreRepository(IBlobClient blobClient, IPublishingResiliencePolicies resiliencePolicies, ILogger logger) { Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient"); Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(logger, nameof(logger)); _resilience = resiliencePolicies.BlobClient; _blobClient = blobClient; _logger = logger; }
public DeletePublishedFundingBlobDocumentsService(IPublishingResiliencePolicies resiliencePolicies, IBlobClient blobClient, ILogger logger) { Guard.ArgumentNotNull(resiliencePolicies?.BlobClient, "resiliencePolicies.BlobClient"); Guard.ArgumentNotNull(blobClient, nameof(blobClient)); Guard.ArgumentNotNull(logger, nameof(logger)); _blobClientPolicy = resiliencePolicies.BlobClient; _blobClient = blobClient; _logger = logger; }
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundButNoResults_DoesNotCreateNewMessages() { //Arrange IEnumerable <SpecModel.SpecificationSummary> specificationSummaries = new[] { new SpecModel.SpecificationSummary { Id = "spec-1" } }; ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient(); specificationsApiClient .GetSpecificationSummaries() .Returns(new ApiResponse <IEnumerable <SpecModel.SpecificationSummary> >(HttpStatusCode.OK, specificationSummaries)); ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository(); calculationResultsRepository .ProviderHasResultsBySpecificationId( Arg.Is("spec-1")) .Returns(false); IBlobClient blobClient = CreateBlobClient(); blobClient .DoesBlobExistAsync($"{CalculationResultsReportFilePrefix}-spec-1", CalcsResultsContainerName) .Returns(false); ILogger logger = CreateLogger(); IJobManagement jobManagement = CreateJobManagement(); ResultsService resultsService = CreateResultsService( logger, specificationsApiClient: specificationsApiClient, resultsRepository: calculationResultsRepository, jobManagement: jobManagement, blobClient: blobClient); //Act await resultsService.QueueCsvGenerationMessages(); //Assert await jobManagement .DidNotReceive() .QueueJob(Arg.Any <JobCreateModel>()); logger .DidNotReceive() .Information($"Found new calculation results for specification id 'spec-1'"); }
protected BaseFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories) { if (blobClient == null) { throw new ArgumentNullException("blobClient"); } if (repositories == null) { throw new ArgumentNullException("repositories"); } BlobClient = blobClient; RepositoryContainer = repositories; ServiceOfferingRepository = repositories.Obtain<IServiceOfferingRepository>(); StudentRepository = repositories.Obtain<IStudentRepository>(); StudentAssignedOfferingRepository = repositories.Obtain<IStudentAssignedOfferingRepository>(); SubjectRepository = repositories.Obtain<ISubjectRepository>(); ServiceAttendanceRepository = repositories.Obtain<IServiceAttendanceRepository>(); }
public ServiceAttendanceFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories) : base(blobClient, repositories) { }
public StorageManager(ITableClient tables, IBlobClient blobs) { _tables = tables; }
public void SetBlobClient(IBlobClient blobClient) { _blobClient = blobClient; }
public PublicFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor) : base(repositories, blobClient, dataTableBinder, auditor) { }
public ServiceOfferingFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories) : base(blobClient, repositories) { }
public PrivateHealthFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor) : base(repositories, blobClient, dataTableBinder, auditor) { ProviderRepository = repositories.Obtain<IProviderRepository>(); }
private void DeleteDataDisks(IBlobClient client) { // delete the data disks in the reverse order if (_vmRole.HardDisks.HardDiskCollection == null) return; for (int i = _vmRole.HardDisks.HardDiskCollection.Count - 1; i >= 0; i--) { var dataDiskCommand = new DeleteVirtualMachineDiskCommand(_vmRole.HardDisks.HardDiskCollection[i].DiskName) { SubscriptionId = Properties.SubscriptionId, Certificate = Properties.Certificate }; dataDiskCommand.Execute(); int pos = _vmRole.HardDisks.HardDiskCollection[i].MediaLink.LastIndexOf('/'); string diskFile = _vmRole.HardDisks.HardDiskCollection[i].MediaLink.Substring(pos + 1); if(client != null) client.DeleteBlob(diskFile); } }