public void UserService_UpdateUserData_PasswordSuccess()
{
//Arrange
var mockService = new Mock <IDatabase>();
var service = new UserService(mockService.Object);
var vm = new UpdateUserDataViewModel
{
UserAccountId = "1",
Firstname = "",
Lastname = "",
Email = "*****@*****.**",
OldPassword = "******",
};
mockService.Setup(serv => serv.CheckPassword(vm.UserAccountId, vm.OldPassword))
.Returns(true);
mockService.Setup(serv => serv.UpdateUserData(vm));
//Act
var result = service.UpdateUserData(vm: vm);
//Assert
Assert.True(result);
}
public void UpdateUserData(UpdateUserDataViewModel vm)
{
var user = PrivGetData(locUsers).Result.
SingleOrDefault(x => x.UserAccountId == vm.UserAccountId);
user.Update(vm);
}
public async Task <IActionResult> ChangePicture(UpdateUserDataViewModel model)
{
if (ModelState.IsValid && model.ImageFile != null)
{
var user = await _userHelper.GetUserByIdAsync(model.User.Id);
if (user != null)
{
if (user.ImageUrl != string.Empty)
{
_imageHelper.RemovePictureAsync(user.ImageUrl, "users");
}
var pic = await _imageHelper.UploadImageAsync(model.ImageFile, "Users");
user.ImageUrl = pic;
await _userHelper.UpdateUserAsync(user);
return(Redirect($"EditUser/{user.Id}"));
}
}
return(Redirect($"EditUser/{model.User.Id}"));
}
public async Task <IHttpActionResult> UpdateUserData()
{
var result = new UpdateUserDataViewModel();
await GetUserData(result);
return(Ok(result));
}
public void Update(UpdateUserDataViewModel vm)
{
FirstName = vm.Firstname;
LastName = vm.Lastname;
EmailAddress = vm.Email;
if (!String.IsNullOrWhiteSpace(vm.NewPassword))
{
Password = vm.NewPassword;
}
}
public bool UpdateUserData(UpdateUserDataViewModel vm)
{
var passConfirm = _db.CheckPassword(vm.UserAccountId, vm.OldPassword);
if (!passConfirm)
{
return(false);
}
_db.UpdateUserData(vm);
return(true);
}
public User ToUserFromUpdate(UpdateUserDataViewModel model, User user, int zipCodeId, string path)
{
var updateUser = user;
updateUser.FirstName = model.FirstName;
updateUser.LastName = model.LastName;
updateUser.Address = model.Address;
updateUser.ZipCodeId = zipCodeId;
updateUser.ImageUrl = path;
updateUser.City = model.City;
updateUser.PhoneNumber = model.PhoneNumber;
updateUser.TaxPayerNumber = model.TaxPayerNumber;
updateUser.IsActive = true;
return(updateUser);
}
public UpdateUserDataViewModel ToUpdateDataViewModel(User user, ZipCode zipCode)
{
var model = new UpdateUserDataViewModel
{
User = user,
FirstName = user.FirstName,
LastName = user.LastName,
Address = user.Address,
ZipCode4 = zipCode.ZipCode4,
ZipCode3 = zipCode.ZipCode3,
City = user.City,
TaxPayerNumber = user.TaxPayerNumber,
PhoneNumber = user.PhoneNumber,
};
return(model);
}
public IActionResult UpdateUserData([FromBody] UpdateUserDataViewModel vm)
{
if (ModelState.IsValid)
{
if (_userService.UpdateUserData(vm))
{
return(Ok());
}
else
{
return(BadRequest());
}
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> EditUser(UpdateUserDataViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userHelper.GetUserByIdAsync(model.User.Id);
if (user == null)
{
return(NotFound());
}
var zipCodeId = await _zipCodeRepository.GetZipCodeAsync(model.ZipCode4, model.ZipCode3);
var path = string.Empty;
if (model.ImageFile != null)
{
path = await _imageHelper.UploadImageAsync(model.ImageFile, "Users");
}
else
{
path = user.ImageUrl;
}
var userUpdated = _converterHelper.ToUserFromUpdate(model, user, zipCodeId.Id, path);
var result = await _userHelper.UpdateUserAsync(userUpdated);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, "Unable to change your profile at the moment, please try again later");
return(View(model));
}
ViewBag.Message = "Changes were applied to your profile";
return(View(model));
}
return(View(model));
}
public async Task <IActionResult> ResetPasswordFromEditUser(UpdateUserDataViewModel model)
{
if (ModelState.IsValid)
{
var user = await _converterHelper.ToUserFromEditUserResetPassword(model);
if (user == null)
{
return(NotFound());
}
string newPassword = model.NewPassword;
var result = await _userHelper.ChangePasswordAsync(user, model.OldPassword, newPassword);
if (result.Succeeded)
{
return(Redirect($"EditUser/{user.Id}"));
}
}
return(RedirectToAction("EditUser", new { id = model.User.Id }));
}
public void UserController_UpdateUserData_Success()
{
//Arrange
var mockService = new Mock <IUserService>();
var controller = new UserController(mockService.Object);
var vm = new UpdateUserDataViewModel
{
Firstname = "",
Lastname = "",
Email = "*****@*****.**",
OldPassword = "",
UserAccountId = ""
};
mockService.Setup(serv => serv.UpdateUserData(vm))
.Returns(true);
//Act
var result = controller.UpdateUserData(vm);
//Assert
Assert.IsType <OkResult>(result);
}
public async Task <User> ToUserFromEditUserResetPassword(UpdateUserDataViewModel model)
{
return(await _userHelper.GetUserByEmailAsync(model.User.UserName));
}
public async Task <IActionResult> UpdateUser(UpdateUserDataViewModel model)
{
if (ModelState.IsValid)
{
try
{
var user = await _userHelper.GetUserByIdAsync(model.User.Id);
var zipCodeId = await _zipCodeRepository.GetZipCodeAsync(model.ZipCode4, model.ZipCode3);
if (zipCodeId == null)
{
var zip = await _zipCodeRepository.GetCityIdFromZip4(model.ZipCode4);
if (zip == null)
{
ModelState.AddModelError(string.Empty, "The first 4 numbers of zip code are not valid, please insert again");
return(View(model));
}
var newZipCode = _converterHelper.ToNewZipCode(model.ZipCode4, model.ZipCode3, zip.CityId);
await _zipCodeRepository.CreateAsync(newZipCode);
var pathZipNull = string.Empty;
if (model.ImageFile != null)
{
pathZipNull = await _imageHelper.UploadImageAsync(model.ImageFile, "Users");
}
var zipCodeIdNew = await _zipCodeRepository.GetZipCodeAsync(model.ZipCode4, model.ZipCode3);
var updateUserZipNull = _converterHelper.ToUserFromUpdate(model, user, zipCodeIdNew.Id, pathZipNull);
if (updateUserZipNull == null)
{
ModelState.AddModelError(string.Empty, "User not found, please try again");
return(View(model));
}
var resultZipNull = await _userHelper.UpdateUserAsync(updateUserZipNull);
if (resultZipNull.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
var path = string.Empty;
if (model.ImageFile != null)
{
path = await _imageHelper.UploadImageAsync(model.ImageFile, "Users");
}
var updateUser = _converterHelper.ToUserFromUpdate(model, user, zipCodeId.Id, path);
if (updateUser == null)
{
ModelState.AddModelError(string.Empty, "User not found, please try again");
return(View(model));
}
var result = await _userHelper.UpdateUserAsync(updateUser);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("duplicate"))
{
if (ModelState.IsValid)
{
var user = await _userHelper.GetUserByIdAsync(model.User.Id);
await _userHelper.DeleteUserAsync(user);
return(RedirectToAction("DuplicatedUser"));
}
}
else
{
ModelState.AddModelError(string.Empty, ex.InnerException.Message);
}
}
}
return(View(model));
}
