public async Task <UserDto> Handle(GetUserByEmailQuery request, CancellationToken cancellationToken)
{
using var connection = new SqlConnection(_connectionStringProvider.ConnectionString);
connection.Open();
return(await connection.QueryFirstOrDefaultAsync <UserDto>(sql, new { request.Email }));
}
public static UserDto GetUserByEmail(string userEmail)
{
var queryObject = new GetUserByEmailQuery(userEmail);
var handler = new GetUserByEmailQueryHandler();
UserDto user = handler.Handle(queryObject).Result;
return(user);
}
public Task <SingleUserQueryResponse> Handle(GetUserByEmailQuery request, CancellationToken cancellationToken)
{
TravelUser user = _repo.GetUserByEmail(request.Email);
var response = new SingleUserQueryResponse(user);
response.Status = GetResponseStatus(user);
return(Task.FromResult(response));
}
public async Task <User> ByEmail(string email)
{
var getUserByEmailQuery = new GetUserByEmailQuery()
{
Email = email
};
return(await _mediator.Send(getUserByEmailQuery));
}
public async Task Handle_Should_Call_Repository_GetByEmail()
{
_repositoryMock.Setup(x => x.GetByEmail(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new User()));
var query = new GetUserByEmailQuery(EMAIL);
var handler = new GetUserByEmailQuery.Handler(_mapperMock.Object, _repositoryMock.Object);
await handler.Handle(query, CancellationToken.None);
_repositoryMock.Verify(x => x.GetByEmail(EMAIL, CancellationToken.None), Times.Once);
}
public async Task <UserDetail> HandleAsync(GetUserByEmailQuery query)
{
var user = await _repository.GetByEmail(query.Email);
if (user == null)
{
return(null);
}
return(_mapper.Map <UserDetail>(user));
}
public async Task Handle_Should_Map_User_Entity_To_UserDto()
{
var entity = new User();
_repositoryMock.Setup(x => x.GetByEmail(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(entity));
var query = new GetUserByEmailQuery(EMAIL);
var handler = new GetUserByEmailQuery.Handler(_mapperMock.Object, _repositoryMock.Object);
await handler.Handle(query, CancellationToken.None);
_mapperMock.Verify(x => x.Map <UserDto>(entity), Times.Once);
}
public static ValidateUserResponse ValidateUser(string useremail, string password)
{
var response = new ValidateUserResponse {
Validated = false
};
//1 - Decode the username (which is user email)
//and the password
Encoding encoding = Encoding.GetEncoding("iso-8859-1");
var decodedUserEmail = encoding.GetString(Convert.FromBase64String(useremail));
var decodedPassword = encoding.GetString(Convert.FromBase64String(password));
//2 - get the user by username (email address) only
var emailQueryObject = new GetUserByEmailQuery(decodedUserEmail);
var emailQueryHandler = new GetUserByEmailQueryHandler();
var byEmailOnlyUser = emailQueryHandler.Handle(emailQueryObject).Result;
if (byEmailOnlyUser == null)
{
return(response);
}
//get salt associated with this user account
var saltBytes = Convert.FromBase64String(byEmailOnlyUser.Salt);
//append salt to password
var passwordAndSalt = decodedPassword + Convert.ToBase64String(saltBytes);
//hash the password using the salt
var pbkdf2 = new Rfc2898DeriveBytes(passwordAndSalt, saltBytes, 10000);
byte[] hashPassword = pbkdf2.GetBytes(32);
//we check the hashed user given password against the hashedPassword stored for the user
var hashedPasswordString = Convert.ToBase64String(hashPassword);
var dbPassword = byEmailOnlyUser.PasswordHash;
if (string.Compare(dbPassword, hashedPasswordString) != 0)
{
return(response);
}
if (byEmailOnlyUser != null)
{
response.UserId = byEmailOnlyUser.UserId;
response.Validated = true;
}
return(response);
}
private bool EmailNotExist(string email)
{
var userByEmailQuery = new GetUserByEmailQuery {
Email = email.ToLower().Trim()
};
var userResult = _mediator.Send(userByEmailQuery);
if (userResult.Result != null)
{
return(false);
}
return(true);
}
public async Task <UserDto> GetUser(GetUserByEmailQuery byEmailQuery)
{
var user = await _dbContext.Users.FirstOrDefaultAsync(e => e.Email == byEmailQuery.Email);
if (user == null)
{
throw new UserFriendlyException("User does not exist!");
}
var mappedUser = Mapper.Map <UserDto>(user);
user.RetrieveDetails();
mappedUser.Age = user.Detail.Age;
return(mappedUser);
}
public async Task <UserDto> GetByEmail(string email)
{
try
{
var getUserByEmailQuery = new GetUserByEmailQuery()
{
Email = email
};
return(await _mediator.Send(getUserByEmailQuery));
}
catch (Exception e)
{
Log.Error($"Error in GetByEmail method. { e.Message}");
throw;
}
}
public async Task GivenGetUserByEmailQuery_ReturnsUserFromMongo()
{
// Arrange
var cancellationToken = new CancellationToken();
var getUserByEmailQuery = new GetUserByEmailQuery
{
EmailAddress = "*****@*****.**"
};
var user = new UserEntity
{
Id = Guid.NewGuid(),
EmailAddress = "*****@*****.**",
Password = "******",
UserName = "******",
FriendlyName = "John Smith",
Roles = new List <UserRole> {
UserRole.Standard
}
};
await _userCollection.InsertOneAsync(user, null, cancellationToken);
// Act
var result = await _classUnderTests.Handle(getUserByEmailQuery, cancellationToken);
// Assert
Assert.Multiple(() =>
{
Assert.That(result.Id, Is.EqualTo(user.Id));
Assert.That(result.EmailAddress, Is.EqualTo(user.EmailAddress));
Assert.That(result.Password, Is.EqualTo(user.Password));
Assert.That(result.UserName, Is.EqualTo(user.UserName));
Assert.That(result.FriendlyName, Is.Null);
CollectionAssert.Contains(result.Roles, UserRole.Standard);
});
}
public async Task <IActionResult> Get([FromRoute] GetUserByEmailQuery query) => await DispatchQueryAsync(query);
public async Task <IActionResult> Login(LoginInputModel model, string button)
{
var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
if (ModelState.IsValid)
{
var validateUserPasswordQuery = new ValidateUserPasswordQuery()
{
Email = model.Email, Password = model.Password
};
if (await _mediator.Send(validateUserPasswordQuery))
{
var query = new GetUserByEmailQuery()
{
Email = model.Email
};
UserDto user = await _mediator.Send(query);
await _events.RaiseAsync(new UserLoginSuccessEvent(username : user.UserName, subjectId : user.Id.ToString(), name : user.GivenName, clientId : context?.Client?.ClientId));
AuthenticationProperties props = null;
if (model.RememberLogin)
{
props = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
};
}
var isuser = new IdentityServerUser(user.Id.ToString())
{
DisplayName = $"{user.GivenName} {user.FamilyName}".Trim(),
};
await HttpContext.SignInAsync(isuser, props);
if (context != null)
{
if (await _clientStore.IsPkceClientAsync(context?.Client?.ClientId))
{
return(this.LoadingPage("Redirect", model.ReturnUrl));
}
return(Redirect(model.ReturnUrl));
}
if (Url.IsLocalUrl(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(Redirect("~/"));
}
throw new Exception("invalid return URL");
}
await _events.RaiseAsync(new UserLoginFailureEvent(model.Email, "invalid credentials", clientId : context?.Client?.ClientId));
ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
}
var vm = await BuildLoginViewModelAsync(model);
return(View(vm));
}
public async Task <SingleUserQueryResponse> GetUserByEmail(string email)
{
var query = new GetUserByEmailQuery(email);
return(await _mediator.Send(query));
}
