private OrderDataLines SetupOrderDataLines_List(List <string> OrderList, string Key)
{
OrderDataLines orderLines = new OrderDataLines();
orderLines.OrderKey = Key;
orderLines.Lines = OrderList;
return(orderLines);
}
public void OrderHeaderHaveIncorrectDateFormatForCargoReady()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("H,PO2008-01,SHANGHAI FURNITURE COMPANY,CNSHA,AUMEL,25/25/20", "PO2008-01");
Mock <OrderHeaderMapper> sut = new Mock <OrderHeaderMapper>();
//Assert
Assert.Throws <Exception>(() => sut.Object.Map(dataLines));
}
public void OrderHeaderHaveMissingDestination()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("H,PO2008-01,SHANGHAI FURNITURE COMPANY,CNSHA,,1/05/2014", "PO2008-01");
Mock <OrderHeaderMapper> sut = new Mock <OrderHeaderMapper>();
//Assert
Assert.Throws <Exception>(() => sut.Object.Map(dataLines));
}
public void OrderHeaderHaveMissingSupplierName()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("H,PO2008-01,,CNSHA,AUMEL,1/05/2014", "PO2008-01");
Mock <OrderHeaderMapper> sut = new Mock <OrderHeaderMapper>();
//Assert
Assert.Throws <Exception>(() => sut.Object.Map(dataLines));
}
public void OrderDetailsHaveMissingProductDescription()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("D,PO2008-01,1,,100,", "PO2008-01");
Mock <OrderDetailsMapper> sut = new Mock <OrderDetailsMapper>();
//Assert
Assert.Throws <Exception>(() => sut.Object.Map(dataLines));
}
public void OrderDetailsNotFoundForIncorrectOrderNumber()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_List(fakeOrderList, "PO20007 - 01");
Mock <OrderDetailsMapper> mockOrderDetailsMapper = new Mock <OrderDetailsMapper>();
//Assert
Assert.Throws <Exception>(() => new OrderDetailsReader(dataLines, mockOrderDetailsMapper.Object));
}
public void MissingOrderDetailsForOrderNumber()
{
//arrange
OrderDataLines orderLines = SetupOrderDataLines_Single("H,PO2008 - 01,SHANGHAI FURNITURE COMPANY,CNSHA,AUMEL,1 / 05 / 2014", "PO2008 - 01");
Mock <OrderDetailsMapper> mockOrderDetailsMapper = new Mock <OrderDetailsMapper>();
//Assert
Assert.Throws <Exception>(() => new OrderDetailsReader(orderLines, mockOrderDetailsMapper.Object));
}
public void OrderDetailsHaveIncorrectDataFormatForOrderQty()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("D,PO2008-01,1,RED LOUNGES,ABC,", "PO2008-01");
Mock <OrderDetailsMapper> sut = new Mock <OrderDetailsMapper>();
//Assert
Assert.Throws <Exception>(() => sut.Object.Map(dataLines));
}
public void DoMappingForPurchaseOrderSuccessfully()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("H,PO2008-01,SHANGHAI FURNITURE COMPANY,CNSHA,AUMEL,01/02/2014", "PO2008-01");
Mock <OrderHeaderMapper> sut = new Mock <OrderHeaderMapper>();
//Assert
Assert.NotNull(sut.Object.Map(dataLines));
}
public void OrderDetailsHaveMissingOrderNumber()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_Single("D,,1,RED LOUNGES,100,", "PO2008-01");
Mock <OrderDetailsMapper> sut = new Mock <OrderDetailsMapper>();
//Assert
Assert.Throws <Exception>(() => sut.Object.Map(dataLines));
}
public void MissingLineNumberForOrderDetails()
{
//arrange
OrderDataLines orderLines = SetupOrderDataLines_Single("D,PO2008 - 01,,RED LOUNGES,100,", "PO2008 - 01");
Mock <OrderDetailsMapper> mockOrderDetailsMapper = new Mock <OrderDetailsMapper>();
OrderDetailsReader sut = new OrderDetailsReader(orderLines, mockOrderDetailsMapper.Object);
//assert
Assert.Throws <Exception>(() => sut.GetPurchaseOrderLineList());
}
public void GetMatchingDetailsForOrderNumber()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_List(fakeOrderList, "PO2008 - 01");
Mock <OrderDetailsMapper> mockOrderDetailsMapper = new Mock <OrderDetailsMapper>();
OrderDetailsReader sut = new OrderDetailsReader(dataLines, mockOrderDetailsMapper.Object);
//Assert
Assert.Equal(2, sut.GetPurchaseOrderLineList().Count);
}
public void GetMatchingHeaderForOrderNumber()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_List(fakeOrderList, "PO2008 - 01");
Mock <OrderHeaderMapper> mockOrderHeaderMapper = new Mock <OrderHeaderMapper>();
OrderHeaderReader sut = new OrderHeaderReader(dataLines, mockOrderHeaderMapper.Object);
//Assert
Assert.NotNull(sut.GetPurchaseOrder());
}
public void OrderDetailsFoundForOrderNumber()
{
//Arrange
OrderDataLines dataLines = SetupOrderDataLines_List(fakeOrderList, "PO2008 - 01");
Mock <OrderDetailsMapper> mockOrderDetailsMapper = new Mock <OrderDetailsMapper>();
OrderDetailsReader sut = new OrderDetailsReader(dataLines, mockOrderDetailsMapper.Object);
//Assert
Assert.NotNull(sut);
}
private OrderDataLines SetupOrderDataLines_Single(string DataList, string Key)
{
OrderDataLines orderLines = new OrderDataLines();
List <string> OrderDetailList = new List <string>();
OrderDetailList.Add(DataList);
orderLines.OrderKey = Key;
orderLines.Lines = OrderDetailList;
return(orderLines);
}
public OrderDataLines SetupOrderDataLines_Single(string orderHeaderLine, string orderKey)
{
List <string> Lines = new List <string>();
Lines.Add(orderHeaderLine);
OrderDataLines order = new OrderDataLines();
order.OrderKey = orderKey;
order.Lines = Lines;
return(order);
}
public OrderHeaderReader(OrderDataLines orderDataLines, IOrderHeaderMapper mapper)
{
this._orderDataLines = orderDataLines;
this._mapper = mapper;
// Get Single Line that start with H for Order Header
this.HeaderLine = orderDataLines.Lines.Where(x => x.ToUpper().StartsWith("H") &&
x.Split(",")[1].ToString() == orderDataLines.OrderKey)
.FirstOrDefault();
if (this.HeaderLine == null)
{
throw new Exception(String.Format(Messages.No_Header_Found_For, this._orderDataLines.OrderKey));
}
}
public void MissingHeaderForOrderDetails()
{
//arrange
List <string> OrderDetailsList = new List <string>();
OrderDetailsList.Add("D,PO2008 - 01,1,RED LOUNGES,100,");
OrderDetailsList.Add("D,PO2008 - 01,2,GREY LOUNGES,50,");
OrderDataLines dataLines = SetupOrderDataLines_List(OrderDetailsList, "PO2008 - 01");
Mock <OrderHeaderMapper> sut = new Mock <OrderHeaderMapper>();
//Assert
Assert.Throws <Exception>(() => new OrderHeaderReader(dataLines, sut.Object));
}
/// <summary>
/// Get Purchase order based on both the Header and Details
/// </summary>
/// <param name="orderDataLine"></param>
/// <returns></returns>
public PurchaseOrder GetPurchaseOrder(OrderDataLines orderDataLine)
{
PurchaseOrder purchaseOrder = new PurchaseOrder();
//Get the Header for the orderKey
OrderHeaderReader header = new OrderHeaderReader(orderDataLine, orderHeaderMapper);
purchaseOrder = header.GetPurchaseOrder();
//Then Get the Order Line list for that orderKey
OrderDetailsReader content = new OrderDetailsReader(orderDataLine, orderDetailsMapper);
purchaseOrder.Lines = content.GetPurchaseOrderLineList();
return(purchaseOrder);
}
/// <summary>
/// Return Single PurchaseOrder without any orderlines
/// </summary>
/// <returns>PurchaseOrder</returns>
public PurchaseOrder GetPurchaseOrder()
{
var lines = HeaderLine.Split(",").ToList();
if (lines == null)
{
throw new Exception(String.Format(Messages.No_Header_Found_For, this._orderDataLines.OrderKey));
}
OrderDataLines order = new OrderDataLines()
{
Lines = lines,
OrderKey = this._orderDataLines.OrderKey
};
return(this._mapper.Map(order));
}
public OrderDetailsReader(OrderDataLines orderLines, IOrderDetailsMapper mapper)
{
this._orderLines = orderLines;
this._mapper = mapper;
// Filter the Lines to have only ones start with "D" for Order details
// for specific Order
this._orderLines.Lines = orderLines.Lines.FindAll(x => x.ToUpper().StartsWith("D") &&
x.Split(",")[1].ToString() == orderLines.OrderKey)
.ToList();
if (this._orderLines.Lines.Count() == 0)
{
throw new Exception(String.Format(Messages.No_Order_Details_Found_For, this._orderLines.OrderKey));
}
}
/// <summary>
/// Validate The ORder Details if it has any missing data or incorrect data type
/// Map the Order Details to the PurchaseOrderLine object
/// </summary>
/// <param name="orderDataLines">PurchaseOrderLine</param>
/// <returns></returns>
public PurchaseOrderLine Map(OrderDataLines orderDataLines)
{
if (orderDataLines.Lines.Count == 0)
{
throw new Exception(String.Format(Messages.No_Order_Details_Found_For, orderDataLines.OrderKey));
}
//Perform validation on data and throw exception if there is any before proceed to perform mapping
this.Validate(orderDataLines);
var Lines = orderDataLines.Lines.SplitDataArray();
return(new PurchaseOrderLine()
{
LineNumber = int.Parse(Lines[2]),
ProductDescription = Lines[3],
OrderQty = int.Parse(Lines[4])
});
}
/// <summary>
/// Validate The ORder Header if it has any missing data or incorrect data type
/// throw an exception if any data or incorrect data type
/// </summary>
/// <param name="orderDataLines"></param>
private void Validate(OrderDataLines orderDataLines)
{
int index = 0;
string FieldsNewReview = "";
var Lines = orderDataLines.Lines.SplitDataArray();
foreach (string item in Lines)
{
if (index == 1 && item == "")
{
FieldsNewReview += "CustomerPo,";
}
else if (index == 2 && item == "")
{
FieldsNewReview += "Supplier,";
}
else if (index == 3 && item == "")
{
FieldsNewReview += "Origin,";
}
else if (index == 4 && item == "")
{
FieldsNewReview += "Destination,";
}
else if (index == 5 && (item == "" || !item.IsValidDate()))
{
FieldsNewReview += "CargoReady,";
}
index += 1;
}
if (FieldsNewReview.EndsWith(","))
{
FieldsNewReview = FieldsNewReview.Substring(0, FieldsNewReview.Length - 1);
}
if (FieldsNewReview.Length > 0)
{
throw new Exception(String.Format(Messages.Header_Fields_Need_Review, FieldsNewReview, orderDataLines.OrderKey));
}
}
/// <summary>
/// Validate The ORder Header if it has any missing data or incorrect data type
/// Map the Order Header to the PurchaseOrder object
/// </summary>
/// <param name="orderDataLines"></param>
/// <returns>PurchaseOrderLine</returns>
public PurchaseOrder Map(OrderDataLines orderDataLines)
{
if (orderDataLines.Lines.Count == 0)
{
throw new Exception(String.Format(Messages.No_Header_Found_For, orderDataLines.OrderKey));
}
//Perform validation on data and throw exception if there is any before proceed to perform mapping
this.Validate(orderDataLines);
var Lines = orderDataLines.Lines.SplitDataArray();
return(new PurchaseOrder()
{
CustomerPo = Lines[1],
Supplier = Lines[2].GenerateCodeId(),
Origin = Lines[3],
Destination = Lines[4],
CargoReady = DateTime.Parse(Lines[5])
});
}
/// <summary>
/// Get the Purchase Order Lines for specific Order
/// </summary>
/// <returns>List<PurchaseOrderLine></returns>
public List <PurchaseOrderLine> GetPurchaseOrderLineList()
{
List <PurchaseOrderLine> purchaseOrderLineList = new List <PurchaseOrderLine>();
var OrderLines = this._orderLines.Lines.Select(x => x.Split(",")).ToList();
if (OrderLines.Count() == 0)
{
throw new Exception(String.Format(Messages.No_Order_Details_Found_For, this._orderLines.OrderKey));
}
foreach (string[] data in OrderLines)
{
OrderDataLines order = new OrderDataLines()
{
OrderKey = this._orderLines.OrderKey,
Lines = data.ToList()
};
purchaseOrderLineList.Add(this._mapper.Map(order));
}
return(purchaseOrderLineList);
}
