public async void CreateAsync_Returns_UserDto()
{
var userEntity = User.Create(
_userValidator.Object,
_userPasswordService.Object,
"*****@*****.**",
"DisplayName",
"Password1",
"11111",
1);
var dto = new UserPasswordDto
{
Id = userEntity.Id,
Email = userEntity.Email,
DisplayName = userEntity.DisplayName,
PostalCode = userEntity.PostalCode,
Password = "******"
};
_userRepository
.Setup(r => r.CreateAsync(It.IsAny <User>()))
.Returns(Task.FromResult(userEntity));
var result = await _userService.CreateAsync(dto);
Assert.NotNull(result);
Assert.Equal(dto.Id, result.Id);
Assert.Equal(dto.Email, result.Email);
Assert.Equal(dto.DisplayName, result.DisplayName);
Assert.Equal(dto.PostalCode, result.PostalCode);
}
private void ButtonRegister_Clicked(object sender, EventArgs e)
{
var userPasswordDto = new UserPasswordDto
{
user = new User
{
email = EntryEmail.Text,
userName = EntryUsername.Text,
phoneNumber = EntryPhone.Text,
emailConfirmed = true,
lockoutEnabled = true,
phoneNumberConfirmed = true
},
password = new Password
{
password = EntryPassword.Text,
confirmPassword = EntryPassword.Text
}
};
var result = App.AppService.SignUp(userPasswordDto);
if (result == false)
{
DisplayAlert("Não foi possível criar o usuário!", "Erro ao tentar criar o usuário!", "Ok");
return;
}
DisplayAlert("Usuário Criado", "Usuário criado com sucesso!", "Ok");
Navigation.PopModalAsync();
}
public ActionResult Create(UserPasswordDto model)
{
ResultHelper result = JsonConvert.DeserializeObject <ResultHelper>(userPasswordService.AddUserPassword(model));
ViewBag.Message = Helper.GetResultMessage(result.Result, result.ResultDescription);
return(View());
}
public async Task <ActionResult <TUserDto> > PostCustomer([FromBody] UserPasswordDto userPasswordDto)
{
if (!EqualityComparer <TUserDtoKey> .Default.Equals(userPasswordDto.user.Id, default))
{
return(BadRequest(_errorResources.CannotSetId()));
}
var(identityResult, userId) = await _identityService.CreateUserAsync(userPasswordDto.user);
var createdUser = await _identityService.GetUserAsync(userId.ToString());
//Add Role to the new User
var role = await _identityService.GetRoleAsync("b66e640a-b235-49d9-96e5-d51e97255701");
var userAndRole = new UserRoleApiDto <TUserDtoKey, TRoleDtoKey>();
userAndRole.UserId = createdUser.Id;
userAndRole.RoleId = role.Id;
var userRolesDto = _mapper.Map <TUserRolesDto>(userAndRole);
await _identityService.CreateUserRoleAsync(userRolesDto);
//Set User Password
userPasswordDto.password.UserId = createdUser.Id;
var userChangePasswordDto = _mapper.Map <TUserChangePasswordDto>(userPasswordDto.password);
await _identityService.UserChangePasswordAsync(userChangePasswordDto);
return(CreatedAtAction(nameof(Get), new { id = createdUser.Id }, createdUser));
}
public bool SignUp(SignUpViewModel signUpViewModel)
{
var userPasswordDto = new UserPasswordDto
{
user = new UserPasswordDto.User
{
userName = signUpViewModel.Username,
email = signUpViewModel.Email,
emailConfirmed = true,
phoneNumber = signUpViewModel.Phone,
phoneNumberConfirmed = true
},
password = new UserPasswordDto.Password
{
password = signUpViewModel.Password,
confirmPassword = signUpViewModel.Password
}
};
var token = GetAdminToken();
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", "bearer " + token);
var serializedUserPassword = serializerService.Serialize(userPasswordDto);
var httpContent = new StringContent(serializedUserPassword, Encoding.UTF8, "application/json");
var result = httpClient.PostAsync("https://petshop-sergio-iammicroservice-api.azurewebsites.net/api/UsersAndRoles", httpContent).Result;
if (!result.IsSuccessStatusCode)
{
return(false);
}
return(true);
}
public async Task <IActionResult> Authenticate([FromBody] UserPasswordDto model)
{
var user = await _userService.AuthenticateAsync(model.Email, model.Password);
if (user == null)
{
return(Unauthorized());
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = System.Text.Encoding.Default.GetBytes(_applicationSettings.AuthenticationSecret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString()),
new Claim(ApiClaimTypes.TimeZoneId, user.TimeZone.Id.ToString()),
new Claim(ApiClaimTypes.TimeZoneName, user.TimeZone.Name),
new Claim(ApiClaimTypes.TimeZoneUtcOffset, user.TimeZone.UtcOffset.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(Ok(new
{
Id = user.Id,
Email = user.Email,
DisplayName = user.DisplayName,
Token = tokenString
}));
}
public IHttpActionResult ValidateUser([FromUri] string userName, [FromBody] UserPasswordDto userPasswordDto)
{
_loggingService.LogInfo($"Attempting to validate user '{userName}' credentials");
var valid = _userService.ValidateUser(userName, userPasswordDto.Password);
_loggingService.LogInfo($"User '{userName}' credentials have been validated");
return(Ok(valid));
}
public IHttpActionResult UpdatePassword([FromUri] string userName, [FromBody] UserPasswordDto userPasswordDto)
{
_loggingService.LogInfo($"Attempting to update password for user '{userName}'");
_userService.UpdatePassword(userName, userPasswordDto.Password);
_loggingService.LogInfo($"Successfully updated password for user '{userName}'");
return(NoContent());
}
public List <UserDto> GetAllUser()
{
try
{
List <UserDto> list = new List <UserDto>();
using (UnitOfWork unitofWork = new UnitOfWork())
{
List <user> collection = unitofWork.GetRepository <user>().Select(null, null).ToList();
foreach (var item in collection)
{
UserDto user = new UserDto();
user.UserID = item.UserID;
user.Name = item.Name;
user.SurName = item.SurName;
user.FullName = item.Name + " " + item.SurName;
user.Gender = item.Gender;
user.NationID = item.NationID;
user.UserTitleID = (int)item.UserTitleID;
var userTitle = unitofWork.GetRepository <usertitle>().GetById(model => model.UserTitleID == item.UserTitleID);
UserTitleDto userTitleDto = new UserTitleDto();
userTitleDto.UserTitleId = item.UserTitleID.Value;
userTitleDto.TitleName = userTitle.TitleName;
user.UserTitleDto = userTitleDto;
var depUser = unitofWork.GetRepository <userdepartment>().GetById(model => model.UserID == user.UserID);
UserDepartmentDto userDepartmentDto = new UserDepartmentDto();
userDepartmentDto.UserDepartmentID = depUser.DepartmentID.Value;
userDepartmentDto.UserID = item.UserID;
userDepartmentDto.UserDepartmentID = depUser.UserDepartmentID;
userDepartmentDto.UserDepartmentID = depUser.DepartmentID.Value;
user.UserDepartmentDto = userDepartmentDto;
var department = unitofWork.GetRepository <department>().GetById(model => model.DepartmentID == depUser.DepartmentID);
DepartmentDto departmentDto = new DepartmentDto();
departmentDto.DepartmentID = department.DepartmentID;
departmentDto.Name = department.Name;
user.DepartmentDto = departmentDto;
var password = unitofWork.GetRepository <userpassword>().GetById(x => x.UserID == user.UserID);
UserPasswordDto userPasswordDto = new UserPasswordDto();
userPasswordDto.UserPasswordID = password.UserPasswordID;
userPasswordDto.Password = password.Password;
user.UserPasswordDto = userPasswordDto;
list.Add(user);
}
return(list);
}
}
catch (Exception ex)
{
return(new List <UserDto>());
}
}
public ActionResult Edit(UserPasswordDto model)
{
ResultHelper result = JsonConvert.DeserializeObject <ResultHelper>(userPasswordService.SetUserPassword(model));
if (result.Result)
{
return(View());
}
{
ViewBag.Message = Helper.GetResultMessage(result.Result, result.ResultDescription);
}
return(View());
}
public async Task <IActionResult> Password([FromBody] UserPasswordDto user)
{
if (ModelState.IsValid)
{
var claims = HttpContext.User.Claims;
var Id = claims.FirstOrDefault(x => x.Type == "Id")?.Value;
var existingUser = await _userManager.FindByIdAsync(Id);
if (existingUser == null)
{
return(BadRequest(new RegistrationResponse()
{
Errors = new List <string>()
{
"Invalid login request"
},
Success = false
}));
}
var result =
await _userManager.ChangePasswordAsync(existingUser, user.CurrentPassword, user.NewPassword);
if (!result.Succeeded)
{
return(BadRequest(new RegistrationResponse()
{
Errors = new List <string>()
{
"Invalid login request"
},
Success = false
}));
}
return(Ok(new RegistrationResponse()
{
Success = true
}));
}
return(BadRequest(new RegistrationResponse()
{
Errors = new List <string>()
{
"Invalid payload"
},
Success = false
}));
}
public async Task UpdateUserPasswordAsync_WithUserIdAndUserPasswordDto_CallsRepoUpdateUserPasswordAsyncAndReturnsUpdatedUser()
{
var userPasswordDto = new UserPasswordDto
{
Password = _userPassword,
ConfirmPassword = _userPassword
};
var user = await _userService.UpdateUserPasswordAsync(_userId, userPasswordDto);
var hashVerification = user != null && HashUtilities.VerifyHash(userPasswordDto.Password, user.PasswordHash, user.PasswordSalt);
_userRepositoryMock.Verify(repo => repo.UpdateUserPasswordAsync(_userId, user.PasswordHash, user.PasswordSalt));
Assert.True(hashVerification);
}
public bool IsThere(UserPasswordDto userPasswordDto)
{
using (UnitOfWork unitofWork = new UnitOfWork())
{
var item = unitofWork.GetRepository <userpassword>().GetById(x => x.UserPasswordID == userPasswordDto.UserPasswordID && x.Password == userPasswordDto.Password && x.UserID == userPasswordDto.UserID);
if (item != null)
{
return(true);
}
else
{
return(false);
}
}
}
public bool SignUp(UserPasswordDto userPassword)
{
var token = GetAdminToken();
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("Authorization", "bearer " + token);
var serializedUserPassword = JsonConvert.SerializeObject(userPassword);
var httpContent = new StringContent(serializedUserPassword, Encoding.UTF8, "application/json");
var result = httpClient.PostAsync("https://worldstore-gustavo-iammicroservice-api.azurewebsites.net/api/UsersAndRoles", httpContent).Result;
if (!result.IsSuccessStatusCode)
{
return(false);
}
return(true);
}
public async void Authenticate_Returns_UnauthorizedResult()
{
var dto = new UserPasswordDto
{
Email = "*****@*****.**",
Password = "******"
};
_userService
.Setup(s => s.AuthenticateAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult <UserDto>(null));
var result = await _usersController.Authenticate(dto);
Assert.IsType <UnauthorizedResult>(result);
}
public UserPasswordDto GetUserPassword(int userId)
{
try
{
using (UnitOfWork unitofWork = new UnitOfWork())
{
var item = unitofWork.GetRepository <userpassword>().GetById(x => x.UserID == userId);
UserPasswordDto userPasswordDto = new UserPasswordDto();
userPasswordDto.UserID = item.UserID.Value;
userPasswordDto.UserPasswordID = item.UserPasswordID;
return(userPasswordDto);
}
}
catch (Exception)
{
return(null);
}
}
public ResultHelper SetUserPassword(UserPasswordDto userPasswordDto)
{
try
{
userpassword item = new userpassword();
item.Password = userPasswordDto.Password;
item.UserID = userPasswordDto.UserID;
item.UserPasswordID = userPasswordDto.UserPasswordID;
using (UnitOfWork unitofWork = new UnitOfWork())
{
unitofWork.GetRepository <userpassword>().Update(item);
unitofWork.saveChanges();
return(new ResultHelper(true, item.UserPasswordID, ResultHelper.SuccessMessage));
}
}
catch (Exception)
{
return(new ResultHelper(false, userPasswordDto.UserPasswordID, ResultHelper.UnSuccessMessage));
}
}
public async void Register_Returns_OkObjectResult_With_UserDto()
{
var dto = new UserPasswordDto
{
Email = "*****@*****.**",
DisplayName = "My User",
PostalCode = "11111"
};
var expectedModel = new UserDto
{
Id = Guid.NewGuid(),
Email = dto.Email,
DisplayName = dto.DisplayName,
PostalCode = dto.PostalCode
};
_userService
.Setup(s => s.CreateAsync(It.IsAny <UserPasswordDto>()))
.Returns(Task.FromResult(expectedModel));
var result = await _usersController.Register(dto);
Assert.IsType <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.IsType <UserDto>(okResult.Value);
var model = okResult.Value as UserDto;
Assert.Equal(expectedModel.Id, model.Id);
Assert.Equal(expectedModel.Email, model.Email);
Assert.Equal(expectedModel.DisplayName, model.DisplayName);
Assert.Equal(expectedModel.PostalCode, model.PostalCode);
}
public bool UpdatePassword(
UserPasswordDto userPasswordDto,
int modifiedByUserId,
ref IList<string> errorMessages)
{
var user = _userRepository.GetById(userPasswordDto.UserId);
#region Validation
if (!userPasswordDto.IsValid)
{
errorMessages = userPasswordDto.ErrorMessages.ToList();
}
if (!VerifyPassword(userPasswordDto.CurrentPassword, user.HashedPassword))
{
errorMessages.Add("The current password supplied doesn't match what's in the database.");
}
if (userPasswordDto.UserId != modifiedByUserId)
{
errorMessages.Add("Wo wo wo, you're attempting to update another user's password. You can only edit your own password.");
}
if (errorMessages.Count > 0)
{
return false;
}
#endregion
user.HashedPassword = HashPassword(userPasswordDto.NewPassword);
user.ModifiedByUserId = modifiedByUserId;
user.ModifiedDateTime = DateTime.Now.ToGmtDateTime();
_userRepository.Update(user);
var userLog = new UserLog
{
UserId = modifiedByUserId,
UserLogTypeId = (int)UserLogType.Types.EditedUserPassword,
ActionAgainstUserId = userPasswordDto.UserId,
AddedDateTime = DateTime.Now.ToGmtDateTime()
};
_userLogRepository.Insert(userLog);
UnitOfWork.Commit();
return true;
}
public string SetUserPassword(UserPasswordDto userPasswordDto)
{
return(JsonConvert.SerializeObject(userPasswordLogic.SetUserPassword(userPasswordDto)));
}
public async Task <User> UpdateUserPasswordAsync(int userId, UserPasswordDto userPasswordDto)
{
HashUtilities.CreateHash(userPasswordDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
return(await _userRepository.UpdateUserPasswordAsync(userId, passwordHash, passwordSalt));
}
public static UserPassword ToEntity(this UserPasswordDto userPasswordDto)
{
return(userPasswordDto.MapTo <UserPasswordDto, UserPassword>());
}
// POST api/users
public async Task <IActionResult> Register([FromBody] UserPasswordDto model)
{
var user = await _userService.CreateAsync(model);
return(Ok(user));
}
