public async Task <IActionResult> Edit(int id, CarServiceModel carServiceModel)
{
var car = carService.GetById(id).Result;
carServiceModel.Picture = car.Picture;
carServiceModel.CarStatus = car.CarStatus;
carServiceModel.CarStatusId = car.CarStatusId;
if (!this.ModelState.IsValid)
{
var allCarStatuses = await this.carService
.GetAllStatuses()
.ToListAsync();
this.ViewData["types"] = allCarStatuses
.Select(productType => new CarCreateCarStatusViewModel
{
Name = productType.Name
})
.ToList();
return(this.View(carServiceModel));
}
await this.carService.EditAsync(id, carServiceModel);
return(this.Redirect("/"));
}
public async Task <IActionResult> Create(CarCreateBindingModel carCreateBindingModel)
{
if (!this.ModelState.IsValid)
{
List <CarStatusServiceModel> allCarStatuses = await this.carService
.GetAllStatuses()
.ToListAsync();
this.ViewData["statuses"] = allCarStatuses
.Select(carStatus => new CarCreateCarStatusViewModel
{
Name = carStatus.Name
})
.ToList();
return(this.View());
}
string pictureUrl = await this.cloudinaryService.UploadPictureAsync(
carCreateBindingModel.Picture,
carCreateBindingModel.Model);
CarServiceModel carServiceModel = AutoMapper.Mapper
.Map <CarServiceModel>(carCreateBindingModel);
carServiceModel.Picture = pictureUrl;
await this.carService.Create(carServiceModel);
return(this.Redirect("/"));
}
public async Task EditAsync(int id, CarServiceModel carServiceModel)
{
Car carFromDb = await this.context
.Cars
.SingleOrDefaultAsync(car => car.Id == id);
if (carFromDb == null)
{
throw new ArgumentNullException(nameof(carFromDb));
}
carFromDb.Brand = carServiceModel.Brand;
carFromDb.Model = carServiceModel.Model;
carFromDb.Picture = carServiceModel.Picture;
carFromDb.PricePerDay = carServiceModel.PricePerDay;
carFromDb.ManufacturedOn = carServiceModel.ManufacturedOn;
carFromDb.AirConditioner = carServiceModel.AirConditioner;
carFromDb.AutomaticGearbox = carServiceModel.AutomaticGearbox;
carFromDb.Diesel = carServiceModel.Diesel;
carFromDb.Group = carServiceModel.Group;
carFromDb.CarStatus = carServiceModel.CarStatus;
carFromDb.CarStatusId = carServiceModel.CarStatusId;
this.context.Cars.Update(carFromDb);
context.SaveChanges();
}
public async Task <bool> CreateAsync(CarServiceModel model)
{
if (!this.IsEntityStateValid(model))
{
return(false);
}
if (!await this.carModelsRepository.All()
.AnyAsync(m => m.Id == model.ModelId))
{
return(false);
}
var owner = await this.usersRepository.All().SingleOrDefaultAsync(u => u.UserName == model.Owner.UserName);
if (owner == null)
{
return(false);
}
var car = Mapper.Map <Car>(model);
car.Owner = owner;
await this.carsRepository.AddAsync(car);
await this.carsRepository.SaveChangesAsync();
return(true);
}
public static CarServiceModel Create(string id)
{
var model = new CarServiceModel()
{
Id = id
};
return(model);
}
public async Task AddCarAsync(CarServiceModel carServiceModel)
{
if (carServiceModel != null)
{
Car car = this.mapper.Map <Car>(carServiceModel);
this.context.Cars.Add(car);
await this.context.SaveChangesAsync();
}
}
public async Task UpdateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var car = new Car
{
ModelId = model.Id,
Colour = "Test Colour",
OwnerId = user.Id
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
var serviceModel = new CarServiceModel
{
Id = car.Id,
ModelId = car.ModelId,
OwnerId = car.OwnerId,
Colour = "Updated Colour",
Details = "Updated Details"
};
// Act
var result = await carsService.UpdateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.Cars.SingleAsync();
Assert.Equal(serviceModel.Colour, dbModel.Colour);
Assert.Equal(serviceModel.Details, dbModel.Details);
}
public async void WithTCarUsedCar_ShouldCreateUsedCar()
{
var dbContext = this.GetDbContext();
var service = this.GetService(dbContext);
var model = new CarServiceModel();
await service.CreateNewAsync <UsedCar>(model);
var dbCars = dbContext.UsedCars.ToList();
Assert.Single(dbCars);
}
public async Task <IActionResult> Edit(int id)
{
CarServiceModel carServiceModel = (await this.carService.GetById(id));
if (carServiceModel == null)
{
// TODO: Error Handling
return(this.Redirect("/"));
}
return(this.View(carServiceModel));
}
public async Task CreateNewAsync <TCar>(CarServiceModel model) where TCar : BaseCar, new()
{
var dbCar = Mapper.Map <TCar>(model);
dbCar.Pictures = Mapper.Map <ICollection <Picture> >(model.Pictures);
this.carRepository.Add(dbCar);
var rowsAffected = await this.carRepository.CompleteAsync();
RepositoryValidator.ValidateCompleteChanges(rowsAffected);
}
public async Task UpdateAsync_WithNonExistentCarId_ReturnsFalse()
{
// Arrange
var testCarId = Guid.NewGuid().ToString();
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
var car = new Car
{
ModelId = model.Id,
OwnerId = user.Id,
Colour = "Test Colour",
Details = "Test Details"
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
var serviceModel = new CarServiceModel
{
Id = testCarId,
ModelId = car.ModelId,
OwnerId = car.OwnerId,
Colour = "Updated Colour",
Details = "Updated Details"
};
// Act
var result = await carsService.UpdateAsync(serviceModel);
// Assert
Assert.False(result);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), new EfRepository <CarModel>(context), new EfRepository <PoolItUser>(context));
var serviceModel = new CarServiceModel
{
ModelId = model.Id,
Colour = "Test Colour",
Owner = new PoolItUserServiceModel
{
UserName = user.UserName
}
};
// Act
var result = await carsService.CreateAsync(serviceModel);
// Assert
Assert.True(result);
var dbModel = await context.Cars.SingleOrDefaultAsync();
Assert.NotNull(dbModel);
Assert.Equal(user.Id, dbModel.OwnerId);
}
public async Task EditCarDataAsync(CarServiceModel carServiceModel)
{
if (carServiceModel != null)
{
var carFromDb = this.context.Cars.FirstOrDefault(c => c.Id == carServiceModel.Id);
this.context.Cars.Update(carFromDb);
carFromDb.Model = carServiceModel.Model;
carFromDb.Brand = carServiceModel.Brand;
carFromDb.YearFrom = carServiceModel.YearFrom;
carFromDb.Number = carServiceModel.Number;
await this.context.SaveChangesAsync();
}
}
public async Task CreateAsync_WithInvalidModel_ReturnsFalse()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
await context.CarModels.AddAsync(model);
var user = new PoolItUser
{
UserName = "******"
};
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), new EfRepository <CarModel>(context), new EfRepository <PoolItUser>(context));
var serviceModel = new CarServiceModel
{
ModelId = model.Id,
Owner = new PoolItUserServiceModel
{
UserName = user.UserName
}
};
// Act
var result = await carsService.CreateAsync(serviceModel);
// Assert
Assert.False(result);
var dbModelAdded = await context.Cars.AnyAsync();
Assert.False(dbModelAdded);
}
public void IsUserOwner_WithNullUserName_ReturnsFalse()
{
// Arrange
var serviceModel = new CarServiceModel
{
Owner = new PoolItUserServiceModel
{
UserName = "******"
}
};
var carsService = new CarsService(null, null, null);
// Act
var result = carsService.IsUserOwner(serviceModel, null);
// Assert
Assert.False(result);
}
public void IsUserOwner_WithOtherUserOwner_ReturnsFalse()
{
// Arrange
const string testUserName = "******";
var serviceModel = new CarServiceModel
{
Owner = new PoolItUserServiceModel
{
UserName = "******"
}
};
var carsService = new CarsService(null, null, null);
// Act
var result = carsService.IsUserOwner(serviceModel, testUserName);
// Assert
Assert.False(result);
}
public async Task <bool> UpdateAsync(CarServiceModel model)
{
if (!this.IsEntityStateValid(model) || model.Id == null)
{
return(false);
}
var car = await this.carsRepository.All().SingleOrDefaultAsync(c => c.Id == model.Id);
if (car == null)
{
return(false);
}
car.Colour = model.Colour;
car.Details = model.Details;
this.carsRepository.Update(car);
await this.carsRepository.SaveChangesAsync();
return(true);
}
public async Task <bool> Create(CarServiceModel carServiceModel)
{
CarStatus carStatusFromDb = await this.context
.CarStatuses
.SingleOrDefaultAsync(carStatus =>
carStatus.Name == carServiceModel.CarStatus.Name);
if (carStatusFromDb == null)
{
throw new ArgumentNullException(nameof(carStatusFromDb));
}
Car car = AutoMapper.Mapper.Map <Car>(carServiceModel);
car.CarStatus = carStatusFromDb;
this.context.Cars.Add(car);
int result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task EditAsync <TCar>(CarServiceModel model) where TCar : BaseCar
{
var dbCar = await this.carRepository.Set <TCar>().FindAsync(model.Id);
DataValidator.ValidateNotNull(dbCar, new ArgumentException(ErrorConstants.IncorrectId));
// TODO: Optimize
if (model.Pictures.Count() > 0)
{
await this.pictureRepository.RemoveRangeWhereAsync(p => p.CarId == dbCar.Id);
dbCar.Pictures = Mapper.Map <ICollection <Picture> >(model.Pictures);
}
if (model.Options.Count() > 0)
{
await this.carOptionRepository.RemoveAllWithCarIdAsync(dbCar.Id);
}
Mapper.Map(model, dbCar);
var rowsAffected = await this.carOptionRepository.CompleteAsync();
RepositoryValidator.ValidateCompleteChanges(rowsAffected);
}
private async Task AddPicturesToServiceModel(CarServiceModel serviceModel, AdminCarBindingModel model)
{
var publicIds = await this.cloudinaryService.UploadPicturesAsync(model.Pictures);
serviceModel.Pictures = Mapper.Map <ICollection <PictureServiceModel> >(publicIds);
}
public bool IsUserOwner(CarServiceModel carServiceModel, string userName) => userName != null && carServiceModel.Owner.UserName == userName;
public async Task UpdateAsync_WithModelAndUserChanged_DoesNotUpdate()
{
// Arrange
var context = new PoolItDbContext(new DbContextOptionsBuilder <PoolItDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new CarModel
{
Model = "Test Model"
};
var newModel = new CarModel
{
Model = "New Model"
};
await context.CarModels.AddRangeAsync(model, newModel);
var user = new PoolItUser
{
UserName = "******"
};
var newUser = new PoolItUser
{
UserName = "******"
};
await context.Users.AddRangeAsync(user, newUser);
var car = new Car
{
ModelId = model.Id,
Colour = "Test Colour",
OwnerId = user.Id
};
await context.Cars.AddAsync(car);
await context.SaveChangesAsync();
var carsService = new CarsService(new EfRepository <Car>(context), null, null);
var serviceModel = new CarServiceModel
{
Id = car.Id,
ModelId = newModel.Id,
OwnerId = newUser.Id,
Colour = "Updated Colour",
Details = "Updated Details"
};
// Act
await carsService.UpdateAsync(serviceModel);
// Assert
var dbModel = await context.Cars.SingleAsync();
Assert.Equal(user.Id, dbModel.OwnerId);
Assert.Equal(model.Id, dbModel.ModelId);
}
