public async Task <IActionResult> Delete(int id, int page)
{
CarModel carModel = await db.CarModels.FindAsync(id);
if (carModel == null)
{
return(NotFound());
}
bool deleteFlag = false;
string message = "Do you want to delete this entity";
if (db.Cars.Any(s => s.CarModelId == carModel.CarModelId))
{
message = "This entity has entities, which dependents from this. Do you want to delete this entity and other, which dependents from this?";
}
CarModelViewModel model = new CarModelViewModel();
model.Entity = carModel;
model.PageViewModel = new PageViewModel {
CurrentPage = page
};
model.DeleteViewModel = new DeleteViewModel {
Message = message, IsDeleted = deleteFlag
};
return(View(model));
}
public async Task <Result> SaveAsync(CarModelViewModel model)
{
try
{
var dto = _mapper.Map <CarModel>(model);
var result = model.Id == Guid.Empty ? await _service.CreateAsync(dto) : await _service.EditAsync(dto);
if (result.IsSucceed)
{
await _unitOfWork.CommitAsync();
return(Succeed());
}
return(Failure(result.Exception));
}
catch (ApplicationException ex)
{
ex.HandleException();
return(Result.Failure(ex));
}
catch (Exception ex)
{
ex.HandleException();
return(Result.Failure(ExceptionMessages.FatalError));
}
}
public void Edit(CarModelViewModel carModelView)
{
CarModel a = db.CarModels.Find(carModelView.ID);
a.Title = carModelView.Title;
db.SaveChanges();
}
public IActionResult Index(SortState sortState = SortState.CarModelsNameAsc, int page = 1)
{
CarModelsFilterViewModel filter = HttpContext.Session.Get <CarModelsFilterViewModel>(filterKey);
if (filter == null)
{
filter = new CarModelsFilterViewModel {
CarModelName = string.Empty, CarModelDescription = string.Empty, CarMarkName = string.Empty
};
HttpContext.Session.Set(filterKey, filter);
}
string modelKey = $"{typeof(CarModel).Name}-{page}-{sortState}-{filter.CarModelName}-{filter.CarModelDescription}";
if (!cache.TryGetValue(modelKey, out CarModelViewModel model))
{
model = new CarModelViewModel();
IQueryable <CarModel> carModels = GetSortedEntities(sortState, filter.CarModelName, filter.CarModelDescription);
int count = carModels.Count();
int pageSize = 10;
model.PageViewModel = new PageViewModel(page, count, pageSize);
model.Entities = count == 0 ? new List <CarModel>() : carModels.Skip((model.PageViewModel.CurrentPage - 1) * pageSize).Take(pageSize).ToList();
model.SortViewModel = new SortViewModel(sortState);
model.CarModelsFilterViewModel = filter;
cache.Set(modelKey, model);
}
return(View(model));
}
private async void btnSave_Click(object sender, EventArgs e)
{
try
{
if (txtName.IsNotNullOrEmpty())
{
MessageBoxUtil.MessageError(this, AlertMessages.MISSING_DATA);
errorIcon.SetError(txtName, AlertMessages.ENTER_A_NAME);
}
else
{
if (isNew)
{
await carModelService.AddAsync(
new CarModel
{
Name = txtName.Text,
Description = txtDescription.Text,
CreatedDate = DateTime.Now,
CarBrandId = (int)cbCarBrand.SelectedValue,
CreatedBy = Program.CurrentUser.UserName
});
MessageBoxUtil.MessageOk(this, AlertMessages.INSERTED_SUCCESSFULLY);
}
else
{
var entity = await carModelService.GetByIdAsync(int.Parse(txtIdCarModel.Text));
var Model = new CarModelViewModel
{
Id = int.Parse(txtIdCarModel.Text),
Name = txtName.Text,
Description = txtDescription.Text,
CarBrandId = entity.CarBrandId,
CreatedDate = entity.CreatedDate,
ModifiedDate = DateTime.Now,
CreatedBy = Program.CurrentUser.UserName
};
entity = mapper.Map(Model, entity);
await carModelService.UpdateAsync(entity);
MessageBoxUtil.MessageOk(this, AlertMessages.UPDATED_SUCCESSFULLY);
}
this.isNew = false;
this.isEdit = false;
this.EnableBottons();
this.ClearTextBox();
this.LoadCarModels();
}
}
catch (Exception ex)
{
MessageBoxUtil.MessageError(this, ex.Message);
}
}
public ActionResult Create(CarModelViewModel model)
{
if (ModelState.IsValid)
{
_carModelManager.Add(_carModelFieldCopier.CopyFields(model, new CarModel()));
return(RedirectToAction("List"));
}
return(View(model));
}
public IActionResult ChooseCar()
{
var viewModel = new CarModelViewModel
{
CarsModels = this.carReservationService.GetAll <CarPropertiesViewModel>(),
};
return(this.View(viewModel));
}
public static CarModel Map(CarModelViewModel model)
{
return(new CarModel
{
CarBrandId = model.CarBrandId,
CarTypeId = model.CarTypeId,
Name = model.Name
});
}
CarModelViewModel ICarModelService.Create(CarModelViewModel carModel)
{
var entity = EntityMapper.Map(carModel);
CatalogUow.CarModels.InsertOrUpdate(entity);
CatalogUow.Commit();
var updated = ((ICarModelService)(this)).GetById(entity.Id);
return(EntityMapper.Map(updated));
}
public void Create(CarModelViewModel car)
{
var item = new CarModel
{
Title = car.Title,
CarManufacturerID = car.CarManufacturerID
};
db.CarModels.Add(item);
db.SaveChanges();
}
public ActionResult Edit(int ID, CarModelViewModel carModelViewModel)
{
var Model = repository.CheckDuplicate(carModelViewModel.Title);
if (Model)
{
ViewBag.ErrorMessage = "عنوان وارد شده تکراریست";
return(View());
}
repository.Edit(carModelViewModel);
return(RedirectToAction(nameof(Index)));
}
public async Task <object> Get(string idString)
{
try
{
var model = await _context.CarProducents
.Where(x => x.IdString == idString.ToLower())
.Where(x => x.Deleted == false)
.Include(x => x.CarModels)
.FirstOrDefaultAsync();
if (model == null)
{
return new
{
Succeeded = false
}
}
;
var carModelVMs = new List <CarModelViewModel>();
if (model.CarModels != null)
{
foreach (var item in model.CarModels)
{
if (item.Deleted == true)
{
continue;
}
var carVM = new CarModelViewModel()
{
IdString = item.IdString,
ModelName = item.ModelName
};
carModelVMs.Add(carVM);
}
}
return(new
{
Succeeded = true,
model.IdString,
model.ProducentName,
ModelList = carModelVMs
});
}
catch
{
return(new
{
Succeeded = false
});
}
}
public IActionResult Create(int page)
{
CarModelViewModel model = new CarModelViewModel
{
PageViewModel = new PageViewModel {
CurrentPage = page
}
};
model.SelectList = db.CarMarks.ToList();
return(View(model));
}
public CarModel CopyFields(CarModelViewModel from, CarModel to)
{
if (to == null)
{
throw new NullReferenceException();
}
if (from == null)
{
throw new NullReferenceException();
}
to.Name = from.Name;
to.ManufacturerId = from.ManufacturerId;
return(to);
}
public async Task <object> Save(CarModelViewModel model)
{
try
{
var producer = await _context.CarProducents
.Where(x => x.IdString == model.IdProducer.ToLower())
.Include(x => x.CarModels)
.FirstOrDefaultAsync();
string idString = new string(model.ModelName.Select(x => char.IsLetterOrDigit(x) ? x : '-').ToArray()).ToLower();
if (producer.CarModels.Where(x => x.IdString == idString).Where(x => x.Deleted == false).FirstOrDefault() != null)
{
return new
{
Succeeded = false,
Errors = new[]
{
new
{
Code = "BusyName"
}
}
}
}
;
CarModel carModel = new CarModel()
{
Id = Guid.NewGuid(),
ModelName = model.ModelName,
IdString = idString,
CarProducent = producer
};
await _context.CarModels.AddAsync(carModel);
await _context.SaveChangesAsync();
return(new
{
Succeeded = true
});
}
catch (Exception ex)
{
return(new
{
Succeeded = false
});
}
}
public async Task <IActionResult> Save(CarModelViewModel model)
{
if (!ModelState.IsValid)
{
return(ValidationProblem());
}
var result = await _facade.SaveAsync(model);
if (result.IsSucceed)
{
return(RedirectToAction(nameof(Index)));
}
return(AjaxFailureResult(result));
}
public ActionResult Edit(CarModelViewModel model)
{
if (ModelState.IsValid)
{
var dbItem = _carModelManager.GetById(model.Id);
if (dbItem == null)
{
throw new NullReferenceException();
}
dbItem = _carModelFieldCopier.CopyFields(model, dbItem);
_carModelManager.Edit(dbItem);
return(RedirectToAction("List"));
}
return(View(model));
}
public async Task <ActionResult <CarModelViewModel> > GetCarModel(int id)
{
var carModel = await _context.CarModels.Include(x => x.Brand).FirstOrDefaultAsync(x => x.Id == id);
if (carModel == null)
{
return(NotFound());
}
var result = new CarModelViewModel
{
Id = carModel.Id,
Name = carModel.Name,
BrandName = carModel.Brand.Name
};
return(result);
}
public async Task <IActionResult> Details(int id, int page)
{
CarModel carModel = await db.CarModels.Include(s => s.CarMark).FirstOrDefaultAsync(s => s.CarModelId == id);
if (carModel == null)
{
return(NotFound());
}
CarModelViewModel model = new CarModelViewModel();
model.Entity = carModel;
model.PageViewModel = new PageViewModel {
CurrentPage = page
};
return(View(model));
}
public async Task <IActionResult> Add(Guid?id)
{
var model = new CarModelViewModel();
if (id.HasValue)
{
var result = await _facade.GetModel(id.Value);
if (result.IsSucceed)
{
model = result.Data;
}
else
{
return(AjaxFailureResult(result));
}
}
return(PartialView("_Form", model));
}
public async Task <IActionResult> Delete(CarModelViewModel model)
{
CarModel carModel = await db.CarModels.FindAsync(model.Entity.CarModelId);
if (carModel == null)
{
return(NotFound());
}
db.CarModels.Remove(carModel);
await db.SaveChangesAsync();
cache.Clean();
model.DeleteViewModel = new DeleteViewModel {
Message = "The entity was successfully deleted.", IsDeleted = true
};
return(View(model));
}
public async Task <IActionResult> Edit(int id, int page)
{
CarModel carModel = await db.CarModels.FindAsync(id);
if (carModel != null)
{
CarModelViewModel model = new CarModelViewModel();
model.PageViewModel = new PageViewModel {
CurrentPage = page
};
model.Entity = carModel;
model.SelectList = db.CarMarks.ToList();
model.CarMarkName = model.Entity.CarMark.Name;
return(View(model));
}
return(NotFound());
}
public static void UpdateModelFromViewModel(Model model, CarModelViewModel vm)
{
model.Description = vm.ModelDescription;
model.Name = vm.ModelName;
model.Price = vm.Price;
if (!String.IsNullOrEmpty(vm.ImagePath)) // new image selected
{
using (MemoryStream stream = new MemoryStream())
{
Image img = Image.FromFile(vm.ImagePath);
byte[] newImageBytes;
img.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
newImageBytes = stream.ToArray();
if (newImageBytes.Length > 0)
{
model.Picture = newImageBytes;
}
}
}
}
public IActionResult AddModel(CarModelViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
if (model.Id == 0)
{
var carModel = new Model
{
BrandId = model.BrandId,
Name = model.Name
};
_modelApiCall.PostApiCall(carModel);
TempData["SuccessResultF"] = true;
TempData["SuccessResultM"] = "Model added successfully";
}
else
{
var carModel = _modelApiCall.GetT(model.Id);
carModel.BrandId = model.BrandId;
carModel.Name = model.Name;
_modelApiCall.PutApiCall(carModel, model.Id);
TempData["SuccessResultF"] = true;
TempData["SuccessResultM"] = "Model edited successfully";
}
}
catch (Exception)
{
TempData["SuccessResultF"] = false;
TempData["SuccessResultM"] = "Something went wrong.";
throw;
}
return(RedirectToAction("Models", new { brandId = model.BrandId }));
}
public ActionResult Create(CarModelViewModel car)
{
var Model = repository.CheckDuplicate(car.Title);
if (Model)
{
var list = manufactureRepository.GetList()
.Select(x => new SelectListItem
{
Text = x.Title,
Value = x.ID.ToString()
}).ToList();
list.Insert(0, new SelectListItem {
Value = "", Text = "انتخاب نمایید"
});
ViewBag.ManufactureList = list;
ViewBag.ErrorMessage = "عنوان وارد شده تکراریست";
return(View());
}
repository.Create(car);
return(RedirectToAction("Index"));
}
// GET: Cars
public async Task <IActionResult> Index(string carModel, string searchYear, string searchPrice, string searchSeats)
{
// Use LINQ to get list of genres.
IQueryable <string> genreQuery = from m in _context.Car
orderby m.Model
select m.Model;
var cars = from m in _context.Car
select m;
if (!string.IsNullOrEmpty(searchYear))
{
cars = cars.Where(s => s.Year.Equals(int.Parse(searchYear)));
}
if (!string.IsNullOrEmpty(searchPrice))
{
cars = cars.Where(s => s.DailyPrice.Equals(int.Parse(searchPrice)));
}
if (!string.IsNullOrEmpty(searchSeats))
{
cars = cars.Where(s => s.NumSeats.Equals(int.Parse(searchSeats)));
}
if (!string.IsNullOrEmpty(carModel))
{
cars = cars.Where(x => x.Model == carModel);
}
cars = cars.Where(x => x.Quantity > 0);
var carModelVM = new CarModelViewModel
{
Models = new SelectList(await genreQuery.Distinct().ToListAsync()),
Cars = await cars.ToListAsync()
};
return(View(carModelVM));
}
public IActionResult AddModel(int id, int brandId)
{
var carModel = new CarModelViewModel();
if (id != 0)
{
try
{
var model = _modelApiCall.GetT(id);
carModel.BrandId = model.BrandId;
carModel.Name = model.Name;
}
catch (Exception)
{
throw;
}
}
else
{
carModel.BrandId = brandId;
}
return(View(carModel));
}
public async Task <IActionResult> Create(CarModelViewModel model)
{
model.SelectList = db.CarMarks.ToList();
var carMark = db.CarMarks.FirstOrDefault(g => g.Name == model.CarMarkName);
if (carMark == null)
{
ModelState.AddModelError(string.Empty, "Please select carMark from list.");
return(View(model));
}
if (ModelState.IsValid & CheckUniqueValues(model.Entity))
{
model.Entity.CarMarkId = carMark.CarMarkId;
await db.CarModels.AddAsync(model.Entity);
await db.SaveChangesAsync();
cache.Clean();
return(RedirectToAction("Index", "CarModels"));
}
return(View(model));
}
public async Task <IActionResult> Edit(CarModelViewModel model)
{
model.SelectList = db.CarMarks.ToList();
var carMark = db.CarMarks.FirstOrDefault(g => g.Name == model.CarMarkName);
if (carMark == null)
{
ModelState.AddModelError(string.Empty, "Please select genre from list.");
return(View(model));
}
if (ModelState.IsValid & CheckUniqueValues(model.Entity))
{
CarModel carModel = await db.CarModels.FindAsync(model.Entity.CarModelId);
if (carModel != null)
{
carModel.Name = model.Entity.Name;
carModel.Description = model.Entity.Description;
carModel.CarMarkId = model.Entity.CarMarkId;
db.CarModels.Update(carModel);
await db.SaveChangesAsync();
cache.Clean();
return(RedirectToAction("Index", "CarModels", new { page = model.PageViewModel.CurrentPage }));
}
else
{
return(NotFound());
}
}
return(View(model));
}
public IActionResult Create([FromBody] CarModelViewModel model)
{
var carModel = carModelService.Create(model);
return(Json(carModel));
}
