public IActionResult Post([FromBody] OrderViewModels model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModels, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModels>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Falha para a salvar uma nova order: {ex}");
}
return(BadRequest("Falha para salvar nova ordem"));
}
public async Task <ActionResult> Post([FromBody] OrderViewModel model)
{
try
{
var order = _mapper.Map <OrderViewModel, Order>(model);
if (order.OrderDate == DateTime.MinValue)
{
order.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
order.User = currentUser;
_repo.AddEntity(order);
if (ModelState.IsValid)
{
if (_repo.SaveAll())
{
return(Created($"http://localhost:5000/api/orders/{order.Id}", _mapper.Map <Order, OrderViewModel>(order)));
}
return(BadRequest("Couldn't save"));
}
return(BadRequest(ModelState));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest("Something went wrong"));
}
}
public IActionResult Post([FromBody] OrderViewModel model)
{
// add it to the db
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.UtcNow;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"api/orders/{vm.OrderId}", vm));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to insert order {ex}");
return(BadRequest($"Failed to insert order"));
}
return(BadRequest($"Failed to insert order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
// build Order object from passed ViewModel object
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
// override OrderDate if not specified
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repo.AddEntity(newOrder);
if (_repo.SaveAll())
{
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (System.Exception ex)
{
_logger.LogCritical($"Failed to save new order: {ex}");
}
return(BadRequest("Failed to save new order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
//add it to db
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(model);
if (_repository.SaveAll())
{
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to process order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
// For HTTP POST, we need to use created() instead of Ok() to give a 201 instead of 200
return(Created($"/api/orders/{newOrder.Id}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to get orders: {ex}");
return(BadRequest("Failed to get orders"));
}
return(BadRequest("Failed to save new order"));
}
public async Task <IActionResult> PostOrder([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
_repository.AddEntity(newOrder);
if (_repository.SaveChanges())
{
return(Created($"/api/Orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}catch (Exception ex)
{
_logger.LogInformation($"Could not post the order{ex}!");
return(BadRequest("Could not post the order"));
}
return(BadRequest("Failed to save order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var order = mapper.Map <OrderViewModel, Order>(model);
if (order.OrderDate == DateTime.MinValue)
{
order.OrderDate = DateTime.Now;
}
var currentUser = await userManager.FindByNameAsync(User.Identity.Name);
order.User = currentUser;
repository.AddEntity(order);
if (repository.SaveAll())
{
var viewModel = mapper.Map <Order, OrderViewModel>(order);
return(Created($"/api/orders/{viewModel.OrderId}", viewModel));
}
}
return(BadRequest(ModelState));
}
catch (Exception exception)
{
logger.LogError($"Failed to save a new order: {exception}");
return(BadRequest());
}
}
public IActionResult Post([FromBody] OrderViewModels model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModels, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_respository.AddEntity(newOrder);
if (_respository.SaveAll())
{
return(Created($"api/Orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModels>(newOrder)));
}
else
{
return(BadRequest($"Failed to save new order"));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception er)
{
_logger.LogError($" Failed to save a new order {er}");
return(BadRequest());
}
}
public IActionResult Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = mapper.Map <OrderViewModel, Order>(model);
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
return(Created($"/api/orders/{model}", model));
}
else
{
return(BadRequest(ModelState));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(BadRequest());
}
}
public IActionResult Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
repository.AddEntity(newOrder);
if (repository.SaveAll())
{
var vm = mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"/api/orders/{vm.OrderId}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("failed to create new order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
await _repository.AddEntity(newOrder);
if (await _repository.SaveAll())
{
return(Created($"/api/Orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save order {ex}");
return(BadRequest("Failed to save order"));
}
return(BadRequest("Not order saved"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
//add it to database
try
{
//if (ModelState.IsValid)
//{ }
var newOrder = new Order()
{
OrderDate = model.OrderDate,
OrderNumber = model.OrderNumber,
Id = model.OrderId
};
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(model);
_repository.SaveAll();
var vm = new OrderViewModel()
{
OrderId = newOrder.Id,
OrderDate = newOrder.OrderDate,
OrderNumber = newOrder.OrderNumber
};
return(Created($"/api/orders/{vm.OrderId}", vm));
}
catch (Exception ex)
{
_logger.LogError($"Failed to save new order: {ex}");
return(BadRequest("Failed"));
}
}
public IActionResult Post([FromBody] OrderViewModel model)
{
// Add it to the DB.
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
// This means the order date was not specified.
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"/api/orders/{vm.OrderId}", vm));
}
}
else
{
BadRequest(ModelState);
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to save a new order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
newOrder.User = await userManager.FindByNameAsync(User.Identity.Name);
repository.AddEntity(newOrder);
if (repository.SaveAll())
{
return(Created($"/app/orders/{newOrder.Id}", mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
logger.LogError($"Failed add orders: {ex}");
}
return(BadRequest("Failed add orders"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(userName : "******");
newOrder.User = currentUser;
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to save new order"));
}
[HttpPost] //Maps
public IActionResult Post([FromBody] OrderViewModel model)
{
//add it to database
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
//Validate new order
if (newOrder.OrderDate == DateTime.Now)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
//Pass new data through this url
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
BadRequest(ModelState);
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save new order: {ex}.");
}
return(BadRequest("Failed to save new order."));
}
public IActionResult Post(int orderId, [FromBody] OrderItemViewModel model)
{
try
{
// Ensure model state is valid.
if (ModelState.IsValid)
{
// Creater map the ViewModel back to an OrderItem.
var newOrderItem = mapper.Map <OrderItemViewModel, OrderItem>(model);
// Add the newOrderItem object into the database.
repository.AddEntity(newOrderItem);
// return a 201 response if it successfully saves to database.
if (repository.SaveAll())
{
// convert Order back to ViewModel to be returned. Also generate custom URI.
return(Created($"/api/orders/{orderId}/items/{newOrderItem.Id}", mapper.Map <OrderItem, OrderItemViewModel>(newOrderItem)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to save new order"));
}
public async Task <IActionResult> AddOrder([FromBody] OrderViewModel orderDetails)
{
//we can use [FromQuery] [FromRoute] in function it self
//for validting the model - we have created new View Model and replaced it in the request
try
{
if (ModelState.IsValid)
{
var newOrder = new Order()
{
OrderDate = orderDetails.OrderDate,
OrderNumber = orderDetails.OrderNumber,
Id = orderDetails.OrderId
};
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
_repo.AddEntity(newOrder);
if (_repo.SaveAll())
{
var viewModel = new OrderViewModel()
{
OrderDate = newOrder.OrderDate,
OrderId = newOrder.Id,
OrderNumber = newOrder.OrderNumber
};
return(Created($"/api/orders/{viewModel.OrderId}", viewModel));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogInformation($"Failed to add the new order: {ex}");
}
return(BadRequest($"Failed to add the new order."));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model) // If tag FromBody is not given the data is tried to get from the url querystring and not from the post body
{
// Add to the db
try
{
if (ModelState.IsValid) // Validation is defined in the OrderViewModel
{
// Without AutoMapper convert Order View Model to an order
//var newOrder = new Order()
//{
// OrderDate = model.OrderDate,
// OrderNumber = model.OrderNumber,
// Id = model.OrderId
//};
// With AutoMapper convert Order View Model to an order
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
// Validation if OrderDate has been specified
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
// New orders should be assigned to a specific user
// User.Identity.Name is just a claim and not the actual user object from the db; therefore we need to get it
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name); // due to await the method must return an async Task
newOrder.User = currentUser;
_repository.AddEntity(newOrder);
if (_repository.SaveAll()) // The SaveAll will safe the new order in the db, where it will gets its Id generated
{
// Without AutoMapper convert the new order back to a order view model
//var vm = new OrderViewModel()
//{
// OrderId = newOrder.Id,
// OrderDate = newOrder.OrderDate,
// OrderNumber = newOrder.OrderNumber
//};
//return Created($"/api/orders/{vm.OrderId}", vm); // You have to return Created instead of Ok when a new object has been created
// With AutoMapper convert the new order back to a order view model
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder))); // You have to return Created instead of Ok when a new object has been created
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to save new order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
// add it to the db
try
{
if (ModelState.IsValid)
{
var newOrder = mapper.Map <OrderViewModel, Order>(model);
//var newOrder = new Order()
//{
// OrderDate = model.OrderDate,
// OrderNumber = model.OrderNumber,
// Id = model.OrderId
//};
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
repository.AddEntity(newOrder);
if (repository.SaveAll())
{
//var vm = mapper.Map<Order, OrderViewModel>(newOrder);
//var vm = new OrderViewModel()
//{
// OrderId = newOrder.Id,
// OrderNumber = newOrder.OrderNumber,
// OrderDate = newOrder.OrderDate
//};
return(Created($"/api/orders/{newOrder.Id}", mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception e)
{
logger.LogError($"Failed to save a new order: {e}");
}
return(BadRequest("Failed to save a new order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
//because we are using a viewmodel we have to go through the trouble to create a new model order
//var newOrder = new Order
//{
// OrderDate = model.OrderDate,
// OrderNumber = model.OrderNumber,
// Id = model.OrderId
//};
var newOrder = mapper.Map <OrderViewModel, Order>(model);
//if user didnt specify a datetime
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
repository.AddEntity(newOrder);
if (repository.SaveAll())
{
//var vm = new OrderViewModel()
//{
// OrderId = newOrder.Id,
// OrderDate = newOrder.OrderDate,
// OrderNumber = newOrder.OrderNumber
//};
//return Created($"/api/orders/{vm.OrderId}", vm);
return(Created($"/api/orders/{newOrder.Id}", mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
logger.LogError($"Failed to get orders:{ex}");
}
return(BadRequest("Failed to save new order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
// Build the order from the view model
var newOrder = new Order()
{
OrderDate = model.OrderDate,
OrderNumber = model.OrderNumber,
Id = model.OrderId
};
// Order validation and data cleanup
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
// Get and assign the current user to the order
var currentUser = await userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
// Add Entity
repository.AddEntity(newOrder);
// If successfully saved extract the new order back int a VM for view return
if (repository.SaveAll())
{
var vm = new OrderViewModel()
{
OrderId = newOrder.Id,
OrderDate = newOrder.OrderDate,
OrderNumber = newOrder.OrderNumber
};
return(Created($"api/orders/{vm.OrderId}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
logger.LogError($"Failed to add to database {ex}");
}
return(BadRequest("Failed to add to database"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
// We can't pass a DTO to a DB so we have to convert it an Order Model
//var newOrder = new Order()
//{
// OrderDate = model.OrderDate,
// OrderNumber = model.OrderNumber,
// Id = model.OrderId
//};
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
// Check if date specified otherwise set it.
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.UtcNow;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
// Convert Order back to VM
// An alternative of this hole approach is to use AutoMapper
//var vm = new OrderViewModel()
//{
// OrderId = newOrder.Id,
// OrderDate = newOrder.OrderDate,
// OrderNumber = newOrder.OrderNumber
//};
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
return(BadRequest(ModelState));
}
catch (Exception e)
{
_logger.LogError($"Failed to save the order to the db {e}");
}
return(BadRequest("Failed to save the order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
//add it to the DB
try
{
if (ModelState.IsValid)
{
var newOrder = new Order()
{
OrderDate = model.OrderDate,
OrderNumber = model.OrderNumber,
Id = model.OrderId
};
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
;
}
{
var vm = new OrderViewModel()
{
OrderId = newOrder.Id,
OrderDate = newOrder.OrderDate,
OrderNumber = newOrder.OrderNumber
};
return(Created($"/api/orders/{vm.OrderId}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order : {ex}");
}
return(BadRequest("failed to Save Orders"));
}
public async Task <IActionResult> PostOrder([FromBody] OrderViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
//min means they did not specify anything
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
//var vm = new OrderViewModel()
//{
// OrderNumber = newOrder.OrderNumber,
// OrderDate = newOrder.OrderDate,
// OrderId = newOrder.Id
//};
//created is 201 you could pas the order but below
return(CreatedAtAction("GetOrder", new { id = newOrder.Id }, _mapper.Map <Order, OrderViewModel>(newOrder)));
//return Created($"/api/orders/{model.Id}", model);
}
_logger.LogError("Failed to save a new order, something wrong happened");
return(null);
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
throw;
}
}
public IActionResult Post([FromBody] Order model)
{
//add it to the db
try
{
_repository.AddEntity(model);
if (_repository.SaveAll())
{
return(Created($"/api/orders/{model.Id}", model));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to save the new order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
// FromBody attribute overrides default of grabbing model from URL text.
try
{
if (ModelState.IsValid)
{
// Maps OrderViewModel from request to Order entity for operations.
var orderEntity = _mapper.Map <OrderViewModel, Order>(model);
// If date not specified, overwrite it.
if (orderEntity.OrderDate == DateTime.MinValue)
{
orderEntity.OrderDate = DateTime.Now;
}
// Takes data and attaches to context.
_repository.AddEntity(orderEntity);
// Saves changes made in context.
if (_repository.SaveAll())
{
// Maps Order entity back to OrderViewModel for response request.
var returnModel = _mapper.Map <Order, OrderViewModel>(orderEntity);
// HTTP requires POST to return 'Created' 201 response if object created.
return(Created($"/api/order/{returnModel.OrderId}", returnModel));
// URI sent back in case consumer needs to keep track whether they have most recent.
}
}
else
{
// Exposes errors in model state from the data request to sender.
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Orders.Post(order) failed: {ex}");
}
return(BadRequest($"Failed to save a new order"));
}
public IActionResult Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
//var newOrder = new Order()
//{
// OrderDate = model.OrderDate,
// OrderNumber = model.OrderNumber,
// Id = model.OrderId
//};
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
_repository.AddEntity(newOrder);
if (_repository.SaveAll())
{
//var vm = new OrderViewModel()
//{
// OrderId = newOrder.Id,
// OrderDate = newOrder.OrderDate,
// OrderNumber = newOrder.OrderNumber
//};
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"/api/orders/{vm.OrderId}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save a new order: {ex}");
}
return(BadRequest("Failed to save a new order"));
}
public IActionResult Post([FromBody] Order model)
{
_logger.LogInformation("In the post method");
// add it to the database
try
{
_repository.AddEntity(model);
if (_repository.SaveAll())
{
return(Created($"/api/orders/{model.Id}", model));
}
}
catch (Exception e)
{
_logger.LogError($"The post failed with error {e}");
return(Problem($"Got an error writing to db {e}"));
}
return(BadRequest("Failed to save new order"));
}
