public async Task <IActionResult> UpdateOrder([FromBody] SaveOrderResource orderResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentUser = await userRepository.GetCurrentUser();
// check whether current user sent a request
if (currentUser.Id != orderResource.IdentityId)
{
return(NotFound());
}
var order = await repository.GetAsync(orderResource.IdentityId, (int)orderResource.VehicleId);
// check whether is null or wrong vehicle
if (order == null)
{
return(NotFound());
}
mapper.Map(orderResource, order);
await uow.CommitAsync();
order = await repository.GetAsync(orderResource.IdentityId, (int)orderResource.VehicleId);
var result = mapper.Map <PlainOrderResource>(order);
return(Ok(result));
}
public async Task <IActionResult> UpdateOrder(int id, [FromBody] SaveOrderResource orderResourse)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = await _repo.GetOrder(id);
if (order == null)
{
return(NotFound());
}
_mapper.Map(orderResourse, order);
order.LastUpdate = DateTime.Now;
await _uow.CompleteAsync();
order = await _repo.GetOrder(order.Id);
var result = _mapper.Map <Order, OrderResource>(order);
return(Ok(result));
}
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));
}
public async Task <IActionResult> AddOrder([FromBody] SaveOrderResource saveOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = mapper.Map <SaveOrderResource, Order>(saveOrder);
order.Date = DateTime.Now;
order.State = "Placed";
if (saveOrder.InvoiceId == 0)
{
order.InvoiceId = null;
}
if (saveOrder.TotalAmount == 0)
{
order.TotalAmount = 1;
}
orderRepository.AddOrder(order);
await unitOfWork.CompleteAsync();
order = await orderRepository.GetOrderAsync(order.Id);
order.TotalPrice = basketRepository.CalcBasketCost(order.Basket) * order.TotalAmount;
await unitOfWork.CompleteAsync();
var orderResource = mapper.Map <Order, OrderResource>(order);
return(Ok(orderResource));
}
public async Task <IActionResult> CreateOrder([FromBody] SaveOrderResource newOrderResource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Order newOrder = _mapper.Map <SaveOrderResource, Order>(newOrderResource);
await _dbContext.Orders.AddAsync(newOrder);
await _dbContext.SaveChangesAsync();
return(Ok(_mapper.Map <OrderResource>(newOrder)));
}
public async Task <IActionResult> UpdateOrder(int id, [FromBody] SaveOrderResource updatedOrderResource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var updatingOrder = await _dbContext.Orders.FindAsync(id);
if (updatingOrder == null)
{
return(NotFound());
}
_mapper.Map <SaveOrderResource, Order>(updatedOrderResource, updatingOrder);
await _dbContext.SaveChangesAsync();
return(Ok(_mapper.Map <OrderResource>(updatingOrder)));
}
public async Task <IActionResult> AddOrderAsync([FromBody] SaveOrderResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var order = _mapper.Map <SaveOrderResource, Order>(resource);
var result = await _orderService.SaveOrderAsync(order);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var orderResource = _mapper.Map <Order, OrderResource>(result.Order);
return(Ok(orderResource));
}
public async Task <IActionResult> UpdateOrder(int id, [FromBody] SaveOrderResource saveOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = await orderRepository.GetOrderAsync(id);
if (order == null)
{
return(NotFound());
}
mapper.Map <SaveOrderResource, Order>(saveOrder, order);
await unitOfWork.CompleteAsync();
order = await orderRepository.GetOrderAsync(order.Id);
return(Ok(mapper.Map <Order, OrderResource>(order)));
}
public async Task <IActionResult> CreateOrder([FromBody] SaveOrderResource orderResource)
{
var sd = HttpContext.Request.ToString();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = _mapper.Map <SaveOrderResource, Order>(orderResource);
order.LastUpdate = DateTime.Now;
_repo.Add(order);
//_context.Orders.Add(order);
await _uow.CompleteAsync();
order = await _repo.GetOrder(order.Id);
var result = _mapper.Map <Order, OrderResource>(order);
return(Ok(result));
}
