public void AddTestVehicles()
{
if (_vehicleRepo.GetAll().Count() > 0)
{
return;
}
Vehicle testVehicle1 = new Vehicle
{
Id = 1,
Name = "Fleet Vehicle 1",
Model = "Ford Focus",
LicensePlate = "JF3W2-98L",
Status = "In Use",
Notes = "ojasodjfowef ojaweofja woeifjo weofjoajoweofj aewofj"
};
Vehicle testVehicle2 = new Vehicle
{
Id = 2,
Name = "Fleet Vehicle 2",
Model = "Ford Explorer",
LicensePlate = "KWD2-777",
Status = "Not In Use",
Notes = "ojasodjfowef ojaweofja woeifjo weofjoajoweofj aewofj"
};
_vehicleRepo.Add(testVehicle1);
_vehicleRepo.Add(testVehicle2);
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResources vehicleResources)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if ((await featureRepository.GetModelAsync(vehicleResources.ModelId)) == null)
{
ModelState.AddModelError("ModelId", "Invalid ModelId");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <Vehicle>(vehicleResources);
vehicle.LastUpdate = DateTime.Now;
vehicleRepository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await vehicleRepository.GetVehicleAsync(vehicle.Id);
var result = mapper.Map <VehicleResources>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await modelRepository.GetAsync(vehicleResource.ModelId);
if (model == null)
{
ModelState.AddModelError("ModelId", "Invalid modelId.");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdated = DateTime.Now;
vehicleRepository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await vehicleRepository.GetAsync(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource saveVehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await _context.Models.FindAsync(saveVehicleResource.ModelId);
if (model == null)
{
ModelState.AddModelError("ModelId", "Invalid Model Id");
return(BadRequest(ModelState));
}
var vehicle = _mapper.Map <SaveVehicleResource, Vehicle>(saveVehicleResource);
vehicle.LastUpdate = DateTime.Now;
_vehicleRepo.Add(vehicle);
await _context.SaveChangesAsync();
vehicle = await _vehicleRepo.GetVehicle(vehicle.Id);
var result = _mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex.Message + " " + ex.InnerException.ToString()));
}
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
// throw new Exception();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = _mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
//Saving Domain Model (Vehicle)
_repo.Add(vehicle);
await _uow.CompleteAsync();
vehicle = await _repo.GetVehicle(vehicle.Id);
var result = _mapper.Map <Vehicle, VehicleResource>(vehicle);
//Returning Data Transfer Object (VehicleResource)
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// var model = await _context.Models.FindAsync(vehicleResource.ModelId);
// if(model == null)
// {
// ModelState.AddModelError("ModelId", "Invalid model id");
// return BadRequest(ModelState);
// }
var vehicle = _mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
// _context.Vehicles.Add(vehicle);
_repo.Add(vehicle); // *** for OOP reason to decouple from DbContext, cuz it may change.
await _uow.CompleteAsync();
// Complete Vehicle object, incl. Make, Model obj etc.
vehicle = await _repo.GetVehicleAsync(vehicle.Id);
var result = _mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
// throw new Exception("ooppss!!");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await modelRepository.GetModel(vehicleResource.ModelId);
if (model == null)
{
ModelState.AddModelError(nameof(vehicleResource.ModelId), "Invalid Model.");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
vehicleRepository.Add(vehicle);
await unitOfWork.Complete();
vehicle = await vehicleRepository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// var model = await context.Models.FindAsync(vehicleResource.ModelId);
// if(model == null)
// {
// ModelState.AddModelError("ModelId", "Invalid ModelId.");
// return BadRequest(ModelState);
// }
// In order to create a vehicle instance into database
// input data type: VehicleResource
// output data type: Vehicle
// so we need to map VehicleResource to Vehicle
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.UpdateTime = DateTime.Now;
vehicleRepository.Add(vehicle);
await unitOfWork.CompleteAsync();
// await context.Models.Include(m => m.Make).SingleOrDefaultAsync(m => m.Id == vehicle.ModelId);
vehicle = await vehicleRepository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
// Model Validation For DataAnnotations
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Businness Logic Validation
// if(true) {
// ModelState.AddModelError("..","error");
// return BadRequest(ModelState);
// }
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> addVehicleAsync([FromBody] SaveVehicleResource vehicleBody)
{
//throw new Exception();
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newVehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleBody);
newVehicle.LastUpdate = DateTime.Now;
repository.Add(newVehicle);
await unitOfWork.CompleteAsync();
newVehicle = await repository.GetVehicleAsync(newVehicle.Id);
var returnVehicle = mapper.Map <Vehicle, VehicleResource>(newVehicle);
return(Ok(returnVehicle));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
//throw new Exception ();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await repository.GetVehicle(vehicleResource.ModelId, includeRelated : false);
/*if (model == null)
* {
* ModelState.AddModelError("ModelId", "Invalid modelId.");
* return BadRequest(ModelState);
* }*/
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreatVehicle([FromBody] SaveVehicleResource vehicleResorce)
{
// throw new Exception();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle> (vehicleResorce);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
// *** One Way Mapping to resource
// await context.Models.Include(make=>make.Make).SingleOrDefaultAsync(makeId=>makeId.Id == vehicle.ModelId);
// await context.Features.ToListAsync();
// ** Recommentdation Way **//
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource> (vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
try
{
//throw new Exception();
if (ModelState.IsValid)
{
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
vehicleRepository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await vehicleRepository.GetVehicle(vehicle.Id, true);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
//ModelState.AddModelError($"error while creating Vehicle : { ex }", ex);
return(BadRequest($"error while creating Vehicle : { ex }"));
}
}
public async Task <IActionResult> AddVehicle([FromBody] SaveVehicleResource vehicleResource)
{
// if(!ModelState.IsValid)
// {
// this.HttpContext.Response.StatusCode = StatusCodes.Status422UnprocessableEntity;
// return Json(new {
// message = "Validation Error",
// errors = ModelState.Values.SelectMany(v => v.Errors)
// });
// }
var model = await repo.GetModel(vehicleResource.ModelId);
if (model == null)
{
ModelState.AddModelError("ModelId", "Invalid ModelId");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repo.Add(vehicle);
await uow.Complete();
vehicle = await repo.GetVehicleAsync(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
//return Ok(result);
return(Created(Request.Path + "/" + result.Id, result));
}
/// <summary>
/// <see cref="IDgtAppService"/>
/// </summary>
/// <returns><see cref="IDgtAppService"/></returns>
public VehicleDTO AddNewVehicle(VehicleDTO vehicleDTO)
{
if (vehicleDTO == null)
{
throw new ArgumentNullException("vehicleDTO");
}
// Check vehicle license is unique
var licenseSpec = VehicleSpecifications.WithLicense(vehicleDTO.License);
var repeatedLicenseVehicle = _vehicleRepository.AllMatching(licenseSpec);
if (repeatedLicenseVehicle != null && repeatedLicenseVehicle.Any())
{
throw new InvalidOperationException(String.Format(CommonMessages.exception_ItemAlreadyExistsWithProperty, Names.Vehicle, Names.License, vehicleDTO.License));
}
// Cast dto to vehicle and save
var vehicle = MaterializeVehicleFromDto(vehicleDTO);
vehicle.GenerateNewIdentity();
vehicle.CreatedDate = DateTime.Now;
// Add habitual driver
var driver = _driverRepository.Get(vehicleDTO.DriverId);
if (driver == null)
{
throw new InvalidOperationException(String.Format(CommonMessages.exception_EntityWithIdNotExists,
Names.Driver, vehicleDTO.DriverId));
}
// Check driver vehicles
var driverVehicles = _vehicleDriverRepository.GetFiltered(vd => vd.DriverId == driver.Id);
if (driverVehicles.Count() > 10)
{
throw new InvalidOperationException(String.Format(CommonMessages.exception_DriverMaxVehicles,
driver.Identifier, 10));
}
// Add VehicleDriver item
var vehicleDriver = new VehicleDriver()
{
VehicleId = vehicle.Id, DriverId = driver.Id
};
vehicleDriver.GenerateNewIdentity();
vehicleDriver.CreatedDate = DateTime.Now;
// Validate items and save
vehicle.Validate();
vehicleDriver.Validate();
_vehicleRepository.Add(vehicle);
_vehicleRepository.UnitOfWork.Commit();
_vehicleDriverRepository.Add(vehicleDriver);
_vehicleDriverRepository.UnitOfWork.Commit();
return(vehicle.ProjectedAs <VehicleDTO>());
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// var model = await context.Models.FindAsync(vehicleResource.ModelId);
// if (model == null)
// {
// ModelState.AddModelError("ModelId", "Invalid modelId");
// return BadRequest(ModelState);
// }
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
// vehicle = await context.Vehicles
// .Include(v => v.Features)
// .ThenInclude(vf => vf.Feature)
// .Include(v => v.Model)
// .ThenInclude(m => m.Make)
// .SingleOrDefaultAsync(v => v.Id == vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
// ha pl névnek számot ad meg akkor modelstate az hamis
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
/*var model = await context.Models.FindAsync(vehicleResource.ModelId);
* if (model == null)
* {
* ModelState.AddModelError("ModelId", "Invalid modelid");
* return BadRequest(ModelState);
* }*/
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
// use data anotation for input validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await context.Models.FindAsync(vehicleResource.ModelId);
if (model == null)
{
ModelState.AddModelError("ModelId", "Invalid model ID");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
_repository.Add(vehicle);
await _unitOfWork.CompleteAsync();
vehicle = await _repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// var model = await context.Models.FindAsync(vehicleResource.ModelId);
// if (model == null)
// {
// ModelState.AddModelError("ModelId", "Invalid modelId.");
// return BadRequest(ModelState);
// }
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
//Below we load remaining assosiated propeties of the object, but it's ugly (we're strongly depend on EF) so DON'T USE IT
// EF will automatically asossiate returned model with vehicle object( no need to assaigned result to vehicle.model)
//await context.Models.Include(m => m.Make).SingleOrDefaultAsync(m => m.Id == vehicle.Id);
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public IActionResult Post([FromBody] Vehicle vehicle)
{
if (vehicle == null)
{
return(BadRequest());
}
// Check for Model state
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
try
{
vehicle = _vehicleRepository.Add(vehicle);
if (vehicle == null)
{
return(BadRequest());
}
else
{
return(CreatedAtRoute("GetById", new { id = vehicle.Id }, vehicle));
}
}
catch (Exception ex)
{
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
}
[HttpPost] // Create
//[Authorize]
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// mapper convert VehicleResource to Vehicle
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
// set update time
vehicle.LastUpdate = DateTime.Now;
// add vehicle to database
// context.Vehicles.Add(vehicle);
repository.Add(vehicle);
// save database changes
await unitOfWork.Complete();
// reassign the vehicle object with all the properties inside
vehicle = await repository.GetVehicle(vehicle.Id);
// mapper convert Vehicle to VehicleResource
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] VehicleViewModel vehicleVm)
{
if (vehicleVm == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newItem = Mapper.Map <Vehicle>(vehicleVm);
newItem.SetCreation(UserName);
_vehicleRepository.Add(newItem);
if (!await UnitOfWork.SaveAsync())
{
return(StatusCode(500, "保存时出错"));
}
var vm = Mapper.Map <VehicleViewModel>(newItem);
return(CreatedAtRoute("GetVehicle", new { id = vm.Id }, vm));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// validation which is kind of a overkill will get through this later
/*var model= await context.Models.FindAsync(vehicleResource.ModelId);
*
* if(model==null){
* ModelState.AddModelError("ModelId","Invalid modelId.");
* return BadRequest(ModelState);eb
* }*/
var vehicle = mapper.Map <SaveVehicleResource, Vehicle> (vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource> (vehicle);
return(Ok(result));
}
public async Task <IActionResult> Create([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// how to implement business
// if (true)
// {
// ModelState.AddModelError("key", "error message");
// return BadRequest(ModelState);
// }
// var model = await context.Models.FindAsync(vehicleResource.ModelId);
// if (model == null){
// ModelState.AddModelError("ModelId", "Invalid modelId.");
// return BadRequest(ModelState);
// }
Vehicle vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdated = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(CreatedAtRoute("GetVehicle", new { id = vehicle.Id }, result));
}
public async Task <IActionResult> CreateVehicle([FromBody] VehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var model = await vegaDbContext.Models.FindAsync(vehicleResource.Id);
if (model == null)
{
ModelState.AddModelError("Model", "Invalid ModelId");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <VehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await vegaDbContext.SaveChangesAsync();
vehicle = await repository.GetVehicle(vehicle.Id); /*await vegaDbContext.Vehicles.Include(v=>v.Features)
* .ThenInclude(vf=>vf.Feature)
* .Include(m=>m.Model)
* .ThenInclude(m=>m.Make)
* .SingleOrDefaultAsync(v=>v.Id == vehicle.Id)*/;
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
// [Authorize]
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// var model = await context.Models.FindAsync(vehicleResource.ModelId);
// if (model == null)
// {
// ModelState.AddModelError("ModelId", "Invalid ModelId");
// return BadRequest(ModelState);
// }
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
// Repository call
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResources VR)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//var model = await context.Models.FindAsync(VR.ModelId);
var model = await repository.GetModel(VR.ModelId);
if (model == null)
{
ModelState.AddModelError("ModelId", "Invalid Model");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResources, Vehicle>(VR);
vehicle.LastUdpate = DateTime.Now;
//context.Vehicles.Add(vehicle);
repository.Add(vehicle);
await unitofWork.CompleteAsync();
// This will include all the other name properties form id
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResources>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Complex business validation goes here
// if (true)
// {
// ModelState.AddModelError("...", "error");
// return BadRequest(ModelState);
// }
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repository.Add(vehicle);
await uow.CompleteAsync();
// eager load
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
//throw new Exception();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// if(true)
// {
// ModelState.AddModelError("..", "error");
// return BadRequest(ModelState);
// }
// var model = await context.Models.FindAsync(vehicleResource.ModelId);
// if (model == null)
// {
// ModelState.AddModelError("ModelId", "Invalid modelId.");
// return BadRequest(ModelState);
// }
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
repository.Add(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repository.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
