public async void Handle_ShouldReturnCreatedOrder()
{
A.CallTo(() => _orderRepository.AddAsync(A <Order> ._)).Returns(new Order {
CustomerFullName = "Bruce Wayne"
});
var result = await _testee.Handle(new CreateOrderCommand(), default);
result.Should().BeOfType <Order>();
result.CustomerFullName.Should().Be("Bruce Wayne");
}
public async Task TestAddAsync()
{
Guid id = Guid.NewGuid();
var order = new Order(id)
{
Name = "Name", Code = "Code"
};
await _orderRepository.AddAsync(order);
await _unitOfWork.CommitAsync();
var result = await _orderRepository.SingleAsync(t => t.Id == id);
Assert.Equal(id, result.Id);
}
public async Task <Unit> Handle(CreateNewOrderCommand request, CancellationToken cancellationToken)
{
var order = Order.Create(request.OrderName);
await _orderRepository.AddAsync(order);
return(Unit.Value);
}
public async Task AddOrderAsync(AddOrderRequest request)
{
var user = userRepository.GetById(request.UserId);
if (user == null)
{
throw new Exception(ErrorMessage.UserNotFound);
}
var productsList = productRepository.GetProducts(request.Products.Select(p => p.ProductId));
if (productsList == null ||
productsList.Count() == 0 ||
request.Products.Any(p => !productsList.Any(pl => pl.Id == p.ProductId)))
{
throw new Exception(ErrorMessage.ProductsNotFound);
}
var order = mapper.Map <Order>(request);
order.CreationDate = DateTime.Now;
foreach (var product in order.Products)
{
var actualProduct = productsList.First(p => p.Id == product.ProductId);
product.UnityPrice = actualProduct.Price;
}
await orderRepository.AddAsync(order);
}
public async Task AddOrUpdateAsync(OrderDto order, bool isUpdate = false)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (order.UserId <= 0)
{
throw new ArgumentNullException(nameof(order.UserId));
}
if (order.ProductItems == null)
{
throw new ArgumentNullException(nameof(order.ProductItems));
}
var domainOrder = _mapper.Map <OrderDto, Order>(order);
Dictionary <int, int> productItems = new Dictionary <int, int>();
foreach (var item in order.ProductItems)
{
productItems.Add(item.ProductId, item.Amount);
}
if (isUpdate)
{
await _orderRepository.UpdateAsync(domainOrder, productItems);
return;
}
await _orderRepository.AddAsync(domainOrder, productItems);
}
public async Task <ReadOrderModel> AddOrderAsync(CreateOrderModel model, CancellationToken cancellationToken)
{
var order = _mapper.Map <Order>(model);
order.IconId = await _fileService.AddOrUpdateFileByIdAsync(model.Icon, order.IconId, cancellationToken);
foreach (var categoryId in model.CategoryIds)
{
var category = await _categoryRepository.GetByIdAsync(categoryId, cancellationToken);
var orderCategory = new OrderCategory
{
Order = order,
Category = category
};
order.Categories.Add(orderCategory);
}
await _orderRepository.AddAsync(order, cancellationToken);
await _unitOfWork.SaveChangesAsync(cancellationToken);
return(_mapper.Map <ReadOrderModel>(order));
}
public async Task <CreateOrderResponse> Handle(CreateOrderRequest request, CancellationToken cancellationToken = default)
{
try
{
var orderNumber = request.OrderNumber;
var productItemsFromRepository = await _productItemRepository
.GetListByProductNumberAsync(request.Items.Select(x => x.ItemNumber), cancellationToken);
var orderItems = new List <OrderItem>();
foreach (var item in request.Items)
{
var productItem = productItemsFromRepository.FirstOrDefault(x => x.ProductNumber == item.ItemNumber);
orderItems.Add(new OrderItem(productItem.Id, item.Quantity));
}
var order = new Order(orderNumber, orderItems);
await _orderRepository.AddAsync(order);
var requiredBinWidth = await _packageService.CalculateRequiredBinWidthByOrderAsync(order, cancellationToken);
return(new CreateOrderResponse(requiredBinWidth));
}
catch (OrderNumberAlreadyExistRepositoryException ex)
{
throw new OrderNumberAlreadyExistServiceException($"Order {request.OrderNumber} already exist.");
}
catch (ProductItemFoundRepositoryException ex)
{
throw new EntityNotFoundServiceException(ex.Message, ex);
}
}
protected async Task <List <Order> > CreateSomeOrdersAsync(List <Customer> customers, List <Product> products)
{
var customerId = customers[1].Id;
var productId1 = products[1].Id;
var productId2 = products[2].Id;
var orders = new List <Order>();
for (var i = 0; i < 10; i++)
{
var orderItem1 = _orderFactory.CreateNewOrderItem(productId1, 56.92m, 40);
var orderItem2 = _orderFactory.CreateNewOrderItem(productId2, 72.46m, 50);
var orderItems = new List <OrderItem>
{
orderItem1,
orderItem2,
};
var order = _orderFactory.CreateNewOrder(customerId, orderItems);
await _orderRepository.AddAsync(order);
}
return(orders);
}
public async Task <GenericResponse <Order> > SaveAsync(int userId, IEnumerable <OrderItemResource> saveOrderItems)
{
var existingUser = await _userRepository.FindByIdAsync(userId);
var items = await _shoppingCartService.GetItemsListAsync(saveOrderItems);
if (items.Count == 0)
{
return(new GenericResponse <Order>("No items made"));
}
if (existingUser == null)
{
return(new GenericResponse <Order>("No user found"));
}
try
{
var order = new Order {
Created = DateTime.Now, Items = items
};
existingUser.Orders.Add(order);
_userRepository.Update(existingUser);
await _orderRepository.AddAsync(order);
await _unitOfWork.CompleteAsync();
return(new GenericResponse <Order>(order));
}
catch (Exception ex)
{
return(new GenericResponse <Order>($"An error occurred saving the order: {ex.Message}"));
}
}
private async Task <Domain.Aggregates.OrderAggregate.Order> AddOrderRepository(PeriodType periodType, IEnumerable <int> dishes)
{
var order = new Domain.Aggregates.OrderAggregate.Order(periodType, dishes.ToString());
await _orderRepository.AddAsync(order);
return(order);
}
public async Task <IActionResult> Index([FromForm] Order order)
{
var userID = _userManager.GetUserId(User);
var data = new
{
status = 1,
siteID = order.SiteID,
productID = order.ProductID,
quantity = order.Quantity,
customerID = order.CustomerCID,
message = "",
};
if (ModelState.IsValid)
{
CustomResponse response = await _orderRepository.AddAsync(order);
if (response.Status == 1)
{
TempData["SuccessMessage"] = "Order placed successfylly.";
return(RedirectToAction(nameof(Index), new { status = 0, customerID = "" }));
}
TempData["ResponseMessage"] = response.Message;
return(RedirectToAction(nameof(Index), data));
}
return(RedirectToAction(nameof(Index), data));
}
public async Task ProcessAsync(Order order, string baseUrl)
{
await orderRepository.AddAsync(order);
await SendNewOrderEmailAsync(order, baseUrl);
await SavePendingRatesAsync(order);
}
public async Task CreateOrder(OrderDto orderDto)
{
Order order = CreateOrderFromDto(orderDto);
await _orderRepository.AddAsync(order);
await Clients.Others.SendAsync(OrderReceived, order);
}
public async Task <OrderResponse> Handle(CheckoutOrderCommand request, CancellationToken cancellationToken)
{
// var orderEntity = OrderMapper.Mapper.Map<Order>(request);
var orderEntity = new Order
{
AddressLine = request.AddressLine,
CVV = request.CVV,
CardName = request.CardName,
CardNumber = request.CardNumber,
Country = request.Country,
EmailAddress = request.EmailAddress,
Expiration = request.Expiration,
FirstName = request.FirstName,
LastName = request.LastName,
PaymentMethod = request.PaymentMethod,
State = request.State,
TotalPrice = request.TotalPrice,
UserName = request.UserName,
ZipCode = request.ZipCode
};
if (orderEntity == null)
{
throw new ApplicationException("Not Mapped");
}
var newOrder = await _orderRepository.AddAsync(orderEntity);
var orderResponse = OrderMapper.Mapper.Map <OrderResponse>(newOrder);
return(orderResponse);
}
public async Task InitializeAsync()
{
if (!_applicationOptions.Value.SeedData)
{
_logger.LogInformation("Data initialization skipped.");
return;
}
_logger.LogInformation("Initializing data...");
var customers = GetCustomers().ToList();
var products = GetProducts().ToList();
foreach (var customer in customers)
{
await _customerRepository.AddAsync(customer);
}
foreach (var product in products)
{
await _productRepository.AddAsync(product);
}
var orders = GetOrders(customers, products).ToList();
foreach (var order in orders)
{
await _orderRepository.AddAsync(order);
}
_logger.LogInformation("Data initialized.");
}
public async Task <IActionResult> CreateOrder([FromBody] SaveOrderResource orderResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// check whether current user sent a request
var currentUser = await userRepository.GetCurrentUser();
if (currentUser.Id != orderResource.IdentityId)
{
return(NotFound());
}
var order = await repository.GetAsync(orderResource.IdentityId, (int)orderResource.VehicleId);
if (order != null)
{
return(BadRequest(ModelState.AddError("invalid_request", "Order is already done")));
}
order = mapper.Map <Order>(orderResource);
await repository.AddAsync(order);
await uow.CommitAsync();
order = await repository.GetAsync(orderResource.IdentityId, (int)orderResource.VehicleId);
var result = mapper.Map <PlainOrderResource>(order);
return(Ok(result));
}
/// <summary>
/// Creert een order uit het gegeven viewmodel
/// </summary>
/// <param name="dto">Viewmodel met de nodige data voor het aanmaken van een nieuw order</param>
/// <returns>Nieuw aangemaakt order</returns>
/// <exception cref="EntityNotFoundException">Wordt gegooid wanneer een persoon in het order of in een orderline niet gevonden werd.</exception>
public async Task <Order> CreateOrder(CreateOrderDTO dto, string userEmail)
{
var orderedBy = await _leidingRepository.FindByEmailAsync(userEmail);
if (orderedBy == null)
{
throw new EntityNotFoundException($"Besteller '{userEmail}' werd niet gevonden.");
}
var newOrder = Order.Create(orderedBy);
await _orderRepository.AddAsync(newOrder);
foreach (var lineModel in dto.Orderlines)
{
var drank = await _drankRepository.FindByIdAsync(lineModel.DrankId);
if (drank == null)
{
throw new EntityNotFoundException($"Drank met id {lineModel.DrankId} werd niet gevonden");
}
var orderedFor = await _leidingRepository.FindByIdAsync(lineModel.OrderedForId);
if (orderedFor == null)
{
throw new EntityNotFoundException($"Persoon met id {lineModel.OrderedForId} werd niet gevonden.");
}
var personCanOrder = orderedFor.Tak.TabIsAllowed;
if (!personCanOrder)
{
throw new InvalidOperationException($"Leden van {orderedFor.Tak.Naam} kunnen geen gebruik maken van de Poef.");
}
var orderline = Orderline.Create(drank, orderedFor, newOrder, lineModel.Quantity);
await _orderlineRepository.AddAsync(orderline);
//Create a transaction for the submitted order
var amount = orderline.DrinkPrice * orderline.Quantity;
amount = -amount;
var transaction = new Transaction(amount, $"{orderline.Quantity}x {orderline.Drank.Naam}");
var account = await _accountRepository.FindAccountAsync(orderedFor.Id, AccountType.Tab);
if (account == null)
{
account = await _accountService.CreateAccountAsync(orderedFor.Id);
}
account.AddTransaction(transaction);
}
await _orderRepository.SaveChangesAsync();
return(newOrder);
}
public async Task <IServiceResult> CreateAsync(SavedOrderDto orderDto)
{
try
{
var order = _mapper.Map <SavedOrderDto, Order>(orderDto);
await _repository.AddAsync(order);
foreach (var orderItem in orderDto.OrderedItems)
{
order.AddItem(orderItem.ProductId, orderItem.Quantity);
_logger.LogError($"Added product with id {orderItem.ProductId} to order with id {order.Id}.");
}
if (!await _unitOfWork.CompleteAsync())
{
throw new SaveFailedException(nameof(order));
}
_logger.LogInformation($"Added new {nameof(order)} with id: {order.Id}.");
var result = await GetSingleAsync(order.Id.ToString());
return(new ServiceResult(payload: result.Payload));
}
catch (Exception e)
{
_logger.LogError($"Adding new order failed. {e.Message}");
return(new ServiceResult(false, e.Message));
}
}
public async Task <int> PlaceOrder(ShoppingCart carts, OrderVM order, string userEmail)
{
var orderToAdd = _mapper.Map <OrderVM, Order>(order);
orderToAdd.PaymentStatus = false;
orderToAdd.CreatedDate = DateTime.Now;
orderToAdd.CreatedBy = "admin";
orderToAdd.Status = OrderStatus.Waiting;
if (!string.IsNullOrEmpty(userEmail))
{
var user = _applicationUserRepository.GetUserByUserName(userEmail);
orderToAdd.User = user;
}
if (!string.IsNullOrEmpty(carts.CartPromoCode))
{
var discount = await _discountRepository.GetDiscountByPromoCode(carts.CartPromoCode);
orderToAdd.Discount = discount;
}
else
{
var discount = await _discountRepository.GetDiscountById(1);
orderToAdd.Discount = discount;
}
await _orderRepository.AddAsync(orderToAdd);
foreach (var item in carts.Cart)
{
var product = await _productRepository.GetSingleByIDAsync(item.Product.ProductId);
if (product.AvailableQuantity >= item.Quantity)
{
var orderDetail = new OrderDetail()
{
OrderId = orderToAdd.OrderId, ProductId = item.Product.ProductId, Quantity = item.Quantity
};
await _orderDetailRepository.AddAsync(orderDetail);
//Update product sold
var rank = await _productRankRepository.GetSingleByIDAsync(item.Product.ProductId);
rank.Sold += item.Quantity;
await _productRankRepository.UpdateAsync(rank);
product.AvailableQuantity -= item.Quantity;
await _productRepository.UpdateAsync(product);
}
else
{
return(0);
}
}
return(await _unitOfWork.SaveAsync());
}
public virtual async Task <ApiResult <Order> > CreateOrder(OrderDto orderDto, CancellationToken cancellationToken)
{
//var order = Mapper.Map<Order>(orderDto);
var order = orderDto.ToEntity();
await orderRepository.AddAsync(order, cancellationToken);
return(order);
}
public async Task HandleAsync(AddClientOrder command)
{
var order = _mapper.Map <Order>(command.Order);
order.OrderID = Guid.NewGuid();
order.UserID = Guid.Parse(command.User.FindFirst(ClaimTypes.NameIdentifier).Value);
await _orderRepository.AddAsync(order);
}
/// <summary>
/// Добавить заказ
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <OrderDto> MakeOrderAsync(NewOrderDto dto)
{
var order = await _orderRepository.AddAsync(_mapper.Map <Order>(dto));
await _orderRepository.SaveChangesAsync();
return(_mapper.Map <OrderDto>(order));
}
public async Task HandleAsync(CreateOrder command)
{
var order = new Order(command.Id, command.CustomerId, OrderStatus.New, _dateTimeProvider.Now);
await _orderRepository.AddAsync(order);
var events = _eventMapper.MapAll(order.Events);
await _messageBroker.PublishAsync(events.ToArray());
}
public async Task <IActionResult> Post([FromBody] AddShoppingCartModel model)
{
if (string.IsNullOrEmpty(model.UserID) ||
Guid.Empty == model.ProductID || 0 >= model.Amount)
{
return(ResponseHelper.NotAcceptable());
}
var product = await _productRepository.GetAsync(model.ProductID);
if (null == product)
{
return(NotFound());
}
List <ShipAddress> addressList = await _shipAddressRepository.GetAddressAsync(model.UserID, 50, 0);
Order order = new Order()
{
Address = addressList.Count > 0 ? addressList[0].ToString() + "(mobile)" : string.Empty + "(mobile)",
OrderID = Guid.NewGuid(),
OrderDate = DateTime.Now,
OrderStatus = OrderStatus.PendingPayment,
UserID = model.UserID,
};
OrderDetail orderDetail = new OrderDetail()
{
OrderID = order.OrderID,
PlaceDate = DateTime.Now,
ProductName = product.ProductName,
ProductID = product.ProductID,
ThumbImagePath = product.ThumbnailImage,
UnitPrice = product.UnitPrice,
Quantity = model.Amount,
SubTotal = product.UnitPrice * model.Amount
};
order.TotalPrice = orderDetail.SubTotal;
Guid orderID = await _orderRepository.AddAsync(order);
// Add order failed.
if (orderID == Guid.Empty)
{
return(ResponseHelper.InternalServerError());
}
int count = await _orderDetailRepository.AddAsync(orderDetail);
if (0 < count)
{
return(Ok());
}
else
{
return(ResponseHelper.InternalServerError());
}
}
public override async Task <Result> Handler(CreateOrder message)
{
var order = new Order(message.FirstName, message.LastName, message.Email, message.IsActive);
await _OrderRepository.AddAsync(order);
await _OrderRepository.SaveEntitiesAsync();
return(new Result());
}
public async Task <int> Handle(CheckoutOrderCommand request, CancellationToken cancellationToken)
{
var orderEntity = _mapper.Map <Order>(request);
var newOrder = await _orderRepository.AddAsync(orderEntity);
await SendEmail(newOrder);
return(newOrder.Id);
}
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);
}
/// <summary>
/// 添加
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <Unit> Handle(CreateCommand request, CancellationToken cancellationToken)
{
var result = _mapper.Map <Core.Domain.Order>(request);
await _orderRepository.AddAsync(result);
await _orderRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
return(new Unit());
}
public async Task <OrderId> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
IOrderRepository orderRepository = _orderDbContext.OrderRepository;
Order order = Order.Create(request.AccountId, request.OrderItems);
await orderRepository.AddAsync(order, cancellationToken);
return(order.Id);
}
public async Task <OrderDto> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var orderDto = request.OrderDto;
var details = await _detailsRepository.GetAsync(orderDto.ShippingDetailsId);
if (details == null)
{
throw new NotValidException(nameof(orderDto.ShippingDetailsId),
$"ShippingDetails with id ({orderDto.ShippingDetailsId}) doesn't exist");
}
var order = _mapper.Map <Order>(orderDto);
order.OrderStatus = OrderStatus.Pending;
order.DateOrdered = DateTime.UtcNow;
foreach (var orderItem in order.OrderItems)
{
var product = await _productRepository.GetAsync(orderItem.ProductId);
if (product == null || product.SoftDeleted)
{
throw new NotValidException(nameof(orderItem.ProductId),
$"Product with id ({orderItem.ProductId}) does not exist");
}
if (!product.IsAvailable)
{
throw new NotValidException(nameof(orderItem),
$"Product with id ({orderItem.ProductId}) is not available");
}
if (product.PromotionEndDate < DateTime.UtcNow && product.PromotionPrice.HasValue)
{
orderItem.PricePerUnit = product.PromotionPrice.Value;
}
else
{
orderItem.PricePerUnit = product.Price;
}
}
if (order.TotalSum < 1)
{
throw new NotValidException(nameof(Order.TotalSum), "Order total sum should be greater than 1");
}
await _orderRepository.AddAsync(order);
await _orderRepository.UnitOfWork.SaveChangesAsync();
var result = _mapper.Map <OrderDto>(order);
return(result);
}
