public async Task <IActionResult> Post([FromBody] OrderAddResource model)
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new MyUnprocessableEntityObjectResult(ModelState));
}
var order = _mapper.Map <OrderAddResource, Order>(model);
_orderRepository.AddOrderAsync(order);
if (await _unitOfWork.SaveChangesAsync() <= 0)
{
throw new Exception("Save Failed!");
}
var orderResource = _mapper.Map <Order, OrderResourceModel>(order);
var links = CreateLinksForOrder(order.Id);
var linkedOrderResoure = orderResource.ToDynamic() as IDictionary <string, object>;
linkedOrderResoure.Add("links", links);
return(CreatedAtRoute("GetOrder", new { id = linkedOrderResoure["Id"] }, linkedOrderResoure));
}
/// <summary>
/// Add order and order details
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public async Task AddOrderAsync(Order order)
{
//Insert order first
Order newOrder = new Order
{
OrderConformationNumber = _orderHelper.GenerateOrderConformationNumber(),
OrderedDate = DateTime.Now,
OrderStatusId = (int)OrderStausEnum.ACTIVE,
CustomerId = order.CustomerId
};
await _orderRepository.AddOrderAsync(newOrder);
//Get newly insterted orderID
int id = newOrder.ID;
//Insert all the order details
foreach (var orderDetail in order.OrderDetails)
{
OrderDetail newOrderDetail = new OrderDetail
{
Quantity = orderDetail.Quantity,
OrderId = id,
ItemId = orderDetail.ItemId,
VendorId = orderDetail.VendorId,
OrderDetailStatusId = (int)OrderDetailStausEnum.ACTIVE
};
await _orderDetailRepository.AddOrderDetailAsync(newOrderDetail);
}
}
public async Task <IActionResult> addOrder(Order model)
{
if (model.cartId == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var order = await _repo.AddOrderAsync(model);
OrderProduct orderProduct = new OrderProduct
{
OrderId = order.Id
};
var basket = await _basketrepo.GetBasketAsync(order.cartId);
var products = await _db.products.ToListAsync();
foreach (var item in products)
{
if (item.ProductId == basket.items.FirstOrDefault().Id)
{
orderProduct.ProductId = item.ProductId;
item.Amount -= basket.items.FirstOrDefault().Quantity;
//await _db.SaveChangesAsync();
}
}
_db.orderProducts.Add(orderProduct);
await _db.SaveChangesAsync();
return(Ok());
}
return(BadRequest());
}
public async Task <Order> ProcessOrderAsync(BasketViewModel basket, OrderInformationViewModel orderInformation)
{
return(await orderRepository.AddOrderAsync((order) =>
{
orderOperations.AddUserInformationToOrder(ref order, orderInformation);
orderOperations.AddOrderInformationToOrder(ref order, basket, orderInformation);
orderOperations.AddBasketLinesToOrder(basket, ref order);
}));
}
public async Task <OrderDto> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var order = new Order(request.UserID, request.CurriculumID, request.CurriculumTitle, request.CurriculumPrice, request.DiscountsPrice);
await _OrderRepository.AddOrderAsync(order);
await _OrderRepository._Unitwork.DomianSaveChangesAnsyc();
return(_Mapper.Map <OrderDto>(order));
}
public async Task <AddOrderResponse> AddOrderDb(AddOrderRequest request)
{
var orderId = await _repository.AddOrderAsync(request);
if (orderId > 0)
{
return(new AddOrderResponse(true, orderId));
}
return(new AddOrderResponse(false, 0));
}
public async Task AddOrderAsync(Order order)
{
Order order1 = new Order()
{
DateCreated = DateTime.Now,
OrderState = "New", //TODO Make OrderState enum
CustomerId = order.CustomerId
};
await _orderRepository.AddOrderAsync(order1);
}
public async Task <OrderDto> CreateOrderAsync(OrderDto orderDto)
{
var order = orderDto.ToEntity();
order.Date = DateTime.Now;
var created = await _repository.AddOrderAsync(order);
if (created == null)
{
throw new Exception("Order already exists.");
}
return(new OrderDto(created));
}
public async Task <IActionResult> AddOrder([FromBody] Order order)
{
try
{
var newOrder = await _repository
.AddOrderAsync(order);
return(Ok(newOrder));
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
public async Task <IActionResult> AddOrder(OrderAddDto orderAddDto)
{
//get user id from token
var order = new Order {
UserId = orderAddDto.UserId
};
await _orderRepository.AddOrderAsync(order);
if (!await _unitOfWOrk.SaveAsync())
{
return(BadRequest("Failed to add order"));
}
return(Created("Orders", new { id = order.Id }));
}
public async Task <bool> AddAsync(Order order, int customerId)
{
Customer customer = await _customerRepository.GetByIdAsync(customerId);
if (customer == null)
{
return(false);
}
order.Customer = customer;
await _orderRepository.AddOrderAsync(order);
return(true);
}
public async Task <OrderModel> AddOrderAsync(OrderModel orderModel)
{
var orderToAdd = _mapper.Map <OrderModel, Order>(orderModel);
var productsAsNoTracking = await _productRepository.GetProductsAsNoTracking();
var productsInOrder =
productsAsNoTracking.Where(x => orderModel.OrderItems.Select(p => p.ProductId).Contains(x.Id)).ToList();
orderToAdd.TotalCost = OrderHelper.GetOrderTotalCost(orderModel.OrderItems, productsInOrder);
var addedOrder = await _orderRepository.AddOrderAsync(orderToAdd);
var productsToUpdateQuantity =
ProductHelper.SetNewProductQuantities(productsInOrder, orderModel.OrderItems);
await _productRepository.UpdateProductsAsync(productsToUpdateQuantity);
var result = await _orderRepository.GetOrderByIdAsync(addedOrder.Id);
return(_mapper.Map <Order, OrderModel>(result));
}
public async Task <IActionResult> AddOrder(Order order)
{
if (ModelState.IsValid)
{
AdminUser user = await userManager.FindByIdAsync(order.UserId);
if (user != null)
{
await orepository.AddOrderAsync(order);
return(RedirectToAction(nameof(Orders)));
}
else
{
ModelState.AddModelError("", "The User doesn't exists");
return(View("Orders", await orepository.OrdersAsync()));
}
}
else
{
return(View("Orders", await orepository.OrdersAsync()));
}
}
public async Task <OrderResponse> SaveOrderAsync(Order order)
{
try
{
var existingClient = await _clientRepository.GetClientByIdAsync(order.ClientId);
if (existingClient == null)
{
return(new OrderResponse("Client not found"));
}
await _orderRepository.AddOrderAsync(order);
await _unitOfWork.CompleteAsync();
return(new OrderResponse(order));
}
catch (Exception e)
{
Console.WriteLine(e);
return(new OrderResponse($"An error has occurred while adding the order: {e.Message}"));
}
}
public async Task CreateOrderAsync(string userName)
{
var user = await _users.GetUserByUserName(userName);
var allItems = await _items.Find(x => x.ShopCartId == user.ShopCartId);
if (allItems.Count() == 0)
{
throw new ArgumentNullException("ShopCart does not contain purchases");
}
Order newOrder = new Order()
{
User = user
};
foreach (var it in allItems)
{
newOrder.Details.Add(new OrderDetail()
{
ProductId = it.ProductId,
TotalCost = it.Product.Price * it.Quantity,
Quantity = it.Quantity
});
}
newOrder.TotalCost = allItems.Sum(x => x.Quantity * x.Product.Price);
var userRoles = await _users.GetUserRoles(user);
newOrder.TotalCost *= _discount.CalculateDiscount(userRoles);
await _orders.AddOrderAsync(newOrder);
await _items.DeleteRangeAsync(allItems);
}
public async Task <string> PayRoom(OrderRequestModel model)
{
try
{
if (model.ReservationId == null)
{
throw new Exception("operation is impossible without Id");
}
var userId = _headerService.GetUserId();
if (userId == null)
{
throw new Exception("operation is impossible without Id");
}
var verify = new VerificationReservationId()
{
ReservationId = model.ReservationId.ToString(),
UserId = userId.ToString()
};
var reservation = await _publisher.VerifyReservationId(verify);
var receiveReservation = JsonConvert.DeserializeObject <ReceiveReservation>(reservation);
var amountPaid = receiveReservation.AmountPaid.ToString();
var pay = new PaymentModel()
{
AmountPaid = amountPaid, UserId = userId.ToString()
};
var message = await _publisher.PayRoom(pay);
var m = "spspspsps";
var mmm = "rtrtrtrtrtrtr";
if (message == m)
{
throw new Exception(message);
}
if (message == mmm)
{
throw new Exception(message);
}
var errorMessage = "I'm sorry, but it appears your account has insufficient funds";
if (message == errorMessage)
{
throw new Exception(message);
}
var dateOfPayment = DateTime.UtcNow;
var newOrder = new Order()
{
Id = Guid.NewGuid(),
UserId = userId,
RoomId = receiveReservation.RoomId,
ReservStartDate = receiveReservation.ReservStartDate,
ReservFinishDate = receiveReservation.ReservFinishedDate,
DateOfPayment = dateOfPayment,
AmountPaid = receiveReservation.AmountPaid,
};
await _orderRepository.AddOrderAsync(newOrder);
var payment = new Payment()
{
ReservationId = model.ReservationId.ToString()
};
await _publisher.PublishPayment(payment);
return(message);
}
catch (Exception ex)
{
_logger.LogError(ex, "faild orderService");
throw;
}
}
