public void FillOrderListTest()
{
Order testOrder1 = new Order() { Id = 1 };
Order testOrder2 = new Order() { Id = 2 };
List<Order> testOrders = new List<Order>() { testOrder1, testOrder2 };
mockContract.GetOrderList(Arg.Any<int>()).Returns(testOrders);
presentor.FillOrderList();
Assert.AreEqual(mocktechnologistOrdersView.Orders, testOrders);
Assert.AreEqual(mocktechnologistOrdersView.Orders[0], testOrder1);
Assert.AreEqual(mocktechnologistOrdersView.Orders[1], testOrder2);
}
/// <summary>
/// Gets the otrder items list of the specified order
/// </summary>
/// <param name="orderID">Order ID</param>
/// <returns>The list of order items</returns>
public List<OrderItem> GetOrderItems(Order order)
{
if (technologistView.Orders.FirstOrDefault(o => o == order) != null)
{
if (order.Items == null && order.Id != 0)
FillOrderItemsList(order.Id);
return technologistView.Orders.First(oi => oi.Id == order.Id).Items.ToList();
}
else
{
throw new ArgumentException("The specified order is not at the order list");
}
}
public static OrderItem TranslateToOrderItem(ClientOrderItem clientOrderItem, Order order)
{
if (clientOrderItem != null)
{
OrderItem orderItem = new OrderItem();
orderItem.Product = new Product();
orderItem.Product.Id = clientOrderItem.Id;
orderItem.Product.Name = clientOrderItem.Name;
orderItem.Count = clientOrderItem.Count;
orderItem.Order = order;
return orderItem;
}
return null;
}
public void FillOrderListTest()
{
Order testOrder1 = new Order() { Id = 1 };
Order testOrder2 = new Order() { Id = 2 };
List<Order> testOrders = new List<Order>() { testOrder1, testOrder2 };
mockContract.GetOrderList(Arg.Any<int>()).Returns(testOrders);
presenter.FillOrderList();
Assert.AreEqual(mockCustomerOrdersView.Orders.Count, testOrders.Count);
Assert.AreEqual(mockCustomerOrdersView.Orders[0].Id, testOrder1.Id);
Assert.AreEqual(mockCustomerOrdersView.Orders[0].PlacingDate, testOrder1.PlacingDate);
Assert.AreEqual(mockCustomerOrdersView.Orders[0].Status, testOrder1.Status);
Assert.AreEqual(mockCustomerOrdersView.Orders[1].Id, testOrder2.Id);
Assert.AreEqual(mockCustomerOrdersView.Orders[1].PlacingDate, testOrder2.PlacingDate);
Assert.AreEqual(mockCustomerOrdersView.Orders[1].Status, testOrder2.Status);
}
//Interfase
public IList<Order> GetAllOrders()
{
IList<Order> OrderList = new List<Order>();
SqlCeConnection conn = SQLQueryString.connection;
conn.Open();
try
{
string commandText = SQLQueryString.SelectAllOrderString;
SqlCeCommand cmd = new SqlCeCommand(commandText, conn);
SqlCeDataReader dr = cmd.ExecuteReader();
Order ord;
while (dr.Read())
{
IList<OrderItem> OrderItem = GetOrderItems((int)dr[0], conn);
ord = new Order();
ord.Id = (int)dr[0];
ord.PlacingDate = (DateTime)dr[1];
ord.Status = (Status)dr[2];
ord.User = GetUser((int)dr[3], conn);
OrderList.Add(ord);
}
return OrderList;
}
catch (SqlCeException ex)
{
log.Error(ex.Message);
return null;
}
finally
{
conn.Close();
}
}
public void GetOrderItemsTest()
{
Order testOrder1 = new Order() { Id = 1 };
Order testOrder2 = new Order() { Id = 2 };
List<Order> testOrders = new List<Order>() { testOrder1, testOrder2 };
//mockCustomerOrdersView.Orders.Returns(testOrders);
OrderItem testOrderItem1 = new OrderItem() { Id = 0, Count = 2, Order = testOrder1, Product = new Product() { Id = 1, Name = "Test Product 1", } };
OrderItem testOrderItem2 = new OrderItem() { Id = 1, Count = 5, Order = testOrder1, Product = new Product() { Id = 2, Name = "Test Product 2", } };
List<OrderItem> testOrderItems = new List<OrderItem>() { testOrderItem1, testOrderItem2 };
mockContract.GetOrderItems(Arg.Any<int>()).Returns(testOrderItems);
presentor.GetOrderItems(mocktechnologistOrdersView.Orders[0]);
Assert.AreEqual(mocktechnologistOrdersView.Orders, testOrders);
Assert.AreEqual(mocktechnologistOrdersView.Orders[1].Items, null);
Assert.AreEqual(mocktechnologistOrdersView.Orders[0].Items.Count, testOrder1.Items.Count);
Assert.AreEqual(mocktechnologistOrdersView.Orders[0].Items[0], testOrder1.Items[0]);
Assert.AreEqual(mocktechnologistOrdersView.Orders[0].Items[1], testOrder1.Items[1]);
}
public static ClientOrder TranslateToClientOrder(Order order)
{
if (order != null)
{
ClientOrder clientOrder = new ClientOrder(order.Id);
clientOrder.PlacingDate = order.PlacingDate;
clientOrder.Status = order.Status;
if (order.Items != null)
{
clientOrder.Products = new System.ComponentModel.BindingList<ClientOrderItem>();
foreach (var item in order.Items)
{
clientOrder.Products.Add(TranslateToClientOrderItem(item));
}
}
return clientOrder;
}
return null;
}
public static Order TranslateToOrder(ClientOrder clientOrder, User user)
{
if (clientOrder != null)
{
Order order = new Order();
order.Id = clientOrder.Id;
order.PlacingDate = clientOrder.PlacingDate;
order.Status = clientOrder.Status;
order.User = user;
if (clientOrder.Products != null)
{
order.Items = new List<OrderItem>();
for (int i = 0; i < clientOrder.Products.Count; i++)
{
order.Items.Add(TranslateToOrderItem(clientOrder.Products[i], order));
}
}
return order;
}
return null;
}
public void TranslateToClientOrderTest()
{
DateTime dt = DateTime.Now;
Order order = new Order()
{
Id = 10,
PlacingDate = dt,
Status = Status.New,
User = new User()
{
Id = 1,
Login = "******",
Name = "Name",
Password = "******",
Role = Role.Customer
},
Items = new List<OrderItem>()
{
new OrderItem
{
Id=5,
Count=2,
Product=new Product(){Id=1,Name="Test product 1", Price=new ProductPrice(){Price=100}}
},
new OrderItem
{
Id=20,
Count=10,
Product=new Product(){Id=1,Name="Test product 2", Price=new ProductPrice(){Price=1000}}
}
}
};
ClientOrder clientOrder = EntitiesTranslator.TranslateToClientOrder(order);
Assert.AreEqual(order.Id, clientOrder.Id);
Assert.AreEqual(order.PlacingDate, clientOrder.PlacingDate);
Assert.AreEqual(order.Status, clientOrder.Status);
Assert.AreEqual(order.Items.Count, clientOrder.Products.Count);
Assert.AreEqual(order.Items[0].Product.Name, clientOrder.Products[0].Name);
Assert.AreEqual(order.Items[1].Product.Name, clientOrder.Products[1].Name);
}
public Order SaveNewOrder(Order order)
{
return orderDAL.SaveNewOrder(order);
}
public void RemoveOrder(Order order)
{
orderDAL.RemoveOrder(order);
}
public Order SaveNewOrder(Order order)
{
throw new NotImplementedException();
}
public void RemoveOrder(Order order)
{
throw new NotImplementedException();
}
public Order SaveNewOrder(Order order)
{
SqlCeConnection conn = SQLQueryString.connection;
conn.Open();
DateTime date = DateTime.Now;
try
{
string commandText = SQLQueryString.InsertOrderString;
SqlCeCommand cmd = new SqlCeCommand(commandText, conn);
cmd.Parameters.AddWithValue("@date", date);
cmd.Parameters.AddWithValue("@status", order.Status);
cmd.Parameters.AddWithValue("@user", order.User.Id);
cmd.ExecuteNonQuery();
Order neworder = new Order();
neworder.Id = GetOrderID(date, conn);
neworder.PlacingDate = date;
neworder.Status = order.Status;
neworder.User = GetUser(order.User.Id, conn);
return neworder;
}
finally
{
conn.Close();
}
}
public void TranslateToOrderItemTest()
{
ClientOrderItem clientOrderItem = new ClientOrderItem(1)
{
Count = 10,
Name = "Test product 1",
Price = 100,
};
Order order = new Order();
OrderItem orderItem = EntitiesTranslator.TranslateToOrderItem(clientOrderItem, order);
Assert.AreEqual(orderItem.Product.Id, clientOrderItem.Id);
Assert.AreEqual(orderItem.Count, clientOrderItem.Count);
Assert.AreEqual(orderItem.Order, order);
Assert.AreEqual(orderItem.Product.Name, clientOrderItem.Name);
}
public Order GetOrder(int orderID, SqlCeConnection conn)
{
try
{
string commandText = SQLQueryString.SelectOrderbyID;
SqlCeCommand cmd = new SqlCeCommand(commandText, conn);
cmd.Parameters.AddWithValue("@id", orderID);
SqlCeDataReader dr = cmd.ExecuteReader();
Order ord;
while (dr.Read())
{
ord = new Order();
ord.Id = (int)dr[0];
ord.PlacingDate = (DateTime)dr[1];
ord.Status = (Status)dr[2];
ord.User = GetUser((int)dr[3], conn);
return ord;
}
return null;
}
catch (SqlCeException ex)
{
log.Error(ex.Message);
return null;
}
}
public void RemoveOrder(Order order)
{
SqlCeConnection conn = SQLQueryString.connection;
try
{
conn.Open();
string commandText = SQLQueryString.DeleteOrderString;
SqlCeCommand cmd = new SqlCeCommand(commandText, conn);
cmd.Parameters.AddWithValue("@id", order.Id);
cmd.ExecuteNonQuery();
Console.WriteLine("Data has been successfully deleted!");
}
finally
{
conn.Close();
}
}
