public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var result = new List <string>();
XDocument xDoc = XDocument.Parse(xmlString);
var elements = xDoc.Root.Elements();
foreach (var o in elements)
{
var customer = o.Element("Customer")?.Value;
var employeeName = o.Element("Employee")?.Value;
var timeAsString = o.Element("DateTime")?.Value;
var typeAsString = o.Element("Type")?.Value;
if (customer == null || timeAsString == null || typeAsString == null || employeeName == null)
{
result.Add(FailureMessage);
continue;
}
var employee = context.Employees.SingleOrDefault(e => e.Name == employeeName);
if (employee == null)
{
result.Add(FailureMessage);
continue;
}
var time = DateTime.ParseExact(timeAsString, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
object typeObj;
var isTypeValid = Enum.TryParse(typeof(OrderType), typeAsString, out typeObj);
if (!isTypeValid)
{
result.Add(FailureMessage);
continue;
}
var type = (OrderType)typeObj;
bool areItemsValid = true;
var items = new List <ItemDto>();
foreach (var i in o.Element("Items").Elements())
{
string name = i.Element("Name")?.Value;
string quantityAsString = i.Element("Quantity")?.Value;
if (quantityAsString == null || name == null)
{
result.Add(FailureMessage);
areItemsValid = false;
}
int quantity = int.Parse(quantityAsString);
var item = context.Items.SingleOrDefault(it => it.Name == name);
if (item == null || quantity <= 0)
{
result.Add(FailureMessage);
areItemsValid = false;
}
items.Add(new ItemDto {
Name = name, Quantity = quantity
});
}
if (!areItemsValid)
{
result.Add(FailureMessage);
continue;
}
var order = new Order {
Customer = customer, DateTime = time, Employee = employee, Type = type
};
context.Orders.Add(order);
foreach (var itemDto in items)
{
var item = context.Items.SingleOrDefault(i => i.Name == itemDto.Name);
context.OrderItems.Add(new OrderItem {
Item = item, Order = order, Quantity = itemDto.Quantity
});
}
context.SaveChanges();
result.Add($"Order for {customer} on {time.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)} added");
}
return(String.Join(Environment.NewLine, result));
}
public static string ImportItems(FastFoodDbContext context, string jsonString)
{
var sb = new StringBuilder();
var deserializedItems = JsonConvert.DeserializeObject <ItemDto[]>(jsonString);
var validItems = new List <Item>();
var validCategories = new List <Category>();
Category category = null;
foreach (var itemDto in deserializedItems)
{
if (!IsValid(itemDto))
{
sb.AppendLine(FailureMessage);
continue;
}
if (validCategories.All(c => c.Name != itemDto.Category))
{
category = new Category
{
Name = itemDto.Category
};
validCategories.Add(category);
}
else
{
category = validCategories.SingleOrDefault(c => c.Name == itemDto.Category);
}
if (validItems.Any(i => i.Name == itemDto.Name))
{
sb.AppendLine(FailureMessage);
continue;
}
var validItem = new Item
{
Name = itemDto.Name,
Category = category,
Price = itemDto.Price
};
validItems.Add(validItem);
sb.AppendLine(string.Format(SuccessMessage, validItem.Name));
}
context.Categories.AddRange(validCategories);
context.Items.AddRange(validItems);
var result = sb.ToString();
return(result);
}
private static void BonusTask(FastFoodDbContext context)
{
var bonusOutput = DataProcessor.Bonus.UpdatePrice(context, "Ribs", 8.00m);
Console.WriteLine(bonusOutput);
}
private static Category FindOrCreateCategory(FastFoodDbContext context, string categoryName)
{
var category = FindCategory(context, categoryName) ?? CreateCategory(context, categoryName);
return(category);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var xml = XDocument.Parse(xmlString);
var deserializedOrders = xml.Element("Orders");
var validOrders = new List <Order>();
var sb = new StringBuilder();
foreach (var orderElement in deserializedOrders.Elements())
{
var order = new Order();
var customer = orderElement.Element("Customer").Value;
order.Customer = customer;
var employee = FindEmployee(context, orderElement.Element("Employee").Value);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
order.Employee = employee;
var orderType = Enum.Parse <OrderType>(orderElement.Element("Type").Value);
order.Type = orderType;
var dateTime = DateTime.ParseExact(orderElement.Element("DateTime").Value, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
order.DateTime = dateTime;
var orderItems = new List <OrderItem>();
var itemsElement = orderElement.Element("Items");
foreach (var itemElement in itemsElement.Elements())
{
var item = FindItem(context, itemElement.Element("Name").Value);
if (item == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var quantity = int.Parse(itemElement.Element("Quantity").Value);
var orderItem = new OrderItem
{
Item = item,
Quantity = quantity
};
orderItems.Add(orderItem);
}
order.OrderItems = orderItems;
if (!IsValid(order))
{
sb.AppendLine(FailureMessage);
continue;
}
validOrders.Add(order);
sb.AppendLine(string.Format("Order for {0} on {1} added",
order.Customer,
order.DateTime.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)));
}
context.Orders.AddRange(validOrders);
context.SaveChanges();
var result = sb.ToString();
return(result);
}
private static Item FindItem(FastFoodDbContext context, string itemName)
{
var item = context.Items.SingleOrDefault(i => i.Name == itemName);
return(item);
}
private static Position FindOrCreatePosition(FastFoodDbContext context, string positionName)
{
var position = FindPosition(context, positionName) ?? CreatePosition(context, positionName);
return(position);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var deserializedOrders = (OrderDto[])xmlSerializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
var orders = new List <Order>();
foreach (var orderDto in deserializedOrders)
{
var employee = context
.Employees
.FirstOrDefault(e => e.Name == orderDto.Employee);
var employeeExists = employee != null;
if (!IsValid(orderDto) || !employeeExists)
{
sb.AppendLine(FailureMessage);
continue;
}
var orderItems = new List <OrderItem>();
var hasInvalidItems = false;
foreach (var oiDto in orderDto.Items)
{
var item = context.Items.FirstOrDefault(i => i.Name == oiDto.ItemName);
if (item == null)
{
hasInvalidItems = true;
break;
}
var orderItem = new OrderItem()
{
Item = item,
Quantity = oiDto.Quantity
};
orderItems.Add(orderItem);
}
if (hasInvalidItems)
{
sb.AppendLine(FailureMessage);
continue;
}
var isTypeValid = Enum.TryParse(orderDto.Type, true, out OrderType orderType);
if (!isTypeValid)
{
sb.AppendLine(FailureMessage);
continue;
}
var dateTime = DateTime.ParseExact(orderDto.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var order = new Order()
{
Customer = orderDto.Customer,
Employee = employee,
DateTime = dateTime,
Type = orderType,
OrderItems = orderItems
};
orders.Add(order);
sb.AppendLine(string.Format(SuccessfullyAddedOrder, orderDto.Customer, orderDto.DateTime));
}
context
.Orders
.AddRange(orders);
context
.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var deserializedOrders = (OrderDto[])serializer.Deserialize(new StringReader(xmlString));
var sb = new StringBuilder();
var orders = new List <Order>();
var orderItems = new List <OrderItem>();
foreach (OrderDto orderDto in deserializedOrders)
{
bool isItemValid = true;
if (!IsValid(orderDto))
{
sb.AppendLine(FailureMessage);
continue;
}
foreach (OrderItemDto orderItemDto in orderDto.Items)
{
if (!IsValid(orderItemDto))
{
sb.AppendLine(FailureMessage);
isItemValid = false;
break;
}
}
if (!isItemValid)
{
sb.AppendLine(FailureMessage);
continue;
}
Employee employee = context.Employees.SingleOrDefault(e => e.Name == orderDto.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
bool itemsExist = CheckIfAllItemsExist(context, orderDto.Items);
if (!itemsExist)
{
sb.AppendLine(FailureMessage);
continue;
}
var datetime = DateTime.ParseExact(orderDto.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
OrderType type = Enum.TryParse(orderDto.Type, out OrderType orderType) ? orderType : OrderType.ForHere;
var order = new Order
{
Customer = orderDto.Customer,
DateTime = datetime,
Type = type,
Employee = employee
};
orders.Add(order);
foreach (OrderItemDto orderItemDto in orderDto.Items)
{
Item item = context.Items.SingleOrDefault(i => i.Name == orderItemDto.Name);
var orderItem = new OrderItem
{
Order = order,
Item = item,
Quantity = orderItemDto.Quantity
};
orderItems.Add(orderItem);
}
string date = datetime.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
sb.AppendLine($"Order for {order.Customer} on {date} added");
}
context.Orders.AddRange(orders);
context.SaveChanges();
context.OrderItems.AddRange(orderItems);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var xDoc = XDocument.Parse(xmlString);
var elements = xDoc.Root.Elements();
var sb = new StringBuilder();
foreach (var e in elements)
{
var customer = e.Element("Customer").Value;
var employee = e.Element("Employee").Value;
var dateTime = e.Element("DateTime").Value;
var type = e.Element("Type").Value;
if (customer == null || employee == null || dateTime == null || type == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var currentEmployee = context.Employees.FirstOrDefault(o => o.Name == employee);
if (currentEmployee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var currentDateTime = DateTime.ParseExact(dateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
Object typeObj;
var IsValidType = Enum.TryParse(typeof(OrderType), type, out typeObj);
if (!IsValidType)
{
sb.AppendLine(FailureMessage);
continue;
}
var currentType = (OrderType)typeObj;
var isValidItems = true;
var listItems = new List <ItemDto>();
foreach (var itemElement in e.Element("Items").Elements())
{
var itemName = itemElement.Element("Name")?.Value;
var quantity = itemElement.Element("Quantity")?.Value;
if (itemName == null || quantity == null)
{
sb.AppendLine(FailureMessage);
isValidItems = false;
}
var currentQuantity = int.Parse(quantity);
var itemExist = context.Items.Any(it => it.Name == itemName);
if (!itemExist || currentQuantity <= 0)
{
sb.AppendLine(FailureMessage);
isValidItems = false;
}
listItems.Add(new ItemDto()
{
Name = itemName, Quantity = currentQuantity
});
}
if (!isValidItems)
{
sb.AppendLine(FailureMessage);
continue;
}
var order = new Order()
{
Customer = customer, Employee = currentEmployee, DateTime = currentDateTime, Type = currentType
};
context.Orders.Add(order);
foreach (var dto in listItems)
{
var item = context.Items.FirstOrDefault(it => it.Name == dto.Name);
context.OrderItems.Add(new OrderItem()
{
Item = item, Order = order, Quantity = dto.Quantity
});
}
context.SaveChanges();
sb.AppendLine($"Order for {customer} on {dateTime} added");
}
return(sb.ToString().Trim());
}
public static string ImportEmployees(FastFoodDbContext context, string jsonString)
{
var dObjs = JsonConvert.DeserializeAnonymousType(jsonString, new[]
{
new
{
Name = String.Empty,
Age = 0,
Position = String.Empty
}
});
var employees = new List <Employee>();
var sb = new StringBuilder();
foreach (var e in dObjs)
{
if (String.IsNullOrEmpty(e.Name) || e.Name.Length < 3 || e.Name.Length > 30 || e.Age < 15 || e.Age > 80 || e.Position.Length < 3 || e.Position.Length > 30)
{
sb.AppendLine(FailureMessage);
continue;
}
var positionExist = context.Positions.Any(p => p.Name == e.Position);
if (!positionExist)
{
context.Positions.Add(new Position()
{
Name = e.Position
});
context.SaveChanges();
}
var position = context.Positions.FirstOrDefault(p => p.Name == e.Position);
var newEmployee = new Employee()
{
Name = e.Name,
Age = e.Age,
Position = position
};
employees.Add(newEmployee);
sb.AppendLine(String.Format(SuccessMessage, e.Name));
}
context.Employees.AddRange(employees);
context.SaveChanges();
return(sb.ToString().Trim());
//------------------------------------------------------------------------------------
//var result = new List<string>();
//var objects = JsonConvert.DeserializeAnonymousType(jsonString, new[] { new { Name = String.Empty, Age = 0, Position = String.Empty } });
//foreach (var obj in objects)
//{
// if (obj.Name == null || obj.Position == null || obj.Name.Length < 3 || obj.Name.Length > 30 || obj.Age < 15 || obj.Age > 80 || obj.Position.Length < 3 || obj.Position.Length > 30)
// {
// result.Add(FailureMessage);
// continue;
// }
// bool positionExists = context.Positions
// .Any(p => p.Name == obj.Position);
// if (!positionExists)
// {
// context.Positions.Add(new Position { Name = obj.Position });
// context.SaveChanges();
// }
// var position = context.Positions.FirstOrDefault(p => p.Name == obj.Position);
// context.Employees.Add(new Employee { Age = obj.Age, Name = obj.Name, Position = position });
// context.SaveChanges();
// result.Add(String.Format(SuccessMessage, obj.Name));
//}
//return String.Join(Environment.NewLine, result);
}
public static string ImportItems(FastFoodDbContext context, string jsonString)
{
//var result = new List<string>();
//var objects = JsonConvert.DeserializeAnonymousType(jsonString, new[] { new { Name = String.Empty, Price = 0.00m, Category = String.Empty } });
//foreach (var obj in objects)
//{
// bool itemExists = context.Items.Any(i => i.Name == obj.Name);
// if (itemExists || obj.Name.Length < 3 || obj.Name.Length > 30 || obj.Price < 0.01m || obj.Category.Length < 3 || obj.Category.Length > 30)
// {
// result.Add(FailureMessage);
// continue;
// }
// bool categoryExists = context.Categories.Any(c => c.Name == obj.Category);
// if (!categoryExists)
// {
// context.Categories.Add(new Category { Name = obj.Category });
// context.SaveChanges();
// }
// var category = context.Categories.SingleOrDefault(c => c.Name == obj.Category);
// context.Items.Add(new Item { Category = category, Name = obj.Name, Price = obj.Price });
// context.SaveChanges();
// result.Add(String.Format(SuccessMessage, obj.Name));
//}
//return String.Join(Environment.NewLine, result);
//-----------------------------------------------------------------------------------------------
var deserializeItems = JsonConvert.DeserializeAnonymousType(jsonString, new[]
{
new
{
Name = String.Empty,
Price = 0.00m,
Category = String.Empty
}
});
var itemsList = new List <Item>();
var sb = new StringBuilder();
foreach (var obj in deserializeItems)
{
var itemExist = context.Items.Any(it => it.Name == obj.Name);
if (itemExist || obj.Name.Length < 3 || obj.Name.Length > 30 || obj.Price < 0.01m || obj.Category.Length < 3 || obj.Category.Length > 30)
{
sb.AppendLine(FailureMessage);
continue;
}
var categoryExist = context.Categories.Any(c => c.Name == obj.Category);
if (!categoryExist)
{
context.Categories.Add(new Category()
{
Name = obj.Category
});
context.SaveChanges();
}
var category = context.Categories.SingleOrDefault(c => c.Name == obj.Category);
var newItem = new Item()
{
Category = category,
Name = obj.Name,
Price = obj.Price,
};
context.Items.Add(newItem);
context.SaveChanges();
sb.AppendLine(String.Format(SuccessMessage, obj.Name));
}
var result = sb.ToString().Trim();
return(result);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var deserializedOrders = (OrderDto[])serializer
.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var validOrders = new List <Order>();
var sb = new StringBuilder();
foreach (var orderDto in deserializedOrders)
{
if (!IsValid(orderDto))
{
sb.AppendLine(FailureMessage);
continue;
}
var employee = context
.Employees
.FirstOrDefault(e => e.Name == orderDto.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var dateTime = DateTime.ParseExact(orderDto.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var type = Enum.Parse <OrderType>(orderDto.Type);
//• If any of the order’s items do not exist, do not import the order.
var itemsExist = orderDto
.Items
.All(i => context.Items.Any(it => it.Name == i.Name));
if (!itemsExist)
{
sb.AppendLine(FailureMessage);
continue;
}
var orderItems = new List <OrderItem>();
var currentOrder = new Order
{
Customer = orderDto.Customer,
Employee = employee,
DateTime = dateTime,
Type = type
};
foreach (var oi in orderDto.Items)
{
var item = context
.Items
.FirstOrDefault(i => i.Name == oi.Name);
var orderItem = new OrderItem
{
Item = item,
Order = currentOrder,
Quantity = oi.Quantity
};
orderItems.Add(orderItem);
}
currentOrder.OrderItems = orderItems;
validOrders.Add(currentOrder);
sb.AppendLine($"Order for {currentOrder.Customer} on {dateTime:dd/MM/yyyy HH:mm} added");
}
context.Orders.AddRange(validOrders);
context.SaveChanges();
var result = sb.ToString();
return(result);
}
public static string UpdatePrice(FastFoodDbContext context, string itemName, decimal newPrice)
{
throw new NotImplementedException();
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
StringBuilder sb = new StringBuilder();
var orderItemsList = new List <OrderItem>();
var orderList = new List <Order>();
var serializer = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var deserializedOrders = (OrderDto[])serializer.Deserialize(new StringReader(xmlString));
foreach (var orderDto in deserializedOrders)
{
bool isValidItem = true;
if (!IsValid(orderDto))
{
sb.AppendLine(FailureMessage);
continue;
}
foreach (var itemDto in orderDto.OrderItems)
{
if (!IsValid(itemDto))
{
sb.AppendLine(FailureMessage);
isValidItem = false;
break;
}
}
if (!isValidItem)
{
sb.AppendLine(FailureMessage);
continue;
}
var employee = context.Employees.FirstOrDefault(x => x.Name == orderDto.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var areValidItems = AreValidItems(context, orderDto.OrderItems);
if (!areValidItems)
{
sb.AppendLine(FailureMessage);
continue;
}
var date = DateTime
.ParseExact(orderDto.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var orderType = Enum.Parse <OrderType>(orderDto.Type);
var order = new Order
{
Customer = orderDto.Customer,
Employee = employee,
DateTime = date,
Type = orderType
};
orderList.Add(order);
foreach (var itemDto in orderDto.OrderItems)
{
var item = context.Items.FirstOrDefault(i => i.Name == itemDto.Name);
var orderItem = new OrderItem
{
Order = order,
Item = item,
Quantity = itemDto.Quantity
};
orderItemsList.Add(orderItem);
}
sb.AppendLine
($"Order for {orderDto.Customer} on {date.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)} added");
}
context.Orders.AddRange(orderList);
context.SaveChanges();
context.OrderItems.AddRange(orderItemsList);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var attr = new XmlRootAttribute("Orders");
var serializer = new XmlSerializer(typeof(List <OrderImportDto>), attr);
StringBuilder sb = new StringBuilder();
var validOrders = new List <Order>();
var validItemsNames = context
.Items
.Select(i => i.Name)
.ToList();
using (StringReader reader = new StringReader(xmlString))
{
var ordersDto = (List <OrderImportDto>)serializer.Deserialize(reader);
foreach (var dto in ordersDto)
{
var employee = context
.Employees
.FirstOrDefault(e => e.Name == dto.Employee);
if (!IsValid(dto) ||
!dto.Items.All(IsValid) ||
employee == null ||
!dto.Items.All(i => validItemsNames.Contains(i.Name)))
{
sb.AppendLine(FailureMessage);
continue;
}
var order = new Order
{
Customer = dto.Customer,
DateTime = DateTime.ParseExact(dto.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
Type = dto.Type,
Employee = employee
};
foreach (var item in dto.Items)
{
var orderItemToAdd = new OrderItem
{
Order = order,
Item = context.Items.First(i => i.Name == item.Name),
Quantity = item.Quantity
};
order.OrderItems.Add(orderItemToAdd);
}
validOrders.Add(order);
sb.AppendLine($"Order for {order.Customer} on {order.DateTime.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)} added");
}
}
context.Orders.AddRange(validOrders);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var sb = new StringBuilder();
var ser = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var desOrders = (OrderDto[])ser.Deserialize(new StringReader(xmlString));
var validOrders = new List <Order>();
var existingItems = context.Items.ToArray();
var existingemployees = context.Employees.ToArray();
foreach (var dtoOrder in desOrders)
{
if (!IsValid(dtoOrder))
{
sb.AppendLine(FailureMessage);
continue;
}
var employee = existingemployees.FirstOrDefault(x => x.Name == dtoOrder.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var dateTime = DateTime.ParseExact(dtoOrder.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var validType = Enum.TryParse <OrderType>(dtoOrder.Type, out OrderType type);
if (!validType)
{
sb.AppendLine(FailureMessage);
continue;
}
var newOrder = new Order
{
Customer = dtoOrder.Customer,
DateTime = dateTime,
EmployeeId = employee.Id,
Type = type
};
bool isItemExisting = true;
foreach (var itemDto in dtoOrder.Items)
{
var currentItem = existingItems.FirstOrDefault(x => x.Name == itemDto.Name);
if (currentItem == null)
{
sb.AppendLine(FailureMessage);
isItemExisting = false;
break;
}
newOrder
.OrderItems
.Add(new OrderItem
{
Quantity = itemDto.Quantity,
ItemId = currentItem.Id
});
}
if (!isItemExisting)
{
continue;
}
sb.AppendLine(string.Format(SuccessMessageOrder, dtoOrder.Customer, dtoOrder.DateTime));
validOrders.Add(newOrder);
}
context.Orders.AddRange(validOrders);
context.SaveChanges();
var result = sb.ToString().TrimEnd();
return(result);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var sb = new StringBuilder();
bool noItems = false;
var orders = new List <Order>();
var serializer = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var deserializedOrders = (OrderDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
foreach (var desOrder in deserializedOrders)
{
if (!IsValid(desOrder))
{
sb.AppendLine(FailureMessage);
continue;
}
var datetime = DateTime.ParseExact(desOrder.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var employee = context.Employees.FirstOrDefault(x => x.Name == desOrder.Employee);
foreach (var desOrderItem in desOrder.Items)
{
if (!context.Items.Any(x => x.Name == desOrderItem.Name))
{
noItems = true;
}
}
if (datetime == null || employee == null || noItems)
{
sb.AppendLine(FailureMessage);
continue;
}
var orderItems = new List <OrderItem>();
var itemExists = true;
foreach (var desOrderItem in desOrder.Items)
{
if (!context.Items.Any(x => x.Name == desOrderItem.Name))
{
itemExists = false;
}
if (itemExists)
{
var orderItem = new OrderItem()
{
Item = context.Items.FirstOrDefault(x => x.Name == desOrderItem.Name),
Quantity = desOrderItem.Quantity
};
orderItems.Add(orderItem);
}
else
{
sb.AppendLine(FailureMessage);
continue;
}
}
var order = new Order()
{
Customer = desOrder.Customer,
DateTime = datetime,
Employee = employee,
OrderItems = orderItems
};
orders.Add(order);
var date = string.Format($"{datetime:dd/MM/yyyy HH:mm}", CultureInfo.InvariantCulture);
var datestring = datetime.ToString("dd/MM/yyyy HH:mm");
sb.AppendLine($"Order for {desOrder.Customer} on {date} added");
}
context.Orders.AddRange(orders);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
private static Employee FindEmployee(FastFoodDbContext context, string employeeName)
{
var employee = context.Employees.SingleOrDefault(e => e.Name == employeeName);
return(employee);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var orders = (OrderDto[])serializer.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var sb = new StringBuilder();
var validOrders = new List <Order>();
foreach (var dto in orders)
{
if (!IsValid(dto))
{
sb.AppendLine(FailureMessage);
continue;
}
Employee employee = FindEmployee(context, dto.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
bool itemExist = true;
var orderItems = new List <OrderItem>();
foreach (var orderItemDto in dto.Items)
{
Item item = FindItem(context, orderItemDto.Name);
if (item == null)
{
itemExist = false;
break;
}
var orderItem = new OrderItem
{
Item = item,
Quantity = orderItemDto.Quantity
};
orderItems.Add(orderItem);
}
if (!itemExist)
{
sb.AppendLine(FailureMessage);
continue;
}
bool isValidDate = DateTime.TryParseExact(dto.DateTime,
"dd/MM/yyyy HH:mm",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out DateTime dateTime);
OrderType orderType = (OrderType)Enum.Parse(typeof(OrderType), dto.Type);
var order = new Order
{
Customer = dto.Customer,
Employee = employee,
DateTime = dateTime,
Type = orderType,
OrderItems = orderItems
};
validOrders.Add(order);
sb.AppendLine(String.Format(SuccessMessageOrder, order.Customer, order.DateTime.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)));
}
context.Orders.AddRange(validOrders);
context.SaveChanges();
string result = sb.ToString().Trim();
return(result);
}
private static Position FindPosition(FastFoodDbContext context, string positionName)
{
var position = context.Positions.SingleOrDefault(p => p.Name == positionName);
return(position);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var sb = new StringBuilder();
var serialiser = new XmlSerializer(typeof(OrderDto[]), new XmlRootAttribute("Orders"));
var deserialisedOrders = (OrderDto[])serialiser.Deserialize(new MemoryStream(Encoding.UTF8.GetBytes(xmlString)));
var validOrders = new List <Order>();
var orderItems = new List <OrderItem>();
foreach (var obj in deserialisedOrders)
{
if (!IsValid(obj))
{
sb.AppendLine(FailureMessage);
continue;
}
var isItemInvalid = false;
var items = new Dictionary <Item, int>();
foreach (var itemImportDto in obj.Items)
{
if (!IsValid(itemImportDto))
{
sb.AppendLine(FailureMessage);
isItemInvalid = true;
}
var item = context.Items.FirstOrDefault(p => p.Name == itemImportDto.Name);
if (item == null)
{
isItemInvalid = true;
}
else
{
items.Add(item, itemImportDto.Quantity);
}
}
if (isItemInvalid)
{
continue;
}
var employee = context.Employees.FirstOrDefault(p => p.Name == obj.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
OrderType type;
DateTime date;
try
{
type = Enum.Parse <OrderType>(obj.Type);
date = DateTime.ParseExact(obj.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
}
catch
{
sb.AppendLine(FailureMessage);
continue;
}
var order = new Order
{
Customer = obj.Customer,
Type = type,
DateTime = date,
Employee = employee,
};
validOrders.Add(order);
foreach (var item in items)
{
var orderItem = new OrderItem()
{
Order = order,
Item = item.Key,
Quantity = item.Value
};
orderItems.Add(orderItem);
}
sb.AppendLine(String.Format(SuccessOrder, obj.Customer, obj.DateTime));
}
context.Orders.AddRange(validOrders);
context.OrderItems.AddRange(orderItems);
context.SaveChanges();
return(sb.ToString().Trim());
}
private static Category FindCategory(FastFoodDbContext context, string categoryName)
{
var category = context.Categories.SingleOrDefault(c => c.Name == categoryName);
return(category);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var serializer = new XmlSerializer(typeof(OrderDTO[]), new XmlRootAttribute("Orders"));
StringBuilder sb = new StringBuilder();
List <Order> orders = new List <Order>();
List <OrderItem> orderItems = new List <OrderItem>();
using (var reader = new StringReader(xmlString))
{
OrderDTO[] desirializedOrders = (OrderDTO[])serializer.Deserialize(reader);
foreach (OrderDTO orderDTO in desirializedOrders)
{
if (!IsValid(orderDTO))
{
sb.AppendLine(FailureMessage);
continue;
}
bool allItemsValid = true;
foreach (OrderItemDTO orderItemDTO in orderDTO.OrderItemDTOs)
{
if (!IsValid(orderItemDTO))
{
allItemsValid = false;
break;
}
}
if (!allItemsValid)
{
sb.AppendLine(FailureMessage);
continue;
}
bool allItemsExist = true;
foreach (OrderItemDTO orderItemDTO in orderDTO.OrderItemDTOs)
{
if (!context.Items.Any(i => i.Name == orderItemDTO.Name))
{
allItemsExist = false;
break;
}
}
if (!allItemsExist)
{
sb.AppendLine(FailureMessage);
continue;
}
Employee employee = context.Employees.FirstOrDefault(e => e.Name == orderDTO.Employee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
Order order = new Order
{
Customer = orderDTO.Customer,
Employee = employee,
DateTime = DateTime.ParseExact(orderDTO.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture),
Type = Enum.Parse <OrderType>(orderDTO.Type)
};
orders.Add(order);
foreach (OrderItemDTO orderItemDTO in orderDTO.OrderItemDTOs)
{
Item item = context.Items.FirstOrDefault(i => i.Name == orderItemDTO.Name);
OrderItem orderItem = new OrderItem
{
Order = order,
Item = item,
Quantity = int.Parse(orderItemDTO.Quantity)
};
orderItems.Add(orderItem);
}
sb.AppendLine($"Order for {order.Customer} on {order.DateTime.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)} added");
}
context.Orders.AddRange(orders);
context.SaveChanges();
context.OrderItems.AddRange(orderItems);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
throw new NotImplementedException();
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
var xmlSerializer = new XmlSerializer(typeof(ImportOrdersDto[]), new
XmlRootAttribute("Orders"));
var importOrdersDto = (ImportOrdersDto[])xmlSerializer.Deserialize(new StringReader(xmlString));
var orders = new List <Order>();
var sb = new StringBuilder();
foreach (var orderDto in importOrdersDto)
{
var ordersItems = new List <OrderItem>();
var employee = context.Employees.FirstOrDefault(x => x.Name == orderDto.Employee);
if (!IsValid(orderDto) || employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
var ctxItems = context.Items.Select(x => x.Name).ToArray();
foreach (var itemDto in orderDto.Item)
{
if (!ctxItems.Contains(itemDto.Name))
{
sb.AppendLine(FailureMessage);
break;
}
var item = context.Items.FirstOrDefault(x => x.Name == itemDto.Name);
var orderItem = new OrderItem
{
Item = item,
Quantity = itemDto.Quantity
};
ordersItems.Add(orderItem);
}
var date = DateTime.ParseExact(orderDto.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
var order = new Order
{
Customer = orderDto.Customer,
Employee = employee,
DateTime = date,
Type = Enum.Parse <OrderType>(orderDto.Type),
OrderItems = ordersItems
};
orders.Add(order);
sb.AppendLine($"Order for {orderDto.Customer} on {date.ToString("dd/MM/yyyy HH:mm")} added");
}
context.Orders.AddRange(orders);
context.SaveChanges();
string result = sb.ToString().TrimEnd();
return(result);
}
private static void BonusTask(FastFoodDbContext context)
{
var bonusOutput = DataProcessor.Bonus.UpdatePrice(context, "Cheeseburger", 6.50m);
Console.WriteLine(bonusOutput);
}
public static string ImportOrders(FastFoodDbContext context, string xmlString)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(OrderDTO[]), new XmlRootAttribute("Orders"));
OrderDTO[] deserializedOrders = (OrderDTO[])xmlSerializer.Deserialize(new StringReader(xmlString));
List <OrderItem> orderItems = new List <OrderItem>();
List <Order> orders = new List <Order>();
StringBuilder sb = new StringBuilder();
foreach (var orderDTO in deserializedOrders)
{
bool isValidOrder = true;
if (!IsValid(orderDTO))
{
sb.AppendLine(FailureMessage);
continue;
}
foreach (var itemDTO in orderDTO.OrderItemsDTO)
{
if (!IsValid(itemDTO))
{
sb.AppendLine(FailureMessage);
isValidOrder = false;
break;
}
}
if (!isValidOrder)
{
sb.AppendLine(FailureMessage);
continue;
}
Employee employee = context.Employees.FirstOrDefault(e => e.Name == orderDTO.Employeee);
if (employee == null)
{
sb.AppendLine(FailureMessage);
continue;
}
bool itemsAreValid = ItemsAreValid(context, orderDTO.OrderItemsDTO);
if (!itemsAreValid)
{
sb.AppendLine(FailureMessage);
continue;
}
DateTime date = DateTime.ParseExact(orderDTO.DateTime, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture);
OrderType orderType = Enum.Parse <OrderType>(orderDTO.Type);
Order order = new Order()
{
Customer = orderDTO.Customer,
Employee = employee,
DateTime = date,
Type = orderType,
};
orders.Add(order);
foreach (var itemDTO in orderDTO.OrderItemsDTO)
{
Item item = context.Items.FirstOrDefault(i => i.Name == itemDTO.Name);
OrderItem orderItem = new OrderItem()
{
Order = order,
Item = item,
Quantity = itemDTO.Quantity
};
orderItems.Add(orderItem);
}
sb.AppendLine($"Order for {order.Customer} on {date.ToString("dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture)} added");
}
context.Orders.AddRange(orders);
context.SaveChanges();
context.OrderItems.AddRange(orderItems);
context.SaveChanges();
return(sb.ToString().Trim());
}
private static void ResetDatabase(FastFoodDbContext context)
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
}
public static string ExportCategoryStatistics(FastFoodDbContext context, string categoriesString)
{
var inputCategories = categoriesString.Split(',');
var cats = context.Categories
.Include(c => c.Items)
.ThenInclude(i => i.OrderItems)
.Where(c => inputCategories.Any(ic => ic == c.Name))
.ToArray();
var categList = new List <CategoryDto>();
foreach (var c in cats)
{
var name = c.Name;
var itemName = c.Items
.OrderByDescending(i => i.OrderItems.Sum(oi => i.Price * oi.Quantity))
.First()
.Name;
var totalMade = c.Items
.OrderByDescending(i => i.OrderItems.Sum(oi => i.Price * oi.Quantity)).First()
.OrderItems.Sum(oi => oi.Quantity * oi.Item.Price);
var timesSold = c.Items
.OrderByDescending(i => i.OrderItems.Sum(oi => oi.Quantity * i.Price)).First()
.OrderItems.Sum(oi => oi.Quantity);
categList.Add(new CategoryDto
{
Name = name,
ItemName = itemName,
TotalMade = totalMade,
TimesSold = timesSold
});
}
categList = categList
.OrderByDescending(c => c.TimesSold)
.ThenByDescending(c => c.TotalMade)
.ToList();
var xDoc = new XDocument();
xDoc.Add(new XElement("Categories"));
foreach (var c in categList)
{
var category = new XElement("Category");
category.Add(new XElement("Name", c.Name));
var mostPopular = new XElement("MostPopularItem");
mostPopular.Add(new XElement("Name", c.ItemName));
mostPopular.Add(new XElement("TotalMade", c.TotalMade));
mostPopular.Add(new XElement("TimesSold", c.TimesSold));
category.Add(mostPopular);
xDoc.Element("Categories").Add(category);
}
var result = xDoc.ToString();
return(result);
}
