public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = mapper.Map <OrderViewModel, Order>(model);
if (order.OrderDate == DateTime.MinValue)
{
order.OrderDate = DateTime.UtcNow;
}
var user = await userManager.FindByNameAsync(User.Identity?.Name);
order.User = user;
repository.AddOrder(order);
if (repository.SaveAll())
{
return(Created($"/api/orders/{order.Id}", mapper.Map <Order, OrderViewModel>(order)));
}
}
catch (Exception e)
{
logger.LogError($"Failed to save order: {e}");
}
return(BadRequest("Failed to save order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
//add POST'ed data to the DB
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.AddOrder(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"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
if (ModelState.IsValid)
{
var newModel = _mapper.Map <OrderViewModel, Order>(model);
if (newModel.OrderDate == DateTime.MinValue)
{
newModel.OrderDate = DateTime.Now;
}
newModel.User = await _userManager.FindByNameAsync(User.Identity.Name);
_dutchRepository.AddOrder(newModel);
if (_dutchRepository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newModel);
return(Created($"/api/orders/{vm.OrderId}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
return(BadRequest("Failed to create model"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
/*
* 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;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
// _dutchRepository.AddEntity(newOrder);
_dutchRepository.AddOrder(newOrder);
bool isSaved = _dutchRepository.SaveAll();
if (!isSaved)
{
return(BadRequest("Failed to save new order"));
}
/*
* var viewModel = new OrderViewModel()
* {
* OrderId = newOrder.Id,
* OrderDate = newOrder.OrderDate,
* OrderNumber = newOrder.OrderNumber
* };
*/
var viewModel = _mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"/api/orders/{viewModel.OrderId}", viewModel));
}
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() <--AutoMapper tak samo
//{ <--AutoMapper tak samo
// OrderDate = model.OrderDate, <--AutoMapper tak samo
// OrderNumber = model.OrderNumber, <--AutoMapper tak samo
// Id = model.OrderId <--AutoMapper tak samo
//};
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
_repository.AddOrder(newOrder);
if (_repository.SaveAll())
{
//var vm = new OrderViewModel() <---AutoMapper tak samo
//{ <---AutoMapper tak samo
// OrderId = newOrder.Id, <---AutoMapper tak samo
// OrderDate = newOrder.OrderDate, <---AutoMapper tak samo
// OrderNumber = newOrder.OrderNumber <---AutoMapper tak samo
//}; <---AutoMapper tak samo
// <---AutoMapper tak samo
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"));
}
public async Task <IActionResult> Post([FromBody] OrderModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
if (User.Identity.Name == null)
{
return(BadRequest("no user!"));
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
if (currentUser == null)
{
return(BadRequest("error of user"));
}
newOrder.Buyer = currentUser;
_repository.AddOrder(newOrder);
if (!_repository.SaveAll())
{
throw new Exception("Can't add model");
}
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderModel>(newOrder)));
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Error while saving Order: {ex}");
}
return(BadRequest("Error while adding model "));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
//var newOrder = new Order
//{
// OrderDate = model.OrderDate == default(DateTime) ? DateTime.Now : model.OrderDate,
// OrderNumber = model.OrderNumber
//};
if (model.OrderDate == default(DateTime))
{
model.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
newOrder.User = currentUser;
_dutchRepository.AddOrder(newOrder);
if (_dutchRepository.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 e)
{
_logger.LogError($"Failed to save a new order : {e}");
}
return(BadRequest("Failed to save data"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
//Since entities goes inside the database we are mapping our order enttity to the view model
//Since we cannot save view model to the dattabase
Order newOrder = _mapper.Map <OrderViewModel, Order>(model);
//Minvalue means if the ordate is not specified or it is null
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = await currentUser;
// _dutchrepository.AddEntity(newOrder);
_dutchrepository.AddOrder(newOrder);
if (_dutchrepository.SaveAll())
{
//After saveAll() this update the model id and noe we pass the updated model with the updated
//modelId to the Postman
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_ilogger.LogError($"Failed to save ordr - {ex}");
}
return(BadRequest($"Unable to save Order"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
//add the order to the database
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;
_dutchRepository.AddOrder(newOrder);
if (_dutchRepository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
// in http when you create an entity, you return Created not just Ok.
// you also need to return the entity with its url.
// done as part of HATEOAS
return(Created($"/api/orders/{newOrder.Id}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (System.Exception ex)
{
_logger.LogError($"Failed to add a new order: {ex}");
}
return(BadRequest("Failed to add 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;
}
var currentUser = await userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
repository.AddOrder(newOrder);
if (repository.SaveChanges())
{
var vm = mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"/api/orders{ vm.OrderId}", model));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (System.Exception ex)
{
logger.LogError($"Failed to save a new order: {ex}");
throw;
}
return(BadRequest("Failed to save new order"));;
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
string responseMsg = "Failed to save a new order";
try
{
//Here we can validate through the view model, but we have to go through the trouble of converting the View model to the order.
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.AddOrder(newOrder);
if (_repository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
return(Created($"/api/orders/{vm.OrderId}", vm));
}
}
else
{
//This way we see what's actually wrong with the model
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"{responseMsg}: {ex}");
}
return(BadRequest(responseMsg));
}
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(User.Identity.Name);
newOrder.User = currentUser;
_repository.AddOrder(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($"Erro ao executar PostOrder: {ex}");
return(BadRequest($"Erro ao executar PostOrder"));
}
return(BadRequest("Ocorreu um erro ao salvar o pedido"));
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
//add to db
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
// User = list of claims from token. Convertes this to a store user
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
//_repository.AddEntity(newOrder);
_repository.AddOrder(newOrder);
if (_repository.SaveAll())
{
var vm = _mapper.Map <Order, OrderViewModel>(newOrder);
//model.id will be updated after save.
return(Created($"/api/orders/{vm.OrderId}", vm)); //Return 201 code which is created
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save new order - {ex.Message}");
}
return(BadRequest("Post failed"));
}
