public async Task <IActionResult> Login(LoginRequestModel model, CancellationToken token)
{
var command = new UserLoginCommand(model.UserName, model.Password);
var response = await _mediator.Send(command, token);
return(Ok(_mapper.Map <LoginResponseModel>(response)));
}
public async Task Login_User_Wrong_UserName()
{
var connection = TestHelper.GetConnection();
var options = TestHelper.GetMockDBOptions(connection);
try
{
using (var context = new AppcentTodoContext(options))
{
TestHelper.EnsureCreated(context);
var service = new UserLoginCommandHandler(context, TestHelper.GetAppSettings());
var command = new UserLoginCommand();
command.Data = new UserLoginRequest
{
Password = "******",
UserName = "******"
};
var result = await service.Execute(command);
Assert.False(result.Result.IsSuccess);
Assert.Equal("Incorrect username or password", result.Result.Error.ErrorText);
}
}
finally
{
connection.Close();
}
}
public async Task <IActionResult> Post([FromBody] AppUserLoginDto login)
{
// 实体映射转换
var command = new UserLoginCommand(login.Account, login.Password, login.VerificationCode);
bool flag = await _mediator.Send(command);
if (flag)
{
return(Ok(new
{
code = 20001,
msg = $"{login.Account} 用户登录成功",
data = login
}));
}
else
{
return(Unauthorized(new
{
code = 40101,
msg = $"{login.Account} 用户登录失败",
data = login
}));
}
}
public async Task <ActionResult> Login(UserLoginView userLogin)
{
var command = new UserLoginCommand(userLogin.Email, userLogin.Password);
var result = await _mediator.SendCommand <UserLoginCommand, UserLoginResponse>(command).ConfigureAwait(false);
return(CustomResponse <UserLoginResponse>(result));
}
public async Task Login_User()
{
var connection = TestHelper.GetConnection();
var options = TestHelper.GetMockDBOptions(connection);
try
{
using (var context = new AppcentTodoContext(options))
{
TestHelper.EnsureCreated(context);
var service = new UserLoginCommandHandler(context, TestHelper.GetAppSettings());
var command = new UserLoginCommand();
command.Data = new UserLoginRequest
{
Password = "******",
UserName = "******"
};
var result = await service.Execute(command);
if (result.GetType().IsAssignableTo(typeof(UserLoginResponse)))
{
var res = (UserLoginResponse)result;
Assert.NotEqual <string>(res.Token, string.Empty);
}
Assert.True(result.Result.IsSuccess);
}
}
finally
{
connection.Close();
}
}
public LoginController(
Logger consoleLogger,
UserLoginCommand command)
{
this.consoleLogger = consoleLogger;
this.command = command;
}
public async Task <CommandResult <UserLoginResponse> > Handle(UserLoginCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
return(new CommandResult <UserLoginResponse>(message.ValidationResult));
}
var userLogged = await _userLoginProvider.UserSignInAsync(message.Email, message.Password);
if (!userLogged.Succeeded)
{
var result = new UserLoginResponse(userLogged);
return(new CommandResult <UserLoginResponse>(result.GetValidationResult()));
}
try
{
var jsonToken = await _userLoginProvider.TokenGenerator(message.Email, _userProvider.Issuer, _userProvider.RefreshTokenExpiration).ConfigureAwait(false);
return(new CommandResult <UserLoginResponse>(jsonToken));
}
catch (UserTokenException ute)
{
var result = new UserLoginResponse(userLogged);
return(new CommandResult <UserLoginResponse>(result.GetValidationResult()));
}
}
public IActionResult Login(UserLoginCommand command)
{
if (null == command)
{
return(Json(new { code = -1, msg = "Error:数据不正确", url = string.Empty }));
}
else if (command.Account.IsNullOrWhitespace() || command.Passwrd.IsNullOrWhitespace())
{
return(Json(new { code = -1, msg = "Error:数据不正确", url = string.Empty }));
}
else if (command.VerifyCode != HttpContext.Session.GetString("verifycode"))
{
HttpContext.Session.Remove("verifycode");
return(Json(new { code = -1, msg = "Error:验证码错误", url = string.Empty }));
}
var commandResult = this._commandInvokerFactory.Handle <UserLoginCommand, UserLoginCommandResult>(command);
if (!commandResult.IsSuccess)
{
return(Json(new { code = -1, msg = $"错误:{commandResult.GetErrors()[0]}", url = string.Empty }));
}
// 登陆验证成功
HttpContext.Session.Remove("verifycode");
AccountLoginManager.SetLogin(HttpContext, commandResult);
return(Json(new { code = 1, msg = "Success:登陆成功", url = command.ReturnUrl.IsNullOrWhitespace() ? "/Admin/Index" : command.ReturnUrl }));
}
public IHttpActionResult Authenticate(UserLoginCommand loginCommand)
{
var loginResponse = new LoginResponse {
};
LoginRequest loginrequest = new LoginRequest {
};
loginrequest.Username = loginCommand.Email;
loginrequest.Password = loginCommand.Password;
IHttpActionResult response;
HttpResponseMessage responseMsg = new HttpResponseMessage();
bool isUsernamePasswordValid = false;
if (loginCommand != null)
{
isUsernamePasswordValid = UserAppService.GetUserByEmail(loginCommand);
}
// if credentials are valid
if (isUsernamePasswordValid)
{
string token = createToken(loginrequest.Username);
//return the token
return(Ok <string>(token));
}
else
{
// if credentials are not valid send unauthorized status code in response
loginResponse.responseMsg.StatusCode = HttpStatusCode.Unauthorized;
response = ResponseMessage(loginResponse.responseMsg);
return(response);
}
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var LoginCommand = new UserLoginCommand();
LoginCommand.Email = context.UserName;
LoginCommand.Password = context.Password;
bool isUsernamePasswordValid = false;
try
{
var authService = SimpleInjectorContainer.container.GetInstance <IUserAppService>();
isUsernamePasswordValid = authService.GetUserByEmail(LoginCommand);
}
catch (Exception ex)
{
context.SetError("invalid_grant", ex.Message);
}
if (isUsernamePasswordValid == false)
{
context.SetError("invalid_grant", "Usuário não encontrado ou senha incorreta.");
return;
}
var identidadeUsuario = new ClaimsIdentity(context.Options.AuthenticationType);
context.Validated(identidadeUsuario);
}
public CommandResultToken Login(UserLoginCommand command)
{
var user = _repository.GetByNameOrEmail(command.Username);
if (user == null)
{
return(new CommandResultToken(false, "Login inválido! "));
}
var salt_tabela = user.Salt;
byte[] salt = Convert.FromBase64String(salt_tabela);
var hashPassword = HashGenerator.Generate(command.Password, salt); // <-- monta hash para comparação / login
user = _repository.Login(command.Username, hashPassword);
if (user == null)
{
return(new CommandResultToken(false, "Login inválido! "));
}
else if (user.EmailConfirm == false)
{
return(new CommandResultToken(false, "Necessário validar seu e-mail! "));
}
else if (user.Active == false)
{
return(new CommandResultToken(false, "Usuário inativo. Contacte o Administrador. "));
}
user.HidePassword();
return(new CommandResultToken(true, "Login efetuado com sucesso! ", user));
}
public void Init()
{
userRepository = new Mock <UserRepository>();
hashingService = new Mock <HashingService>();
command = new UserLoginCommand(
userRepository: userRepository.Object,
hashingService: hashingService.Object);
}
public async Task <IActionResult> LoginAsync([FromBody] UserLoginCommand command)
{
await DispatchCommandAsync(command);
var jwt = GetCachedObject <JwtDto>(command.Id);
return(Ok(jwt));
}
private void GivenACommand()
{
_command = new UserLoginCommand
{
Username = "******",
Password = "******"
};
}
public async Task HandleAsync(UserLoginCommand command)
{
var jwtDto = await _apiHttpWebService.SendAsync <JwtDto>(HttpMethod.Post, Routes.Users.Login, command);
_apiSettings.Token = jwtDto.Token;
_currentUserContext.CurrentUser = jwtDto.User;
_eventAggregator.GetEvent <UserLoggedEvent>().Publish();
}
public async Task <User> VerifyLoginAsync(UserLoginCommand command)
{
var user = await _userRepository.GetByPasswordAndEmailAsync(command.Password, command.Email, _encrypter);
if (user is null)
{
throw new Exception("Não foi possível logar, email ou senha estão incorretos!");
}
return(user);
}
public CommandResultToken Login(UserLoginCommand command)
{
CommandResultToken result = _handler.Login(command);
if (result.Success)
{
result.Token = _tokenService.GenerateToken((UserAuth)result.Object);
}
return(result);
}
public async Task <ActionResult> Login([FromBody] UserLoginCommand command)
{
try
{
return(Ok(await Mediator.Send(command)));
}
catch (UnauthorizedException ex)
{
return(Unauthorized(ex.Message));
}
}
public async Task <User> VerifyLogin(UserLoginCommand command)
{
ValidationResult resultadoValidacao = command.Validate();
if (!resultadoValidacao.IsValid)
{
throw new Exception("Erro! Preencha todos os campos!");
}
return(await _userService.VerifyLoginAsync(command));
}
public async Task <IActionResult> Login(UserLoginModel model)
{
var command = new UserLoginCommand(model.UserName, model.Password);
var response = await _mediator.Send(command);
if (response == null)
{
return(Unauthorized());
}
return(Ok(response));
}
public async Task LoginAsync(string username, string password)
{
var loginCmd = new UserLoginCommand
{
Id = Guid.NewGuid(),
Email = username,
Password = password
};
var jwt = await SendAsync <JwtDto>(HttpMethod.Post, "api/users/login", loginCmd);
_token = jwt.Token;
}
public void UserAuthHandler_Login_user_inactive_Invalid()
{
var repository = new FakeUserAuthRepository();
var logRepository = new FakeAccessLogRepository();
var handler = new UserAuthHandler(repository, logRepository);
var command = new UserLoginCommand();
command.Username = "******";
command.Password = "******";
var result = handler.Login(command);
Assert.IsFalse(result.Success);
}
public void UserAuthHandler_Login_Valid()
{
var repository = new FakeUserAuthRepository();
var logRepository = new FakeAccessLogRepository();
var handler = new UserAuthHandler(repository, logRepository);
var command = new UserLoginCommand();
command.Username = "******";
command.Password = "******";
var result = handler.Login(command);
Assert.IsTrue(result.Success);
}
public async Task <IActionResult> Login([FromBody] UserLoginCommand request)
{
var user = await _mediator.Send(request);
if (!user.IsSuccessfull)
{
return(Ok(user));
}
user = await _authService.CreateApiCode(user);
return(Ok(user));
}
public async Task <ActionResult> Login(UserLoginCommand userLoginCommand)
{
var response = await _mediator.Send(userLoginCommand);
if ((bool)response.isValid)
{
Session["user-id"] = response.Id;
Session["user-username"] = response.AppUserUsername;
Session["user-fullname"] = response.AppUserFullname;
return(RedirectToAction("Index", "Home"));
}
return(View(response));
}
public bool GetUserByEmail(UserLoginCommand loginCommand)
{
var user = UserRepository.GetUserByEmail(loginCommand.Email);
if (user != null)
{
return(user.ValidatePassword(loginCommand.Password));
}
else
{
return(false);
}
}
public async Task <ActionResult> LoginUser([FromBody] UserLoginCommand login)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await Mediator.Send(login);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task <ActionResult> Login([FromBody] UserLoginDto viewRequest)
{
if (!TryValidateModel(viewRequest))
{
return(BadRequest(ValidationHelper.GetModelErrors(ModelState)));
}
var request = this._mapper.Map <UserLoginRequest>(viewRequest);
var command = new UserLoginCommand
{
Data = request
};
return(await Go(command));
}
public async Task <IActionResult> Authentication(UserLoginCommand command)
{
try
{
return(Ok(await _mediator.Send(command)));
}
catch (UserSignInException ex)
{
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task<IActionResult> Authentication(UserLoginCommand command)
{
if (ModelState.IsValid)
{
var result = await _mediator.Send(command);
if (!result.Succeeded)
{
return BadRequest("Access denied");
}
return Ok(result);
}
return BadRequest();
}
