public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = _mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.Creationdate = DateTime.Now;
await _vehicleRepository.AddVehicle(vehicle);
await _unitOfWork.CompleteAsync();
vehicle = await _vehicleRepository.GetVehicle(vehicle.Id);
return(Ok(_mapper.Map <Vehicle, VehicleResource>(vehicle)));
}
public ThreeObjectsModel AddThreeObjects(ThreeObjectsModel threeObjectsModel)
{
if (threeObjectsModel.personModel is StudentModel)
{
studentRepository.AddStudent(threeObjectsModel.personModel as StudentModel);
}
if (threeObjectsModel.personModel is TeacherModel)
{
teacherRepository.AddTeacher(threeObjectsModel.personModel as TeacherModel);
}
vehicleRepository.AddVehicle(threeObjectsModel.vehicleModel);
approvalRepository.AddApproval(threeObjectsModel.approvalModel);
return(GetAllThreeObjectsByPersonId(threeObjectsModel.personModel.personId));
}
public int AddVehicle(NewVehicleVm vehicle)
{
vehicle.Capacity = vehicle.PermissibleGrossWeight - vehicle.OwnWeight;
vehicle.ProductionDate = new DateTime(vehicle.YearHelper, 1, 1);
vehicle.Vin = vehicle.Vin.ToUpper();
vehicle.RegistrationNumber = vehicle.RegistrationNumber.ToUpper();
vehicle.Model = vehicle.Model.ToUpper();
var vehicl = _mapper.Map <Domain.Model.Vehicle>(vehicle);
vehicl.CreatedDateTime = DateTime.Now;
vehicl.CreatedById = "userid";
vehicl.IsActive = true;
var result = _vehicleRepository.AddVehicle(vehicl);
return(result); // result = 0 is false
}
public async Task <IActionResult> CreateVehicle(SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
repo.AddVehicle(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await repo.GetVehicle(vehicle.Id);
var result = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <IActionResult> AddVehicle([FromBody] SaveVehicleResource vehicleResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdatedOn = DateTime.Now;
vehicleRepository.AddVehicle(vehicle);
await unitOfwork.CompleteAsync();
vehicle = await vehicleRepository.GetVehicle(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 vehicle = _mapper.Map <SaveVehicleResource, Vehicle>(saveVehicleResource);
vehicle.LastUpdate = DateTime.Now;
_vehicleRepository.AddVehicle(vehicle);
await _unitOfWork.SaveChangesAsync();
vehicle = await _vehicleRepository.GetVehicleWithFeaturesAndModels(vehicle.Id);
var result = _mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(result));
}
public async Task <ActionResult <VehicleDto> > CreateVehicle([FromBody] SaveVehicleDto vehicleDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicle = _mapper.Map <Vehicle>(vehicleDto);
vehicle.LastUpdate = DateTime.Now;
_repository.AddVehicle(vehicle);
await _unitOfWork.CompleteAsync();
vehicle = await _repository.GetVehicleAsync(vehicle.Id);
var result = _mapper.Map <VehicleDto>(vehicle);
return(Ok(result));
}
/// <summary>
/// Añade un vehículo al sistema
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public async Task <bool> AddVehicle(VehicleDataAPI value)
{
// Comprobamos que sea administraodr
if (!IsAdmin())
{
return(false);
}
Guid?userId = null;
if (!String.IsNullOrEmpty(value.UserName))
{
var usr = await _userRepository.GetUser(value.UserName);
userId = usr?.Id;
}
// Añadimos el vehiculo
return(await _vehicleRepository.AddVehicle(value, userId));
}
public HttpResponseMessage AddVehicle(VehicleModel vehicleModel)
{
try
{
HttpResponseMessage hrm = new HttpResponseMessage(HttpStatusCode.Created)
{
Content = new StringContent(JsonConvert.SerializeObject(vehicleRepository.AddVehicle(vehicleModel)))
};
return(hrm);
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
HttpResponseMessage hr = new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(errors.ToString())
};
return(hr);
}
}
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.LastUpdated = DateTime.Now;
repository.AddVehicle(vehicle);
await uow.CompleteAsync();// context.SaveChangesAsync();
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)
{
System.Console.WriteLine("model state bad: ");
return(BadRequest(ModelState));
}
var vehicle = mapper.Map <SaveVehicleResource, Vehicle>(vehicleResource);
vehicle.LastUpdate = DateTime.Now;
vehicleRepository.AddVehicle(vehicle);
await unitOfWork.CompleteAsync();
vehicle = await vehicleRepository.GetVehicle(vehicle.Id);
var vr = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(vr));
}
//[Authorize]
public async Task <IActionResult> CreateVehicle([FromBody] SaveVehicleVM vehicleModelVM)
{
//throw new Exception();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vehicleModel = mapper.Map <SaveVehicleVM, VehicleModel>(vehicleModelVM);
vehicleModel.LastUpdate = DateTime.Now;
vehicleRepository.AddVehicle(vehicleModel);
await unitofWork.CompleteAsync();
vehicleModel = await vehicleRepository.GetVehicle(vehicleModel.Id);
var result = mapper.Map <VehicleModel, VehicleModelVM>(vehicleModel);
return(Ok(result));
}
public HttpResponseMessage AddVehicle(VehicleModel vehicleModel)
{
try
{
if (vehicleModel == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
VehicleModel addedVehicle = vehicleRepository.AddVehicle(vehicleModel);
return(Request.CreateResponse(HttpStatusCode.Created, addedVehicle));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(Request.CreateResponse(HttpStatusCode.InternalServerError, errors));
}
}
public IActionResult AddVehicle(VehicleModel vehicleModel)
{
try
{
if (vehicleModel == null)
{
return(BadRequest("Data is null."));
}
if (!ModelState.IsValid)
{
Errors errors = ErrorsHelper.GetErrors(ModelState);
return(BadRequest(errors));
}
VehicleModel addedVehicle = vehicleRepository.AddVehicle(vehicleModel);
return(StatusCode(StatusCodes.Status201Created, addedVehicle));
}
catch (Exception ex)
{
Errors errors = ErrorsHelper.GetErrors(ex);
return(StatusCode(StatusCodes.Status500InternalServerError, errors));
}
}
public IActionResult CreateVehicle([FromBody] SaveVehicleResource vehicleResource)
{
//throw new Exception();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//var model = context.Models.Find(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.AddVehicle(vehicle);
unitOfWork.Complete();
vehicle = repository.GetVehicle(vehicle.Id);
var vehicleResourceOut = mapper.Map <Vehicle, VehicleResource>(vehicle);
return(Ok(vehicleResourceOut));
}
public async Task AddVehicle(Vehicle item)
{
await _vehicleRepository.AddVehicle(item);
}
public async Task <bool> AddVehicle(string username, PostVehicleDTO v)
{
return(await _repository.AddVehicle(username, v.ToEntity()));
}
public async Task <bool> AddVehicleAsync(VehicleModel vehicleModel, CancellationToken cancellationToken)
{
return(await _vehicleRepository.AddVehicle(vehicleModel, cancellationToken));
}
public async Task <ActionResult> AddNewVehicle([FromBody] VehicleDto newVehicle)
{
return(Ok(await _vehicleRepository.AddVehicle(newVehicle)));
}
public IActionResult Action1([FromBody] Vehicle value)
{
_vehiclesList.AddVehicle(value);
Console.WriteLine("Vehicle1");
return(Created("", value));
}
