public async Task <IActionResult> Create([FromForm] Car car, [FromForm] IFormFile image)
{
byte[] file;
using (var memoryStream = new MemoryStream()) {
await image.CopyToAsync(memoryStream);
file = memoryStream.ToArray();
}
var name = $"img_{car.NumberPlate.Replace(" ", "").Replace("-", "_")}";
car.ImgPath = name;
if (ModelState.IsValid)
{
await carRepository.UploadImage(file, name);
await carRepository.Create(car);
return(Ok());
}
var allErrors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage));
return(BadRequest(allErrors));
}
static void Main(string[] args)
{
ICarRepository repository = new CarRepository();
var cars = repository.GetCars();
var newCar = new Car {
Name = "Igor123"
};
repository.Create(newCar);
cars = repository.GetCars();
var lastUserId = cars.Max(x => x.Id);
newCar.Id = lastUserId;
newCar.Name = "UpdatedName";
repository.Update(newCar);
repository.Delete(lastUserId);
//Console.WriteLine("Compiled succesfully!");
Console.ReadKey();
}
public ActionResult Create(Car car)
{
if (ModelState.IsValid)
{
_carRepository.Create(car);
return(RedirectToAction("Index"));
}
return(View(car));
}
private void CreateCar()
{
Car newCar = new Car();
newCar = view.GetNewCarInfo();
repo.Create(newCar);
Run();
}
public ActionResult Create([Bind(Include = "ID,Brand,Model,Year")] Car car)
{
if (ModelState.IsValid)
{
_carRepository.Create(car);
return(RedirectToAction("Index"));
}
return(View(car));
}
public ActionResult CreatePost(CarCreateViewModel model)
{
if (model.New.BranchId <= 0)
{
}
else
{
carRepo.Create(model.New);
}
return(RedirectToAction("Index"));
}
public async Task <IHttpActionResult> Post(Car car)
{
WebApiConfig.Logger.info("enter CarsController->Post car = " + car.ToString());
if (!ModelState.IsValid)
{
WebApiConfig.Logger.warning("return from CarsController->Post car = " + car.ToString() + " BAD REQUEST");
return(BadRequest(ModelState));
}
db.Create(car);
WebApiConfig.Logger.info("return from CarsController->Post car = " + car.ToString());
return(Created(car)); //(IHttpActionResult) db.Get(car.Id);
}
public void ShouldCreateCarWhenSuccess()
{
_repo.Create(new Car
{
Id = 3,
Make = "E",
Model = "F",
Type = Car.CarType.Diesel.ToString(),
Vin = "C1",
Milage = 1,
Year = 2000
});
var result = _repo.FindCarById(3);
Assert.NotNull(result);
}
public void Car_Create_OK()
{
// Arrange
BaseEntity car = new Car()
{
price = 500000,
year = 2010
};
Repository crud = new CarRepository(car, 10);
// Act
crud.Create();
// Assert
Assert.IsTrue(crud.getStatus());
}
public void Create(CarModel model)
{
var car = new Car
{
Model = model.Model,
ManufacturerId = model.ManufacturerId,
Details = model.Details?.Select(x => new Detail
{
Price = x.Price,
CarId = x.CarId,
ManufacturerId = x.ManufacturerId,
TypeId = x.TypeId
}).ToList()
};
carRepository.Create(car);
}
public async Task <IActionResult> CreateCar(CarViewModel cvm)
{
if (!ModelState.IsValid)
{
return(View(cvm));
}
var car = new Car
{
IdOwner = await _userManager.FindByIdAsync(_userManager.GetUserId(HttpContext.User)),
IdCar = cvm.IdCar,
IdDriver = String.Empty,
IdGroup = cvm.IdGroup,
CarModel = cvm.CarModel,
CarcassNumber = cvm.CarcassNumber,
RegistrationNumber = cvm.RegistrationNumber,
Photo = await _fileManager.SaveImage(cvm.Image),
Color = cvm.Color,
CargoType = cvm.CargoType,
CarType = cvm.CarType,
CarryingCapacity = cvm.CarryingCapacity,
CarryingCapacitySqM = cvm.CarryingCapacitySqM,
HeightCargoCompartment = cvm.HeightCargoCompartment,
WidthCargoCompartment = cvm.WidthCargoCompartment,
LengthCargoCompartment = cvm.LengthCargoCompartment,
CostPerKm = cvm.CostPerKm
};
if (cvm.IdCar > 0)
{
_carRepository.Update(car);
}
else
{
_carRepository.Create(car);
}
if (await _carRepository.SaveChangesAsync())
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(car));
}
}
public ActionResult Create(CreateCarModels model)
{
if (ModelState.IsValid)
{
try
{
Car car = carRepository.Create(model.Make, model.CarModel, model.Year, model.Engine);
return(RedirectToAction("Edit", new { id = car.Id }));
}
catch
{
return(View());
}
}
else
{
return(View());
}
}
public void CreateCallsAdd()
{
//Arrange
var mockSet = new Mock <DbSet <Car> >();
mockSet.Setup(a => a.Add(It.IsAny <Car>())).Verifiable();
var mock = new Mock <RentContext>();
mock.Setup(a => a.Cars).Returns(mockSet.Object);
//Act
var repository = new CarRepository(mock.Object);
repository.Create(new Car());
//Assert
Mock.Verify(mockSet);
}
public void Create(CarModel carModel)
{
var car = new Car
{
Id = carModel.Id,
Name = carModel.Name,
ManufacturerId = carModel.ManufacturerId,
Details = carModel.Details?.Select(x => new Detail
{
Id = x.Id,
CarId = x.CarId,
Name = x.Name,
Price = x.Price,
DetailTypeId = x.DetailTypeId,
ManufacturerId = x.ManufacturerId
}).ToList()
};
carRepository.Create(car);
}
public void GivenTheseExistingCars(Table table)
{
table.Rows.ForEach(values =>
{
_carRepository.RemoveByRegistration(values["Registration"]);
int customerId = values.ContainsKey("Customer") ?
_customerRepository.GetIdByName(values["Customer"]) :
_customerRepository.GetFirstCustomerId();
var car = new CarInfo(
values["Registration"],
customerId,
values["Make"],
values["Model"],
values.GetDateOrDefault("MOT Expiry"),
values.GetBoolOrDefault("Suppress MOT Reminder"));
_carRepository.Create(car);
});
}
//CREATE/POST
internal Car Create(Car newCar)
{
return(_repo.Create(newCar));
}
public async Task Post(Car bookedCar)
{
await _repository.Create(bookedCar);
}
public Car Create(Car newCar)
{
return(_repository.Create(newCar));
}
internal object Create(Car newCar)
{
return(_repo.Create(newCar));
}
public void Create(Car model)
{
_carRepository.Create(model);
}
internal Car Create(Car car)
{
return(_repo.Create(car));
}