private async Task <SalesCatalogueDataResponse> CreateSalesCatalogueDataResponse(HttpResponseMessage httpResponse, string batchId, string correlationId)
{
var response = new SalesCatalogueDataResponse();
var body = await httpResponse.Content.ReadAsStringAsync();
if (httpResponse.StatusCode != HttpStatusCode.OK)
{
logger.LogError(EventIds.SalesCatalogueServiceCatalogueDataNonOkResponse.ToEventId(), "Error in sales catalogue service catalogue end point with uri:{RequestUri} responded with {StatusCode} and BatchId:{batchId} and _X-Correlation-ID:{CorrelationId}", httpResponse.RequestMessage.RequestUri, httpResponse.StatusCode, batchId, correlationId);
response.ResponseCode = httpResponse.StatusCode;
response.ResponseBody = null;
throw new FulfilmentException(EventIds.SalesCatalogueServiceCatalogueDataNonOkResponse.ToEventId());
}
else
{
response.ResponseCode = httpResponse.StatusCode;
var lastModified = httpResponse.Content.Headers.LastModified;
if (httpResponse.StatusCode == HttpStatusCode.OK)
{
response.ResponseBody = JsonConvert.DeserializeObject <List <SalesCatalogueDataProductResponse> >(body);
}
if (lastModified != null)
{
response.LastModified = ((DateTimeOffset)lastModified).UtcDateTime;
}
}
return(response);
}
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);
}
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 async Task <SalesCatalogueDataResponse> GetSalesCatalogueDataResponse(string batchId, string correlationId)
{
SalesCatalogueDataResponse salesCatalogueTypeResponse = await fulfilmentSalesCatalogueService.GetSalesCatalogueDataResponse(batchId, correlationId);
return(salesCatalogueTypeResponse);
}
public async Task <bool> CreateProductFile(string batchId, string exchangeSetInfoPath, string correlationId, SalesCatalogueDataResponse salesCatalogueDataResponse)
{
bool isProductFileCreated = false;
if (!string.IsNullOrWhiteSpace(exchangeSetInfoPath))
{
DateTime createProductFileTaskStartedAt = DateTime.UtcNow;
isProductFileCreated = await logger.LogStartEndAndElapsedTimeAsync(EventIds.CreateProductFileRequestStart,
EventIds.CreateProductFileRequestCompleted,
"Create product file request for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId}",
async() => {
return(await fulfilmentAncillaryFiles.CreateProductFile(batchId, exchangeSetInfoPath, correlationId, salesCatalogueDataResponse));
},
batchId, correlationId);
DateTime createProductFileTaskCompletedAt = DateTime.UtcNow;
monitorHelper.MonitorRequest("Create Product File Task", createProductFileTaskStartedAt, createProductFileTaskCompletedAt, correlationId, null, null, null, batchId);
}
return(isProductFileCreated);
}
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());
}
}
public async Task <bool> CreateProductFile(string batchId, string exchangeSetInfoPath, string correlationId, SalesCatalogueDataResponse salesCatalogueDataResponse)
{
if (salesCatalogueDataResponse.ResponseCode == HttpStatusCode.OK)
{
string fileName = fileShareServiceConfig.Value.ProductFileName;
string filePath = Path.Combine(exchangeSetInfoPath, fileName);
var productsBuilder = new ProductListBuilder();
productsBuilder.UseDefaultOutputTime = false;
foreach (var product in salesCatalogueDataResponse.ResponseBody.OrderBy(p => p.ProductName))
{
productsBuilder.Add(new ProductListEntry()
{
ProductName = product.ProductName + fileShareServiceConfig.Value.BaseCellExtension,
Compression = product.Compression,
Encryption = product.Encryption,
BaseCellIssueDate = product.BaseCellIssueDate,
BaseCellEdition = product.BaseCellEditionNumber,
IssueDateLatestUpdate = product.IssueDateLatestUpdate,
LatestUpdateNumber = product.LatestUpdateNumber,
FileSize = product.FileSize,
TenDataCoverageCoordinates = ",,,,,,,,,,,,,,,,,,,",
CellLimitSouthernmostLatitude = Convert.ToDecimal(product.CellLimitSouthernmostLatitude.ToString(Convert.ToString("f10"))),
CellLimitWesternmostLatitude = Convert.ToDecimal(product.CellLimitWesternmostLatitude.ToString(Convert.ToString("f10"))),
CellLimitNorthernmostLatitude = Convert.ToDecimal(product.CellLimitNorthernmostLatitude.ToString(Convert.ToString("f10"))),
CellLimitEasternmostLatitude = Convert.ToDecimal(product.CellLimitEasternmostLatitude.ToString(Convert.ToString("f10"))),
BaseCellUpdateNumber = product.BaseCellUpdateNumber,
LastUpdateNumberForPreviousEdition = product.LastUpdateNumberPreviousEdition,
BaseCellLocation = product.BaseCellLocation,
CancelledCellReplacements = String.Join(";", product.CancelledCellReplacements)
});
}
var content = productsBuilder.WriteProductsList(DateTime.UtcNow);
fileSystemHelper.CheckAndCreateFolder(exchangeSetInfoPath);
var response = fileSystemHelper.CreateFileContent(filePath, content);
await Task.CompletedTask;
if (!response)
{
logger.LogError(EventIds.ProductFileIsNotCreated.ToEventId(), "Error in creating sales catalogue data product.txt file for BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId} ", batchId, correlationId);
throw new FulfilmentException(EventIds.ProductFileIsNotCreated.ToEventId());
}
return(true);
}
else
{
logger.LogError(EventIds.SalesCatalogueServiceCatalogueDataNonOkResponse.ToEventId(), "Error in sales catalogue service catalogue end point for product.txt responded with {ResponseCode} and BatchId:{BatchId} and _X-Correlation-ID:{CorrelationId} ", salesCatalogueDataResponse.ResponseCode, batchId, correlationId);
throw new FulfilmentException(EventIds.SalesCatalogueServiceCatalogueDataNonOkResponse.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
});
}
}
