private void MapToOwner(Owner o, OwnerViewModel model)
{
o.FirstName = model.FirstName;
o.LastName = model.LastName;
o.Email = model.Email;
o.CellphoneNumber = model.CellphoneNumber;
}
public IActionResult Owners()
{
var model = new CarListViewModel();
model.Owners = new List <OwnerViewModel>();
var allOwners = _entityContext.Owner.ToList();
model.Cars = new List <CarDetailViewModel>();
var allcars = _entityContext.Car.Include(x => x.Owner).Include(x => x.Cartype).OrderBy(x => x.Id).ToList();
foreach (var owner in allOwners)
{
var vm = new OwnerViewModel
{
FullName = owner.FullName
};
model.Owners.Add(vm);
}
foreach (var car in allcars)
{
var vm = new CarDetailViewModel
{
Id = car.Id,
Color = car.Color,
Buydate = car.Buydate,
Plate = car.Plate,
Owner = car.Owner.FullName,
Cartype = car.Cartype.FullType
};
model.Cars.Add(vm);
}
return(View(model));
}
public async Task <ActionResult <OwnerViewModel> > Post(OwnerViewModel createOwner)
{
OwnerModel owner = _mapper.MapObjectTo <OwnerModel>(createOwner);
bool isCreated = await _ownerService.CreateOwnerAsync(owner);
return(isCreated ? Created(Url.Action(nameof(GetOwnerById), new { id = owner.Id }), _mapper.MapObjectTo <OwnerViewModel>(owner)) as ActionResult : BadRequest() as ActionResult);
}
public ActionResult CreateOwner()
{
Owner o = new Owner();
OwnerViewModel ovm = new OwnerViewModel(o);
return(View(ovm));
}
public IActionResult Delete(int id, bool?saveChangesError = false)
{
var owner = _ownerService.GetById(id);
if (owner == null)
{
return(NotFound());
}
if (saveChangesError.GetValueOrDefault())
{
ViewData["ErrorMessage"] =
"Delete failed. Possible due to Owner still linked to house. If persists, call your system administrator.";
}
var deleteVM = new OwnerViewModel
{
OwnerId = owner.OwnerId,
EmailAddress = owner.EmailAddress,
PhoneNumber = owner.PhoneNumber,
PropertiesOwned = owner.PropertiesOwned,
FullName = owner.FullName
};
return(View(deleteVM));
}
public OwnerViewModel GetOwnerViewModelByCat(List <OwnerModel> ownerList)
{
OwnerViewModel ownerViewModel = new OwnerViewModel();
try
{
if (ownerList != null)
{
ownerViewModel.MaleOwnerCatList = ownerList.Where(x => x.Gender.ToLower() == Constants.GENDERMALE && x.Pets != null)
.SelectMany(y => y.Pets)
.Where(c => c.Type.ToLower() == Constants.PETTYPE).ToList();
ownerViewModel.FemaleOwnerCatList = ownerList.Where(x => x.Gender.ToLower() == Constants.GENDERFEMALE && x.Pets != null)
.SelectMany(y => y.Pets)
.Where(c => c.Type.ToLower() == Constants.PETTYPE).ToList();
ownerViewModel.MaleOwnerCatList = ownerViewModel.MaleOwnerCatList.OrderBy(x => x.Name).ToList();
ownerViewModel.FemaleOwnerCatList = ownerViewModel.FemaleOwnerCatList.OrderBy(x => x.Name).ToList();
}
}
catch (Exception ex)
{
_logger.LogError("Error in GetOwnerViewModelByCat " + ex.Message);
throw ex;
}
return(ownerViewModel);
}
public IActionResult Owners(int?currentParameterID, int page = 1)
{
int pageSize = 10; // количество элементов на странице
int currOwnerID = currentParameterID ?? 0;
_db.Owners.Select(c => new Owner());
List <OwnerBirthDateFilter> ownerBirthDates = _db.Owners.Select(b => new OwnerBirthDateFilter {
OwnerBirthDate = b.OwnerBirthDate, Id = b.OwnerID
}).ToList();
ownerBirthDates.Insert(0, new OwnerBirthDateFilter {
OwnerBirthDate = DateTime.Now, Id = 0
});
var owners = _db.Owners.OrderBy(s => s.OwnerID).ToList();
OwnerBirthDateFilter obdf = ownerBirthDates.Where(c => c.Id == currOwnerID).ToList()[0];
if (currOwnerID > 0)
{
owners = owners.Where(c => c.OwnerBirthDate == obdf.OwnerBirthDate).ToList();
}
PageViewModel pageViewModel = new PageViewModel(owners.Count, page, pageSize, currOwnerID);
OwnerViewModel ownerViewModel = new OwnerViewModel {
PageViewModel = pageViewModel, Owners = owners.Skip((page - 1) * pageSize).Take(pageSize).ToList(), OwnerBirthDates = ownerBirthDates, CurrentOwnerBirthDate = obdf
};
return(View(ownerViewModel));
}
public JsonResult NewEditOwner(OwnerViewModel model)
{
BAL objBal = new BAL();
string status = objBal.EditOwner(model);
return(Json(status, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Post([FromBody] OwnerViewModel ownerVievModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var owner = new Owner
{
Name = ownerVievModel.Name,
Address = new OwnerAddress
{
Address = ownerVievModel.OwnerAddress,
Country = ownerVievModel.Country,
State = ownerVievModel.State,
City = ownerVievModel.City,
Email = ownerVievModel.Email,
Phone1 = ownerVievModel.Phone1,
Phone2 = ownerVievModel.Phone2,
}
};
_context.Owners.Add(owner);
await _context.SaveChangesAsync();
return(Ok(owner));
}
public void FindCarsByOwner()
{
// Arrange
OwnerViewModel ow = new OwnerViewModel()
{
Name = "Дмитро", LastName = "Квадратний", MidName = "Олександрович"
};
CarViewModel[] cars = new CarViewModel[]
{
new CarViewModel {
Number = "AA8586MO", Brand = "Volkswagen", Model = "Polo", Color = "red", Year = "2015"
},
new CarViewModel {
Number = "AA6554OP", Brand = "Volkswagen", Model = "Passat", Color = "white", Year = "2016"
},
new CarViewModel {
Number = "AA0001KP", Brand = "Volkswagen", Model = "Raptor", Color = "black", Year = "2018"
}
};
string expected = "";
for (int i = 0; i < cars.Length; i++)
{
expected += JsonConvert.SerializeObject(cars);
}
expected = JsonConvert.SerializeObject(cars);
// Act
string actual = JsonConvert.SerializeObject(controller.GetOwnerCars(ow).Result);
// Assertч
Assert.Contains(expected, actual);
}
public IActionResult Create(OwnerViewModel model)
{
if (ModelState.IsValid)
{
if (model.File != null)
{
string uploads = Path.Combine(_hosting.WebRootPath, @"img\portfolio");
string fullpath = Path.Combine(uploads, model.File.FileName);
model.File.CopyTo(new FileStream(fullpath, FileMode.Create));
Owner owner = new Owner
{
FullName = model.FullName,
Profil = model.Profil,
Avatar = model.File.FileName
};
_owner.Entity.Insert(owner);
_owner.Save();
}
else
{
Owner owner = new Owner
{
FullName = model.FullName,
Profil = model.Profil,
Avatar = "Avatar.jpg"
};
_owner.Entity.Insert(owner);
_owner.Save();
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public IEnumerable <OwnerViewModel> GetAllOwnerViewModels()
{
var owners = new List <OwnerViewModel>();
foreach (var owner in _repository.GetAllOwners())
{
var ownerCars = new List <CarViewModel>();
foreach (var car in GetAllCarViewModels())
{
if (car.OwnerLabel.Equals(owner.FirstName + " " + owner.Name))
{
ownerCars.Add(car);
}
}
var ownerView = new OwnerViewModel()
{
Id = owner.Id,
FirstName = owner.FirstName,
Name = owner.Name,
Cars = ownerCars
};
owners.Add(ownerView);
}
return(owners);
}
public void Post([FromBody] OwnerViewModel owner)
{
Mapper.Initialize(cfg => cfg.CreateMap <OwnerViewModel, OwnerDto>());
var ownersDto = Mapper.Map <OwnerViewModel, OwnerDto>(owner);
ownerService.AddOwner(ownersDto);
}
public ActionResult EditOwner(int id)
{
var ownerModel = new OwnerViewModel();
ownerModel.Owner = _ownerService.GetOwnerDto(id);
ViewBag.ListCar = _carService.GetCarsDtoList();
return(View(MethodName.AddOrUpdateOwner, ownerModel));
}
public ActionResult Edit(OwnerViewModel ownerViewModel)
{
var model = mapperService.Map <OwnerViewModel, OwnerDTO>(ownerViewModel);
dbService.Update(model);
//db.Entry(owner).State = EntityState.Modified;
//db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult List()
{
OwnerViewModel ownerViewModel = new OwnerViewModel();
var UserID = SessionManager.GetSessionUser().Id;
ownerViewModel.OwnerDetailsList = GBContext.OwnerDetails.ToList();
ownerViewModel.OwnerDetailsList = ownerViewModel.OwnerDetailsList.OrderByDescending(x => x.CreatedOn).ToList();
return(View(ownerViewModel));
}
public async Task<bool> RegisterOwner(OwnerViewModel ownerViewModel)
{
var owner = _mapper.Map<Owner>(ownerViewModel);
if (owner.Invalid)
{
_notifiable.AddNotification(new Notification("Register failed - Invalid Fields"));
return false;
}
return await _ownerService.RegisterOwner(owner);
}
public OwnersController()
{
logic = new MainLogic();
mapper = MapperFactory.CreateMapper();
vm = new OwnerViewModel();
vm.EditedOwner = new Owner();
var owners = logic.ReadAllOwners();
vm.OwnersList = mapper.Map <IEnumerable <MyLogiscool.Data.Owners>, List <Models.Owner> >(owners);
}
public async Task <IActionResult> Delete(int id)
{
var viewModel = new OwnerViewModel {
Owner = await _service.Get <Owner>(o => o.ID == id).FirstAsync()
};
viewModel.Equipment = await _service.Get <Equipment>(e => e.OwnerName == viewModel.Owner.FullName).ToListAsync();
return(View(viewModel));
}
public IActionResult Edit(Guid id, OwnerViewModel model)
{
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
if (model.File != null)
{
string uploads = Path.Combine(_hosting.WebRootPath, @"img");
string fullpath = Path.Combine(uploads, model.File.FileName);
model.File.CopyTo(new FileStream(fullpath, FileMode.Create));
Owner owner = new Owner
{
Id = model.Id,
FullName = model.FullName,
Profil = model.Profil,
Avatar = model.File.FileName
};
_owner.Entity.Update(owner);
_owner.Save();
}
else
{
Owner owner = new Owner
{
Id = model.Id,
FullName = model.FullName,
Profil = model.Profil,
Avatar = model.Avatar
};
_owner.Entity.Update(owner);
_owner.Save();
}
}
catch (DbUpdateConcurrencyException)
{
if (!OwnerExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <IActionResult> Post([FromBody] OwnerViewModel ownerViewModel)
{
var result = await _registerOwnerUseCase.RegisterOwner(ownerViewModel);
if (result)
{
return(CustomResponse(ownerViewModel));
}
return(CustomResponse());
}
public void Check_Whether_GetOwnerViewModelByCat_Returning_Correct_Value()
{
List <OwnerModel> ownerList = PrepareData();
Mock <ILogger <PetHelper> > mockLoggerService = new Mock <ILogger <PetHelper> >();
PetHelper helper = new PetHelper(mockLoggerService.Object);
OwnerViewModel ownerViewModel = helper.GetOwnerViewModelByCat(ownerList);
Assert.NotNull(ownerViewModel);
Assert.Equal(3, ownerViewModel.FemaleOwnerCatList.Count);
Assert.Equal(2, ownerViewModel.MaleOwnerCatList.Count);
}
public void Check_Whether_GetOwnerViewModelByCat_Returns_empty_viewModel()
{
List <OwnerModel> ownerList = null;
Mock <ILogger <PetHelper> > mockLoggerService = new Mock <ILogger <PetHelper> >();
PetHelper helper = new PetHelper(mockLoggerService.Object);
OwnerViewModel ownerViewModel = helper.GetOwnerViewModelByCat(ownerList);
Assert.NotNull(ownerViewModel);
Assert.Null(ownerViewModel.MaleOwnerCatList);
Assert.Null(ownerViewModel.FemaleOwnerCatList);
}
public async Task <ActionResult <OwnerModel> > UpdateOwnerAsync(long id, OwnerViewModel updateOwner)
{
OwnerModel owner = _mapper.MapObjectTo <OwnerModel>(updateOwner);
bool isSaved = await _ownerService.UpdateOwnerAsync(id, owner);
if (!isSaved)
{
return(NotFound());
}
return(Ok(isSaved));
}
public PanelController(ApplicationDbContext db, HostingEnvironment hostingEnvironment)
{
_db = db;
_hostingEnvironment = hostingEnvironment;
OwnerVM = new OwnerViewModel()
{
Owner = new Owner(),
Lots = _db.Lots.ToList()
};
}
public IActionResult Edit(int id)
{
IEnumerable <OwnerDTO> ownerDTO = ownerService.GetOwners();
OwnerViewModel ownerViewModel = Mapper.Map <IEnumerable <OwnerDTO>, IEnumerable <OwnerViewModel> >(ownerDTO).SingleOrDefault(c => c.Id == id);
if (ownerViewModel == null)
{
return(NotFound());
}
return(View(ownerViewModel));
}
public ActionResult Index(int?page)
{
int currentpage = (int)(page.HasValue ? page - 1 : 0);
OwnerViewModel owner = new OwnerViewModel();
owner.Owners = _deviceBaseService.OwnerRepository.GetOwners().ToPagedList(currentpage, 20);
if (owner.Owners == null)
{
return(HttpNotFound());
}
return(View("Index", owner));
}
public ActionResult GetOneProduct(int id)
{
OwnerViewModel data = null;
data = Service.GetOne(id);
var newListToJson = new List <OwnerViewModel> {
data
};
return(Json(SerializeJson(newListToJson), JsonRequestBehavior.AllowGet));
}
public ActionResult EditOwner(int id)
{
Owner o = ownerRepo.FindById(id);
if (o == null)
{
return(HttpNotFound());
}
OwnerViewModel ovm = new OwnerViewModel(o);
return(View(ovm));
}
public ActionResult EditOwner(OwnerViewModel ownerModel, int[] selectedCar)
{
OwnerDTO owner = ownerModel.Owner;
if (ModelState.IsValid)
{
_ownerService.AddOrUpdateOwnerDto(owner, selectedCar);
return(RedirectToAction(MethodName.OwnersList));
}
ViewBag.ListCar = _carService.GetCarsDtoList();
return(View(MethodName.AddOrUpdateOwner, ownerModel));
}
