public async Task <ActionResult> PostImportXml(OrdersDto ordersDto)
{
var idList = ordersDto.Orders.Select(o => o.OxId).ToArray();
if (await _context.Orders.AnyAsync(o => idList.Contains(o.OxId)))
{
return(Conflict());
}
var orders = ordersDto.Orders.Select(dto =>
{
var order = _mapper.Map <Order>(dto);
order.BillingAddresses.Add(_mapper.Map <BillingAddresse>(dto.BillingAddress));
foreach (var paymentDto in dto.Payments)
{
order.Payments.Add(_mapper.Map <Payment>(paymentDto));
}
foreach (var articleDto in dto.Articles)
{
order.Articles.Add(_mapper.Map <Article>(articleDto));
}
return(order);
});
await _context.Orders.AddRangeAsync(orders);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetOrders), ordersDto));
}
private static List <OrdersDto> convertToDto(List <Orders> orders)
{
var dtOrders = new List <OrdersDto>();
foreach (var order in orders)
{
var dto = new OrdersDto();
dto.OrderId = order.OrderId;
dto.Size = order.Size;
dto.Crust = order.Crust;
dto.Sausage = order.Sausage;
dto.Pepperoni = order.Pepperoni;
dto.Onions = order.Onions;
dto.GreenPeppers = order.GreenPeppers;
dto.Name = order.Name;
dto.Adress = order.Adress;
dto.Zip = order.Zip;
dto.Phone = order.Phone;
dto.TotalCost = order.TotalCost;
dto.PaymentType = order.PaymentType;
dto.Completed = order.Completed;
dtOrders.Add(dto);
}
return(dtOrders);
}
public async Task <ActionResult <OrdersDto> > GetordersById(int id)
{
var order = await _ordersRepository.GetById(id);
ICollection <OrderDetailsDto> odds = new List <OrderDetailsDto>();
foreach (var item in order.OrderDetails)
{
var product = await _productRepository.GetProductById(item.ProductId);
//Console.WriteLine("###############################" + item.ProductId);
OrderDetailsDto o = new OrderDetailsDto {
Id = item.Id,
Product = product,
CartQty = item.CartQty,
ProductPrice = item.productPrice
};
odds.Add(o);
}
OrdersDto newOrder = new OrdersDto {
Id = order.Id,
UserType = order.UserType,
OrderDetails = odds,
AppUser = order.AppUser,
ContactDetails = order.ContactDetail,
OrderStatus = order.OrderStatus,
CreatedDate = order.CreatedDate,
LastUpdated = order.LastUpdated
};
return(newOrder);
}
static public OrdersViewModel MapOrder(OrdersDto order)
{
OrdersViewModel brunchViewModel = new OrdersViewModel();
brunchViewModel.Id = order.Id;
return(brunchViewModel);
}
private static decimal determineToppingsCost(PizzaPriceDto price, OrdersDto order)
{
decimal cost = 0.0M;
cost += (order.Sausage) ? price.SausageCost : 0M;
cost += (order.Pepperoni) ? price.PepperoniCost : 0M;
cost += (order.Onions) ? price.OnionsCost : 0M;
cost += (order.GreenPeppers) ? price.GreenPeppersCost : 0M;
return(cost);
}
public void Load(OrdersDto order)
{
if (order == null)
{
return;
}
this._id = order.IDOrder;
dpStartDate.Text = order.StartDate.ToString();
dpFinallyDate.Text = order.FinallyDate.ToString();
tbDebt.Text = order.Debt.ToString();
tbPaid.Text = order.Paid.ToString();
tbSum.Text = order.Cost.ToString();
tbAllSum.Text = order.AllSum.ToString();
foreach (ManagersDto m in managerGet)
{
if (m.IDManager == order.FullNameManager.IDManager)
{
this.cbManager.SelectedItem = m;
break;
}
}
foreach (EnterprisesDto tr in enterpriseGet)
{
if (tr.IDEnterprise == order.NameEnterprise.IDEnterprise)
{
this.cbEnterprise.SelectedItem = tr;
break;
}
}
foreach (TypeReklamaDto tr in reklamaGet)
{
if (tr.IDTypeReklama == order.TypeReklama.IDTypeReklama)
{
this.cbReklama.SelectedItem = tr;
break;
}
}
if (order.Paid >= order.Cost)
{
tbPaid.IsEnabled = false;
}
cbEnterprise.IsEnabled = false;
cbManager.IsEnabled = false;
cbReklama.IsEnabled = false;
cbEnterprise.IsEnabled = false;
tbAllSum.IsEnabled = false;
dpStartDate.IsEnabled = false;
tbSum.IsEnabled = false;
}
public static decimal CalculateCost(OrdersDto order)
{
//var cost = getPizzaPrice();
decimal cost = 0M;
var price = getPizzaPrice();
cost += determineSizeCost(price, order);
cost += determineCrustCost(price, order);
cost += determineToppingsCost(price, order);
return(cost);
}
public static void Save(OrdersDto order)
{
if (order.Id == 0)
{
HttpResponseMessage response = GlobalVariables.WebApiClient.PostAsJsonAsync("Orders", order).Result;
}
else
{
HttpResponseMessage response = GlobalVariables.WebApiClient.PutAsJsonAsync("Orders/" + order.Id, order).Result;
}
}
public async Task <ActionResult> CreateOrder(OrdersDto body)
{
var result = await _DataOrders.CreateOrder(body);
// Retorna un 201
return(CreatedAtAction(
"GetOrderById",
new { id = result.IdOrder },
result
));
}
public HttpResponseMessage AddOrder(OrdersDto order)
{
var repo = new OrdersRepository();
var result = repo.Create(order);
if (result)
{
return(Request.CreateResponse(HttpStatusCode.Created));
}
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Could not create order, try again later..."));
}
public async Task <ActionResult> Post([FromBody] OrdersDto orders)
{
try
{
await _orderService.SetOrderAsync(orders);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public static OrderViewModel MapOrder(OrdersDto order)
{
OrderViewModel orderViewModel = new OrderViewModel();
orderViewModel.Id = order.Id;
orderViewModel.Brunch_id = order.Brunch_id;
orderViewModel.Client_id = order.Client_id;
orderViewModel.Gift_id = order.Gift_id;
orderViewModel.Staff_id = order.Staff_id;
orderViewModel.Staff = new StaffViewModel();
return(orderViewModel);
}
public ActionResult Create(OrdersDto order)
{
try
{
// TODO: Add insert logic here
OrderLoader.Save(order);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> UpdateOrder(OrdersDto orderStatus)
{
var status = orderStatus.OrderStatus;
var Id = orderStatus.Id;
var order = await _ordersRepository.GetById(Id);
order.OrderStatus = status;
_ordersRepository.Update(order);
if (await _ordersRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed To Update Order"));
}
private void btnEditO_Click(object sender, RoutedEventArgs e)
{
OrdersDto item = dgOrders.SelectedItem as OrdersDto;
if (item == null)
{
MessageBox.Show("Выберите запись для редактирования", "Редактирование");
return;
}
AddOrder window = new AddOrder();
window.Load(item);
window.ShowDialog();
btnUpdateO_Click(sender, e);
}
public bool Create(OrdersDto order)
{
using (var db = GetConnection())
{
db.Open();
var records = db.Execute(@"INSERT INTO [dbo].[Order]
([PaymentID]
,[CustomerID]
,[Purchased])
VALUES
(@PaymentID
,@CustomerID
,@Purchased)", order);
return(records == 1);
}
}
public async Task <OrdersDto> CreateOrder(OrdersDto body)
{
var entry = _mapper.Map <Orders>(body);
// Prepare order detail
PrepareDetail(entry.ListDetailOrders);
// Prepare order header
PrepareHeader(entry);
await _context.AddAsync(entry);
await _context.SaveChangesAsync();
return(_mapper.Map <OrdersDto>(
await GetOrderById(entry.IdOrder)
));
}
public static OrdersDto Convert(Orders orders)
{
if (orders == null)
{
return(null);
}
OrdersDto ordersDto = new OrdersDto();
ordersDto.Cost = orders.Cost;
ordersDto.Debt = orders.Debt;
ordersDto.AllSum = orders.AllSum;
ordersDto.FinallyDate = orders.FinallyDate;
ordersDto.FullNameManager = Convert(DaoFactory.GetManagersDao().Get(orders.FullNameManager));
ordersDto.IDOrder = orders.IDOrder;
ordersDto.NameEnterprise = Convert(DaoFactory.GetEnterprisesDao().Get(orders.NameEnterprise));
ordersDto.Paid = orders.Paid;
ordersDto.StartDate = orders.StartDate;
ordersDto.TypeReklama = Convert(DaoFactory.GetTypeReklamaDao().Get(orders.TypeReklama));
return(ordersDto);
}
public static Orders Convert(OrdersDto ordersDto)
{
if (ordersDto == null)
{
return(null);
}
Orders orders = new Orders();
orders.Cost = ordersDto.Cost;
orders.Debt = ordersDto.Debt;
orders.AllSum = ordersDto.AllSum;
orders.FinallyDate = ordersDto.FinallyDate;
orders.FullNameManager = ordersDto.FullNameManager.IDManager;
orders.IDOrder = ordersDto.IDOrder;
orders.NameEnterprise = ordersDto.NameEnterprise.IDEnterprise;
orders.Paid = ordersDto.Paid;
orders.StartDate = ordersDto.StartDate;
orders.TypeReklama = ordersDto.TypeReklama.IDTypeReklama;
return(orders);
}
public List <OrdersDto> GetOrderList(int userId)
{
List <OrdersDto> userOrders = new List <OrdersDto>();
List <string> userOrderId = new List <string>();
userOrderId = _dbContext.CustomerOrders.Where(x => x.UserId == userId)
.Select(x => x.OrderId).ToList();
foreach (string orderid in userOrderId)
{
OrdersDto order = new OrdersDto
{
OrderId = orderid,
CartTotal = _dbContext.CustomerOrders.FirstOrDefault(x => x.OrderId == orderid).CartTotal,
OrderDate = _dbContext.CustomerOrders.FirstOrDefault(x => x.OrderId == orderid).DateCreated
};
List <CustomerOrderDetails> orderDetail = _dbContext.CustomerOrderDetails.Where(x => x.OrderId == orderid).ToList();
order.OrderDetails = new List <CartItemDto>();
foreach (CustomerOrderDetails customerOrder in orderDetail)
{
CartItemDto item = new CartItemDto();
Product product = new Product();
{
product.ProductId = customerOrder.ProductId;
//product.ProductName= product;
product.Price = _dbContext.CustomerOrderDetails.FirstOrDefault(x => x.ProductId == customerOrder.ProductId && customerOrder.OrderId == orderid).Price;
};
item.Product = product;
item.Quantity = _dbContext.CustomerOrderDetails.FirstOrDefault(x => x.ProductId == customerOrder.ProductId && x.OrderId == orderid).Quantity;
order.OrderDetails.Add(item);
}
userOrders.Add(order);
}
return(userOrders.OrderByDescending(x => x.OrderDate).ToList());
}
private void btnDeletetO_Click(object sender, RoutedEventArgs e)
{
OrdersDto item = dgOrders.SelectedItem as OrdersDto;
if (item == null)
{
MessageBox.Show("Выберите запись для удаления", "Удаление заказа");
return;
}
MessageBoxResult result = MessageBox.Show("Удалить " + item.IDOrder + "?", "Удаление заказа", MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result != MessageBoxResult.Yes)
{
return;
}
ProcessFactory.GetOrdersProcess().Delete(item.IDOrder);
btnUpdateO_Click(sender, e);
}
public async Task <ResponseWrapper <OrdersDto> > GetOrderDetails(string dateFrom, string dateTo, int pageIndex, int pageSize)
{
try
{
DateTime?dateFromCast = DateTime.Parse(dateFrom);
DateTime?dateToCast = DateTime.Parse(dateTo);
var source = _context.PurchaseOrderDetails
.Where(x => x.DueDate >= dateFromCast.Value && x.DueDate <= dateToCast.Value)
.GroupBy(x => x.DueDate, (x, y) => new PurchaseOrderDetailDto
{
Day = x,
LineTotal = y.Sum(z => z.LineTotal),
OrderQty = y.Sum(z => z.OrderQty),
TotalSum = y.Sum(z => z.OrderQty) + y.Sum(z => z.LineTotal)
});
int totalCount = source.Count();
var totalPages = totalCount / pageSize;
if (totalCount % pageSize > 0)
{
totalPages++;
}
List <PurchaseOrderDetailDto> orders = await source
.Skip((pageIndex - 1) *pageSize).Take(pageSize)
.ToListAsync();
var returnOrders = new OrdersDto
{
Orders = orders,
TotalPages = totalPages
};
return(ResponseWrapper <OrdersDto> .Success(returnOrders));
}
catch (Exception)
{
return(ResponseWrapper <OrdersDto> .Error(AppConstants.GetFailed));
}
}
public async Task <ActionResult <int> > CreateOrder([FromBody] OrdersDto model)
{
try {
if (!ModelState.IsValid)
{
return(BadRequest());
}
using (var transaction = _ordersRepo.BeginTransaction())
{
Orders entity = new Orders();
var order = model.ToEntity(entity, ActionType.Insert);
var insertedOrder = _ordersRepo.Add(order);
await _ordersRepo.SaveChangesAsync();
if (model.OrderItems != null && model.OrderItems.Any())
{
var itemsList = new List <OrderItems>();
itemsList.AddRange(model.OrderItems.Select(x => x.ToEntity(new OrderItems(), insertedOrder.OrderId)));
await _ordersRepo.SaveChangesAsync();
var stocksToUpdate = new List <UpdateStocksDto>();
stocksToUpdate.AddRange(itemsList.Select(x => new UpdateStocksDto {
StoreId = insertedOrder.StoreId, ProductId = x.ProductId, Quantity = x.Quantity
}));
_queueSender.SendAsync(stocksToUpdate).Wait();
}
transaction.Commit();
return(Ok());
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Failed to update price!"));
}
}
private static decimal determineCrustCost(PizzaPriceDto price, OrdersDto order)
{
decimal cost = 0.0M;
switch (order.Crust)
{
case DTO.Enums.CrustType.Regular:
cost = price.RegularCrustCost;
break;
case DTO.Enums.CrustType.Thin:
cost = price.ThinCrustCost;
break;
case DTO.Enums.CrustType.Thick:
cost = price.ThickCrustCost;
break;
default:
break;
}
return(cost);
}
private static decimal determineSizeCost(PizzaPriceDto price, OrdersDto order)
{
var cost = 0.0M;
switch (order.Size)
{
case DTO.Enums.SizeType.Small:
cost = price.SmallSizeCost;
break;
case DTO.Enums.SizeType.Medium:
cost = price.MediumSizeCost;
break;
case DTO.Enums.SizeType.Large:
cost = price.LargeSizeCost;
break;
default:
break;
}
return(cost);
}
public void CreateOrder(int userId, OrdersDto orderDetails)
{
try
{
StringBuilder orderid = new StringBuilder();
orderid.Append(CreateRandomNumber(3));
orderid.Append('-');
orderid.Append(CreateRandomNumber(6));
CustomerOrders customerOrder = new CustomerOrders
{
OrderId = orderid.ToString(),
UserId = userId,
DateCreated = DateTime.Now.Date,
CartTotal = orderDetails.CartTotal
};
_dbContext.CustomerOrders.Add(customerOrder);
_dbContext.SaveChanges();
foreach (CartItemDto order in orderDetails.OrderDetails)
{
CustomerOrderDetails productDetails = new CustomerOrderDetails
{
OrderId = orderid.ToString(),
ProductId = order.Product.ProductId,
Quantity = order.Quantity,
Price = order.Product.Price
};
_dbContext.CustomerOrderDetails.Add(productDetails);
_dbContext.SaveChanges();
}
}
catch
{
throw;
}
}
public void Update(OrdersDto order)
{
_ordersDao.Update(DtoConvert.Convert(order));
}
public int Post(string userId, [FromBody] OrdersDto checkedOutItems)
{
_orderService.CreateOrder(userId, checkedOutItems);
return(_cartService.ClearCart(userId));
}
public IHttpActionResult GetOrders()
{
List <OrdersDto> orders = new List <OrdersDto>();
var ordersFromDb = _context.Orders.ToList();
if (ordersFromDb.Count == 0)
{
return(BadRequest("No orders"));
}
foreach (var ord in ordersFromDb)
{
if (orders.Count == 0)
{
OrdersDto temp = new OrdersDto
{
TableId = ord.TableId,
DateOrdered = ord.DateOrdered
};
temp.Drinks = new List <string>();
var singleDrinkFromDb = _context.Drinks.SingleOrDefault(d => d.Id == ord.drinkId);
if (singleDrinkFromDb != null)
{
temp.Drinks.Add(singleDrinkFromDb.Name);
}
temp.Meals = new List <string>();
var singleMealFromDb = _context.Meals.SingleOrDefault(d => d.Id == ord.mealId);
if (singleMealFromDb != null)
{
temp.Meals.Add(singleMealFromDb.Name);
}
orders.Add(temp);
continue;
}
if (!(orders[orders.Count - 1].TableId == ord.TableId && orders[orders.Count - 1].DateOrdered == ord.DateOrdered))
{
OrdersDto temp = new OrdersDto
{
TableId = ord.TableId,
DateOrdered = ord.DateOrdered
};
temp.Drinks = new List <string>();
var singleDrinkFromDb = _context.Drinks.SingleOrDefault(d => d.Id == ord.drinkId);
if (singleDrinkFromDb != null)
{
temp.Drinks.Add(singleDrinkFromDb.Name);
}
temp.Meals = new List <string>();
var singleMealFromDb = _context.Meals.SingleOrDefault(d => d.Id == ord.mealId);
if (singleMealFromDb != null)
{
temp.Meals.Add(singleMealFromDb.Name);
}
orders.Add(temp);
}
else
{
var singleDrinkFromDb = _context.Drinks.SingleOrDefault(d => d.Id == ord.drinkId);
var singleMealFromDb = _context.Meals.SingleOrDefault(d => d.Id == ord.mealId);
if (singleDrinkFromDb != null)
{
orders[orders.Count - 1].Drinks.Add(singleDrinkFromDb.Name);
}
if (singleMealFromDb != null)
{
orders[orders.Count - 1].Meals.Add(singleMealFromDb.Name);
}
}
}
return(Ok(orders));
}
public void GetOrders_ClientExists_Success(int _clientId)
{
var expectedOrderEntry = new OrderEntryDto
{
key = 2,
name = "Vergnano",
quantity = 1,
price = 25
};
var expectedOrderEntries = new OrderEntryDto[1];
expectedOrderEntries[0] = expectedOrderEntry;
var expectedAddress = new AddressDto
{
key = 2,
country = "Poland",
city = "Cracow",
street = "Krakowska",
ZIPCode = 30000,
buildingNumber = 1,
apartmentNumber = ""
};
var expectedOrder = new OrderDto
{
key = 2,
orderEntries = expectedOrderEntries,
totalPrice = 25,
address = expectedAddress,
status = 0,
openDate = "2018-06-12",
closeDate = ""
};
var expectedOrders = new OrderDto[1];
expectedOrders[0] = expectedOrder;
var expectedOrderDto = new OrdersDto
{
isSuccess = true,
orders = expectedOrders
};
DatabaseQueryProcessor.Erase();
Shared.FillTheDatabase();
int clientId = _clientId;
var testSessionToken = SessionRepository.StartNewSession(clientId);
var getOrdersQuery = new GetOrdersQuery
{
sessionToken = testSessionToken,
};
var handler = new GetOrdersQueryHandler();
var result = (OrdersDto)handler.Handle(getOrdersQuery);
DatabaseQueryProcessor.Erase();
SessionRepository.RemoveSession(testSessionToken);
Assert.IsTrue(result.isSuccess);
Assert.AreEqual(result.orders.Length, expectedOrderDto.orders.Length);
Assert.AreEqual(result.orders[0].orderEntries.Length, expectedOrderDto.orders[0].orderEntries.Length);
Assert.AreEqual(result.orders[0].status, expectedOrderDto.orders[0].status);
Assert.AreEqual(result.orders[0].address.apartmentNumber, expectedOrderDto.orders[0].address.apartmentNumber);
}
