public async Task <IActionResult> PutVehicle([FromRoute] int id, [FromBody] Vehicle vehicle)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != vehicle.Id)
{
return(BadRequest());
}
_context.Entry(vehicle).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Customer> Create(Customer customer)
{
_context.Customers.Add(customer);
await _context.SaveChangesAsync();
return(customer);
}
public async Task <int> InsertAsync(TEntity entity)
{
try
{
if (entity == null)
{
throw new ArgumentException("entity");
}
Entities.Add(entity);
return(await Context.SaveChangesAsync());
}
catch (DbEntityValidationException dbEx)
{
var msg = string.Empty;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
msg += string.Format("Property: {0} Error: {1}",
validationError.PropertyName, validationError.ErrorMessage) + Environment.NewLine;
}
}
var fail = new Exception(msg, dbEx);
throw fail;
}
}
public async Task <ActionResult <Vehicle> > PostVehicle(Vehicle vehicle)
{
_context.Vehicles.Add(vehicle);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetVehicles), new { id = vehicle.Id }, vehicle));
}
public async Task <VehicleModel> CreateModelAsync(VehicleModel newModel)
{
context.VehicleModels.Add(newModel);
await context.SaveChangesAsync();
return(newModel);
}
public async Task <Vehicle> Create(Vehicle vehicle)
{
_context.Vehicles.Add(vehicle);
await _context.SaveChangesAsync();
return(vehicle);
}
public async Task <ResultModel <VehicleModel> > Create(VehicleModel model)
{
try
{
var validationErrors = CheckCreateValidations(model);
if (validationErrors.Any())
{
return(new ErrorResultModel <VehicleModel>(validationErrors));
}
var entity = ToEntity(model);
await _context.Vehicles.AddAsync(entity);
var rowsAffected = await _context.SaveChangesAsync();
if (rowsAffected > 0)
{
model.Id = entity.Id;
return(new SuccessResultModel <VehicleModel>(model));
}
else
{
return(new ErrorResultModel <VehicleModel>("No se pudo guardar el vehiculo"));
}
}
catch (Exception e)
{
return(new ErrorResultModel <VehicleModel>(e.Message));
}
}
public async Task <VehicleMake> CreateMakeAsync(VehicleMake newMake)
{
context.VehicleMakes.Add(newMake);
await context.SaveChangesAsync();
return(newMake);
}
public async Task <IActionResult> PutVehicle(string vin, Vehicle vehicle)
{
if (vin != vehicle.VIN)
{
return(BadRequest());
}
_context.Entry(vehicle).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VehicleExists(vin))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Create([Bind("ID,Question,Answer,Type,Creator")] Rule rule)
{
var user = await _userManager.GetUserAsync(User);
rule.Creator = user.UserName;
rule.State = State.Pending;
if (ModelState.IsValid)
{
try
{
_context.Add(rule);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RuleExists(rule.ID))
{
return(NotFound());
}
else
{
throw;
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
return(RedirectToAction(nameof(Index)));
}
return(View(rule));
}
public async Task <Vehicle> SaveVehicle(Vehicle vehicle)
{
await _context.Vehicles.AddAsync(vehicle);
await _context.SaveChangesAsync();
return(vehicle);
}
public async Task <T> CreteAsync(T newItem)
{
await context.Set <T>().AddAsync(newItem);
await context.SaveChangesAsync();
return(newItem);
}
/// <summary>
/// Instert new vehicle.
/// </summary>
/// <param name="vehicleModel">Vehicle model.</param>
/// <returns>Updates database.</returns>
public Task InsertVehicleAsync(IVehicleModel vehicleModel)
{
vehicleModel.Id = Guid.NewGuid();
vehicleModel.Abrv = vehicleModel.Name.Substring(0, 3);
vehicleContext.VehicleModels.Add(mapper.Map <DAL.Entities.VehicleModel>(vehicleModel));
return(vehicleContext.SaveChangesAsync());
}
public async Task <Guid> Create(TEntity entity)
{
await authContext.Set <TEntity>().AddAsync(entity);
await authContext.SaveChangesAsync();
return(entity.Id);
}
public async Task <ItemsInStockModel> AddAsync(ItemsInStockModel model)
{
await StockEntities.AddAsync(model);
await Context.SaveChangesAsync();
return(model);
}
public async Task <int> InsertAsync(TEntity entity)
{
if (entity == null)
{
throw new ArgumentException("entity");
}
Entities.Add(entity);
return(await Context.SaveChangesAsync());
}
public async Task <ActionResult <Vehicle> > AddVehicle([FromBody] Vehicle vehicle)
{
_context.Vehicles.Add(vehicle);
await _context.SaveChangesAsync();
return(CreatedAtAction(
"GetVehiclebyID",
new { id = vehicle.Id }, vehicle
));
}
public async Task <IActionResult> Create([Bind("Id,Patente,Marca,Modelo,Puertas,Titular")] Vehicle vehicle)
{
if (ModelState.IsValid)
{
_context.Add(vehicle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(vehicle));
}
public async Task <IActionResult> Create([Bind("ID,Question,Answer,State,Type,Creator")] Rule rule)
{
if (ModelState.IsValid)
{
_context.Add(rule);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(rule));
}
public async Task <IActionResult> Create([Bind("Id,VehicleRegNumber,DateOfRegistration,OwnerNationalIdNumber,MonthlyInsuranceAmount")] Vehicle vehicle)
{
if (ModelState.IsValid)
{
_context.Add(vehicle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(vehicle));
}
public async Task <IActionResult> Create([Bind("Id,Brand,Model,Year")] Car car)
{
if (ModelState.IsValid)
{
_context.Add(car);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(car));
}
public async Task <IActionResult> Create([Bind("VehicleID,Type,GasAmount,TiresNum")] Vehicle vehicle)
{
if (ModelState.IsValid)
{
_context.Add(vehicle);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(vehicle));
}
public async Task <int> AddModel(VehicleModel model)
{
if (db != null)
{
db.vehicleModels.Add(model);
await db.SaveChangesAsync();
return(model.ID);
}
return(0);
}
public async Task <ActionResult> Create(VehicleModel vehicleModel)
{
if (ModelState.IsValid)
{
db.VehicleModels.Add(vehicleModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(vehicleModel));
}
public async Task <ActionResult> Create([Bind(Include = "ID,Name,Abrv")] VehicleMake vehicleMake)
{
if (ModelState.IsValid)
{
db.vehicleMakes.Add(vehicleMake);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(vehicleMake));
}
public async Task <int> AddMake(VehicleMake make)
{
if (db != null)
{
db.vehicleMakes.Add(make);
await db.SaveChangesAsync();
return(make.ID);
}
return(0);
}
public async Task <IActionResult> Create([Bind("ID,Model,VType,Brand,Capacity,Description,ReleaseDate")] Vehicle vehicle)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
vehicle.ModifyBy = user.UserName;
_context.Add(vehicle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(vehicle));
}
public async Task <bool> InsertMake(VehicleMake make)
{
try
{
context.VehicleMakes.Add(make);
await context.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public async Task <bool> InsertModel(VehicleModel model)
{
try
{
context.VehicleModels.Add(model);
await context.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public async Task <bool> CreateVehicleModel(VehicleModel vehicleModelToInsert)
{
try
{
_datacontext.VehicleModels.Add(vehicleModelToInsert);
await _datacontext.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}