public UsersDto GetSingle(UserLoginRequestDto request)
{
try
{
var ReturnData = new UserLoginResponseDto();
var EncryptPass = PasswordHelper.EncryptData(request.Password);
#region DynamicQuerryParameters
var list = DynamicQuerryParameters.Create();
list.Add(DynamicQuerryParameters.AddParameter("UserName", request.UserName, DbType.String));
list.Add(DynamicQuerryParameters.AddParameter("Password", EncryptPass, DbType.String));
list.Add(DynamicQuerryParameters.AddParameter("ActivationStatus", (int)ActivationStatusType.Active, DbType.Int16));
#endregion
var querry = QueryGenerator.GenerateQuery(list, QueryGenerator.tableName <UserEntity>());
var result = Db.GetSingleData <UserEntity>(querry);
if (result != null)
{
ReturnData = result.ConvertTo <UserLoginResponseDto>();
ReturnData.TokenKey = Authentication.CreateTokenAuthentication(result.Id);
}
return(ReturnData);
}
catch (KnownException ex)
{
throw ex;
}
catch (Exception ex)
{
Logger.AddLog(LogTypeEnum.Error, "UserManager.GetSingle", null, ex.Message, request.ToJson(), ex);
throw new KnownException(ErrorTypeEnum.UnexpectedExeption, ex.Message, ex);
}
}
public async Task <AuthenticationResultDto> Login([FromBody] UserLoginRequestDto loginForm)
{
var tokenRequestResult = await _authenticationService.LoginAsync(loginForm.Username, loginForm.Password);
_logger.LogInformation($"User {loginForm.Username} logged in.");
return(_mapper.Map <AuthenticationResultDto>(tokenRequestResult));
}
public async Task <AuthResponse> Login(UserLoginRequestDto user)
{
if (await _userRepository.UserExists(user.Email))
{
var existingUser = await _userRepository.FindByEmail(user.Email);
if (await _userRepository.CheckCredentials(existingUser, user.Password))
{
var jwtToken = GenerateJwtToken(existingUser);
return(new AuthResponse()
{
Result = true,
Token = jwtToken
});
}
throw new HandlerException(
HttpStatusCode.Unauthorized,
new List <string>()
{
"El usuario/password son incorrectos."
}
);
}
throw new HandlerException(
HttpStatusCode.NotFound,
new List <string>()
{
"El usuario no se encuentra en el sistema."
}
);
}
public ActionResult <string> Post([FromBody] UserLoginRequestDto request)
{
if (request.UserName != "admin" || request.Password != "1234")
{
return(Unauthorized());
}
return(_authenticationService.GetToken(request.UserName, request.Password));
}
public async Task <ActionResult> Login([FromBody] UserLoginRequestDto request)
{
try
{
return(Ok(await _userService.Login(request)));
}
catch (Exception e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <ActionResult <UserLoginResponseDto> > Login(
[FromBody] UserLoginRequestDto requestDto,
[FromHeader(Name = "User-Agent")] string userAgent,
[FromHeader(Name = "X-Application-Version")]
string appVersion
)
{
requestDto.UserAgent = userAgent;
requestDto.AppVersion = appVersion;
return(await ProcessResultAsync(() => _authenticationService.Login(requestDto)));
}
public async Task <ActionResult> Login([FromBody] UserLoginRequestDto model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (result.Succeeded)
{
// create token
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, model.UserName),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JwtSettings:Secret"]));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
_configuration["JwtSettings:Issuer"],
_configuration["JwtSettings:Audience"],
claims,
expires: DateTime.UtcNow.AddDays(1),
signingCredentials: credentials
);
var response = new UserLoginResponseDto
{
User = new UserDto
{
UserName = user.UserName
},
Token = new JwtSecurityTokenHandler().WriteToken(token),
TokenExpiration = token.ValidTo
};
return(Created("", response));
}
}
ModelState.AddModelError("", "Failed to login");
return(BadRequest(ModelState));
}
return(BadRequest(ModelState));
}
public async void LoginUserFailEmail()
{
// Arrange
UserLoginRequestDto userLogin = new UserLoginRequestDto()
{
Email = "*****@*****.**",
Password = "******"
};
// Act
//Assert
await Assert.ThrowsAsync <HandlerException>(() => _authService.Login(userLogin));
}
public async Task <JsonResult> LoginAsync([FromBody] UserLoginRequestDto userDto)
{
if (!userDto.IsGuest)
{
var(token, error) = await _loginService.LoginAsRegisteredUserAsync(userDto);
return(error == null?Json(token)
: Json(new { Error = error }));
}
else
{
return(Json(await _loginService.LoginAsGuestAsync()));
}
}
public virtual ActionResponseDto LoginAdmin(UserLoginRequestDto request)
{
// 检查验证码
if (!_captchaManager.Check("AdminLogin", request.Captcha))
{
throw new BadRequestException("Incorrect captcha");
}
// 登录用户
_adminManager.Login(
request.Tenant,
request.Username,
request.Password,
request.RememberLogin ?? true);
return(ActionResponseDto.CreateSuccess());
}
public async void LoginUserSuccess()
{
// Arrange
UserLoginRequestDto userLogin = new UserLoginRequestDto()
{
Email = "*****@*****.**",
Password = "******"
};
// Act
AuthResponse user = await _authService.Login(userLogin);
//Assert
Assert.NotEmpty(user.Token);
}
public async Task <UserLoginResponseDto> Login(UserLoginRequestDto requestDto)
{
var user = await _userRepository.GetByEmail(requestDto.Email);
if (user == null)
{
return(new UserLoginResponseDto
{
Error = ErrorCodes.IncorrectEmailOrPassword,
ErrorField = new List <string> {
nameof(requestDto.Email), nameof(requestDto.Email)
}
});
}
if (_cryptoHelper.GetHash(requestDto.Password) != user.Password)
{
return(new UserLoginResponseDto
{
Error = ErrorCodes.IncorrectEmailOrPassword,
ErrorField = new List <string> {
nameof(requestDto.Email), nameof(requestDto.Email)
}
});
}
var sessionId = Guid.NewGuid();
var token = _tokenService.GenerateToken(user.Id, sessionId, _secretKey);
await _tokenRepository.Create(new TokenModel
{
Id = sessionId,
UserAgent = requestDto.UserAgent,
Token = token,
UserId = user.Id,
AppVersion = requestDto.AppVersion
},
user.Id.Value
);
return(new UserLoginResponseDto
{
Id = user.Id,
AuthToken = token
});
}
/// <summary>
/// User login operation
/// </summary>
/// <param name="userForLoginDto"></param>
/// <returns></returns>
//[PerformanceAspect(5)]
public IDataResult <User> Login(UserLoginRequestDto userForLoginDto)
{
ValidationTool.Validate(new LoginValidation(), userForLoginDto);
var userToCheck = _userRepository.GetUserByEmail(userForLoginDto.Email);
if (userToCheck == null)
{
return(new ErrorDataResult <User>(ErrorMessages.UserNotFound));
}
if (!HashingHelper.VerifyPasswordHash(userForLoginDto.Password, userToCheck.PasswordHash, userToCheck.PasswordSalt))
{
return(new ErrorDataResult <User>(ErrorMessages.PassError));
}
return(new SuccessDataResult <User>(userToCheck, SuccessMessages.SuccessfulLogin));
}
public IActionResult Login(UserLoginRequestDto request)
{
var userToLogin = _authService.Login(request);
if (!userToLogin.Success)
{
return(BadRequest(userToLogin.Message));
}
var result = _authService.CreateAccessToken(userToLogin.Data);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok(result.Data));
}
public IActionResult Login(UserLoginRequestDto userLoginRequestDto)
{
var validationResult = _userLoginRequestValidator.Validate(userLoginRequestDto);
if (validationResult.Errors.Any())
{
return(BadRequest(validationResult));
}
var responseDto = _userProcessor.Login(userLoginRequestDto);
if (responseDto == null)
{
return(Unauthorized());
}
return(Ok(responseDto));
}
public async Task <ActionResult> Login([FromBody] UserLoginRequestDto requestDto)
{
if (User.Identity.IsAuthenticated)
{
return(Forbid());
}
requestDto.UserAgent = Request.Headers["User-Agent"].ToString();
var result = await _authenticateService.Login(requestDto);
if (result.Error != null)
{
var error = result.Error ?? ErrorCodes.NotFound;
BadRequest(error, result.ErrorField);
}
return(Ok(result));
}
public async Task <UserLoginResponseDto> Login(UserLoginRequestDto login)
{
try
{
var validate = new UserLoginValidator().Validate(login);
if (!validate.IsValid)
{
return(new UserLoginResponseDto()
{
Sucess = false,
Message = validate.Errors[0].ErrorMessage
});
}
var result = _mapper.Map <UserEntityDto>((await _repository.LoginAsync(_mapper.Map <User>(login))));
if (result != null)
{
return(new UserLoginResponseDto()
{
Sucess = true,
Message = "Login realizado com sucesso",
User = result
});
}
else
{
return(new UserLoginResponseDto()
{
Sucess = false,
Message = "Usuário ou senha incorreto"
});
}
}
catch (Exception e)
{
return(new UserLoginResponseDto()
{
Sucess = false,
Message = "Ocorreu um erro, tente novamente " + e.Message
});
}
}
public async Task <IActionResult> Login([FromBody] UserLoginRequestDto loginRequestDto,
CancellationToken cancellationToken = default(CancellationToken))
{
var validateResult = _userService.CredentialsValid(loginRequestDto);
if (validateResult)
{
var token = await _tokenService.CreateToken(_mapper.Map <TokenCreateDto>(loginRequestDto),
cancellationToken);
if (token != null)
{
return(Ok(new ApiOkResponse(token)));
}
}
var errorMessage = ApiResponse.CreateErrorMessage(ErrorMessages.WrongCredentials, ErrorMessages.DefaultKey);
return(BadRequest(new ApiResponse(StatusCodes.Status400BadRequest, errorMessage)));
}
/// <summary>
/// Logs the specified user in by authenticating the provided credentials
/// (POST request to the Glitched Epistle Web API).
/// If authentication is successful, a valid JWT <c>string</c> is returned along with the user's keypair.
/// That's needed for subsequent requests.
/// </summary>
/// <param name="paramsDto">HTTP Request parameters wrapped into a DTO instance.</param>
/// <returns><see cref="UserLoginSuccessResponseDto"/> if auth was successful; <c>null</c> otherwise.</returns>
public async Task <UserLoginSuccessResponseDto> Login(UserLoginRequestDto paramsDto)
{
var request = new RestRequest(
method: Method.Post,
resource: new Uri("users/login", UriKind.Relative)
);
request.AddStringBody(JsonSerializer.Serialize(paramsDto), "application/json");
RestResponse response = await restClient.ExecuteAsync(request).ConfigureAwait(false);
try
{
var r = JsonSerializer.Deserialize <UserLoginSuccessResponseDto>(response.Content);
return(response.StatusCode == HttpStatusCode.OK ? r : null);
}
catch
{
return(null);
}
}
public UserLoginResponseDto Login(UserLoginRequestDto userLoginRequestDto)
{
var foundUser = _userRepository.FindUser(userLoginRequestDto.Email);
if (foundUser == null)
{
return(null);
}
if (!_hashingService.VerifyHashedPassword(foundUser.Password, userLoginRequestDto.Password))
{
// Maybe return a different response here?
return(null);
}
var userResponse = _mapper.Map <UserResponseDto>(foundUser);
var token = _tokenProvider.GenerateToken(userResponse);
return(_mapper.Map <UserLoginResponseDto>((token, userResponse)));
}
public IHttpActionResult Login(UserLoginRequestDto req)
{
UserLoginResponseDto response;
var user = context.User.Where(x => (x.Email == req.Email || x.Username == req.Email) && x.Password == req.Password).FirstOrDefault();
if (user != null)
{
response = new UserLoginResponseDto()
{
Data = mapper.Map <User, UserLoginDto>(user),
ErrorMessage = null
};
}
else
{
response = new UserLoginResponseDto()
{
Data = null,
ErrorMessage = "incorrect password or email "
};
}
return(Json(response));
}
/// <summary>
/// User auth
/// </summary>
/// <param name="requestDto" class="UserLoginResponseDto">UserLoginResponseDto</param>
/// <returns></returns>
public async Task <Result <UserLoginResponseDto> > Login(UserLoginRequestDto requestDto)
{
var user = await _userRepository.GetByEmail(requestDto.Email);
if (user == null)
{
return(Result <UserLoginResponseDto> .FromIError(new ApiError(ErrorCodes.IncorrectEmailOrPassword)));
}
if (_cryptoHelper.GetHash(requestDto.Password) != user.Password)
{
return(Result <UserLoginResponseDto> .FromIError(new ApiError(ErrorCodes.IncorrectEmailOrPassword)));
}
var sessionId = Guid.NewGuid();
var token = _tokenService.GenerateToken(user.Id, sessionId, _secretKey);
await _tokenRepository.Create(new TokenModel
{
Id = sessionId,
UserAgent = requestDto.UserAgent,
Token = token,
UserId = user.Id,
AppVersion = requestDto.AppVersion,
CreatorId = user.Id
}
);
return(new Result <UserLoginResponseDto>(
new UserLoginResponseDto
{
Id = user.Id,
AuthToken = token
}
));
}
public bool CredentialsValid(UserLoginRequestDto userLoginRequestDto)
{
var user = GetUser(userLoginRequestDto.Email);
return(user != null && VerifyPassword(user, userLoginRequestDto.Password));
}
public TokenAuthenticateCommand(UserLoginRequestDto requesDto)
{
EmailAddress = requesDto.Username.Trim();
Password = requesDto.Password.Trim();
}
/// <summary>
/// 作为注册用户登录
/// </summary>
/// <param name="userDto">用户信息</param>
/// <returns>异步获取Token的任务，发生错误时返回错误信息</returns>
public async Task <(AccessTokenResponseDto, Dictionary <string, string> error)> LoginAsRegisteredUserAsync(UserLoginRequestDto userDto)
{
User user = await _dbContext.User
.FirstOrDefaultAsync(u => u.Username == userDto.Username);
if (user != null &&
ValidatePassword(userDto.Password, user.Salt, user.PasswordHash))
{
AccessTokenResponseDto tokenDto = new AccessTokenResponseDto
{
AccessToken = await _tokenAuthService.GenerateAccessTokenAsync(user),
RefreshToken = await _tokenAuthService.GenerateRefreshTokenAsync(user)
};
return(tokenDto, null);
}
else
{
// 用户名或密码错误
var error = new Dictionary <string, string>
{
["username"] = _msg.GetMessage("E001", "用户名或密码")
};
return(null, error);
}
}
public async Task <IActionResult> Authorize([FromBody] UserLoginRequestDto request)
{
return(Ok(await _mediator.Send(new TokenAuthenticateCommand(request))));
}
public async Task <IActionResult> Login([FromBody] UserLoginRequestDto user)
{
return(Ok(await _authService.Login(user)));
}
public async Task <IActionResult> Login([FromBody] UserLoginRequestDto loginDto)
{
if (ModelState.IsValid)
{
// Check email
var existingUser = await _userManager.FindByEmailAsync(loginDto.Email);
if (existingUser is null)
{
return(BadRequest(new UserLoginResponseDto()
{
Success = false,
Errors = new List <string>()
{
"Invalid authentication request"
}
}));
}
// Check password
var isCorrect = await _userManager.CheckPasswordAsync(existingUser, loginDto.Password);
if (isCorrect)
{
var userRoles = await _userManager.GetRolesAsync(existingUser);
var jwtToken = GenerateJwtToken(existingUser, userRoles);
return(Ok(new UserLoginResponseDto()
{
Success = true,
Token = jwtToken,
Email = loginDto.Email,
id = existingUser.Id.ToString()
}));
}
else
{
return(BadRequest(new UserLoginResponseDto()
{
Success = false,
Errors = new List <string>()
{
"Invalid authentication request"
}
}));
}
}
else
{
return(BadRequest(
new UserRegistrationResponseDto
{
Success = false,
Errors = new List <string>()
{
"Invalid payload"
}
}
));
}
}
