public async Task <bool> SendCallBackResponse(SalesCatalogueProductResponse salesCatalogueProductResponse, SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage) { if (!string.IsNullOrWhiteSpace(scsResponseQueueMessage.CallbackUri)) { try { ExchangeSetResponse exchangeSetResponse = SetExchangeSetResponse(salesCatalogueProductResponse, scsResponseQueueMessage); CallBackResponse callBackResponse = SetCallBackResponse(exchangeSetResponse); callBackResponse.Subject = essCallBackConfiguration.Value.Subject; if (ValidateCallbackRequestPayload(callBackResponse)) { string payloadJson = JsonConvert.SerializeObject(callBackResponse); return(await SendResponseToCallBackApi(false, payloadJson, scsResponseQueueMessage)); } else { logger.LogError(EventIds.ExchangeSetCreatedPostCallbackUriNotCalled.ToEventId(), "Post Callback uri is not called after exchange set is created for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId} as payload data is incorrect.", scsResponseQueueMessage.BatchId, scsResponseQueueMessage.CorrelationId); return(false); } } catch (Exception ex) { logger.LogError(EventIds.ExchangeSetCreatedPostCallbackUriNotCalled.ToEventId(), ex, "Post Callback uri is not called after exchange set is created for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId} and Exception:{Message}", scsResponseQueueMessage.BatchId, scsResponseQueueMessage.CorrelationId, ex.Message); return(false); } } else { logger.LogInformation(EventIds.ExchangeSetCreatedPostCallbackUriNotProvided.ToEventId(), "Post callback uri was not provided by requestor for successful exchange set creation for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId}", scsResponseQueueMessage.BatchId, scsResponseQueueMessage.CorrelationId); return(false); } }
public void WhenIsCancellationRequestedinExchangeSet_ThenThrowCancelledException() { SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage = GetScsResponseQueueMessage(); SalesCatalogueProductResponse salesCatalogueProductResponse = GetSalesCatalogueResponse(); string storageAccountConnectionString = "DefaultEndpointsProtocol = https; AccountName = testessdevstorage2; AccountKey =testaccountkey; EndpointSuffix = core.windows.net"; fakeConfiguration["HOME"] = @"D:\\Downloads"; A.CallTo(() => fakeScsStorageService.GetStorageAccountConnectionString(null, null)) .Returns(storageAccountConnectionString); var productList = new List <Products> { new Products { ProductName = "DE5NOBRK", EditionNumber = 0, UpdateNumbers = new List <int?> { 0, 1 }, FileSize = 400 } }; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); cancellationTokenSource.Cancel(); CancellationToken cancellationToken = cancellationTokenSource.Token; A.CallTo(() => fakeAzureBlobStorageService.DownloadSalesCatalogueResponse(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(salesCatalogueProductResponse); Assert.ThrowsAsync <TaskCanceledException>(async() => await fulfilmentDataService.QueryFileShareServiceFiles(scsResponseQueueMessage, productList, null, cancellationTokenSource, cancellationToken)); }
private Task <bool> SaveSalesCatalogueStorageDetails(SalesCatalogueProductResponse salesCatalogueResponse, string batchId, string callBackUri, string correlationId, string expiryDate) { return(logger.LogStartEndAndElapsedTimeAsync(EventIds.SCSResponseStoreRequestStart, EventIds.SCSResponseStoreRequestCompleted, "SCS response store request for BatchId:{batchId} and _X-Correlation-ID:{CorrelationId}", async() => { bool result = await exchangeSetStorageProvider.SaveSalesCatalogueStorageDetails(salesCatalogueResponse, batchId, callBackUri, correlationId, expiryDate); return result; }, batchId, correlationId)); }
public static long GetFileSize(SalesCatalogueProductResponse salesCatalogueResponse) { long fileSize = 0; if (salesCatalogueResponse != null && salesCatalogueResponse.ProductCounts.ReturnedProductCount > 0) { foreach (var item in salesCatalogueResponse.Products) { fileSize += item.FileSize.Value; } } return(fileSize); }
public async Task WhenPostProductVersionsAsyncCallsApi_ThenValidateCorrectParametersArePassed() { //Data string actualAccessToken = "notRequiredDuringTesting"; var requestBody = new List <ProductVersionRequest> { new ProductVersionRequest() { EditionNumber = 1, ProductName = "TEST1", UpdateNumber = 0 } }; string postBodyParam = "This should be replaced by actual value"; //Test variable string accessTokenParam = null; string uriParam = null; HttpMethod httpMethodParam = null; var scsResponse = new SalesCatalogueProductResponse(); var jsonString = JsonConvert.SerializeObject(scsResponse); string correlationIdParam = null; //Mock A.CallTo(() => fakeAuthScsTokenProvider.GetManagedIdentityAuthAsync(A <string> .Ignored)).Returns(actualAccessToken); var httpResponse = new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes(jsonString))) }; A.CallTo(() => fakeSalesCatalogueClient.CallSalesCatalogueServiceApi(A <HttpMethod> .Ignored, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)) .Invokes((HttpMethod method, string postBody, string accessToken, string uri, string correlationId) => { accessTokenParam = accessToken; uriParam = uri; httpMethodParam = method; postBodyParam = postBody; correlationIdParam = correlationId; }) .Returns(httpResponse); //Method call var response = await salesCatalogueService.PostProductVersionsAsync(requestBody, string.Empty); //Test Assert.AreEqual(response.ResponseCode, HttpStatusCode.OK); Assert.AreEqual(HttpMethod.Post, httpMethodParam); Assert.AreEqual($"/{fakeSaleCatalogueConfig.Value.Version}/productData/{fakeSaleCatalogueConfig.Value.ProductType}/products/productVersions", uriParam); Assert.AreEqual(JsonConvert.SerializeObject(requestBody), postBodyParam); Assert.AreEqual(actualAccessToken, accessTokenParam); }
public Task <SalesCatalogueProductResponse> DownloadSalesCatalogueResponse(string scsResponseUri, string batchId, string correlationId) { return(logger.LogStartEndAndElapsedTimeAsync(EventIds.DownloadSalesCatalogueResponseDataStart, EventIds.DownloadSalesCatalogueResponseDataCompleted, "Sales catalogue response download from blob for scsResponseUri:{scsResponseUri} and BatchId:{batchId} and _X-Correlation-ID:{correlationId}", async() => { string storageAccountConnectionString = scsStorageService.GetStorageAccountConnectionString(); CloudBlockBlob cloudBlockBlob = azureBlobStorageClient.GetCloudBlockBlobByUri(scsResponseUri, storageAccountConnectionString); var responseFile = await azureBlobStorageClient.DownloadTextAsync(cloudBlockBlob); SalesCatalogueProductResponse salesCatalogueProductResponse = JsonConvert.DeserializeObject <SalesCatalogueProductResponse>(responseFile); return salesCatalogueProductResponse; }, scsResponseUri, batchId, correlationId)); }
public async Task <bool> SendCallBackErrorResponse(SalesCatalogueProductResponse salesCatalogueProductResponse, SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage) { salesCatalogueProductResponse.ProductCounts.ReturnedProductCount = 0; salesCatalogueProductResponse.ProductCounts.RequestedProductsNotReturned = new List <RequestedProductsNotReturned> { new RequestedProductsNotReturned { ProductName = null, Reason = essCallBackConfiguration.Value.Reason } }; if (!string.IsNullOrWhiteSpace(scsResponseQueueMessage.CallbackUri)) { try { ExchangeSetResponse exchangeSetResponse = SetExchangeSetResponse(salesCatalogueProductResponse, scsResponseQueueMessage); exchangeSetResponse.Links.ExchangeSetFileUri = null; exchangeSetResponse.Links.ExchangeSetErrorFileUri = new LinkSetErrorFileUri { Href = $"{fileShareServiceConfig.Value.PublicBaseUrl}/batch/{scsResponseQueueMessage.BatchId}/files/{fileShareServiceConfig.Value.ErrorFileName}" }; CallBackResponse callBackResponse = SetCallBackResponse(exchangeSetResponse); callBackResponse.Subject = essCallBackConfiguration.Value.ErrorSubject; if (ValidateCallbackErrorRequestPayload(callBackResponse)) { string payloadJson = JsonConvert.SerializeObject(callBackResponse); return(await SendResponseToCallBackApi(true, payloadJson, scsResponseQueueMessage)); } else { logger.LogError(EventIds.ExchangeSetCreatedWithErrorPostCallbackUriNotCalled.ToEventId(), "Post Callback uri is not called after exchange set is created with error for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId} as payload data is incorrect.", scsResponseQueueMessage.BatchId, scsResponseQueueMessage.CorrelationId); return(false); } } catch (Exception ex) { logger.LogError(EventIds.ExchangeSetCreatedWithErrorPostCallbackUriNotCalled.ToEventId(), "Post Callback uri is not called after exchange set is created with error for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId} and Exception:{Message}", scsResponseQueueMessage.BatchId, scsResponseQueueMessage.CorrelationId, ex.Message); return(false); } } else { logger.LogInformation(EventIds.ExchangeSetCreatedWithErrorPostCallbackUriNotProvided.ToEventId(), "Post callback uri was not provided by requestor for exchange set creation with error for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId}", scsResponseQueueMessage.BatchId, scsResponseQueueMessage.CorrelationId); return(false); } }
public async Task WhenSCSClientReturns200_ThenGetProductsFromSpecificDateAsyncReturns200AndDataInResponse() { SalesCatalogueProductResponse scsResponse = GetSalesCatalogueServiceResponse(); var jsonString = JsonConvert.SerializeObject(scsResponse); A.CallTo(() => fakeAuthScsTokenProvider.GetManagedIdentityAuthAsync(A <string> .Ignored)).Returns("notRequiredDuringTesting"); var httpResponse = new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes(jsonString))) }; A.CallTo(() => fakeSalesCatalogueClient.CallSalesCatalogueServiceApi(A <HttpMethod> .Ignored, null, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)) .Returns(httpResponse); var response = await salesCatalogueService.GetProductsFromSpecificDateAsync(DateTime.UtcNow.ToString(), string.Empty); Assert.AreEqual(HttpStatusCode.OK, response.ResponseCode, $"Expected {HttpStatusCode.OK} got {response.ResponseCode}"); Assert.AreEqual(jsonString, JsonConvert.SerializeObject(response.ResponseBody)); }
public async Task WhenCallStoreSaleCatalogueServiceResponseAsync_ThenReturnsTrue() { string batchId = "7b4cdf10-adfa-4ed6-b2fe-d1543d8b7272"; string containerName = "testContainer"; string callBackUri = "https://essTest/myCallback?secret=test&po=1234"; string correlationId = "a6670458-9bbc-4b52-95a2-d1f50fe9e3ae"; string storageAccountConnectionString = "DefaultEndpointsProtocol = https; AccountName = testessdevstorage2; AccountKey =testaccountkey; EndpointSuffix = core.windows.net"; SalesCatalogueProductResponse salesCatalogueProductResponse = GetSalesCatalogueServiceResponse(); CancellationToken cancellationToken = CancellationToken.None; A.CallTo(() => fakeScsStorageService.GetStorageAccountConnectionString(null, null)).Returns(storageAccountConnectionString); A.CallTo(() => fakeAzureBlobStorageClient.GetCloudBlockBlob(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(new CloudBlockBlob(new System.Uri("http://tempuri.org/blob"))); A.CallTo(() => fakeSmallExchangeSetInstance.GetInstanceNumber(1)).Returns(3); var response = await azureBlobStorageService.StoreSaleCatalogueServiceResponseAsync(containerName, batchId, salesCatalogueProductResponse, callBackUri, correlationId, cancellationToken, fakeExpiryDate); Assert.IsTrue(response); }
public async Task WhenGetProductsFromSpecificDateAsyncCallsApi_ThenValidateCorrectParametersArePassed() { //Data string actualAccessToken = "notRequiredDuringTesting"; string postBodyParam = "This should be null when passed to api call"; string sinceDateTime = DateTime.UtcNow.ToString(); //Test variable string accessTokenParam = null; string uriParam = null; HttpMethod httpMethodParam = null; var scsResponse = new SalesCatalogueProductResponse(); var jsonString = JsonConvert.SerializeObject(scsResponse); string correlationIdParam = null; //Mock A.CallTo(() => fakeAuthScsTokenProvider.GetManagedIdentityAuthAsync(A <string> .Ignored)).Returns(actualAccessToken); var httpResponse = new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes(jsonString))) }; A.CallTo(() => fakeSalesCatalogueClient.CallSalesCatalogueServiceApi(A <HttpMethod> .Ignored, null, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)) .Invokes((HttpMethod method, string postBody, string accessToken, string uri, string correlationId) => { accessTokenParam = accessToken; uriParam = uri; httpMethodParam = method; postBodyParam = postBody; correlationIdParam = correlationId; }) .Returns(httpResponse); //Method call var response = await salesCatalogueService.GetProductsFromSpecificDateAsync(sinceDateTime, string.Empty); //Test Assert.AreEqual(HttpStatusCode.OK, response.ResponseCode); Assert.AreEqual(HttpMethod.Get, httpMethodParam); Assert.AreEqual($"/{fakeSaleCatalogueConfig.Value.Version}/productData/{fakeSaleCatalogueConfig.Value.ProductType}/products?sinceDateTime={sinceDateTime}", uriParam); Assert.IsNull(postBodyParam); Assert.AreEqual(actualAccessToken, accessTokenParam); }
public void Setup() { postBodyParam = "This should be replace by actual value when param passed to api call"; uriParam = null; httpMethodParam = null; salesCatalogueProductResponse = GetSalesCatalogueServiceResponse(); scsResponseQueueMessage = GetScsResponseQueueMessage(); fakeEssCallBackConfiguration = Options.Create(new EssCallBackConfiguration() { }); fakeCallBackClient = A.Fake <ICallBackClient>(); fakeFileShareServiceConfig = Options.Create(new FileShareServiceConfiguration() { }); fakeLogger = A.Fake <ILogger <FulfilmentCallBackService> >(); fulfilmentCallBackService = new FulfilmentCallBackService(fakeEssCallBackConfiguration, fakeCallBackClient, fakeFileShareServiceConfig, fakeLogger); }
public async Task WhenValidMessageQueueTrigger_ThenReturnsExchangeSetCreatedSuccessfully() { SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage = GetScsResponseQueueMessage(); SalesCatalogueProductResponse salesCatalogueProductResponse = GetSalesCatalogueResponse(); var fulfilmentDataResponse = new List <FulfilmentDataResponse>() { new FulfilmentDataResponse { BatchId = "63d38bde-5191-4a59-82d5-aa22ca1cc6dc", EditionNumber = 10, ProductName = "Demo", UpdateNumber = 3, FileUri = new List <string> { "http://ffs-demo.azurewebsites.net" } } }; string storageAccountConnectionString = "DefaultEndpointsProtocol = https; AccountName = testessdevstorage2; AccountKey =testaccountkey; EndpointSuffix = core.windows.net"; fakeConfiguration["HOME"] = @"D:\\Downloads"; fakeFileShareServiceConfig.Value.ExchangeSetFileFolder = "V01X01"; fakeFileShareServiceConfig.Value.EncRoot = "ENC_ROOT"; SalesCatalogueDataResponse salesCatalogueDataResponse = GetSalesCatalogueDataResponse(); A.CallTo(() => fakeScsStorageService.GetStorageAccountConnectionString(null, null)) .Returns(storageAccountConnectionString); string filePath = @"D:\\Downloads"; A.CallTo(() => fakeAzureBlobStorageService.DownloadSalesCatalogueResponse(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(salesCatalogueProductResponse); A.CallTo(() => fakeQueryFssService.SearchReadMeFilePath(A <string> .Ignored, A <string> .Ignored)).Returns(filePath); A.CallTo(() => fakeQueryFssService.DownloadReadMeFile(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(true); A.CallTo(() => fakeQueryFssService.CreateZipFileForExchangeSet(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(true); A.CallTo(() => fakeQueryFssService.UploadZipFileForExchangeSetToFileShareService(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(true); A.CallTo(() => fakeFulfilmentAncillaryFiles.CreateCatalogFile(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored, fulfilmentDataResponse, salesCatalogueDataResponse, salesCatalogueProductResponse)).Returns(true); A.CallTo(() => fakeFulfilmentSalesCatalogueService.GetSalesCatalogueDataResponse(A <string> .Ignored, A <string> .Ignored)).Returns(salesCatalogueDataResponse); A.CallTo(() => fakeFulfilmentAncillaryFiles.CreateProductFile(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored, salesCatalogueDataResponse)).Returns(true); A.CallTo(() => fakeFulfilmentCallBackService.SendCallBackResponse(A <SalesCatalogueProductResponse> .Ignored, A <SalesCatalogueServiceResponseQueueMessage> .Ignored)).Returns(true); string salesCatalogueResponseFile = await fulfilmentDataService.CreateExchangeSet(scsResponseQueueMessage, currentUtcDate); Assert.AreEqual("Exchange Set Created Successfully", salesCatalogueResponseFile); }
public ExchangeSetResponse SetExchangeSetResponse(SalesCatalogueProductResponse salesCatalogueProductResponse, SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage) { return(new ExchangeSetResponse() { Links = new Links() { ExchangeSetBatchStatusUri = new LinkSetBatchStatusUri { Href = $"{fileShareServiceConfig.Value.PublicBaseUrl}/batch/{scsResponseQueueMessage.BatchId}/status" }, ExchangeSetBatchDetailsUri = new LinkSetBatchDetailsUri { Href = $"{fileShareServiceConfig.Value.PublicBaseUrl}/batch/{scsResponseQueueMessage.BatchId}" }, ExchangeSetFileUri = new LinkSetFileUri { Href = $"{fileShareServiceConfig.Value.PublicBaseUrl}/batch/{scsResponseQueueMessage.BatchId}/files/{fileShareServiceConfig.Value.ExchangeSetFileName}" } }, ExchangeSetUrlExpiryDateTime = Convert.ToDateTime(scsResponseQueueMessage.ExchangeSetUrlExpiryDate).ToUniversalTime(), RequestedProductCount = salesCatalogueProductResponse.ProductCounts.RequestedProductCount.Value, ExchangeSetCellCount = salesCatalogueProductResponse.ProductCounts.ReturnedProductCount.Value, RequestedProductsAlreadyUpToDateCount = salesCatalogueProductResponse.ProductCounts.RequestedProductsAlreadyUpToDateCount.Value, RequestedProductsNotInExchangeSet = GetRequestedProductsNotInExchangeSet(salesCatalogueProductResponse) }); }
public async Task WhenInvalidMessageQueueTrigger_ThenReturnsExchangeSetIsNotCreated() { SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage = GetScsResponseQueueMessage(); SalesCatalogueProductResponse salesCatalogueProductResponse = GetSalesCatalogueResponse(); string storageAccountConnectionString = "DefaultEndpointsProtocol = https; AccountName = testessdevstorage2; AccountKey =testaccountkey; EndpointSuffix = core.windows.net"; fakeConfiguration["HOME"] = @"D:\\Downloads"; fakeFileShareServiceConfig.Value.ExchangeSetFileFolder = "V01X01"; fakeFileShareServiceConfig.Value.EncRoot = "ENC_ROOT"; A.CallTo(() => fakeScsStorageService.GetStorageAccountConnectionString(null, null)) .Returns(storageAccountConnectionString); string filePath = @"D:\\Downloads"; A.CallTo(() => fakeAzureBlobStorageService.DownloadSalesCatalogueResponse(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(salesCatalogueProductResponse); A.CallTo(() => fakeQueryFssService.SearchReadMeFilePath(A <string> .Ignored, A <string> .Ignored)).Returns(filePath); A.CallTo(() => fakeQueryFssService.DownloadReadMeFile(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(true); A.CallTo(() => fakeQueryFssService.CreateZipFileForExchangeSet(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(true); A.CallTo(() => fakeQueryFssService.UploadZipFileForExchangeSetToFileShareService(A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(false); string salesCatalogueResponseFile = await fulfilmentDataService.CreateExchangeSet(scsResponseQueueMessage, currentUtcDate); Assert.AreEqual("Exchange Set Is Not Created", salesCatalogueResponseFile); }
public async Task WhenSCSClientReturns200_ThenPostProductVersionsAsyncReturns200AndDataInResponse() { SalesCatalogueProductResponse scsResponse = GetSalesCatalogueServiceResponse(); var jsonString = JsonConvert.SerializeObject(scsResponse); A.CallTo(() => fakeAuthScsTokenProvider.GetManagedIdentityAuthAsync(A <string> .Ignored)).Returns("notRequiredDuringTesting"); var httpResponse = new HttpResponseMessage() { StatusCode = HttpStatusCode.OK, Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes(jsonString))) }; A.CallTo(() => fakeSalesCatalogueClient.CallSalesCatalogueServiceApi(A <HttpMethod> .Ignored, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored, A <string> .Ignored)) .Returns(httpResponse); var response = await salesCatalogueService.PostProductVersionsAsync(new List <ProductVersionRequest> { new ProductVersionRequest() { EditionNumber = 1, ProductName = "TEST1", UpdateNumber = 0 } }, String.Empty); Assert.AreEqual(HttpStatusCode.OK, response.ResponseCode, $"Expected {HttpStatusCode.OK} got {response.ResponseCode}"); Assert.AreEqual(jsonString, JsonConvert.SerializeObject(response.ResponseBody)); }
public async Task UploadSalesCatalogueServiceResponseToBlobAsync(CloudBlockBlob cloudBlockBlob, SalesCatalogueProductResponse salesCatalogueResponse) { var serializeJsonObject = JsonConvert.SerializeObject(salesCatalogueResponse); using (var ms = new MemoryStream()) { LoadStreamWithJson(ms, serializeJsonObject); await azureBlobStorageClient.UploadFromStreamAsync(cloudBlockBlob, ms); } }
public async Task AddQueueMessage(string batchId, SalesCatalogueProductResponse salesCatalogueResponse, string callBackUri, string correlationId, CloudBlockBlob cloudBlockBlob, int instanceNumber, string storageAccountConnectionString, string expiryDate) { SalesCatalogueServiceResponseQueueMessage scsResponseQueueMessage = GetSalesCatalogueServiceResponseQueueMessage(batchId, salesCatalogueResponse, callBackUri, correlationId, cloudBlockBlob, expiryDate); var scsResponseQueueMessageJSON = JsonConvert.SerializeObject(scsResponseQueueMessage); await azureMessageQueueHelper.AddMessage(batchId, instanceNumber, storageAccountConnectionString, scsResponseQueueMessageJSON, correlationId); }
public async Task <bool> StoreSaleCatalogueServiceResponseAsync(string containerName, string batchId, SalesCatalogueProductResponse salesCatalogueResponse, string callBackUri, string correlationId, CancellationToken cancellationToken, string expiryDate) { string uploadFileName = string.Concat(batchId, ".json"); long fileSize = CommonHelper.GetFileSize(salesCatalogueResponse); var fileSizeInMB = CommonHelper.ConvertBytesToMegabytes(fileSize); var instanceCountAndType = GetInstanceCountBasedOnFileSize(fileSizeInMB); var storageAccountWithKey = GetStorageAccountNameAndKeyBasedOnExchangeSetType(instanceCountAndType.Item2); string storageAccountConnectionString = scsStorageService.GetStorageAccountConnectionString(storageAccountWithKey.Item1, storageAccountWithKey.Item2); CloudBlockBlob cloudBlockBlob = await azureBlobStorageClient.GetCloudBlockBlob(uploadFileName, storageAccountConnectionString, containerName); cloudBlockBlob.Properties.ContentType = CONTENT_TYPE; await UploadSalesCatalogueServiceResponseToBlobAsync(cloudBlockBlob, salesCatalogueResponse); logger.LogInformation(EventIds.SCSResponseStoredToBlobStorage.ToEventId(), "Sales catalogue service response stored to blob storage with fileSizeInMB:{fileSizeInMB} for BatchId:{batchId} and _X-Correlation-ID:{CorrelationId} ", fileSizeInMB, batchId, correlationId); await AddQueueMessage(batchId, salesCatalogueResponse, callBackUri, correlationId, cloudBlockBlob, instanceCountAndType.Item1, storageAccountConnectionString, expiryDate); return(true); }
public async Task <bool> CreateCatalogFile(string batchId, string exchangeSetRootPath, string correlationId, List <FulfilmentDataResponse> listFulfilmentData, SalesCatalogueDataResponse salesCatalogueDataResponse, SalesCatalogueProductResponse salesCatalogueProductResponse) { var catBuilder = new Catalog031BuilderFactory().Create(); var readMeFileName = Path.Combine(exchangeSetRootPath, fileShareServiceConfig.Value.ReadMeFileName); var outputFileName = Path.Combine(exchangeSetRootPath, fileShareServiceConfig.Value.CatalogFileName); if (fileSystemHelper.CheckFileExists(readMeFileName)) { catBuilder.Add(new CatalogEntry() { FileLocation = fileShareServiceConfig.Value.ReadMeFileName, Implementation = "TXT" }); } if (listFulfilmentData != null && listFulfilmentData.Any()) { listFulfilmentData = listFulfilmentData.OrderBy(a => a.ProductName).ThenBy(b => b.EditionNumber).ThenBy(c => c.UpdateNumber).ToList(); List <Tuple <string, string> > orderPreference = new List <Tuple <string, string> > { new Tuple <string, string>("application/s63", "BIN"), new Tuple <string, string>("text/plain", "ASC"), new Tuple <string, string>("text/plain", "TXT"), new Tuple <string, string>("image/tiff", "TIF") }; foreach (var listItem in listFulfilmentData) { CreateCatalogEntry(listItem, orderPreference, catBuilder, salesCatalogueDataResponse, salesCatalogueProductResponse, exchangeSetRootPath, batchId, correlationId); } } var cat031Bytes = catBuilder.WriteCatalog(fileShareServiceConfig.Value.ExchangeSetFileFolder); fileSystemHelper.CheckAndCreateFolder(exchangeSetRootPath); fileSystemHelper.CreateFileContentWithBytes(outputFileName, cat031Bytes); await Task.CompletedTask; if (fileSystemHelper.CheckFileExists(outputFileName)) { return(true); } else { logger.LogError(EventIds.CatalogFileIsNotCreated.ToEventId(), "Error in creating catalog.031 file for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId}", batchId, correlationId); throw new FulfilmentException(EventIds.CatalogFileIsNotCreated.ToEventId()); } }
private void CreateCatalogEntry(FulfilmentDataResponse listItem, List <Tuple <string, string> > orderPreference, ICatalog031Builder catBuilder, SalesCatalogueDataResponse salesCatalogueDataResponse, SalesCatalogueProductResponse salesCatalogueProductResponse, string exchangeSetRootPath, string batchId, string correlationId) { int length = 2; listItem.Files = listItem.Files.OrderByDescending( item => Enumerable.Reverse(orderPreference).ToList().IndexOf(new Tuple <string, string>(item.MimeType.ToLower(), GetMimeType(item.Filename.ToLower(), item.MimeType.ToLower(), batchId, correlationId)))); foreach (var item in listItem.Files) { string fileLocation = Path.Combine(listItem.ProductName.Substring(0, length), listItem.ProductName, listItem.EditionNumber.ToString(), listItem.UpdateNumber.ToString(), item.Filename); string mimeType = GetMimeType(item.Filename.ToLower(), item.MimeType.ToLower(), batchId, correlationId); string comment = string.Empty; BoundingRectangle boundingRectangle = new BoundingRectangle(); if (mimeType == "BIN") { var salescatalogProduct = salesCatalogueDataResponse.ResponseBody.Where(s => s.ProductName == listItem.ProductName).Select(s => s).FirstOrDefault(); if (salescatalogProduct == null) { logger.LogError(EventIds.SalesCatalogueServiceCatalogueDataNotFoundForProduct.ToEventId(), "Error in sales catalogue service catalogue end point when product details not found for Product:{ProductName} and BatchId:{batchId} and _X-Correlation-ID:{CorrelationId}", listItem.ProductName, batchId, correlationId); throw new FulfilmentException(EventIds.SalesCatalogueServiceCatalogueDataNotFoundForProduct.ToEventId()); } comment = SetCatalogFileComment(listItem, salescatalogProduct, salesCatalogueProductResponse); boundingRectangle.LatitudeNorth = salescatalogProduct.CellLimitNorthernmostLatitude; boundingRectangle.LatitudeSouth = salescatalogProduct.CellLimitSouthernmostLatitude; boundingRectangle.LongitudeEast = salescatalogProduct.CellLimitEasternmostLatitude; boundingRectangle.LongitudeWest = salescatalogProduct.CellLimitWesternmostLatitude; } catBuilder.Add(new CatalogEntry() { FileLocation = fileLocation, FileLongName = "", Implementation = mimeType, Crc = (mimeType == "BIN") ? item.Attributes.Where(a => a.Key == "s57-CRC").Select(a => a.Value).FirstOrDefault() : GetCrcString(Path.Combine(exchangeSetRootPath, fileLocation)), Comment = comment, BoundingRectangle = boundingRectangle }); } }
public async Task <bool> CreateCatalogFile(string batchId, string exchangeSetRootPath, string correlationId, List <FulfilmentDataResponse> listFulfilmentData, SalesCatalogueDataResponse salesCatalogueDataResponse, SalesCatalogueProductResponse salesCatalogueProductResponse) { bool isFileCreated = false; if (!string.IsNullOrWhiteSpace(exchangeSetRootPath)) { DateTime createCatalogFileTaskStartedAt = DateTime.UtcNow; isFileCreated = await logger.LogStartEndAndElapsedTimeAsync(EventIds.CreateCatalogFileRequestStart, EventIds.CreateCatalogFileRequestCompleted, "Create catalog file request for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId}", async() => { return(await fulfilmentAncillaryFiles.CreateCatalogFile(batchId, exchangeSetRootPath, correlationId, listFulfilmentData, salesCatalogueDataResponse, salesCatalogueProductResponse)); }, batchId, correlationId); DateTime createCatalogFileTaskCompletedAt = DateTime.UtcNow; monitorHelper.MonitorRequest("Create Catalog File Task", createCatalogFileTaskStartedAt, createCatalogFileTaskCompletedAt, correlationId, null, null, null, batchId); } return(isFileCreated); }
private SalesCatalogueServiceResponseQueueMessage GetSalesCatalogueServiceResponseQueueMessage(string batchId, SalesCatalogueProductResponse salesCatalogueResponse, string callBackUri, string correlationId, CloudBlockBlob cloudBlockBlob, string expiryDate) { long fileSize = CommonHelper.GetFileSize(salesCatalogueResponse); var scsResponseQueueMessage = new SalesCatalogueServiceResponseQueueMessage() { BatchId = batchId, ScsResponseUri = cloudBlockBlob.Uri.AbsoluteUri, FileSize = fileSize, CallbackUri = callBackUri == null ? string.Empty : callBackUri, CorrelationId = correlationId, ExchangeSetUrlExpiryDate = expiryDate }; return(scsResponseQueueMessage); }
public virtual async Task <bool> SaveSalesCatalogueStorageDetails(SalesCatalogueProductResponse salesCatalogueResponse, string batchId, string callBackUri, string correlationId, string expiryDate) { return(await azureBlobStorageService.StoreSaleCatalogueServiceResponseAsync(storageConfig.Value.StorageContainerName, batchId, salesCatalogueResponse, callBackUri, correlationId, CancellationToken.None, expiryDate)); }
private async Task CreateAncillaryFiles(string batchId, string exchangeSetPath, string correlationId, List <FulfilmentDataResponse> listFulfilmentData, SalesCatalogueProductResponse salecatalogueProductResponse) { var exchangeSetRootPath = Path.Combine(exchangeSetPath, fileShareServiceConfig.Value.EncRoot); var exchangeSetInfoPath = Path.Combine(exchangeSetPath, fileShareServiceConfig.Value.Info); SalesCatalogueDataResponse salesCatalogueDataResponse = await GetSalesCatalogueDataResponse(batchId, correlationId); await CreateProductFile(batchId, exchangeSetInfoPath, correlationId, salesCatalogueDataResponse); await CreateSerialEncFile(batchId, exchangeSetPath, correlationId); await DownloadReadMeFile(batchId, exchangeSetRootPath, correlationId); await CreateCatalogFile(batchId, exchangeSetRootPath, correlationId, listFulfilmentData, salesCatalogueDataResponse, salecatalogueProductResponse); }
private string SetCatalogFileComment(FulfilmentDataResponse listItem, SalesCatalogueDataProductResponse salescatalogProduct, SalesCatalogueProductResponse salesCatalogueProductResponse) { string getIssueAndUpdateDate = null; int? cancelledUpdateNumber = null; var salescatalogProductResponse = salesCatalogueProductResponse.Products.Where(s => s.ProductName == listItem.ProductName).Where(s => s.EditionNumber == listItem.EditionNumber).Select(s => s).FirstOrDefault(); if (salescatalogProductResponse.Dates != null) { var dates = salescatalogProductResponse.Dates.Where(s => s.UpdateNumber == listItem.UpdateNumber).Select(s => s).FirstOrDefault(); getIssueAndUpdateDate = GetIssueAndUpdateDate(dates); } if (salescatalogProductResponse.Cancellation != null) { cancelledUpdateNumber = salescatalogProductResponse.Cancellation.UpdateNumber; } //BoundingRectangle and Comment only required for BIN return(salescatalogProduct.BaseCellEditionNumber == 0 && cancelledUpdateNumber == listItem.UpdateNumber ? $"{fileShareServiceConfig.Value.CommentVersion},EDTN={salescatalogProduct.BaseCellEditionNumber},UPDN={listItem.UpdateNumber},{getIssueAndUpdateDate}" : $"{fileShareServiceConfig.Value.CommentVersion},EDTN={listItem.EditionNumber},UPDN={listItem.UpdateNumber},{getIssueAndUpdateDate}"); }
public async Task SendErrorCallBackResponse(SalesCatalogueServiceResponseQueueMessage fulfilmentServiceQueueMessage) { SalesCatalogueProductResponse salesCatalogueProductResponse = await azureBlobStorageService.DownloadSalesCatalogueResponse(fulfilmentServiceQueueMessage.ScsResponseUri, fulfilmentServiceQueueMessage.BatchId, fulfilmentServiceQueueMessage.CorrelationId); await fulfilmentCallBackService.SendCallBackErrorResponse(salesCatalogueProductResponse, fulfilmentServiceQueueMessage); }
public List <RequestedProductsNotInExchangeSet> GetRequestedProductsNotInExchangeSet(SalesCatalogueProductResponse salesCatalogueProductResponse) { var listRequestedProductsNotInExchangeSet = new List <RequestedProductsNotInExchangeSet>(); foreach (var item in salesCatalogueProductResponse.ProductCounts.RequestedProductsNotReturned) { var requestedProductsNotInExchangeSet = new RequestedProductsNotInExchangeSet { ProductName = item.ProductName, Reason = item.Reason }; listRequestedProductsNotInExchangeSet.Add(requestedProductsNotInExchangeSet); } return(listRequestedProductsNotInExchangeSet); }