public OrderItemDTO AddOrderItem(OrderItemDTO orderItemDto)
        {
            var orderItem     = OrderItemMapper.DtoToDomain(orderItemDto);
            var errorMessages = new List <string>();

            if (!OrderItemValidator.Validate(orderItem, unitOfWork, ref errorMessages))
            {
                throw new InvalidObjectException("Order", orderItem, errorMessages);
            }

            try
            {
                var item = unitOfWork.ItemRepository.GetById(orderItemDto.ItemId);

                orderItem.ItemPrice         = item.Price;
                orderItem.ItemHeight        = item.Height;
                orderItem.ItemWidth         = item.Width;
                orderItem.ItemUnit          = item.Unit;
                orderItem.ItemWeightInGrams = item.WeightInGrams;

                unitOfWork.OrderItemRepository.Add(orderItem);
                unitOfWork.Commit();

                return(OrderItemMapper.DomainToDto(orderItem));
            }
            catch (Exception exception)
            {
                throw new Exception("An exception occured adding customer: ", exception);
            }
        }
示例#2
0
 public OrderService(IOrderRepository orderRepository,
                     IOrderItemRepository orderItemRepository,
                     IPaymentRepository paymentRepository,
                     OrderMapper orderMapper,
                     OrderItemMapper orderItemMapper,
                     ExchangeRateProvider exchangeRateProvider)
 {
     _orderRepository      = orderRepository;
     _orderItemRepository  = orderItemRepository;
     _paymentRepository    = paymentRepository;
     _orderMapper          = orderMapper;
     _orderItemMapper      = orderItemMapper;
     _exchangeRateProvider = exchangeRateProvider;
 }
        public async Task <bool> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
        {
            var orderId = Guid.NewGuid();
            var order   = new Order(orderId, request.CustomerId);

            foreach (var orderItem in request.OrderItems)
            {
                order.AddOrderItem(OrderItemMapper.MapToOrderItem(orderItem, orderId));
            }

            _logger.LogInformation("----- Creating Order - Order: {@Order}", order);

            await _repositroy.CreateAsync(order);

            await _repositroy.UnitOfWork.SaveEntitiesAsync();

            return(true);
        }
示例#4
0
        private async Task <OrderItemModelItem> CreateOrderItemsAsync(CartModelItem model)
        {
            var paymentId = await GetPaymentIdAsync(model.TransactionId);

            var orderId = await GetOrderIdAsync(paymentId);

            var response = new OrderItemModelItem();
            var items    = new List <OrderItem>();

            foreach (var item in model.OrderItems)
            {
                var orderItem = OrderItemMapper.MapModelToEntity(item);
                orderItem.OrderId = orderId;
                items.Add(orderItem);
            }
            var result = await _orderItemRepository.CreateRangeAsync(items);

            if (!result)
            {
                response.Errors.Add(ErrorConstants.ImpossibleToCreateOrderItem);
            }
            response.OrderId = orderId;
            return(response);
        }