public HttpResponseMessage EditOrders(UpdateOrderDTO request)
{
HttpResponseMessage responseMessage;
JSendMessage json;
var order = db.Orders.FirstOrDefault(o => o.OrderId == request.OrderId);
if (null != order)
{
order.Sent = request.Sent;
db.Orders.Update(order);
db.SaveChanges();
json = new JSendMessage("success", "Order successfully updated");
responseMessage = Request.CreateResponse(HttpStatusCode.OK, json);
}
else
{
json = new JSendMessage("success", "Order not found");
responseMessage = Request.CreateResponse(HttpStatusCode.NotFound, json);
}
return(responseMessage);
}
public async Task <Order> UpdateOrder(UpdateOrderDTO dto, int orderId)
{
var order = await _orderRepository.FindByIdAsync(orderId);
if (order == null)
{
throw new EntityNotFoundException($"Order met id {orderId} werd niet gevonden.");
}
bool shouldUpdate = dto.OrderedById != order.OrderedBy.Id;
if (shouldUpdate)
{
var leiding = await _leidingRepository.FindByIdAsync(dto.OrderedById);
if (leiding == null)
{
throw new EntityNotFoundException($"Persoon met id {dto.OrderedById} werd niet gevonden.");
}
order.OrderedBy = leiding;
await _orderRepository.SaveChangesAsync();
}
return(order);
}
public async Task <IActionResult> Put([FromBody] UpdateOrderDTO updateOrderDTO)
{
UpdateOrderModel UpdateCreateOrder = new DTOMapper <UpdateOrderDTO, UpdateOrderModel>().Serialize(updateOrderDTO);
var OrderUpdateResponse = await _orderService.UpdateOrders(UpdateCreateOrder);
return(Ok(OrderUpdateResponse));
}
public void Update(int id, UpdateOrderDTO dto)
{
var order = _dbContext
.Orders
.FirstOrDefault(o => o.Id == id);
order.Repair = dto.Repair;
order.IsReady = dto.IsReady;
_dbContext.SaveChanges();
}
public async Task <IActionResult> Put(UpdateOrderDTO model)
{
try {
await this.m_orderService.UpdateOrderAsync(model);
return(this.Ok());
} catch (Exception exception) {
return(this.BadRequest(exception.Message));
}
}
public ActionResult Update([FromBody] OrdersDTO dto)
{
var _dto = new UpdateOrderDTO()
{
IsReady = dto.IsReady,
Repair = dto.Repair
};
_csService.Update(1, _dto);
return(RedirectToAction("index", "Home"));
}
public async Task <ActionResult> Update([FromRoute] int id, [FromBody] UpdateOrderDTO orderDTO)
{
Order order = await _orderRepository.FindByIdAsync(id);
if (order.IsNull())
{
return(NotFound());
}
order = _mapper.Map(orderDTO, order);
await _orderRepository.UpdateAsync(order);
return(NoContent());
}
public async Task UpdateOrderAsync(UpdateOrderDTO model)
{
var order = await this.Repository.GetByIdAsync(model.Id);
if (order == null)
{
throw new Exception("Order not found.");
}
order.Address = model.Address;
order.Name = model.Name;
order.Status = (int)model.Status < 5?model.Status:order.Status;
order.PhoneNumber = model.PhoneNumber;
order.UpdatedBy = this.HttpContext.User.Claims.FirstOrDefault()?.Value;
await this.Repository.UpdateAsync(order);
}
public async Task <ActionResult> UpdatePartial([FromRoute] int id, [FromBody] JsonPatchDocument <UpdateOrderDTO> patchOrderDTO)
{
Order order = await _orderRepository.FindByIdAsync(id);
if (order.IsNull())
{
return(NotFound());
}
UpdateOrderDTO orderDTO = _mapper.Map <UpdateOrderDTO>(order);
patchOrderDTO.ApplyTo(orderDTO);
if (!TryValidateModel(orderDTO))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(orderDTO, order);
await _orderRepository.UpdateAsync(order);
return(NoContent());
}
public async Task <IActionResult> UpdateOrder([FromBody] UpdateOrderDTO dto, [FromRoute] int orderId)
{
var updatedOrder = await _orderService.UpdateOrder(dto, orderId);
return(Ok(updatedOrder));
}
