public async Task WhenOrder_IsCompletedOverOneDay_ShouldFail() { // Arrange var orderService = TestableOrderService.Create(); const long TestOrderId = 10; var orderRequest = new OrderFormVm() { OrderId = TestOrderId }; var mockOrderRepo = new Mock <IRepository <Order> >(); var order = new Order(TestOrderId) { CompletedOn = DateTimeOffset.Now.AddDays(-2), OrderStatus = OrderStatus.Complete }; var mockOrders = new Order[] { order }.AsQueryable().BuildMock(); orderService.MockOrderRepo.Setup(repo => repo.Query()).Returns(mockOrders.Object); // Action var feedback = await orderService.UpdateOrderAsync(orderRequest); // Assert Assert.False(feedback.Success); Assert.True(feedback.ErrorMessage.HasValue()); }
public async Task <IActionResult> Edit([FromBody] OrderFormVm orderForm) { var getOrderFeedback = await _orderService.GetOrderAsync(orderForm.OrderId); if (!getOrderFeedback.Success) { return(BadRequest(new { Error = getOrderFeedback.ErrorMessage })); } var currentUser = await _workContext.GetCurrentUser(); var order = getOrderFeedback.Result; ActionFeedback feedback = ActionFeedback.Succeed(); if (!CanEditFullOrder(User.IsInRole(RoleName.Admin), currentUser, order.CreatedById, order.VendorId)) { if (order.OrderStatus != orderForm.OrderStatus || order.TrackingNumber != orderForm.TrackingNumber || order.PaymentProviderId != orderForm.PaymentProviderId) { feedback = await _orderService.UpdateOrderStateAsync(orderForm); } } else { feedback = await _orderService.UpdateOrderAsync(orderForm); } return(feedback.Success ? (IActionResult)Accepted() : BadRequest(new { Error = feedback.ErrorMessage })); }
public IActionResult Pay() { var cart = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart"); ViewBag.cart = cart; ViewBag.total = cart.Sum(item => item.Product.Price * item.Quantity); int count = 0; foreach (var item in cart) { count++; } OrderFormVm orderFormVm = new OrderFormVm { Amount = count, Total = ViewBag.total, Username = User.Identity.Name }; _orderClient.PostOrders(orderFormVm); cart.Clear(); ViewBag.cart = cart; ViewBag.total = 0; SessionHelper.SetObjectAsJson(HttpContext.Session, "cart", cart); return(RedirectToAction("Index", "Home")); }
public async Task <ActionFeedback> UpdateOrderAsync(OrderFormVm orderRequest) { if (orderRequest.OrderItems == null || !orderRequest.OrderItems.Any()) { return(ActionFeedback.Fail("Shopping cart cannot be empty")); } var order = await _orderRepository.Query() .Include(item => item.OrderItems).ThenInclude(item => item.Product) .FirstOrDefaultAsync(item => item.Id == orderRequest.OrderId); if (order == null) { return(ActionFeedback.Fail($"Cannot find order with id {orderRequest.OrderId}")); } if (!CanEditOrder(order)) { return(ActionFeedback.Fail($"Order has been completed already!")); } var feedback = await UpdateOrderDetailsAsync(order, orderRequest); if (!feedback.Success) { return(feedback); } await _orderRepository.SaveChangesAsync(); return(ActionFeedback.Succeed()); }
public async Task <ActionFeedback <long> > CreateOrderAsync(OrderFormVm orderRequest) { if (orderRequest.OrderItems == null || !orderRequest.OrderItems.Any()) { return(ActionFeedback <long> .Fail("Shopping cart cannot be empty")); } var user = await _workContext.GetCurrentUser(); var order = new Order() { CreatedById = user.Id }; var feedback = await UpdateOrderDetailsAsync(order, orderRequest); if (!feedback.Success) { return(ActionFeedback <long> .Fail(feedback.ErrorMessage)); } _orderRepository.Add(order); await _orderRepository.SaveChangesAsync(); return(ActionFeedback <long> .Succeed(order.Id)); }
public async Task <ImportResult> ImportAsync(IEnumerable <ImportingOrderDto> orders) { var importResult = new ImportResult { ImportResultDetails = new List <ImportResultDetail>() }; foreach (var orderDto in orders) { try { if (await ValidateOrderIsImportedAsync(orderDto.ExternalId)) { Report(importResult, orderDto.ExternalId, ImportResultDetailStatus.Imported, null); continue; } var orderItem = await GetOrderItemAsync(orderDto); if (orderItem is null) { Report(importResult, orderDto.ExternalId, ImportResultDetailStatus.SkuNotFound, null); continue; } var orderForm = new OrderFormVm { ExternalId = orderDto.ExternalId, TrackingNumber = orderDto.TrackingNumber, ShippingAmount = orderDto.ShippingAmount, ShippingCost = orderDto.ShippingCost, OrderStatus = orderDto.Status, CustomerId = await GetCustomerIdAsync(orderDto), OrderItems = new List <OrderItemVm> { orderItem } }; var feedback = await _orderService.CreateOrderAsync(orderForm); if (feedback.Success) { Report(importResult, orderDto.ExternalId, ImportResultDetailStatus.Success, null); } else { Report(importResult, orderDto.ExternalId, ImportResultDetailStatus.Others, feedback.ErrorMessage); } } catch (Exception exception) { Report(importResult, orderDto.ExternalId, ImportResultDetailStatus.Others, exception.Message); _telemetry.TrackException(exception); } } return(importResult); }
public async Task <IActionResult> Create([FromBody] OrderFormVm orderForm) { var feedback = await _orderService.CreateOrderAsync(orderForm); return(feedback.Success ? (IActionResult)Ok(new { Id = feedback.Result }) : BadRequest(new { Error = feedback.ErrorMessage })); }
public async Task PostOrders(OrderFormVm orderFormVm) { var client = new HttpClient(); OrderFormVm jsonInString = new OrderFormVm { Amount = orderFormVm.Amount, Status = orderFormVm.Status, Username = orderFormVm.Username, Total = orderFormVm.Total }; await client.PostAsync(_configuration["local:BackEndUrl"] + "api/orders", new StringContent(JsonConvert.SerializeObject(jsonInString), Encoding.UTF8, "application/json")); }
public async Task <ActionResult> UpdateCategory(int id, OrderFormVm model) { var order = await _dataContext.Orders.FirstOrDefaultAsync(x => x.OrderID == id); if (order == null) { return(NotFound()); } order.Amount = model.Amount; order.Status = model.Status; order.Total = model.Total; order.Username = model.Username; await _dataContext.SaveChangesAsync(); return(Accepted()); }
public async Task WhenShoppingCart_IsNull_ShouldFail() { // Arrange var orderRequest = new OrderFormVm() { OrderItems = null }; // Action var orderService = TestableOrderService.Create(); var feedback = await orderService.UpdateOrderAsync(orderRequest); // Assert Assert.False(feedback.Success); Assert.True(feedback.ErrorMessage.HasValue()); }
public async Task ShouldFail_WhenShoppingCart_IsNull() { // Arrange var orderRequest = new OrderFormVm() { OrderItems = null }; // Action var orderService = TestableOrderService.Create(); var feedback = await orderService.CreateOrderAsync(orderRequest); // Assert Assert.Equal(0, feedback.Result); Assert.False(feedback.Success); Assert.NotNull(feedback.ErrorMessage); }
public async Task <ActionFeedback> UpdateOrderStateAsync(OrderFormVm orderRequest) { var order = await _orderRepository.Query() .Include(item => item.OrderItems).ThenInclude(item => item.Product) .FirstOrDefaultAsync(item => item.Id == orderRequest.OrderId); if (order == null) { return(ActionFeedback.Fail($"Cannot find order with Id: {orderRequest.OrderId}")); } if (!CanEditOrder(order)) { return(ActionFeedback.Fail($"Order has been completed already!")); } order.TrackingNumber = orderRequest.TrackingNumber; order.PaymentProviderId = orderRequest.PaymentProviderId; await UpdateStatusAndOrderTotalAsync(order, orderRequest.OrderStatus); await _orderRepository.SaveChangesAsync(); return(ActionFeedback.Succeed()); }
public async Task WithCanceledStatus_ShouldResetOrderItemQuantities() { // Arrange var(orderId, products) = Init("CanUpdateOrder_WithCanceledStatus_ShouldResetOrderItemQuantities"); var orderRequest = new OrderFormVm() { OrderId = orderId, OrderStatus = OrderStatus.Cancelled, CustomerId = 10, ShippingAmount = 10000, ShippingCost = 5000, Discount = 2000, TrackingNumber = "VAN", PaymentProviderId = 2, OrderItems = new List <OrderItemVm> { new OrderItemVm { ProductId = products[0].Id, Quantity = 5, ProductPrice = products[0].Price, ProductCost = products[0].Cost }, new OrderItemVm { ProductId = products[1].Id, Quantity = 3, ProductPrice = products[1].Price, ProductCost = products[1].Cost }, } }; var mockHttpContextAccessor = GetMockHttpContextAccessorWithUserInRole(RoleName.Seller); // Action ActionFeedback feedback; using (var context = new SimplDbContext(_options)) { var orderRepo = new Repository <Order>(context); var productRepo = new Repository <Product>(context); var orderService = new OrderService(orderRepo, productRepo, null, null, null, null, null, null, null, null, null, mockHttpContextAccessor.Object, null); feedback = await orderService.UpdateOrderAsync(orderRequest); } Order updatedOrder; using (var context = new SimplDbContext(_options)) { var orderRepo = new Repository <Order>(context); updatedOrder = await orderRepo.QueryAsNoTracking() .Include(item => item.OrderItems).ThenInclude(item => item.Product) .FirstOrDefaultAsync(i => i.Id == orderId); } // Assert Assert.True(feedback.Success); Assert.NotNull(updatedOrder); Assert.Equal(orderRequest.OrderStatus, updatedOrder.OrderStatus); Assert.Equal(orderRequest.TrackingNumber, updatedOrder.TrackingNumber); Assert.Equal(orderRequest.PaymentProviderId, updatedOrder.PaymentProviderId); Assert.Equal(0, updatedOrder.SubTotal); Assert.Equal(orderRequest.ShippingAmount, updatedOrder.OrderTotal); Assert.Equal(orderRequest.ShippingCost, updatedOrder.OrderTotalCost); Assert.Equal(products[0].Stock, updatedOrder.OrderItems[0].Product.Stock); Assert.Equal(products[1].Stock, updatedOrder.OrderItems[1].Product.Stock); }
public async Task WithCanceledStatus_ShouldResetOrderItemQuantities() { // Arrange var products = Init(nameof(WithCanceledStatus_ShouldResetOrderItemQuantities)); var workContextMock = new Mock <IWorkContext>(); var userId = 123; workContextMock.Setup(x => x.GetCurrentUser()).ReturnsAsync(new User() { Id = userId }); var orderRequest = new OrderFormVm() { OrderStatus = OrderStatus.Cancelled, CustomerId = 10, ShippingAmount = 10000, ShippingCost = 5000, Discount = 2000, TrackingNumber = "VAN", PaymentProviderId = 2, OrderItems = new List <OrderItemVm> { new OrderItemVm { ProductId = products[0].Id, Quantity = 5, ProductPrice = products[0].Price, ProductCost = products[0].Cost }, new OrderItemVm { ProductId = products[1].Id, Quantity = 3, ProductPrice = products[1].Price, ProductCost = products[1].Cost }, } }; // Action ActionFeedback <long> feedback; using (var context = new SimplDbContext(_options)) { var orderRepo = new Repository <Order>(context); var productRepo = new Repository <Product>(context); var workContext = workContextMock.Object; var orderService = new OrderService(orderRepo, productRepo, null, null, null, null, null, null, null, null, workContext, null, null); feedback = await orderService.CreateOrderAsync(orderRequest); } Order createdOrder; using (var context = new SimplDbContext(_options)) { var orderRepo = new Repository <Order>(context); createdOrder = await orderRepo.QueryAsNoTracking() .Include(item => item.OrderItems).ThenInclude(item => item.Product) .FirstOrDefaultAsync(i => i.Id == feedback.Result); } // Assert Assert.True(feedback.Success); Assert.NotNull(createdOrder); Assert.Equal(orderRequest.OrderStatus, createdOrder.OrderStatus); Assert.Equal(orderRequest.TrackingNumber, createdOrder.TrackingNumber); Assert.Equal(orderRequest.PaymentProviderId, createdOrder.PaymentProviderId); Assert.Equal(0, createdOrder.SubTotal); Assert.Equal(orderRequest.ShippingAmount, createdOrder.OrderTotal); Assert.Equal(orderRequest.ShippingCost, createdOrder.OrderTotalCost); Assert.Equal(products[0].Stock, createdOrder.OrderItems[0].Product.Stock); Assert.Equal(products[1].Stock, createdOrder.OrderItems[1].Product.Stock); }