public void ShoppingCartItemsAreMappedToOrder()
{
var shoppingCartItems = new List <ShoppingCartItem>
{
new ShoppingCartItem
{
Customer = CustomerName,
ProductId = "test1",
Quantity = 1,
UnitPrice = 15.50m
},
new ShoppingCartItem()
{
Customer = CustomerName,
ProductId = "test2",
Quantity = 2,
UnitPrice = 25
}
};
var result = OrderMapper.Map(shoppingCartItems);
Assert.Equal(result.Amount, 65.50m);
Assert.Equal(CustomerName, result.Customer);
Assert.Equal(result.OrderLines.Count(), 2);
Assert.Equal(result.OrderId, result.OrderLines[0].OrderId);
Assert.Equal(result.OrderId, result.OrderLines[1].OrderId);
}
public async Task <AddOrderResult> AddOrder(OrderResult orderResult)
{
var orderToCopy = orderResult.Orders.Single();
var ordersToSend = OrderMapper.Map(orderToCopy);
var parameters = new Dictionary <string, string>
{
{ "token", ConfigurationManager.AppSettings["token"] }, //change on your own token!
{ "method", "addOrder" },
{ "parameters", JsonConvert.SerializeObject(ordersToSend).ToLower() }
};
var encodedContent = new FormUrlEncodedContent(parameters);
using (var response = await ApiHelper.ApiClient.PostAsync(url, encodedContent).ConfigureAwait(false))
{
if (response.IsSuccessStatusCode)
{
var json = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <AddOrderResult>(json));
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
}
public bool PlaceOrder(OrderDto orderDto, int customerId)
{
// load the customer
Customer customer = _customerRepository.Load(customerId);
if (customer == null)
{
throw new CustomerNotFoundException();
}
// do not proceed with order if amount is 0
if (orderDto.Amount == 0)
{
return(false);
}
// get the appropriate vat for the customers country
orderDto.VAT = VatCalculator.GetVat(customer.Country);
// build and save the order
var order = OrderMapper.Map(orderDto);
order.CustomerId = customerId;
_orderRepository.Add(order);
return(true);
}
public override void Execute(object parameter)
{
List <Order> orders = DB.OrderRepository.Get();
List <OrderModel> orderModels = new List <OrderModel>();
OrderMapper orderMapper = new OrderMapper();
for (int i = 0; i < orders.Count; i++)
{
Order order = orders[i];
OrderModel orderModel = orderMapper.Map(order);
orderModel.No = i + 1;
orderModels.Add(orderModel);
}
Enumeration.Enumerate(orderModels);
OrderViewModel orderViewModel = new OrderViewModel();
orderViewModel.AllOrders = orderModels;
orderViewModel.Orders = new ObservableCollection <OrderModel>(orderModels);
OrdersControl ordersControl = new OrdersControl();
ordersControl.DataContext = orderViewModel;
MainWindow mainWindow = (MainWindow)mainViewModel.Window;
mainWindow.GrdCenter.Children.Clear();
mainWindow.GrdCenter.Children.Add(ordersControl);
}
public async Task <IActionResult> GetById(int id)
{
var item = await _orderService.GetById(id);
var res = OrderMapper.Map(item);
return(PartialView("OrderInfo", res));
}
public async Task <OrderDto> AddAsync(int userId, OrderDto dto)
{
var model = OrderMapper.Map(dto);
var newModel = await _orderRepository.AddAsync(userId, model);
var result = OrderDtoMapper.Map(newModel);
return(result);
}
public async Task <ActionResult <V1DTO.Order> > GetOrder(Guid id)
{
var userTKey = User.IsInRole("Customer") ? (Guid?)User.UserGuidId() : null;
var order = await _bll.Orders.FirstOrDefaultAsync(id, userTKey);
if (order == null)
{
return(NotFound(new V1DTO.MessageDTO($"Order with id {id} not found")));
}
if (User.IsInRole("Restaurant") && !await _bll.RestaurantUsers.AnyAsync(ru =>
ru.AppUserId.Equals(User.UserGuidId()) && ru.RestaurantId.Equals(order.RestaurantId)))
{
return(Unauthorized(new V1DTO.MessageDTO("User not authorized for this restaurant")));
}
return(Ok(_mapper.Map(order)));
}
public void it_should_convert_Order()
{
var order = new Order();
var view = new OrderViewModel {
Address = "test"
};
var mapper = new OrderMapper();
order = mapper.Map(view);
Assert.AreEqual(order.ShipAddress, view.Address);
}
public override void Execute(object parameter)
{
List <Customer> customers = DB.CustomerRepository.Get();
List <CustomerModel> customerModels = new List <CustomerModel>();
CustomerMapper customerMapper = new CustomerMapper();
for (int i = 0; i < customers.Count; i++)
{
Customer customer = customers[i];
CustomerModel customerModel = customerMapper.Map(customer);
customerModels.Add(customerModel);
}
OrderAddWindow orderAddWindow = new OrderAddWindow();
OrderAddViewModel orderAddViewModel = new OrderAddViewModel
{
CurrentOrder = orderViewModel.CurrentOrder,
CurrentWindow = orderAddWindow,
Customers = customerModels
};
orderAddWindow.DataContext = orderAddViewModel;
orderAddWindow.WindowStyle = System.Windows.WindowStyle.None;
orderAddWindow.AllowsTransparency = true;
orderAddWindow.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
orderAddWindow.ShowDialog();
List <Order> orders = DB.OrderRepository.Get();
List <OrderModel> orderModels = new List <OrderModel>();
OrderMapper orderMapper = new OrderMapper();
for (int i = 0; i < orders.Count; i++)
{
Order order = orders[i];
OrderModel orderModel = orderMapper.Map(order);
orderModels.Add(orderModel);
}
Enumeration.Enumerate(orderModels);
orderViewModel.AllOrders = orderModels;
orderViewModel.Orders = new ObservableCollection <OrderModel>(orderModels);
orderViewModel.CurrentOrder = new OrderModel();
}
public async Task <OrderDto> UpdateAsync(int userId, OrderDto dto)
{
var model = await _orderRepository.GetAsync(userId, dto.Id);
if (model == null)
{
return(null);
}
OrderMapper.Map(dto, model);
await _orderRepository.SaveChangesAsync(userId);
// Return a fresh copy of the saved object.
return(await GetAsync(userId, model.Id));
}
public async Task <ResultInfo> Create(OrderRequestModel request)
{
if (!ModelState.IsValid)
{
return(new ResultInfo(ModelState.Values.ToString(), "403"));
}
var model = new OrderModel();
OrderMapper.Map(request, model);
await _orderService.Create(model, null);
return(new ResultInfo());
}
public void OrderMapperAppliesCorrectDiscount()
{
var shoppingcartItems = new List <ShoppingCartItem>
{
new ShoppingCartItem()
{
Customer = CustomerName,
ProductId = "test2",
Quantity = 1,
UnitPrice = 50
}
};
var result = OrderMapper.Map(shoppingcartItems, 50);
Assert.Equal(result.Amount, 25);
}
public Order GenerateOrder(string userName)
{
var cartitems = _basketRepository.Get(userName);
var customer = _customerDetailsRepository.GetDetails(userName);
var order = OrderMapper.Map(cartitems, Discounts.DiscountAmounts[customer.Type]);
if (customer.TwelveMonthTotal + order.Amount > 800)
{
customer.Type = CustomerType.Gold;
_customerDetailsRepository.Update(customer);
}
else if (customer.TwelveMonthTotal + order.Amount > 500)
{
customer.Type = CustomerType.Silver;
_customerDetailsRepository.Update(customer);
}
return(order);
}
/// <summary>
/// Create order
/// </summary>
/// <param name="productId"></param>
/// <param name="variationId"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateOrderAsync(Guid?productId, Guid?variationId)
{
if (productId == null || variationId == null)
{
return(new InvalidParametersResultModel <Guid>());
}
var userRequest = await _userManager.GetCurrentUserAsync();
if (!userRequest.IsSuccess)
{
return(userRequest.Map(Guid.Empty));
}
var productRequest = await _productService.GetProductByIdAsync(productId);
if (!productRequest.IsSuccess)
{
return(productRequest.Map(Guid.Empty));
}
var product = productRequest.Result;
var variation = product.ProductVariations.FirstOrDefault(x => x.Id.Equals(variationId));
var order = OrderMapper.Map(product, variation);
order.UserId = userRequest.Result.Id;
var currency = (await _productService.GetGlobalCurrencyAsync()).Result;
order.CurrencyId = currency.Code;
await _orderDbContext.Orders.AddAsync(order);
var dbRequest = await _orderDbContext.PushAsync();
if (dbRequest.IsSuccess)
{
OrderEvents.Orders.OrderCreated(new AddOrderEventArgs
{
Id = order.Id,
OrderStatus = order.OrderState.ToString()
});
}
await _commerceContext.PushAsync();
return(dbRequest.Map(order.Id));
}
public override void Execute(object parameter)
{
// TODO: Step1. Validate
OrderMapper categoryMapper = new OrderMapper();
Order category = categoryMapper.Map(orderAddViewModel.CurrentOrder);
category.Creator = Kernel.CurrentUser;
if (category.Id != 0)
{
DB.OrderRepository.Update(category);
}
else
{
DB.OrderRepository.Add(category);
}
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
orderAddViewModel.CurrentWindow.Close();
}
/// <summary>
/// Create order
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateOrderAsync(OrderCartViewModel model)
{
if (model == null)
{
throw new NullReferenceException();
}
if (model.CartId == null)
{
return(new NotFoundResultModel <Guid>());
}
var cartRequest = await _cartService.GetCartByIdAsync(model.CartId);
if (!cartRequest.IsSuccess)
{
return(cartRequest.Map(Guid.Empty));
}
var cart = cartRequest.Result;
var order = OrderMapper.Map(cart, model.Notes);
var currency = (await _productService.GetGlobalCurrencyAsync()).Result;
order.CurrencyId = currency.Code;
await _orderDbContext.Orders.AddAsync(order);
var dbRequest = await _orderDbContext.PushAsync();
if (dbRequest.IsSuccess)
{
OrderEvents.Orders.OrderCreated(new AddOrderEventArgs
{
Id = order.Id,
OrderStatus = order.OrderState.ToString()
});
}
_commerceContext.CartItems.RemoveRange(cart.CartItems);
await _commerceContext.PushAsync();
return(dbRequest.Map(order.Id));
}
/// <summary>
/// Create order
/// </summary>
/// <param name="productId"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateOrderAsync(Guid?productId)
{
var userRequest = await _userManager.GetCurrentUserAsync();
if (!userRequest.IsSuccess)
{
return(userRequest.Map(Guid.Empty));
}
var productRequest = await _productService.GetProductByIdAsync(productId);
if (!productRequest.IsSuccess)
{
return(productRequest.Map(Guid.Empty));
}
var product = productRequest.Result;
var order = OrderMapper.Map(product);
var currency = (await _productService.GetGlobalCurrencyAsync()).Result;
order.CurrencyId = currency.Code;
order.UserId = userRequest.Result.Id;
await _orderDbContext.Orders.AddAsync(order);
var dbRequest = await _orderDbContext.PushAsync();
if (dbRequest.IsSuccess)
{
OrderEvents.Orders.OrderCreated(new AddOrderEventArgs
{
Id = order.Id,
OrderStatus = order.OrderState.ToString()
});
}
await _commerceContext.PushAsync();
return(dbRequest.Map(order.Id));
}
public override void Execute(object parameter)
{
SureDialogViewModel sureViewModel = new SureDialogViewModel();
sureViewModel.DialogText = UIMessages.DeleteSureMessage;
SureDialog dialog = new SureDialog();
dialog.DataContext = sureViewModel;
dialog.ShowDialog();
if (dialog.DialogResult == true)
{
OrderMapper mapper = new OrderMapper();
Order order = mapper.Map(orderViewModel.CurrentOrder);
order.IsDeleted = true;
order.Creator = Kernel.CurrentUser;
DB.OrderRepository.Update(order);
int no = orderViewModel.SelectedOrder.No;
orderViewModel.Orders.Remove(orderViewModel.SelectedOrder);
List <OrderModel> orderModelList = orderViewModel.Orders.ToList();
Enumeration.Enumerate(orderModelList, no - 1);
orderViewModel.AllOrders = orderModelList;
orderViewModel.UpdateDataFiltered();
orderViewModel.SelectedOrder = null;
orderViewModel.CurrentOrder = new OrderModel();
MessageBox.Show(UIMessages.OperationSuccessMessage, "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public ICollection <OrderView> FindOrdersForStatus(OrderStatus status)
{
UpdateQueuedOrders();
return(_orderMapper.Map(_db.Orders.Where(o => o.Status == status).ToList()));
}
public async Task <IEnumerable <OrderResponse> > GetOrdersAsync()
{
var orders = await OrderRespository.GetAllAsync();
return(mapper.Map(orders));
}
public void AddOrder(Order o)
{
context.Add(oMapper.Map(o));
context.SaveChanges();
}
public async void CheckoutAsync(Order order)
{
int orderId = await purchaseClient.CreatePurchase(OrderMapper.Map(order)).ConfigureAwait(false);
}
public void Add(Domain.Models.Order t)
{
context.Orders.Add(mapper.Map(t, context));
context.SaveChanges();
}
public async Task <(BadRequestResponseModel, Guid)> CreateOrder(OrderRequestModel orderRequestModel, Guid userId)
{
Guid orderId = Guid.Empty;
var restuarant = await this.foodAppDbContext.Restaurants.AsNoTracking().FirstOrDefaultAsync(x => x.Id == orderRequestModel.RestaurantId);
if (restuarant == null)
{
return(new BadRequestResponseModel()
{
ErrorMessage = "Invalid RestaurantId"
}, orderId);
}
var restuarantFoodCategoryIds = await this.foodAppDbContext.RestaurantFoodCategoryMaps.AsNoTracking()
.Include(x => x.FoodCategory)
.Where(x => x.RestaurantId == orderRequestModel.RestaurantId)
.Select(x => x.FoodCategory.Id)
.ToListAsync();
var restaurantFoods = await this.foodAppDbContext.Foods.AsNoTracking()
.Where(x => restuarantFoodCategoryIds.Any(r => r == x.FoodCategoryId))
.ToListAsync();
var restaurantFoodIds = restaurantFoods.Select(x => x.Id).ToList();
var orderRequestFoodIds = orderRequestModel.OrderLines.Select(x => x.FoodId).ToList();
var foodCustomizationIds = await this.foodAppDbContext.FoodCategoryCustomizationMaps.AsNoTracking()
.Where(x => restuarantFoodCategoryIds.Any(r => r == x.FoodCategoryId))
.Select(x => x.FoodCustomizationId)
.ToListAsync();
var foodCustomizationOptions = await this.foodAppDbContext.FoodCustomizationOptions.AsNoTracking()
.Where(x => foodCustomizationIds.Any(f => f == x.FoodCustomizationId))
.ToListAsync();
bool isFoodIdValid = !orderRequestFoodIds.Except(restaurantFoodIds).Any();
if (!isFoodIdValid)
{
return(new BadRequestResponseModel()
{
ErrorMessage = "FoodId doesnt belong to selected restaurant"
}, orderId);
}
using (var transaction = foodAppDbContext.Database.BeginTransaction())
{
try
{
var order = OrderMapper.Map(orderRequestModel, userId);
orderId = order.Id;
var orderLines = new List <OrderLine>();
var orderLineOptions = new List <OrderLineOption>();
var totalAmount = 0.00m;
foreach (var orderLineRequest in orderRequestModel.OrderLines)
{
var food = restaurantFoods.FirstOrDefault(x => x.Id == orderLineRequest.FoodId);
var orderLine = OrderMapper.Map(orderLineRequest, order.Id, food.UnitPrice);
orderLines.Add(orderLine);
totalAmount += (orderLineRequest.Quantity * food.UnitPrice);
foreach (var orderLineOptionRequest in orderLineRequest.OrderLineOptions)
{
var foodCustomizationOption = foodCustomizationOptions.FirstOrDefault(x => x.Id == orderLineOptionRequest.FoodCustomizationOptionId);
orderLineOptions.Add(OrderMapper.Map(orderLineOptionRequest, orderLine.Id, foodCustomizationOption.UnitPrice));
totalAmount += foodCustomizationOption.UnitPrice;
}
}
order.TotalAmount = totalAmount;
await foodAppDbContext.AddAsync(order);
await foodAppDbContext.SaveChangesAsync();
await foodAppDbContext.AddRangeAsync(orderLines);
await foodAppDbContext.SaveChangesAsync();
await foodAppDbContext.AddRangeAsync(orderLineOptions);
await foodAppDbContext.SaveChangesAsync();
await transaction.CommitAsync();
}
catch (Exception)
{
await transaction.RollbackAsync();
throw;
}
}
return(null, orderId);
}
