public IActionResult CreateOrder(string customerId, [FromBody] OrdersForCreationDTO order)
{
if (order == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_customerRepository.CustometExist(customerId))
{
return(NotFound());
}
var finalOrder = _mapper.Map <Orders>(order);
_customerRepository.AddOrder(customerId, finalOrder);
if (!_customerRepository.Save())
{
return(StatusCode(500, "Plase verify your data"));
}
var customerCreated = _mapper.Map <OrdersDTO>(finalOrder);
return(CreatedAtRoute("GetOrder",
new
{
customerId = customerId,
id = customerCreated.OrderId
}, customerCreated));
}
public IActionResult CreateOrder
(int customerId,
[FromBody] OrdersForCreationDTO order)
{
if (order == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var customer = Repository.Instance
.Customers.FirstOrDefault(c => c.Id == customerId);
if (customer == null)
{
return(NotFound());
}
var maxOrderId =
Repository.Instance.Customers
.SelectMany(c => c.Orders)
.Max(o => o.OrderId);
var finalOrder = new OrdersDTO()
{
OrderId = maxOrderId++,
CustomerId = order.CustomerId,
EmployeeId = order.EmployeeId,
OrderDate = order.OrderDate,
RequiredDate = order.RequiredDate,
ShippedDate = order.ShippedDate,
ShipVia = order.ShipVia,
Freight = order.Freight,
ShipName = order.ShipName,
ShipAddress = order.ShipAddress,
ShipCity = order.ShipCity,
ShipRegion = order.ShipRegion,
ShipPostalCode = order.ShipPostalCode,
ShipCountry = order.ShipCountry
};
customer.Orders.Add(finalOrder);
return(CreatedAtRoute("GetOrder",
new
{
customerId = customerId,
id = finalOrder.OrderId
}, finalOrder));
}
public IActionResult UpdateOrder(int customerId, int id,
[FromBody] OrdersForCreationDTO order)
{
if (order == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var customer = Repository.Instance
.Customers.FirstOrDefault(c => c.Id == customerId);
if (customer == null)
{
return(NotFound());
}
var orderFromRepository =
customer.Orders.FirstOrDefault(o => o.OrderId == id);
if (orderFromRepository == null)
{
return(NotFound());
}
orderFromRepository.CustomerId = order.CustomerId;
orderFromRepository.EmployeeId = order.EmployeeId;
orderFromRepository.OrderDate = order.OrderDate;
orderFromRepository.RequiredDate = order.RequiredDate;
orderFromRepository.ShippedDate = order.ShippedDate;
orderFromRepository.ShipVia = order.ShipVia;
orderFromRepository.Freight = order.Freight;
orderFromRepository.ShipName = order.ShipName;
orderFromRepository.ShipAddress = order.ShipAddress;
orderFromRepository.ShipCity = order.ShipCity;
orderFromRepository.ShipRegion = order.ShipRegion;
orderFromRepository.ShipPostalCode = order.ShipPostalCode;
orderFromRepository.ShipCountry = order.ShipCountry;
return(NoContent());
}
//Creación de un nuevo registro con OrdersController
public IActionResult CreateOrder(int customerId, [FromBody] OrdersForCreationDTO order)
{
if (order == null)
{
return(BadRequest());
}
//Busca ClienteId
var customer = Repository.Instance.Customers.FirstOrDefault(c => c.Id == customerId);
if (customer == null)
{
return(NotFound());
}
//Retorna Id más alto
var maxOrderId = Repository.Instance.Customers.SelectMany(c => c.Orders).Max(o => o.OrderId);
//Asignar propiedades
var finalOrder = new OrdersDTO()
{
OrderId = maxOrderId++,
CustomerId = order.CustomerId,
EmployeeId = order.EmployeeId,
OrderDate = order.OrderDate,
RequiredDate = order.RequiredDate,
ShippedDate = order.ShippedDate,
ShipVia = order.ShipVia,
Freight = order.Freight,
ShipName = order.ShipName,
ShipAddress = order.ShipAddress,
ShipCity = order.ShipCity,
ShipRegion = order.ShipRegion,
ShipPostalCode = order.ShipPostalCode,
ShipCountry = order.ShipCountry
};
customer.Orders.Add(finalOrder);
//retornamos el nuevo recurso creado
return(CreatedAtRoute("GetOrder", new { customerId = customerId, id = finalOrder.OrderId }, finalOrder));
}
public IActionResult CreateOrder(string customerId, [FromBody] OrdersForCreationDTO order)
{
if (order == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <Order, OrderWitchout>();
});
IMapper mapper = config.CreateMapper();
var orderResult = mapper.Map <Order>(order);
_customerRepository.AddOrder(customerId, orderResult);
if (!_customerRepository.Save())
{
return(StatusCode(500, "Place verify your data"));
}
var mapperOrders = MapperOrders();
var resultMapperOrdersDTO = mapperOrders.Map <OrdersDTO>(orderResult);
return(CreatedAtRoute("GetOrder",
new
{
customerId = customerId,
id = resultMapperOrdersDTO.OrderId
},
orderResult
));
}
public IActionResult CreateOrder(string customerId, [FromBody] OrdersForCreationDTO order)// FromBody desde el cuerpo de la petición
{
if (order == null)
{
return(BadRequest());//solictud erronea
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_customerRepository.CustomerExists(customerId))
{
return(NotFound());
}
var finalOrder = Mapper.Map <Orders>(order);//como vamos a enviar datos ala db mapeamos order al dbset Orders
_customerRepository.AddOrder(customerId, finalOrder);
if (!_customerRepository.Save())
{
return(StatusCode(500, "Please verify your data"));
}
var customerCreated = Mapper.Map <OrdersDTO>(finalOrder);
return(CreatedAtRoute("GetOrder",
new
{
//Parametros del metodo GetOrder
customerId = customerId,
id = customerCreated.OrderId
}, customerCreated));
}
public IActionResult CreateOrder(string customerId, [FromBody] OrdersForCreationDTO order)
//Hay que especificar que el parametro order será introducio por el usuario en el Body de la página web de
//donde se está invocando este método (api/customers/3/orders por ejemplo si se trata del cliente con id 3)
{
if (order == null)
{
return(BadRequest("Petición incorrecta: el pedido está incompleto"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_customerRepository.CustomerExists(customerId))
{
return(NotFound($"Cliente con id {customerId} no encontrado en la bbdd"));
}
//var maxOrderId = Repository.Instance.Customers.SelectMany(c=>c.Orders).Max(o=>o.OrderId);
////Capturo en una variable el id max entre todos los pedidos de todos los clientes
var finalOrder = Mapper.Map <Orders>(order);
finalOrder.OrderDate = DateTime.Now;
_customerRepository.AddOrder(customerId, finalOrder);
if (!_customerRepository.Save())
{
return(StatusCode(500, "Por favor, revise los datos introducidos"));
}
var createdOrder = Mapper.Map <OrdersDTO>(finalOrder);
return(CreatedAtRoute("GetOrder", new { customerId = customerId, orderId = createdOrder.OrderId }, createdOrder));
// new OrdersDTO()
//{
// OrderId = maxOrderId++,
// CustomerId = order.CustomerId,
// EmployeeId=order.EmployeeId,
// Freight=order.Freight,
// OrderDate=DateTime.Today,
// RequiredDate=order.RequiredDate,
// ShipAddress=order.ShipAddress,
// ShipCity=order.ShipCity,
// ShipCountry=order.ShipCountry,
// ShipName=order.ShipName,
// ShippedaDate=order.ShippedaDate,
// ShipPostalCode=order.ShipPostalCode,
// ShipRegion=order.ShipRegion,
// ShipVia=order.ShipVia
// //El usuario digamos creará un OrdersForCretionDTO (por el que no tiene que definir el OrderId ni el OrderDate por ejemplo
//};
//customer.Orders.Add(finalOrder);
//return CreatedAtRoute("GetOrder", new { customerId = customerId, orderId = finalOrder.OrderId },finalOrder);
////Como acción final vamos a crear una nueva ruta para que el navegador nos dirija hacia ella: necesita tres
////parametros esta ruta, el primero es el nombre de la ruta (que hemos llemado GetOrder, hubiera sido lo mismo
////volver a escribir "{customerId}/orders/{orderId}"), el segundo son los valores de la ruta ya que esta ruta
////necesita de dos variables para que podamos navegar hacia ella (el customerId y orderId) por lo que creamos
////una nueva instancia de un objeto anonimo con estos dos valores, cogiendolos del pedido que acabamos de crear.
////Y como tercer parametro le pasamos el objeto del que queremos que coja los datos a mostrar en el navegador.
}
public IActionResult UpdateOrder(string customerId, int orderId, [FromBody] OrdersForCreationDTO customerUpdatedOrder)
{
if (customerUpdatedOrder == null)
{
return(BadRequest("Petición incorrecta: el pedido está incompleto"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!_customerRepository.CustomerExists(customerId))
{
return(NotFound($"Cliente con id {customerId} no encontrado en la bbdd"));
}
var existingOrder = _customerRepository.GetOrder(customerId, orderId);
if (existingOrder == null)
{
return(NotFound($"Pedido con id {orderId} no encontrado en la bbdd"));
}
Mapper.Map(customerUpdatedOrder, existingOrder);
if (!_customerRepository.Save())
{
return(StatusCode(500, "Por favor, revise los datos introducidos"));
}
var updatedOrder = Mapper.Map <OrdersDTO>(existingOrder);
return(CreatedAtRoute("GetOrder", new { customerId = customerId, orderId = updatedOrder.OrderId }, updatedOrder));
//var customer = Repository.Instance.Customers.FirstOrDefault(s => s.ID == customerId);
//if (customer == null)
//{
// return NotFound($"Cliente con id {customerId} no encontrado");
//}
//var order = customer.Orders.FirstOrDefault(o => o.OrderId == orderId);
//if (order == null)
//{
// return NotFound($"Pedido {orderId} no encontrado para el cliente {customer.ContactName}");
//}
//order.CustomerId = orderToUpdate.CustomerId;
//order.EmployeeId = orderToUpdate.EmployeeId;
//order.Freight = orderToUpdate.Freight;
//order.RequiredDate = orderToUpdate.RequiredDate;
//order.ShipAddress = orderToUpdate.ShipAddress;
//order.ShipCity = orderToUpdate.ShipCity;
//order.ShipCountry = orderToUpdate.ShipCountry;
//order.ShipName = orderToUpdate.ShipName;
//order.ShippedaDate = orderToUpdate.ShippedaDate;
//order.ShipPostalCode = orderToUpdate.ShipPostalCode;
//order.ShipRegion = orderToUpdate.ShipRegion;
//order.ShipVia = orderToUpdate.ShipVia;
////El usuario digamos creará un OrdersForCretionDTO (por el que no tiene que definir el OrderId ni el OrderDate por ejemplo
//return NoContent();
}
