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