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); }