public IActionResult Create()
{
var user = userManager.GetUserAsync(User).Result;
CarInputModel model = service.PriparedPage(user.UserName);
return(View(model));
}
public IActionResult Create()
{
var model = new CarInputModel();
model.ReleaseDate = DateTime.UtcNow;
return(this.View(model));
}
public ActionResult <CarOutputModel> AddCar([FromBody] CarInputModel car)
{
var result = _carManager.AddCar(car);
return(new ObjectResult(result)
{
StatusCode = StatusCodes.Status201Created
});
}
public IActionResult Create([FromForm] CarInputModel model)
{
if (ModelState.IsValid)
{
return(this.View(model));
}
return(this.View(model));
}
public ActionResult <CarOutputModel> UpdateCarById(Guid id, [FromBody] CarInputModel car)
{
var result = _carManager.UpdateCar(id, car);
return(new ObjectResult(result)
{
StatusCode = StatusCodes.Status202Accepted
});
}
public async Task <IActionResult> Create()
{
var parkings = await this.parkingsService.GetAllAsync <ParkingsServiceDropDownModel>();
var viewModel = new CarInputModel()
{
Parkings = parkings.Select(p => p.To <ParkingsDropDownViewModel>()).ToList(),
};
return(this.View(viewModel));
}
public async Task <ActionResult> Put([FromRoute] int id, [FromBody] CarInputModel inputModel)
{
var updResult = await this._carService.UpdateAsync(id, inputModel);
if (!updResult.isSuccess)
{
return(BadRequest());
}
return(NoContent());
}
public async Task <ActionResult <Car> > Post([FromBody] CarInputModel inputModel)
{
var insResult = await this._carService.InsertAsync(inputModel);
if (!insResult.isSuccess)
{
return(BadRequest());
}
return(CreatedAtAction(nameof(Get), this._mapper.Map <Car, CarViewModel>(insResult.Item2)));
}
public async Task <ServiceResponse <Car> > InsertAsync(CarInputModel inputModel, int ownerId = 1) // TODO: repalce this when implement multiuser func.
{
var carForInsert = this._mapper.Map <CarInputModel, Car>(inputModel);
carForInsert.OwnerId = ownerId;// TODO: put in _mapper
var allCars = this._context.Cars.ToArray();
var res = this._context.Cars.AddAsync(carForInsert);
await this._context.SaveChangesAsync();
return(ServiceResponse <Car> .Success(carForInsert));
}
public CarInputModel GetUserCarInfo(int userId, int carId)
{
using (var conn = new SqlConnection())
{
var privSet = new HashSet <string>();
conn.ConnectionString = _connectionString;
conn.Open();
var command = new SqlCommand(_getUserCarInfoById, conn);
command.Parameters.Add(new SqlParameter("userId", userId));
command.Parameters.Add(new SqlParameter("carId", carId));
var result = new CarInputModel()
{
PidModel = new List <PidModel>()
};
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
if (result.UserModel == null)
{
result.UserModel = new UserModel()
{
FirstName = reader["FirstName"].ToString(),
LastName = reader["LastName"].ToString(),
Age = (int)reader["Age"],
CarMake = reader["Make"].ToString(),
CarModel = reader["Model"].ToString(),
CarYear = reader["Year"].ToString()
};
}
if (!privSet.Contains(reader["PId"].ToString()))
{
result.PidModel.Add(new PidModel()
{
Description = reader["Descriptions"].ToString(),
Pid = reader["PId"].ToString(),
Units = reader["Units"].ToString(),
Value = Math.Round((double)reader["Value"], 2),
NationalValue = Math.Round((double)reader["NationalValue"], 2)
});
privSet.Add(reader["PId"].ToString());
}
}
}
// read Sql
return(result);
}
}
public ActionResult Create(CarInputModel model)
{
if (ModelState.IsValid && model!=null)
{
var allShippersNames = Data.Shippers.All().Select(x => x.Name);
if (model.ShipperName!=null && !allShippersNames.Contains(model.ShipperName))
{
var newShipper = new Shipper
{
Name = model.ShipperName
};
Data.Shippers.Add(newShipper);
Data.SaveChanges();
var newCar = new Car
{
Id = model.Id,
Brand = model.Brand,
Description = model.Description,
Power = model.Power,
ShipperId = newShipper.Id,
Year = model.Year
};
_cars.Add(newCar);
_cars.SaveChanges();
return RedirectToAction("Index");
}
if (allShippersNames.Contains(model.ShipperName))
{
var shipperId = Data.Shippers.All().SingleOrDefault(x => x.Name == model.ShipperName).Id;
var newCar = new Car
{
Id = model.Id,
Brand = model.Brand,
Description = model.Description,
Power = model.Power,
ShipperId = shipperId,
Year = model.Year
};
_cars.Add(newCar);
_cars.SaveChanges();
return RedirectToAction("Index");
}
}
return View();
}
public void Create(CarInputModel inputModel, string userId)
{
var car = new Car
{
Model = inputModel.Model,
Year = inputModel.Year,
PictureUrl = inputModel.Image,
PlateNumber = inputModel.PlateNumber,
OwnerId = userId,
};
this.db.Cars.Add(car);
this.db.SaveChanges();
}
public void MapCarValues(CarInputModel carInputModel, Car carEntity)
{
if (carInputModel == null)
{
throw new Exception("InputModel argument cannot be null.");
}
if (carEntity == null)
{
throw new Exception("Car entity not found.");
}
var carEntityEntry = _carRepository.GetCarEntityEntry(carEntity);
carEntityEntry.CurrentValues.SetValues(carInputModel);
}
public CarInputModel PriparedPage(string userName)
{
var model = new CarInputModel();
model.AllDealerships = GetAllDealerships();
Task.Run(async() =>
{
User loggedUser = await userManager.FindByNameAsync(userName);
model.UserId = loggedUser.Id;
model.User = loggedUser;
}).Wait();
return(model);
}
public async Task <ServiceResponse <Car> > UpdateAsync(int id, CarInputModel inputModel)
{
var carForUpdate = await this._context.Cars.FindAsync(id);
if (carForUpdate == null)
{
return(ServiceResponse <Car> .BadInput());
}
carForUpdate.Nickname = inputModel.Nickname;
carForUpdate.RegistrationNr = inputModel.RegistrationNr;
carForUpdate.Model = inputModel.Model;
carForUpdate.PicUrl = inputModel.PicUrl;
carForUpdate.UpdatedAt = DateTime.UtcNow;
var res = this._context.Cars.Update(carForUpdate);
await this._context.SaveChangesAsync();
return(ServiceResponse <Car> .Success(carForUpdate));
}
private CarInputModel ValidateCar(CarInputModel car)
{
if (!DataProvider.Makes.ContainsKey(car.MakeId))
{
throw new ResourceNotFoundException("MakeId", car.MakeId.ToString());
}
if (!DataProvider.Models.ContainsKey(car.ModelId))
{
throw new ResourceNotFoundException("ModelId", car.ModelId.ToString());
}
if (_httpContextAccessor.HttpContext.Request.Headers.TryGetValue("Token", out var token))
{
car.DealerId = TokenProvider.Instance.GetDealerIdFromToken(token);
return(car);
}
else
{
throw new ResourceNotFoundException("Dealer", "Cannot be inferred from the token");
}
}
public void AddCar(CarInputModel entity)
{
Car car = new Car
{
Manufacturer = entity.Manufacturer,
Model = entity.Model,
Type = entity.Type,
Engine = entity.Engine,
Horsepower = entity.Horsepower,
Transmission = entity.Transmission,
Gears = entity.Gears,
Color = entity.Color,
Price = entity.Price,
UserId = entity.UserId,
User = entity.User,
Dealership = entity.Dealership,
DealershipId = entity.DealershipId
};
context.Cars.Add(car);
context.SaveChanges();
}
public void TestMapCarValuesValidArguments()
{
// Arrange
var options = DbContextOptions;
Car entity;
using (var context = new ApplicationDbContext(options))
{
context.Database.EnsureCreated();
var repository = new CarRepository(context);
var service = new CarService(repository);
entity = context.Car.FirstOrDefault(c => c.Id == 1);
Assert.NotNull(entity);
var inputModel = new CarInputModel
{
Id = 1,
Make = "test make",
Model = "test model",
Trim = "test trim",
VIN = "test VIN"
};
// Act
service.MapCarValues(inputModel, entity);
context.Database.EnsureDeleted();
}
// Assert
Assert.Equal("test make", entity.Make);
Assert.Equal("test model", entity.Model);
Assert.Equal("test trim", entity.Trim);
Assert.Equal("test VIN", entity.VIN);
}
public HttpResponse Add(CarInputModel inputModel)
{
if (!this.IsUserSignedIn())
{
return(this.Redirect("/Users/Login"));
}
var userId = this.GetUserId();
if (this.usersService.IsUserMechanic(userId))
{
return(this.Redirect("/Cars/All"));
}
if (string.IsNullOrWhiteSpace(inputModel.Model) || inputModel.Model.Length < 5 || inputModel.Model.Length > 20)
{
return(this.Error("Car model is required and should be between 5 and 20 characters long."));
}
if (inputModel.Year <= 1900 || inputModel.Year > DateTime.Now.Year)
{
return(this.Error("Invalid car year."));
}
if (string.IsNullOrWhiteSpace(inputModel.Image))
{
return(this.Error("Car image is required."));
}
if (!Regex.IsMatch(inputModel.PlateNumber.Trim(), @"^[A-Z]{2}\d{4}[A-Z]{2}$"))
{
return(this.Error("Invalid plate number. Plate number should be 2 capital English letters, followed by 4 digits, followed by 2 capital English letters."));
}
this.carsService.Create(inputModel, userId);
return(this.Redirect("/Cars/All"));
}
public async Task <IActionResult> Create(CarInputModel carInputModel)
{
if (!this.ModelState.IsValid)
{
var parkings = await this.parkingsService.GetAllAsync <ParkingsServiceDropDownModel>();
carInputModel.Parkings = parkings.Select(p => p.To <ParkingsDropDownViewModel>()).ToList();
return(this.View(carInputModel));
}
var carServiceModel = carInputModel.To <CarServiceInputModel>();
var imageUrl = await this.cloudinaryService.UploadImageAsync(
carInputModel.Image,
$"{carServiceModel.Model}-{carServiceModel.Model}",
GlobalConstants.CarsImagesFolder);
carServiceModel.Image = imageUrl;
await this.carsService.CreateAsync(carServiceModel);
return(this.Redirect("/Administration/Cars/All"));
}
public CarOutputModel UpdateCar(Guid id, CarInputModel car)
{
car = ValidateCar(car);
DataProvider.Cars[id] = car;
return(_mapper.Map <CarOutputModel>(car));
}
public CarOutputModel AddCar(CarInputModel car)
{
car = ValidateCar(car);
DataProvider.Cars.TryAdd(car.Id, car);
return(_mapper.Map <CarOutputModel>(car));
}
public IActionResult Create(CarInputModel InputModel)
{
service.AddCar(InputModel);
return(Redirect("/"));
}
