public async Task <ActionResult> Edit([Bind(Include = "Id, Name, Abrv, VehicleMakeId")] VehicleModelDTO model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var editedModel = await _modelService.FindAsync(model.Id);
Mapper.Map(model, editedModel);
try
{
await _modelService.UpdateAsync(editedModel);
TempData["Message"] = $"Model: {model.Name} successfully updated.";
}
catch (Exception e)
{
TempData["Message"] = $"Something went wrong: {e.Message}";
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task AddVehicleModel(VehicleModelDTO vehicleModelDto)
{
if (!await IsValidVehicleMake(vehicleModelDto.VehicleMakeId))
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.VEHICLE_MAKE_NOT_EXIST);
}
vehicleModelDto.Name = vehicleModelDto.Name.Trim();
var vehicleModelName = vehicleModelDto.Name.ToLower();
if (await _vehicleModelRepo.ExistAsync(v => v.Name.ToLower() == vehicleModelName))
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.VEHICLE_MODEL_EXIST);
}
_vehicleModelRepo.Insert(new VehicleModel
{
Name = vehicleModelDto.Name,
NumberOfSeats = vehicleModelDto.NumberOfSeats,
VehicleMakeId = vehicleModelDto.VehicleMakeId
});
await _unitOfWork.SaveChangesAsync();
}
public async Task <IActionResult> Edit(VehicleModelDTO vehicleModelDTO)
{
VehicleModel model = Mapper.Map <VehicleModel>(vehicleModelDTO);
await ModelService.UpdateAsync(model);
return(RedirectToAction(nameof(Index)));
}
public override async Task <PackageDTO> GetAsync(int id)
{
PackageDTO dto = await base.GetAsync(id);
if (dto != null)
{
IEnumerable <PackageTravelUnit> travelUnitEntity = await this.UnitOfWork.PackageTravelUnitRepository.GetAsyncByEntity(dto.Id);
IEnumerable <VehicleAssembly> assemblyEntity = await this.UnitOfWork.PackageVehicleAssemblyRepository.GetAsyncByEntity(dto.Id);
IEnumerable <VehicleBodyType> bodytypeEntity = await this.UnitOfWork.PackageVehicleBodyTypeRepository.GetAsyncByEntity(dto.Id);
IEnumerable <VehicleFeature> featureEntity = await this.UnitOfWork.PackageVehicleFeatureRepository.GetAsyncByEntity(dto.Id);
IEnumerable <VehicleModel> modelEntity = await this.UnitOfWork.PackageVehicleModelRepository.GetAsyncByEntity(dto.Id);
IEnumerable <VehicleTransmission> transmissionEntity = await this.UnitOfWork.PackageVehicleTransmissionRepository.GetAsyncByEntity(dto.Id);
dto.TravelUnit = PackageTravelUnitDTO.ConvertEntityListToDTOList <PackageTravelUnitDTO>(travelUnitEntity);
dto.VehicleAssembly = VehicleAssemblyDTO.ConvertEntityListToDTOList <VehicleAssemblyDTO>(assemblyEntity);
dto.VehicleBodyType = VehicleBodyTypeDTO.ConvertEntityListToDTOList <VehicleBodyTypeDTO>(bodytypeEntity);
dto.VehicleFeature = VehicleFeatureDTO.ConvertEntityListToDTOList <VehicleFeatureDTO>(featureEntity);
dto.VehicleModel = VehicleModelDTO.ConvertEntityListToDTOList <VehicleModelDTO>(modelEntity);
dto.VehicleTransmission = VehicleTransmissionDTO.ConvertEntityListToDTOList <VehicleTransmissionDTO>(transmissionEntity);
}
return(dto);
}
public async Task <IServiceResponse <bool> > UpdateVehicleMake(int id, VehicleModelDTO vehicleModel)
{
return(await HandleApiOperationAsync(async() => {
await _vehicleModelService.UpdateVehicleModel(id, vehicleModel);
return new ServiceResponse <bool>(true);
}));
}
public async Task <IServiceResponse <bool> > AddVehicleModel(VehicleModelDTO vehicleModel)
{
return(await HandleApiOperationAsync(async() => {
await _vehicleModelService.AddVehicleModel(vehicleModel);
return new ServiceResponse <bool>(true);
}));
}
public async Task <ActionResult> Create()
{
var modelDTO = new VehicleModelDTO();
ViewBag.MakeDropdown = await GetMakeDropDownAsync();
SetMessage();
return(View(modelDTO));
}
public async Task <IActionResult> Create([Bind("Id,MakeId,Name,Abrv")] VehicleModelDTO vehicleModel)
{
if (ModelState.IsValid)
{
var dto = _mapper.Map <VehicleModel>(vehicleModel);
await _model.CreateAsync(dto);
return(RedirectToAction(nameof(Index)));
}
return(View(vehicleModel));
}
public async Task <IActionResult> Create(VehicleModelDTO vehicleModelDTO)
{
if (ModelState.IsValid)
{
var vehicleModel = Mapper.Map <VehicleModel>(vehicleModelDTO);
await ModelService.AddVehicleModelAsync(vehicleModel);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View());
}
}
public async Task UpdateVehicleModel(int id, VehicleModelDTO vehicleModel)
{
var model = await _vehicleModelRepo.GetAsync(id);
if (model == null)
{
throw await _serviceHelper.GetExceptionAsync(ErrorConstants.VEHICLE_MODEL_NOT_EXIST);
}
model.Name = vehicleModel.Name;
model.NumberOfSeats = vehicleModel.NumberOfSeats;
model.VehicleMakeId = vehicleModel.VehicleMakeId;
await _unitOfWork.SaveChangesAsync();
}
private async Task saveDetails(PackageDTO dtoObject, PackageDTO result)
{
Package entity = result.ConvertToEntity();
await this.UnitOfWork.PackageTravelUnitRepository.Create(PackageTravelUnitDTO.ConvertDTOListToEntity(dtoObject.TravelUnit), entity);
await this.UnitOfWork.PackageVehicleAssemblyRepository.Create(VehicleAssemblyDTO.ConvertDTOListToEntity(dtoObject.VehicleAssembly), entity);
await this.UnitOfWork.PackageVehicleBodyTypeRepository.Create(VehicleBodyTypeDTO.ConvertDTOListToEntity(dtoObject.VehicleBodyType), entity);
await this.UnitOfWork.PackageVehicleFeatureRepository.Create(VehicleFeatureDTO.ConvertDTOListToEntity(dtoObject.VehicleFeature), entity);
await this.UnitOfWork.PackageVehicleModelRepository.Create(VehicleModelDTO.ConvertDTOListToEntity(dtoObject.VehicleModel), entity);
await this.UnitOfWork.PackageVehicleTransmissionRepository.Create(VehicleTransmissionDTO.ConvertDTOListToEntity(dtoObject.VehicleTransmission), entity);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,MakeId,Name,Abrv")] VehicleModelDTO vehicleModel)
{
var dto = _mapper.Map <VehicleModel>(vehicleModel);
if (id != dto.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _model.UpdateAsync(dto);
return(RedirectToAction(nameof(Index)));
}
return(View(dto));
}
public async Task <ActionResult> Create([Bind(Include = "Name, Abrv, VehicleMakeId")] VehicleModelDTO model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var newModel = _modelService.VehicleModel;
Mapper.Map(model, newModel);
try
{
await _modelService.AddAsync(newModel);
TempData["Message"] = $"Model: {model.Name} successfully added to the database.";
}
catch (Exception e)
{
TempData["Message"] = $"Something went wrong: {e.Message}";
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(int id)
{
VehicleModelDTO modelDTO = Mapper.Map <VehicleModelDTO>(await ModelService.GetOneVehicleModelAsync(id));
return(View(modelDTO));
}
