public async Task <HttpResponseMessage> Add(VehicleModelView vehicleModelView)
{
try
{
if (vehicleModelView.Name == null || vehicleModelView.Abrv == null || vehicleModelView.VehicleMakeId == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Model is not complete. Please provide name, abrv and make id"));
}
var fMakerExist = await MakeService.Read(vehicleModelView.VehicleMakeId);
if (fMakerExist == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid VehicleMakeId"));
}
vehicleModelView.VehicleModelId = Guid.NewGuid();
var response = await ModelService.Add(AutoMapper.Mapper.Map <VehicleModelDomain>(vehicleModelView));
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Couldn't add model. Database error."));
}
}
public async Task <IActionResult> UpdateAsync(Guid?id, VehicleModelView vehicle)
{
try
{
if (id == null)
{
return(BadRequest());
}
IVehicleModelDomain vehicleUpdate = await _service.GetIdModelAsync(vehicle.Id);
if (vehicleUpdate == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _service.UpdateModelAsync(_mapper.Map <IVehicleModelDomain>(vehicle));
}
}
catch
{
return(NotFound());
}
return(NoContent());
}
public async Task <HttpResponseMessage> Update(VehicleModelView vehicleModelView)
{
try
{
var toBeUpdated = await ModelService.Read(vehicleModelView.VehicleModelId);
if (vehicleModelView.Name != null)
{
toBeUpdated.Name = vehicleModelView.Name;
}
if (vehicleModelView.Abrv != null)
{
toBeUpdated.Abrv = vehicleModelView.Abrv;
}
var response = await ModelService.Update(AutoMapper.Mapper.Map <VehicleModelDomain>(toBeUpdated));
if (response == 0)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Couldn't update model."));
}
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
catch
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Couldn't update model. Database error."));
}
}
// GET: Vehicles/Details/5
public ActionResult Details(int?id)
{
VehicleModelView VehicleModel = new VehicleModelView();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Vehicle vehicle = db.Vehicles
.Include(x => x.Images)
.Include(x => x.watchLists)
.Include(x => x.Dealer)
.Include(x => x.Reviews)
.FirstOrDefault(x => x.Id == id);
if (vehicle == null)
{
return(HttpNotFound());
}
ViewBag.DealerInfo = db.Users.Find(vehicle.Dealer.Id);
ViewBag.VehicleId = id;
VehicleModel.vehicles = db.Vehicles
.ToList()
.Take(6);
VehicleModel.vehicle = vehicle;
return(View(VehicleModel));
}
public ActionResult Delete(VehicleModelView models)
{
try
{
model.Delete(Mapper.Map <VehicleModel>(models));
return(RedirectToAction("Index"));
}
catch (Exception) { }
return(RedirectToAction("Delete", models.Id));
}
public async Task <IActionResult> Create(
[Bind("MakeId,ModelName,Abrv")] VehicleModelView vehicle)
{
if (ModelState.IsValid)
{
var create = mapper.Map <IVehicleModel>(vehicle);
await service.InsertModel(create);
return(RedirectToAction("Index"));
}
ViewBag.MakeId = makeService.GetMakeList();
return(View(vehicle));
}
public ActionResult Create()
{
VehicleModelView vehicleModel = new VehicleModelView()
{
VehicleMakes = Mapper.Map <IList <SelectListItem> >
(model.GetMakes().Select
(c => new SelectListItem {
Value = c.Id.ToString(), Text = c.Name
}))
};
return(View(vehicleModel));
}
public ActionResult Create(VehicleModelView models)
{
try
{
if (ModelState.IsValid)
{
model.Create(Mapper.Map <VehicleModel>(models));
return(RedirectToAction("Index"));
}
}
catch (DataException) { }
return(RedirectToAction("Create"));
}
public ActionResult Edit([Bind(Include = "Id,VehicleMakeId,Name,Abrv")] VehicleModelView models)
{
try
{
if (ModelState.IsValid)
{
model.Edit(Mapper.Map <VehicleModel>(models));
return(RedirectToAction("Index"));
}
}
catch (DataException) { }
return(RedirectToAction("Edit", models.Id));
}
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(BadRequest());
}
var vehicle = await service.GetIdModel(id);
if (vehicle == null)
{
return(NotFound());
}
VehicleModelView getVehicle = mapper.Map <VehicleModelView>(vehicle);
return(View(getVehicle));
}
public async Task <IActionResult> GetAsync(Guid?id)
{
if (id == null)
{
return(BadRequest());
}
VehicleModelView getVehicle = _mapper.Map <VehicleModelView>(await _service.GetIdModelAsync(id));
if (getVehicle == null)
{
return(NotFound());
}
return(Ok(getVehicle));
}
public async Task <IActionResult> Edit(Guid?id)
{
ViewBag.MakeId = makeService.GetMakeList();
if (id == null)
{
return(BadRequest());
}
var vehicle = await service.GetIdModel(id);
if (vehicle == null)
{
return(NotFound());
}
VehicleModelView getVehicle = mapper.Map <VehicleModelView>(vehicle);
return(View(getVehicle));
}
public ActionResult Manage()
{
//find user
var user = db.Users.Find(User.Identity.GetUserId());
VehicleModelView vehicleModel = new VehicleModelView();
if (db.Vehicles.Count() > 0)
{
//chart data
vehicleModel.vehicles = db.Vehicles
.OrderByDescending(x => x.Added)
.Where(x => x.Dealer.Id == user.Id)
.ToList();
vehicleModel.vehicleReports = new List <VehicleReport>();
//get booking data
foreach (var v in vehicleModel.vehicles)
{
//find bookings
var booking = db.Bookings.Include(x => x.Reciept).FirstOrDefault(x => x.vehicle.Id == v.Id);
//get booking deatails
VehicleReport report = new VehicleReport();
try
{
report.vehicleName = v.make + " " + v.model;
report.TotalCharge = booking.Reciept.TotalCharges;
report.NumberOfDays = booking.NumberOfDays;
}
catch (NullReferenceException)
{
report.TotalCharge = 0.1;
report.NumberOfDays = 0;
}
vehicleModel.vehicleReports.Add(report);
}
VehicleReport report2 = new VehicleReport();
ViewBag.earnings = report2.Earnings(vehicleModel.vehicles.ToList());
return(View(vehicleModel));
}
return(View());
}
public async Task <IActionResult> CreateAsync(VehicleModelView vehicle)
{
try
{
if (ModelState.IsValid)
{
await _service.InsertModelAsync(_mapper.Map <IVehicleModelDomain>(vehicle));
return(Ok());
}
return(BadRequest());
}
catch
{
return(StatusCode(500));
}
}
// GET: Vehicles/Details/5
//get the vehicle with reviews join
public async Task <IActionResult> VehicleDetails(int?id)
{
if (id == null)
{
return(RedirectToAction("Error", "Home"));
}
VehicleModelView _VehicleModelView = new VehicleModelView();
Vehicle _Vehicle = await _context.Vehicles.FindAsync(id);
_VehicleModelView.Id = _Vehicle.Id;
_VehicleModelView.VIN = _Vehicle.VIN;
_VehicleModelView.Registration = _Vehicle.Registration;
_VehicleModelView.Model = _Vehicle.Model;
_VehicleModelView.CylinderCapacity = _Vehicle.CylinderCapacity;
_VehicleModelView.NumberOfDoors = _Vehicle.NumberOfDoors;
_VehicleModelView.SixMonthRate = _Vehicle.SixMonthRate;
_VehicleModelView.TwelveMonthRate = _Vehicle.TwelveMonthRate;
_VehicleModelView.DateOfFirstRegistration = _Vehicle.DateOfFirstRegistration;
_VehicleModelView.YearOfManufacture = _Vehicle.YearOfManufacture;
_VehicleModelView.Co2Emissions = _Vehicle.Co2Emissions;
_VehicleModelView.FuelType = _Vehicle.FuelType;
_VehicleModelView.TaxStatus = _Vehicle.TaxStatus;
_VehicleModelView.Transmission = _Vehicle.Transmission;
_VehicleModelView.Colour = _Vehicle.Colour;
_VehicleModelView.TypeApproval = _Vehicle.TypeApproval;
_VehicleModelView.WheelPlan = _Vehicle.WheelPlan;
_VehicleModelView.RevenueWeight = _Vehicle.RevenueWeight;
_VehicleModelView.TaxDetails = _Vehicle.TaxDetails;
_VehicleModelView.MotDetails = _Vehicle.MotDetails;
_VehicleModelView.Taxed = _Vehicle.Taxed;
_VehicleModelView.Mot = _Vehicle.Mot;
_VehicleModelView.UserId = _Vehicle.UserId;
_VehicleModelView.PricePerHour = _Vehicle.PricePerHour;
_VehicleModelView.Image = _Vehicle.Image;
_VehicleModelView.Rating = _Vehicle.Rating;
_VehicleModelView.VehicleReviews = _context.Reviews.Where(vid => vid.VehicleId == id);
return(View(_VehicleModelView));
}
public void Construct(VehicleModelView vehicleModelView)
{
this.vehicleModelView = vehicleModelView;
}
public void ModelControllerGetTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var modelService = new ModelService(modelRepository);
var makeService = new MakeService(makeRepository, modelRepository);
var makeController = new MakeController(makeService);
var testController = new ModelController(modelService, makeService);
testController.Request = new HttpRequestMessage();
testController.Configuration = new HttpConfiguration();
makeController.Request = new HttpRequestMessage();
makeController.Configuration = new HttpConfiguration();
JavaScriptSerializer JSS = new JavaScriptSerializer();
//Add make
var vMake = new VehicleMakeView()
{
Name = "ModelControllerGetTest", Abrv = "ModelControllerGetTest"
};
Task.Run(async() =>
{
var response = await makeController.Add(vMake);
var obj = JSS.Deserialize <int>(response.Content.ReadAsStringAsync().Result);
Assert.AreEqual(1, obj);
}).GetAwaiter().GetResult();
//Get make
VehicleMakeView targetItem = null;
Task.Run(async() =>
{
var response = await makeController.GetAll();
Assert.IsNotNull(response);
IEnumerable <VehicleMakeView> obj = JSS.Deserialize <IEnumerable <VehicleMakeView> >(response.Content.ReadAsStringAsync().Result);
targetItem = obj.LastOrDefault();
}).GetAwaiter().GetResult();
//Add model
var vModel = new VehicleModelView()
{
Name = "ModelControllerGetTest", Abrv = "ModelControllerGetTest", VehicleMakeId = targetItem.VehicleMakeId
};
Task.Run(async() =>
{
var response = await testController.Add(vModel);
var obj = JSS.Deserialize <int>(response.Content.ReadAsStringAsync().Result);
Assert.AreEqual(1, obj);
}).GetAwaiter().GetResult();
VehicleModelView targetModel = null;
//Get all models
Task.Run(async() =>
{
var response = await testController.GetAll();
var obj = JSS.Deserialize <IEnumerable <VehicleModelView> >(response.Content.ReadAsStringAsync().Result);
Assert.IsNotNull(obj);
targetModel = obj.LastOrDefault();
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testController.Get(targetModel.VehicleModelId);
var obj = JSS.Deserialize <VehicleModelView>(result.Content.ReadAsStringAsync().Result);
//Assert
Assert.AreEqual(targetModel.VehicleModelId, obj.VehicleModelId);
}).GetAwaiter().GetResult();
}
