public async Task <ActionResult> CreateOrder([FromBody] SaveOrderDto saveOrder)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
var newOrder = _mapper.Map <SaveOrderDto, Order>(saveOrder);
newOrder.OrderTime = DateTime.Now;
var result = await _context.Orders.AddAsync(newOrder);
if (result.State != EntityState.Added)
{
return(StatusCode(500));
}
await _context.SaveChangesAsync();
await _context.Entry(newOrder).Reference(o => o.Cart).LoadAsync();
await _context.Entry(newOrder.Cart).Collection(c => c.Products).LoadAsync();
foreach (var product in newOrder.Cart.Products)
{
await _context.Entry(product).Reference(p => p.Product).LoadAsync();
}
return(Ok(_mapper.Map <Order, OrderDto>(newOrder)));
}
public void CreateOrder(SaveOrderDto saveOrderDto)
{
var order = _mapper.Map <SaveOrderDto, Order>(saveOrderDto);
_unitOfWork.Orders.Add(order);
_unitOfWork.Complete();
}
public static Order ConvertFromSaveOrderDto(SaveOrderDto orderDto, DateTime createdAt, ApplicationUser applicationUser)
{
return(new Order
{
Description = orderDto.Description,
CreatedAt = createdAt,
ApplicationUser = applicationUser
});
}
public void UpdateOrder(SaveOrderDto saveOrderDto)
{
var order = _unitOfWork.Orders.GetBy(saveOrderDto.OrderId);
if (order == null)
{
return;
}
_mapper.Map <SaveOrderDto, Order>(saveOrderDto, order);
_unitOfWork.Complete();
}
public async Task <IActionResult> SaveOrderAsync([FromBody] SaveOrderDto saveOrderDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var loggedUser = await _userManager.GetUserAsync(HttpContext.User);
var order = Order.ConvertFromSaveOrderDto(saveOrderDto, DateTime.Now, loggedUser);
var savedOrder = _orderRepository.Save(order);
var retVal = OrderDto.ConvertFromOrder(savedOrder);
return(Ok(retVal));
}
public static async Task <object> SaveOrder(
[OrchestrationTrigger] IDurableOrchestrationContext context,
ILogger log
)
{
SaveOrderDto dto = context.GetInput <SaveOrderDto>();
if (!context.IsReplaying)
{
log.LogInformation($"Save Order {dto} starting.....");
}
dto = await context.CallActivityAsync <SaveOrderDto>("A_SaveOrder", dto);
return(await Task.FromResult <object>(new { }));
}
public IActionResult OnGet(int?id)
{
if (id == null)
{
return(NotFound());
}
var order = _service.GetOrder(id ?? default(int));
if (order == null)
{
return(NotFound());
}
Order = _mapper.Map <OrderDto, SaveOrderDto>(order);
return(Page());
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] SaveOrderDto saveOrderDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var order = _orderRepository.Get(id);
if (order == null)
{
return(NotFound());
}
order.ConvertFormSaveOrderDto(saveOrderDto);
_unitOfWork.SaveChanges();
var updatedOrder = _orderRepository.Get(order.Id);
return(Ok(OrderDto.ConvertFromOrder(updatedOrder)));
}
public Order ConvertFormSaveOrderDto(SaveOrderDto orderDto)
{
Description = orderDto.Description;
return(this);
}
public static async Task <string> SaveOrder(
[ActivityTrigger] SaveOrderDto request,
ILogger log)
{
return(await Task.FromResult(""));
}
public IActionResult Comment(string orderId, SaveOrderDto dto)
{
return(Ok(new { dto, orderId }));
}
public IActionResult SetComplete(string orderId, SaveOrderDto dto)
{
return(Ok(new { dto, orderId }));
}
public IActionResult CreateOrder(SaveOrderDto dto)
{
return(Ok(ResponseResult.Success(dto)));
}
