public ActionResult Create(VehicleModel model)
{
var repo = new VehicleModelRepository();
bool isexists = repo.IsFieldExists(repo.ConnectionString(), "VehicleModel", "VehicleModelName", model.VehicleModelName, null, null);
if (!isexists)
{
var result = new VehicleModelRepository().InsertVehicleModel(model);
if (result.VehicleModelId > 0)
{
TempData["Success"] = "Added Successfully!";
TempData["RefNo"] = result.VehicleModelRefNo;
return(RedirectToAction("Create"));
}
else
{
TempData["error"] = "Oops!!..Something Went Wrong!!";
TempData["RefNo"] = null;
return(View("Create", model));
}
}
else
{
TempData["error"] = "This Name Alredy Exists!!";
TempData["RefNo"] = null;
return(View("Create", model));
}
}
public ActionResult Edit(string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var item = _unitOfWork.PartsProducts.GetByID(Convert.ToInt32(id));
var VManufacturer = _unitOfWork.VehicleManufacturer.GetByID(item.VehicleModel.VehicleManufacturerId);
var VModel = _unitOfWork.VehicleModel.GetByID(item.VehicleModel.VehicleModelId);
var PSUbCategory = _unitOfWork.PartsSubCategory.GetByID(item.PartsProductsSubCategoryId);
var PCategory = _unitOfWork.PartsProductsCategory.GetByID(item.PartsProductsSubCategory.PartsProductsCategoryId);
var PManufacturer = _unitOfWork.PartsProductManufacturer.GetByID(item.PartsProductManufacturer.PartsProductManufacturerId);
VehicleModelRepository vehicleModelRepository = new VehicleModelRepository(new AutoSolutionContext());
PartsSubCategoryRepository partsSubCategoryRepository = new PartsSubCategoryRepository(new AutoSolutionContext());
TransmissionTypeRepository transmissionTypeRepository = new TransmissionTypeRepository(new AutoSolutionContext());
VehicleEngineTypeRepository vehicleEngineTypeRepository = new VehicleEngineTypeRepository(new AutoSolutionContext());
PartsProductManufacturerRepository partsProductManufacturerRepository = new PartsProductManufacturerRepository(new AutoSolutionContext());
PartsProductsViewModel partsProductsViewModel = new PartsProductsViewModel();
partsProductsViewModel.PartsProductId = item.PartsProductId;
partsProductsViewModel.EndYear = item.EndYear;
partsProductsViewModel.startYear = item.startYear;
partsProductsViewModel.PartsProductName = item.PartsProductName;
partsProductsViewModel.LongDescription = item.LongDescription;
partsProductsViewModel.ShortDescription = item.ShortDescription;
partsProductsViewModel.UnitPrice = item.UnitPrice;
partsProductsViewModel.VehicleManufacturerList = vehicleModelRepository.GetVehicleManufacturerDropDown();
partsProductsViewModel.VehicleModelList = vehicleModelRepository.GetVehicleModelDropDown();
partsProductsViewModel.PartsProductsCategoryList = partsSubCategoryRepository.GetPartsProductCategoryDropDown();
partsProductsViewModel.PartsProductsSubCategoryList = partsSubCategoryRepository.GetPartsProductSubCategoryDropDown();
partsProductsViewModel.PartProductManufacturerList = partsProductManufacturerRepository.GetPPManufacturerDropDown();
partsProductsViewModel.SelectedManufacturer = VManufacturer.VehicleManufacturerId;
partsProductsViewModel.SelectedModel = VModel.VehicleModelId;
partsProductsViewModel.SelectedPartsProductCategory = PCategory.PartsProductsCategoryId.ToString();
partsProductsViewModel.SelectedPartsProductSubCategory = PSUbCategory.PartsProductsSubCategoryId.ToString();
partsProductsViewModel.SelectedPartProductManufacturer = PManufacturer.PartsProductManufacturerId.ToString();
partsProductsViewModel.SelectedModel = item.VehicleModelId;
partsProductsViewModel.PartProductImagesList = item.PartProductImages.ToList();
if (partsProductsViewModel != null)
{
return(PartialView("_EditPartsProduct", partsProductsViewModel));
}
else
{
return(HttpNotFound());
}
}
catch (Exception)
{
throw;
}
}
public ActionResult Edit(VehicleModel model)
{
model.OrganizationId = 1;
model.CreatedDate = System.DateTime.Now;
model.CreatedBy = UserID.ToString();
var repo = new VehicleModelRepository();
bool isexists = repo.IsFieldExists(repo.ConnectionString(), "VehicleModel", "VehicleModelName", model.VehicleModelName, "VehicleModelId", model.VehicleModelId);
if (!isexists)
{
var result = new VehicleModelRepository().UpdateVehicleModel(model);
if (result.VehicleModelId > 0)
{
TempData["Success"] = "Updated Successfully!";
TempData["RefNo"] = result.VehicleModelRefNo;
return(RedirectToAction("Create"));
}
else
{
TempData["error"] = "Oops!!..Something Went Wrong!!";
TempData["RefNo"] = null;
return(View("Create", model));
}
}
else
{
TempData["error"] = "This Name Alredy Exists!!";
TempData["RefNo"] = null;
return(View("Create", model));
}
}
public ActionResult Edit(string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var item = _unitOfWork.VehicleModel.GetByID(Convert.ToInt32(id));
VehilceModelViewModel vehilceModelViewModel = new VehilceModelViewModel();
VehicleModelRepository vehicleModelRepository = new VehicleModelRepository(new AutoSolutionContext());
vehilceModelViewModel.VehicleModelId = item.VehicleModelId;
vehilceModelViewModel.VehicleModel = item.VehicleModelName;
// vehilceModelViewModel.YearOfManufacture = item.YearOfManufacture;
vehilceModelViewModel.SelectedVehicleManufacturer = item.VehicleManufacturerId.ToString();
vehilceModelViewModel.VehicleManufacturersList = vehicleModelRepository.GetVehicleManufacturerDropDown();
if (vehilceModelViewModel != null)
{
return(PartialView("_EditVehicleModel", vehilceModelViewModel));
}
else
{
return(HttpNotFound());
}
}
catch (Exception)
{
throw;
}
}
public ActionResult AddNew(VehilceModelViewModel vehilceModelViewModel)
{
try
{
if (ModelState.IsValid)
{
string str = vehilceModelViewModel.VehicleModel;
VehicleModelRepository vehicleModelRepository = new VehicleModelRepository(new AutoSolutionContext());
bool IsExist = vehicleModelRepository.isExist(vehilceModelViewModel.VehicleModel);
if (!IsExist)
{
VehicleModel vehicleModel = new VehicleModel();
vehicleModel.VehicleModelName = vehilceModelViewModel.VehicleModel;
vehicleModel.YearOfManufacture = vehilceModelViewModel.YearOfManufacture;
vehicleModel.VehicleManufacturerId = Convert.ToInt32(vehilceModelViewModel.SelectedVehicleManufacturer);
_unitOfWork.VehicleModel.Add(vehicleModel);
_unitOfWork.Complete();
_unitOfWork.Dispose();
return(RedirectToAction("GetVehicleModel"));
}
else
{
return(RedirectToAction("GetVehicleModel"));
}
}
}
catch (Exception)
{
throw;
}
return(View());
}
public void CanLoadModelByMakeId()
{
var repo = new VehicleModelRepository();
var model = repo.GetByMakeId(2).ToList();
Assert.IsNotNull(model);
Assert.AreEqual("Soul", model[0].VehicleModelName);
}
public void CanLoadModelById()
{
var repo = new VehicleModelRepository();
var model = repo.GetById(2);
Assert.AreEqual("Soul", model.VehicleModelName);
}
public ActionResult FillVehicleModelList(int?page)
{
int itemsPerPage = 10;
int pageNumber = page ?? 1;
var repo = new VehicleModelRepository();
var List = repo.FillVehicleModelList();
return(PartialView("VehicleModelListView", List));
}
public void CanLoadVehicleModels()
{
var repo = new VehicleModelRepository();
var models = repo.GetVehicleModels().ToList();
Assert.AreEqual(5, models.Count());
Assert.AreEqual("Explorer", models[0].VehicleModelName);
Assert.AreEqual(1, models[0].VehicleMakeId);
Assert.AreEqual("Ram 1500", models[3].VehicleModelName);
Assert.AreEqual(2, models[1].VehicleMakeId);
}
public ActionResult Edit(string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var item = _unitOfWork.VehicleVersion.GetByID(Convert.ToInt32(id));
var Manufacturer = _unitOfWork.VehicleManufacturer.GetByID(item.VehicleModel.VehicleManufacturerId);
VehicleVersionViewModel vehicleVersionViewModel = new VehicleVersionViewModel();
VehicleModelRepository vehicleModelRepository = new VehicleModelRepository(new AutoSolutionContext());
VehicleEngineTypeRepository vehicleEngineTypeRepository = new VehicleEngineTypeRepository(new AutoSolutionContext());
TransmissionTypeRepository transmissionTypeRepository = new TransmissionTypeRepository(new AutoSolutionContext());
vehicleVersionViewModel.VehicleVersionId = item.VehicleVersionId;
vehicleVersionViewModel.VehicleVersionName = item.VehicleVersionName;
vehicleVersionViewModel.EngineCapacity = item.EngineCapacity;
vehicleVersionViewModel.startYear = item.startYear;
vehicleVersionViewModel.EndYear = item.EndYear;
vehicleVersionViewModel.VehicleManufacturerList = vehicleModelRepository.GetVehicleManufacturerDropDown();
vehicleVersionViewModel.VehicleModelList = vehicleModelRepository.GetVehicleModelDropDown();
vehicleVersionViewModel.TransmissionTypeList = transmissionTypeRepository.GetTransmissionDropDown();
vehicleVersionViewModel.EngineTypeList = vehicleEngineTypeRepository.GetVehicleEngineTypeDropDown();
vehicleVersionViewModel.SelectedManufacturer = Manufacturer.VehicleManufacturerId.ToString();
vehicleVersionViewModel.SelectedEngineType = item.VehicleEngineTypeId.ToString();
vehicleVersionViewModel.SelectedModel = item.VehicleModelId.ToString();
vehicleVersionViewModel.SelectedTransmissionType = item.TransmissionTypeId.ToString();
if (vehicleVersionViewModel != null)
{
return(PartialView("_EditVehicleVersion", vehicleVersionViewModel));
}
else
{
return(HttpNotFound());
}
}
catch (Exception)
{
throw;
}
}
public ActionResult Delete(VehicleModel model)
{
var result = new VehicleModelRepository().DeleteVehicleModel(model);
if (result.VehicleModelId > 0)
{
TempData["Success"] = "Deleted Successfully!";
TempData["RefNo"] = model.VehicleModelRefNo;
return(RedirectToAction("Create"));
}
else
{
TempData["error"] = "Oops!!..Something Went Wrong!!";
TempData["RefNo"] = null;
return(View("Create", model));
}
}
public void CanInsertVehicleModel()
{
var repo = new VehicleModelRepository();
ModelsItem newModel = new ModelsItem()
{
VehicleModelName = "Matrix",
VehicleMakeId = 5,
UserId = "00000000-0000-0000-0000-000000000000"
};
repo.Insert(newModel);
var allModels = repo.GetVehicleModels().ToList();
Assert.AreEqual(6, allModels.Count());
Assert.AreEqual("Matrix", allModels[5].VehicleModelName);
}
public VehicleModelService(VehicleModelRepository repository)
{
this.repository = repository;
}
public ReportAboveAverageRentsForVehicleModels(VehicleModelRepository vehicleModelRepository)
{
_vehicleModelRepository = vehicleModelRepository;
}
public ActionResult Edit(int Id)
{
VehicleModel model = new VehicleModelRepository().GetVehicleModel(Id);
return(View("Create", model));
}
public VehicleModelService(VehicleModelRepository repository, IMapper mapper, UnitOfWork unitOfWork)
{
this.repository = repository;
this.mapper = mapper;
this.unitOfWork = unitOfWork;
}
public VehicleModelDeleteAction(VehicleModelRepository vehicleModelRepository)
{
_vehicleModelRepository = vehicleModelRepository;
}
public VehicleModelAddAction(VehicleModelRepository vehicleModelRepository, VehicleBrandRepository vehicleBrandRepository)
{
_vehicleModelRepository = vehicleModelRepository;
_vehicleBrandRepository = vehicleBrandRepository;
}
public async void FindMakeAsync_Returns_PagedList_IVehicleModel()
{
// problem sa include
var sortMock = new Mock <ISortingParams>();
sortMock.Setup(s => s.SortDirection).Returns("asc");
var filterMock = new Mock <IFilteringParams>();
filterMock.Setup(s => s.Search).Returns("a");
filterMock.Setup(s => s.MakeId).Returns(Guid.NewGuid());
var pageMock = new Mock <IPagingParams>();
pageMock.Setup(s => s.CurrentPage).Returns(2);
pageMock.Setup(s => s.PageSize).Returns(3);
Guid g = Guid.NewGuid();
var makeList = new List <VehicleMake>()
{
new VehicleMake {
Id = g, Name = "Audi", Abrv = "A"
},
}.AsQueryable();
var modelList = new List <VehicleModel>()
{
new VehicleModel {
Id = Guid.NewGuid(), Name = "A1", Abrv = "A", MakeId = g
},
new VehicleModel {
Id = Guid.NewGuid(), Name = "A2", Abrv = "A", MakeId = g
},
new VehicleModel {
Id = Guid.NewGuid(), Name = "A3", Abrv = "A", MakeId = g
},
new VehicleModel {
Id = Guid.NewGuid(), Name = "A4", Abrv = "A", MakeId = g
},
new VehicleModel {
Id = Guid.NewGuid(), Name = "A5", Abrv = "A", MakeId = g
},
new VehicleModel {
Id = Guid.NewGuid(), Name = "A6", Abrv = "A", MakeId = g
},
}.AsQueryable();
var dbContextMock = new Mock <DatabaseContext>();
var dbSetMakersMock = new Mock <DbSet <VehicleMake> >();
dbSetMakersMock.As <IQueryable <VehicleMake> >().Setup(m => m.Provider).Returns(makeList.Provider);
dbSetMakersMock.As <IQueryable <VehicleMake> >().Setup(m => m.Expression).Returns(makeList.Expression);
dbSetMakersMock.As <IQueryable <VehicleMake> >().Setup(m => m.ElementType).Returns(makeList.ElementType);
dbSetMakersMock.As <IQueryable <VehicleMake> >().Setup(m => m.GetEnumerator()).Returns(() => makeList.GetEnumerator());
var dbSetModelsMock = new Mock <DbSet <VehicleModel> >();
dbSetModelsMock.As <IQueryable <VehicleModel> >().Setup(m => m.Provider).Returns(modelList.Provider);
dbSetModelsMock.As <IQueryable <VehicleModel> >().Setup(m => m.Expression).Returns(modelList.Expression);
dbSetModelsMock.As <IQueryable <VehicleModel> >().Setup(m => m.ElementType).Returns(modelList.ElementType);
dbSetModelsMock.As <IQueryable <VehicleModel> >().Setup(m => m.GetEnumerator()).Returns(() => modelList.GetEnumerator());
dbSetModelsMock.As <IQueryable <VehicleModel> >().Setup(s => s.Include(It.IsAny <string>()));
//dbSetModelsMock.Setup(s => s.Include(It.IsAny<string>())).Returns(() => modelList);
dbContextMock.Setup(s => s.Models).Returns(dbSetModelsMock.Object);
dbContextMock.Setup(s => s.Makers).Returns(dbSetMakersMock.Object);
var repository = new VehicleModelRepository(dbContextMock.Object, mapper);
var model = await repository.FindModelAsync(filterMock.Object, sortMock.Object, pageMock.Object);
//Assert
Assert.NotNull(model);
Assert.IsAssignableFrom <IPagedList <IVehicleModel> >(model);
Assert.Equal(2, model.PageNumber);
Assert.Equal(3, model.PageSize);
}
