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); }