public async Task <IActionResult> PutAutomobile(int id, Automobile automobile)
{
if (id != automobile.Id)
{
return(BadRequest());
}
_context.Entry(automobile).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AutomobileExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCar(int id, Car car)
{
if (id != car.Id)
{
return(BadRequest());
}
_context.Entry(car).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <Car> AddAsync(Car newCar, CancellationToken ct = default)
{
context.Car.Add(newCar);
await context.SaveChangesAsync(ct);
return(newCar);
}
public async Task <IActionResult> PutBodyType(int id, BodyType bodyType)
{
if (id != bodyType.Id)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
_context.Entry(bodyType).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BodyTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(NoContent());
}
public async Task CreateCar(CarModel car)
{
lock (glush)
{
context.Cars.Add(car);
};
await context.SaveChangesAsync();
}
public async Task <IActionResult> Create([Bind("FuelID,Kilometres,Burned_fuel,Price,Date,GasStation,CarID")] Fuel fuel)
{
if (ModelState.IsValid)
{
_context.Add(fuel);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Details", "Cars", new { id = fuel.CarID }));
}
public async Task <IActionResult> Create([Bind("CarID,Brand,Model,Year,Vin")] Car car)
{
if (ModelState.IsValid)
{
_context.Add(car);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(car));
}
public async Task <IActionResult> Create([Bind("CarsId,CarModel,CarName,CarType,CarYear")] Cars cars)
{
if (ModelState.IsValid)
{
_context.Add(cars);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cars));
}
public async Task <IActionResult> Create([Bind("AcessorioId,Nome")] Acessorio acessorio)
{
if (ModelState.IsValid)
{
_context.Add(acessorio);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(acessorio));
}
public async Task <IActionResult> Create([Bind("Id,Title,ReleaseDate,Price,Weight")] Car car)
{
if (ModelState.IsValid)
{
_context.Add(car);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(car));
}
public async Task <ActionResult> Create([Bind(Include = "id,date,CarModel,price,mileage,tel,seller,description")] Cars cars) // TODO: check if correct (previously was "model")
{
if (ModelState.IsValid)
{
db.Ads.Add(cars);
await db.SaveChangesAsync();
return(RedirectToAction("ShowAll"));
}
return(View());
}
public async Task <IActionResult> Create([Bind("TireID,Type,SpeedIndx,WeightIndx,Production_date_dot,Brand,Description,CarID")] Tire tire)
{
if (ModelState.IsValid)
{
_context.Add(tire);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CarID"] = new SelectList(_context.Cars, "CarID", "Brand", tire.CarID);
return(View(tire));
}
public async Task <IActionResult> Create([Bind("PartID,Name,Producer,ChangeID")] Part part)
{
if (ModelState.IsValid)
{
_context.Add(part);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ChangeID"] = new SelectList(_context.Changes, "ChangeID", "ChangeID", part.ChangeID);
return(View(part));
}
public async Task <IActionResult> Create([Bind("ChangeID,Milage,Date,Parts_prize,Work_prize,Description,CarID")] Change change)
{
if (ModelState.IsValid)
{
_context.Add(change);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Cars", new { id = change.CarID }));
}
ViewData["CarID"] = new SelectList(_context.Cars, "CarID", "Brand", change.CarID);
return(View(change));
}
public async Task <IActionResult> Create([FromBody] Vehicle vehicle)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Vehicle.Add(vehicle);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetVehicle", new { id = vehicle.Id }, vehicle));
}
public async Task <ActionResult <Car> > Post(Car car)
{
// если есть лшибки - возвращаем ошибку 400
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// если ошибок нет, сохраняем в базу данных
db.Cars.Add(car);
await db.SaveChangesAsync();
return(Ok(car));
}
public async Task AddCar(CarData car)
{
await using var db = new CarsContext();
await db.Cars.AddAsync(car);
await db.SaveChangesAsync();
}
public async Task <ActionResult <Car> > Post(Car car)
{
if (car == null)
{
return(BadRequest());
}
DataBaseHistory dataBaseHistory = new DataBaseHistory();
dataBaseHistory.ChangeDate = DateTime.Now;
dataBaseHistory.Information = "Добавлен автомабиль: " + car.CarBrand + " " + car.CarModel + " ," + car.CarPruductionYear + "года" + car.CarColor + " цвета";
db.DataBaseHistories.Add(dataBaseHistory);
db.Cars.Add(car);
await db.SaveChangesAsync();
return(Ok(car));
}
public async Task <IActionResult> AddOrEdit([Bind("Id,Model,Power,Description,Prize,Version,Name")] Car car)
{
if (ModelState.IsValid)
{
if (car.Id == 0)
{
_context.Add(car);
}
else
{
_context.Update(car);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(car));
}
public async Task <IActionResult> Update([FromRoute] int id, [FromBody] Brand brand)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = _context.Brand.Find(id);
if (item == null)
{
return(NotFound());
}
item.Name = brand.Name;
_context.Brand.Update(item);
await _context.SaveChangesAsync();
return(NoContent());
}
public static async Task <ModelService> GetModelServiceWithMakers(CarsContext carsContextInMemory, IRelatedWordsService relatedWordsService, params Maker[] makers)
{
await carsContextInMemory.Makers.AddRangeAsync(makers);
await carsContextInMemory.SaveChangesAsync().ConfigureAwait(false);
var carRepositoryInMemory = await GetInMemoryCarRepository(carsContextInMemory).ConfigureAwait(false);
var mapper = GetMapper();
var modelService = new ModelService(mapper, carRepositoryInMemory, relatedWordsService);
return(modelService);
}
public async Task <ActionResult <Car> > Post(Car car)
{
/*// обработка частных случаев валидации
* if (car.Power == 99)
* ModelState.AddModelError("Age", "Возраст не должен быть равен 99");
*
* if (user.Name == "admin")
* {
* ModelState.AddModelError("Name", "Недопустимое имя пользователя - admin");
* }*/
// если есть лшибки - возвращаем ошибку 400
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// если ошибок нет, сохраняем в базу данных
db.Cars.Add(car);
await db.SaveChangesAsync();
return(Ok(car));
}
public async Task <IActionResult> Create(
[Bind("Manufacture,Model,Engine,ProductionDate")] Car car)
{
try
{
if (ModelState.IsValid)
{
_context.Add(car);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
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(View(car));
}
public async Task <ActionResult> AddCar([FromBody] JsonElement json)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (null != context.Cars.FirstOrDefault(x => x.Number == json.GetProperty("Number").GetString()))
{
return(BadRequest("This Car exist"));
}
var car = new Car
{
Number = json.GetProperty("Number").GetString(),
Mileage = json.GetProperty("Mileage").GetInt32(),
Data = Convert.ToDateTime(json.GetProperty("Date").GetString()),
CarModel = await context.CarModels.FirstOrDefaultAsync(x => x.Model == json.GetProperty("Model").GetString())
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
return(Ok($"Add car {car.Number}"));
}
public async Task <ActionResult <Car> > Post(Car car)
{
// обработка частных случаев валидации
if (car.Power == 666)
{
ModelState.AddModelError("Power", "Мощность не должен быть равной 666");
}
/*if (car == null || db.Cars.Any(x => x.Name == car.Name))
* {
* ModelState.AddModelError("Name", "Недопустимое название автомобиля, автомобиль уже существет!");
* }*/
// если есть oшибки - возвращаем ошибку 400
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// если ошибок нет, сохраняем в базу данных
db.Cars.Add(car);
await db.SaveChangesAsync();
return(Ok(car));
}
public async Task <IActionResult> Create([Bind("CarroId,Marca,DataCompra,Descricao,Cor")] Carro carro)
{
if (ModelState.IsValid)
{
_context.Add(carro);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(carro));
}
public async Task <IActionResult> Create([FromBody] Option option)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
for (int i = 0; i < option.options.Length; i++)
{
_context.Vehicle_Option.Add(new Vehicle_Option {
OptionFK = option.options[i], VehicleFK = option.vId, Price = 0
});
}
await _context.SaveChangesAsync();
return(null);
}
public async Task <bool> AddCar(Car car)
{
await _carsContext.Cars.AddAsync(car).ConfigureAwait(false);
return(await _carsContext.SaveChangesAsync().ConfigureAwait(false) > 0);
}
public async Task <bool> Add(TEntity entity)
{
entities.Add(entity);
return(await context.SaveChangesAsync() > 0);
}
public Task Save()
{
return(_context.SaveChangesAsync());
}
