public ResidentPage(Resident resident)
{
InitializeComponent();
ResidentViewModel viewModel = new ResidentViewModel(resident);
DataContext = viewModel;
}
public async Task Delete_DeleteResident_DeleteResidentAndReturnsOKResult()
{
// Arrange
var fakeResident = new Resident
{
Name = "John Cena",
Email = "*****@*****.**",
Block = "B",
Apartment = "301",
Cpf = "3243141431"
};
_mockResidentRepository.Setup(repo => repo.GetAsync(It.IsAny <int>())).ReturnsAsync(fakeResident);;
var controller = new ResidentsController(_mockResidentRepository.Object,
_mockUoW.Object, _mapper);
// Act
var residentViewModel = new ResidentViewModel {
Name = "John Cena"
};
var deleteResidentResult = await controller.Delete(2);
// assert
Assert.IsInstanceOf <OkObjectResult>(deleteResidentResult);
var okResult = deleteResidentResult as OkObjectResult;
Assert.IsInstanceOf <ResidentViewModel>(okResult.Value);
Assert.AreEqual(true, fakeResident.Deleted);
}
public static ResidentViewModel ToResidentViewModel(this Resident resident)
{
ResidentViewModel viewModel = new ResidentViewModel();
viewModel.ResidentID = resident.ID;
viewModel.Phone = resident.Phone;
viewModel.Address = resident.Address;
viewModel.MoveInDate = resident.MoveInDate;
viewModel.DateOfBirth = resident.DateOfBirth;
viewModel.EmergencyNotes = resident.EmergencyNotes;
viewModel.EmergencyContact = resident.EmergencyContact;
viewModel.HavePets = resident.HavePets;
viewModel.ResidentType = (ResidentType)Enum.Parse(typeof(ResidentType), resident.ResidentType, true);
viewModel.UnitID = resident.UnitID;
viewModel.UserID = resident.UserID;
if (resident.Unit != null)
{
viewModel.Unit = resident.Unit.ToUnitViewModel();
}
if (resident.User != null)
{
viewModel.User = resident.User.ToUserViewModel();
}
return(viewModel);
}
public static Resident ToResident(this ResidentViewModel residentViewModel)
{
Resident resident = new Resident();
resident.ID = residentViewModel.ResidentID;
resident.Phone = residentViewModel.Phone;
resident.Address = residentViewModel.Address;
resident.MoveInDate = residentViewModel.MoveInDate;
resident.DateOfBirth = residentViewModel.DateOfBirth;
resident.EmergencyNotes = residentViewModel.EmergencyNotes;
resident.EmergencyContact = residentViewModel.EmergencyContact;
resident.HavePets = residentViewModel.HavePets;
resident.ResidentType = residentViewModel.ResidentType.ToString();
resident.UnitID = residentViewModel.UnitID;
resident.UserID = residentViewModel.UserID;
//if (resident.Unit != null)
//{
// resident.Unit = residentViewModel.Unit.ToUnit();
//}
//if (resident.User != null)
//{
// resident.User = residentViewModel.User.ToUser();
//}
return(resident);
}
public ActionResult Details(int id)
{
Resident unit = _residentBusiness.GetResidentDetails(id);
ResidentViewModel unitViewModel = ResidentMapper.ToResidentViewModel(unit);
return(View(unitViewModel));
}
public ActionResult Delete(int id)
{
Resident resident = _residentBusiness.GetResidentDetails(id);
ResidentViewModel residentViewModel = ResidentMapper.ToResidentViewModel(resident);
return(View(residentViewModel));
}
public ActionResult Edit(int id, ResidentViewModel residentViewModel)
{
try
{
IEnumerable <User> userList = _userBusiness.GetAllUsers();
List <UserViewModel> userViewModelList = UserMapper.ToUserViewModelList(userList);
IEnumerable <Unit> unitList = _unitBusiness.GetAllUnits();
List <UnitViewModel> unitViewModelList = UnitMapper.ToUnitViewModelList(unitList);
residentViewModel.Users = new SelectList(userViewModelList, "UserID", "Email");
residentViewModel.Units = new SelectList(unitViewModelList, "UnitID", "Name");
if (ModelState.IsValid)
{
Resident resident = ResidentMapper.ToResident(residentViewModel);
Result <bool> result = _residentBusiness.UpdateResident(resident);
if (result.isSuccess)
{
return(RedirectToAction(nameof(Index)));
}
else
{
ModelState.AddModelError(string.Empty, result.errorMessage);
return(View(residentViewModel));
}
}
else
{
return(View(residentViewModel));
}
}
catch
{
return(RedirectToAction("AppError", "Error"));
}
}
public AddResidentDialog(int num_resident)
{
_residentViewModel = new ResidentViewModel(num_resident);
foreach (var color in typeof(Colors).GetRuntimeProperties())
{
ResidentColorCollection.Add((Color)color.GetValue(null));
}
this.InitializeComponent();
}
public ConfigResidentDialog(ResidentViewModel residentViewModel)
{
foreach (var color in typeof(Colors).GetRuntimeProperties())
{
ResidentColorCollection.Add((Color)color.GetValue(null));
}
this._residentViewModel = residentViewModel;
this.InitializeComponent();
}
public EditResidentDialog(ResidentViewModel residentViewModel, HashSet <string> existingResidentNames)
{
_viewModel = residentViewModel;
_existingResidentNames = existingResidentNames;
if (!ColorCollection.Contains(_viewModel.Color))
{
ColorCollection.Add(_viewModel.Color);
}
this.InitializeComponent();
}
public object Convert(object value, Type targetType, object parameter, string language)
{
string occupantId = value as string;
ResidentViewModel resident = residentItems.ToList().Find(x => x.name == occupantId);
if (resident != null)
{
return(new SolidColorBrush(resident.color));
}
return(new SolidColorBrush(Colors.Black));
}
public async Task <IActionResult> AddAsync(ResidentViewModel model)
{
ViewData["Title"] = "Add Resident Customer";
if (ModelState.IsValid)
{
var result = await repo.Insert(model);
return(Json(result));
}
return(PartialView("_Add", model));
}
public async Task <IActionResult> EditAsync(ResidentViewModel model)
{
ViewData["Title"] = "Edit Resident Customer";
if (ModelState.IsValid)
{
var result = await repo.Update(model);
return(Json(result));
}
return(PartialView("_Edit", model));
}
public ActionResult Create()
{
ResidentViewModel residentViewModel = new ResidentViewModel();
IEnumerable <User> userList = _userBusiness.GetAllUsers();
List <UserViewModel> userViewModelList = UserMapper.ToUserViewModelList(userList);
IEnumerable <Unit> unitList = _unitBusiness.GetAllUnits();
List <UnitViewModel> unitViewModelList = UnitMapper.ToUnitViewModelList(unitList);
residentViewModel.Users = new SelectList(userViewModelList, "UserID", "Email");
residentViewModel.Units = new SelectList(unitViewModelList, "UnitID", "Name");
return(View(residentViewModel));
}
private async void btnDeleteResident_Click(object sender, RoutedEventArgs e)
{
ResidentViewModel selectedResident = ResidentListView.SelectedItem as ResidentViewModel;
string message = "Do you want to remove resident " + selectedResident.name + "?";
var dlg = new MessageDialog(message, "Remove Resident");
dlg.Commands.Add(new UICommand("Yes", new UICommandInvokedHandler(this.DeleteResidentDialogHandler)));
dlg.Commands.Add(new UICommand("Cancel", new UICommandInvokedHandler(this.DeleteResidentDialogHandler)));
dlg.DefaultCommandIndex = 1;
dlg.CancelCommandIndex = 1;
await dlg.ShowAsync();
}
public void ConfirmResidentChange(int residentId, string residentName, string residentSurname, string residentPhone, string residentPESEL)
{
var newResident = new ResidentViewModel()
{
id_najemcy = residentId,
imie = residentName,
nazwisko = residentSurname,
nr_telefonu = residentPhone,
PESEL = residentPESEL
};
var preparedResident = ViewModelMapper.Mapper.Map <ResidentModel>(newResident);
residentsService.AddOrEditResident(preparedResident);
}
public ActionResult Edit(int id)
{
Resident resident = _residentBusiness.GetResidentDetails(id);
ResidentViewModel residentViewModel = ResidentMapper.ToResidentViewModel(resident);
IEnumerable <User> userList = _userBusiness.GetAllUsers();
List <UserViewModel> userViewModelList = UserMapper.ToUserViewModelList(userList);
IEnumerable <Unit> unitList = _unitBusiness.GetAllUnits();
List <UnitViewModel> unitViewModelList = UnitMapper.ToUnitViewModelList(unitList);
residentViewModel.Users = new SelectList(userViewModelList, "UserID", "Email");
residentViewModel.Units = new SelectList(unitViewModelList, "UnitID", "Name");
return(View(residentViewModel));
}
public async Task <IActionResult> Create([FromBody] ResidentViewModel viewModel)
{
if (ModelState.IsValid)
{
var resident = _mapper.Map <Resident>(viewModel);
_residentRepository.Add(resident);
await _unitOfWork.CompleteAsync();
var result = _mapper.Map <ResidentViewModel>(resident);
return(Ok(result));
}
else
{
return(BadRequest(ModelState));
}
}
public ActionResult EditResident(int?residentId)
{
ResidentViewModel viewModel = null;
if (residentId != null)
{
var queryResult = residentsService.GetSingleResident((int)residentId);
viewModel = ViewModelMapper.Mapper.Map <ResidentViewModel>(queryResult);
}
else
{
viewModel = new ResidentViewModel();
viewModel.id_najemcy = -1;
}
return(View(viewModel));
}
public async Task Delete_DeleteNullResident_ReturnsBadRequest()
{
// Arrange
_mockResidentRepository.Setup(repo => repo.GetAsync(It.IsAny <int>())).ReturnsAsync((Resident)null);;
var controller = new ResidentsController(_mockResidentRepository.Object,
_mockUoW.Object, _mapper);
// Act
var residentViewModel = new ResidentViewModel {
Name = "John Cena"
};
var deleteResidentResult = await controller.Delete(2);
// assert
Assert.IsInstanceOf <BadRequestObjectResult>(deleteResidentResult);
}
public async Task <IActionResult> Edit(int id, [FromBody] ResidentViewModel viewModel)
{
if (ModelState.IsValid)
{
var resident = await _residentRepository.GetAsync(id);
_mapper.Map(viewModel, resident);
await _unitOfWork.CompleteAsync();
var result = _mapper.Map <ResidentViewModel>(resident);
return(Ok(result));
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <Metadata> Insert(ResidentViewModel model)
{
Metadata res = new Metadata();
try
{
var resident = (from r in context.Resident where r.residentname.ToLower().Replace(" ", "") == model.ResidentName.ToLower().Replace(" ", "") && r.residentid != model.ResidentID select r).FirstOrDefault();
if (resident != null)
{
return(new Metadata()
{
data = "Resident name is ready", status = false
});
}
string NumberVal = "RC" + DateTime.Now.ToString("yyyyMM");
var lastNumber = (from r in context.Resident where r.residentnumber.Contains(NumberVal) select r).OrderBy(x => x.residentid).LastOrDefault()?.residentnumber;
if (lastNumber == null)
{
model.ResidentNumber = $"{NumberVal}001";
}
else
{
model.ResidentNumber = $"{NumberVal}{(Convert.ToInt32(lastNumber.Remove(0,8)) + 1).ToString("000")}";
}
context.Resident.Add(new ResidentModel()
{
isactive = model.IsActive,
residentname = model.ResidentName,
residentnumber = model.ResidentNumber,
price = model.Price
});
await context.SaveChangesAsync();
res.status = true;
}
catch (Exception e)
{
res.data = e.Message.ToString();
}
return(res);
}
public async Task Create_CreateResidentWithIncompleteData_ReturnsBadRquest()
{
// Arrange
// _mockResidentRepository.Setup(repo => repo.Add(It.IsAny<Resident>()));
var controller = new ResidentsController(_mockResidentRepository.Object,
_mockUoW.Object, _mapper);
controller.ModelState.AddModelError("Email", "Required");
// Act
var residentViewModel = new ResidentViewModel {
Name = "John Cena"
};
var addResidentResult = await controller.Create(residentViewModel);
// assert
Assert.IsInstanceOf <BadRequestObjectResult>(addResidentResult);
}
public async Task <Metadata> Update(ResidentViewModel model)
{
Metadata res = new Metadata();
try
{
var resident = (from r in context.Resident where r.residentname.ToLower().Replace(" ", "") == model.ResidentName.ToLower().Replace(" ", "") && r.residentid != model.ResidentID select r).FirstOrDefault();
if (resident != null)
{
return(new Metadata()
{
data = "Resident name is ready", status = false
});
}
resident = (from r in context.Resident where r.residentid == model.ResidentID select r).FirstOrDefault();
if (resident == null)
{
return(new Metadata()
{
data = "Resident not found", status = false
});
}
resident.residentname = model.ResidentName;
resident.isactive = model.IsActive;
resident.price = model.Price;
await context.SaveChangesAsync();
res.status = true;
}
catch (Exception e)
{
res.data = e.Message.ToString();
}
return(res);
}
public async Task Create_CreateResidentWithCompleteData_ReturnsOKResult()
{
// Arrange
var controller = new ResidentsController(_mockResidentRepository.Object,
_mockUoW.Object, _mapper);
// Act
var residentViewModel = new ResidentViewModel
{
Name = "John Cena",
Email = "*****@*****.**",
Block = "B",
Apartment = "301",
Cpf = "3243141431"
};
var addResidentResult = await controller.Create(residentViewModel);
// assert
Assert.IsInstanceOf <OkObjectResult>(addResidentResult);
var okResult = addResidentResult as OkObjectResult;
Assert.IsInstanceOf <ResidentViewModel>(okResult.Value);
}
public ResidentHandler(ResidentViewModel residentViewModel)
{
ResidentViewModel = residentViewModel;
}
public LogInHandler(ResidentViewModel residentViewModel)
{
ResidentViewModel = residentViewModel;
ResidentCatalogSingleton = ResidentCatalogSingleton.Instance;
}
public async Task <IActionResult> UpdateResident([FromRoute] Guid apartmentId, [FromRoute] Guid id, [FromBody] ResidentViewModel resident)
{
try
{
await _mediator.SendCommand(new UpdateResident()
{
Id = id,
Name = resident.Name,
Birthday = resident.Birthday,
DocumentNumber = resident.DocumentNumber,
Email = resident.Email,
PhoneNumber = resident.PhoneNumber,
ApartmentId = apartmentId
});
return(IsAValidOperation()
? RequestResponse(HttpStatusCode.OK, "kipercondominio/api/v1/apartments")
: RequestResponse(HttpStatusCode.BadRequest, "kipercondominio/api/v1/apartments", isError: true));
}
catch (Exception ex)
{
var error = JsonConvert.SerializeObject(ex);
_logger.LogError(error);
return(RequestResponse(HttpStatusCode.InternalServerError, isError: true, result: "Ocorreu um erro ao realizar a operação"));
}
}
