public async Task <Car> AddNewCar(CreateCarModel newCar)
{
if (await CheckIfRegistrationNumberExists(newCar.RegistrationNumber))
{
throw new EntryAlreadyExistsException("A car with such Registration Number already exists!");
}
var createdCar = new Car()
{
Brand = newCar.Brand,
Color = newCar.Color,
FuelId = (int)newCar.FuelId,
TransmissionId = (int)newCar.TransmissionId,
CarBodyId = (int)newCar.CarBodyId,
FabricationYear = newCar.FabricationYear,
RegistrationNumber = newCar.RegistrationNumber,
Model = newCar.Model,
NumberOfSeats = newCar.NumberOfSeats,
NumberOfDoors = newCar.NumberOfDoors,
AirCoditioning = newCar.AirCoditioning,
PricePerDay = newCar.PricePerDay,
};
_carRepository.Add(createdCar);
await _carRepository.SaveAll();
return(createdCar);
}
public async Task <IActionResult> Create(CreateCarModel createCarModel, int id)
{
var generation = generationsService.GetById(id);
var engine = enginesService.GetById(createCarModel.EngineId);
if (generation == null)
{
return(this.BadRequest());
}
var car = Mapper.Map <Car>(createCarModel);
car.GenerationId = id;
if (this.carsService.Exists(car))
{
this.ModelState.AddModelError("", GlobalConstants.CAR_ALREADY_EXISTS);
}
ValidateTireInfo(createCarModel.TireInfo);
if (!this.ModelState.IsValid)
{
SetUpViewBag(generation);
return(this.View());
}
await carsService.AddAsync(car);
return(this.RedirectToAction(nameof(All), new { id }));
}
public HttpResponse Add(CreateCarModel model)
{
var errorsModel = this.validator.ValidateCar(model);
if (this.context.Cars.Any(c => c.Model == model.Model &&
c.PlateNumber == model.PlateNumber))
{
errorsModel.Add("This car is already in added.");
}
if (errorsModel.Any())
{
return(Error(errorsModel));
}
var car = new Car
{
Model = model.Model,
PictureUrl = model.ImageUrl,
PlateNumber = model.PlateNumber,
Year = model.Year,
OwnerId = this.User.Id
};
this.context.Cars.Add(car);
this.context.SaveChanges();
return(Redirect("/Cars/All"));
}
public ActionResult Create(CreateCarModel carModel)
{
if (carModel != null && ModelState.IsValid)
{
var ownerId = this.User.Identity.GetUserId();
var car = new Car
{
Make = carModel.Make,
Model = carModel.Model,
Color = carModel.Color,
Engine = carModel.Engine,
EngineType = carModel.EngineType,
ImageUrl = carModel.ImageUrl,
Power = carModel.Power,
PricePerDay = carModel.PricePerDay,
Year = carModel.Year,
OwnerId = ownerId
};
var db = new CarsDbContext();
db.Cars.Add(car);
db.SaveChanges();
return(RedirectToAction("Details", new { id = car.Id }));
}
return(View());
}
public void Execute_SavesItemIntoUnitOfWork()
{
var modelToAdd = new CreateCarModel();
_subject.Execute(modelToAdd);
_uow.Verify(c => c.SaveChanges());
}
public void Execute_AddsItemToUnitOfWork()
{
var modelToAdd = new CreateCarModel();
_subject.Execute(modelToAdd);
_uow.Verify(c => c.Cars.Add(It.IsAny <Car>()), Times.Once());
}
public void Execute_GeneratesDomainObjectFromFactory()
{
var modelToAdd = new CreateCarModel();
_subject.Execute(modelToAdd);
_factory.Verify(c => c.Create(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <double>()), Times.Once);
}
public async Task <IActionResult> Post(CreateCarModel newCar)
{
var createdCar = await _carService.AddNewCar(newCar);
var carDto = _mapper.Map <CarModel>(createdCar);
return(Ok(carDto));
}
public IActionResult CreateCar(CreateCarModel inputModel)
{
if (ModelState.IsValid)
{
this.task2Service.CreateCar(inputModel);
}
return(LocalRedirect("/task2/index"));
}
public IActionResult Create(CreateCarModel carModel)
{
var carToAdd = new Car
{
Id = 5,
Make = carModel.Make,
Model = carModel.Model,
MovieDetails = carModel.MovieDetails,
Vin = carModel.Vin
};
Data.Cars.Add(carToAdd);
return(Created("asdasdasdasd", carToAdd));
}
public async Task <CarModel> AddCar(CreateCarModel model)
{
_validator.Validate(model);
var dbCarModel = new CarModel
{
Id = Guid.NewGuid().ToString(),
Name = model.Name,
Description = model.Description,
RegistrationNumber = model.RegistrationNumber
};
await _carRepository.AddCar(dbCarModel);
return(dbCarModel);
}
public async Task <IActionResult> Create([FromBody] CreateCarModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var car = Mapper.Map <Car>(model);
var newCar = await _carService.CreateAsync(car);
if (newCar == null)
{
return(BadRequest());
}
return(Ok(newCar));
}
public ICollection <string> ValidateCar(CreateCarModel model)
{
var errors = new List <string>();
if (model.Model.Length < CarModelNameMinLength || model.Model.Length > CarModelNameMaxLength)
{
errors.Add($"Model have to be between {CarModelNameMinLength} and {CarModelNameMaxLength} charachters long.");
}
if (!Regex.IsMatch(model.Model, CarPlateNumRegex))
{
errors.Add("Invalid plate number.");
}
if (string.IsNullOrWhiteSpace(model.Model) ||
string.IsNullOrWhiteSpace(model.PlateNumber) ||
string.IsNullOrWhiteSpace(model.Year.ToString()))
{
errors.Add("Some field is empty.");
}
return(errors);
}
public void CreateCar(CreateCarModel m)
{
Engine engine = new Engine(m.Speed, m.Power);
CargoType cargoType;
if (!Enum.TryParse(m.CargoType, true, out cargoType))
{
throw new ArgumentException("Invalid cargo type parameter");
}
Cargo cargo = new Cargo(m.Weight, cargoType);
Tire[] tires = new Tire[4];
tires[0] = new Tire(m.Tire1Presure, m.Tire1Age);
tires[1] = new Tire(m.Tire2Presure, m.Tire2Age);
tires[2] = new Tire(m.Tire3Presure, m.Tire3Age);
tires[3] = new Tire(m.Tire4Presure, m.Tire4Age);
Car car = new Car(m.Model, engine, cargo, tires);
Task2Repo.AddCar(car);
}
public virtual async Task <CarItem> CreateOne(CreateCarModel item)
{
return(await _carService.CreateAsync(item));
}
public Task <CarModel> AddCar([FromBody] CreateCarModel model)
{
return(_carService.AddCar(model));
}
public async Task <CarItem> CreateAsync(CreateCarModel item)
{
var car = _mapper.Map <CarItem>(item);
return(await _carDataService.CreateAsync(car));
}
public void Create(CreateCarModel model)
{
_createCommand.Execute(model);
}
