public string AddOrder(OrderForCreationVm order)
{
Order newOrder = _mapper.Map <Order>(order);
int orderId = _orderRepository.AddNewOrder(newOrder);
string orderConfirmation = GenerateOrderConfrimation(orderId);
newOrder.OrderConfirmation = orderConfirmation;
return(orderConfirmation);
}
/// <summary>
/// Eine Bestellung wird für das Produkt angelegt.
/// </summary>
/// <param name="product"></param>
public Order OrderCoffee(Product product)
{
if (GetProducts().Contains(product))
{
Order newOrder = new Order(product);
_orderRepository.AddNewOrder(newOrder);
return(newOrder);
}
else
{
throw new ArgumentException("Produkt nicht verfügbar");
}
}
public async Task <bool> AddNewOrder(NewOrderViewModel order, User orderedBy)
{
try
{
var totalOrder = await _orderRepository.GetOrderCount();
var newServiceId = (totalOrder + 1).ToString().PadLeft(OrderServiceIdLength, '0');
var newOrder = new Order
{
ServiceId = newServiceId,
OrderBy = orderedBy,
Address = order.Address,
Lat = order.Lat,
Lon = order.Lon,
Zone = order.Zone,
Promotion = await GetPromoOffer(),
Status = (int)OrderStatus.New,
OrderPlacingTime = Utilities.GetPresentDateTime(),
OrderItems = new List <OrderItem>()
};
var addMessageResponse = await _userMessageBusiness.AddUserMessage(orderedBy.UserId, (int)MessageType.NewOrder, newServiceId);
var addOrderResponse = await _orderRepository.AddNewOrder(newOrder);
if (addMessageResponse == null && !addOrderResponse)
{
return(false);
}
var notification = new Notification
{
Type = (int)NotificationType.AddNewOrder,
MessageId = addMessageResponse,
Title = Constants.NEW_ORDER_MESSAGE_TITLE,
Text = string.Format(Constants.ACK_MESSAGE_TEXT, newServiceId),
SenderUserName = orderedBy.Name,
SenderUserId = orderedBy.UserId,
ReceiverUserName = orderedBy.Name,
ReceiverUserId = orderedBy.UserId,
Status = (int)NotificationStatus.NotSent,
NotificationId = Guid.NewGuid().ToString()
};
var notificationAdd = await _notificationRepository.AddNotification(notification);
return(notificationAdd);
}
catch (Exception ex)
{
throw new Exception("Error placing order." + ex);
}
}
public IActionResult Post([FromBody] NewOrderInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var res = repo.AddNewOrder(model);
//if(res.Ord_No == null)
//{
// return Ok(new { Message = "Не верный id пользователя", Status = false });
//}
return(Ok(res));
}
public OrderDTO CreateNewOrder(OrderDTO newOrderDTO)
{
Order newOrder = _orderMapper.FromOrderDTOToOrder(newOrderDTO);
newOrder.CustomerOfThisOrder = SearchCustomer(newOrderDTO.IdOfCustomer);
if (newOrder.CustomerOfThisOrder == null)
{
throw new OrderException();
}
foreach (var itemGroup in newOrder.ItemGroups)
{
Item itemOfThisGroup = _itemRepository.GetItemBasedOnId(itemGroup.ItemId);
itemGroup.PriceOfItem = itemOfThisGroup.Price;
itemGroup.ShippingDate = itemGroup.CalculateShippingDate(itemOfThisGroup);
itemOfThisGroup.AmountInStock -= itemGroup.AmountOfThisItem;
}
_orderRepository.AddNewOrder(newOrder);
return(_orderMapper.FromOrderToOrderDTO(newOrder));
}
public ActionResult <Order> PlaceOrder(string flightId, string passengerSeat, List <OrderLineDTO> orderLineDTOs)
{
Passenger passenger = _passengerRepository.GetByFlightIdAndSeatNumber(flightId, passengerSeat);
if (passenger == null)
{
return(NotFound("Passenger not found"));
}
Order order = new Order()
{
Passenger = passenger
};
_orderRepository.AddNewOrder(order);
_orderRepository.SaveChanges();
order = _orderRepository.GetLastOrder();
foreach (OrderLineDTO orderLineDTO in orderLineDTOs)
{
var food = _foodRepository.GetById(orderLineDTO.Food.FoodId);
if (food == null)
{
return(NotFound("Food not found"));
}
OrderLine newOrderLine = new OrderLine
{
FoodId = food.FoodId,
Quantity = orderLineDTO.Quantity
};
order.AddOrderLine(newOrderLine);
}
passenger.Orders.Add(order);
_passengerRepository.SaveChanges();
return(Ok(order));
}
public Task <int> Handle(AddOrderCommand request, CancellationToken cancellationToken)
{
Orders newOrder = new Orders(request.UserId, DateTime.Now, OrderStatus.Draft, request.Payment.CreditCartNumber, request.Payment.Cvv, request.Payment.ExpiredDate, request.Payment.OwnerName, request.ContactMail);
foreach (var product in request.Products)
{
newOrder.AddProduct(product.Id, product.ProductCount, product.Price, product.ProductName, product.ProductCode);
}
orderRepository.AddNewOrder(newOrder);
List <ProductsInStockViewModel> productsToReserve = new List <ProductsInStockViewModel>();
newOrder.Products.ToList().ForEach(x => productsToReserve.Add(new ProductsInStockViewModel()
{
ProductId = x.ProductId,
OrderProductCancelCount = x.OrderCount
}));
ReserveProductsMessage(new ReduceProductInStockCommand(newOrder.Id, productsToReserve));
return(Task.FromResult(newOrder.Id));
}
public void Add(Order newOrder)
{
_repo.AddNewOrder(newOrder);
}
public async Task AddNewOrderAsync(string userId, List <Course> courses)
{
await orderRepository.AddNewOrder(userId, courses);
}
