public async Task <IActionResult> Login([FromBody] LoginRequestViewModel model)
{
var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
string accessToken = string.Empty;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
{
await _events.RaiseAsync(new UserLoginSuccessEvent(user.UserName, user.Id, user.Name));
AuthenticationProperties props = null;
await HttpContext.SignInAsync(user.Id, user.UserName, props);
return(Ok());
}
await _events.RaiseAsync(new UserLoginFailureEvent(model.Email, "invalid credentials"));
//ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
return(BadRequest(ModelState));
}
public ActionResult Login(LoginRequestViewModel model)
{
var loginResult = _userRegistrationService.ValidateUser(model.LoginName, model.Password);
if (loginResult == Core.Domain.Users.UserLoginResults.Successful)
{
var user = this._userService.GetUserByLoginName(model.LoginName);
_authenticationService.SignIn(user, model.RememberMe);
var usermodel = new UserViewModel()
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
IsAdmin = user.IsAdmin,
Language = user.Language,
LoginName = user.LoginName,
Phone = user.Phone,
OpenId = user.OpenId,
QQ = user.QQ,
Sex = user.Sex,
Address = user.Address,
Married = user.Married == null ? false : user.Married.Value,
Education = user.Education,
IdentityCard = user.IdentityCard
};
return(Json(ResponseMessageExt.Success("", usermodel)));
}
else
{
return(Json(ResponseMessageExt.Failed(loginResult.ToString())));
}
}
public LoginResponseViewModel Login(LoginRequestViewModel request)
{
Log.Information("Start - Login request for user: {0}", request.LoginName);
LoginResponseViewModel ret = null;
//1 - validation
var account = _accountRepository.GetByLoginName(request.LoginName);
//2 - Check if account exist
if (account != null && account.Id != 0)
{
//3 - Check if password is correct
if (!String.Equals(CommonHelper.EncodePasswordToBase64(request.Password, _config.GetValue <string>("HashKey")), account.Password))
{
CommonHelper.ThrowAppException("Username or Password is incorrect!");
}
ret = new LoginResponseViewModel()
{
LoginName = account.LoginName,
Id = account.Id,
AccountNumber = account.AccountNumber
};
}
Log.Information("End - Login request for user: {0}", request.LoginName);
return(ret);
}
public IActionResult Post([FromServices] ITokenService service, [FromBody] LoginRequestViewModel request)
{
try
{
var messages = new List <string>();
if (string.IsNullOrEmpty(request.UserName))
{
messages.Add("UserName or Password invalid!");
}
if (string.IsNullOrEmpty(request.Password))
{
messages.Add("UserName or Password invalid!");
}
if (messages.Count > 0)
{
return(NotFound(new GenericCommandResult(false, "Error Login", messages)));
}
var result = service.GenerateToken(request);
if (result.Equals(""))
{
return(Unauthorized());
}
return(Ok(new GenericCommandResult(true, "Successfully logged in", result)));
}
catch (Exception ex)
{
return(Ok(new GenericCommandResult(true, "Error authentication", ex.Message)));
}
}
public async Task <IActionResult> Login(LoginRequestViewModel viewModel)
{
if (ModelState.IsValid)
{
var token = await _userApiClient.Authenticate(viewModel);
if (token != "BadRequest")
{
// Giải mã token
var userprincipal = ValidateToken(token);
var authProperties = new AuthenticationProperties()
{
ExpiresUtc = DateTime.UtcNow.AddMinutes(10),
IsPersistent = false
};
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
userprincipal,
authProperties
);
string id = userprincipal.Claims.FirstOrDefault(x => x.Type == "Id").Value.ToString();
HttpContext.Session.SetString("Token", token);
HttpContext.Session.SetString("UserId", id);
return(Redirect("/Home/Index"));
}
else
{
return(Redirect("Index"));
}
}
return(Redirect("Index"));
}
public string GenerateToken(LoginRequestViewModel model)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var userValido = _userService.DadosValidos(model.UserName, model.Password);
if (userValido)
{
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, model.UserName),
new Claim("UserID", model.Password)
}),
Expires = DateTime.UtcNow.AddHours(2),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenResult = tokenHandler.WriteToken(token);
return(tokenResult);
}
else
{
return("");
}
}
public static LoginResponseViewModel Login(LoginRequestViewModel model)
{
var result = new LoginResponseViewModel();
try
{
var existingUser = db.Users.FirstOrDefault(p => p.UserName == model.UserName);
if (existingUser == null)
{
result.Message = "User not found";
}
else
{
if (model.HashedPassword == existingUser.PasswordHashed)
{
result.Status = true;
result.Message = "Successfully logged in";
result.UserId = existingUser.Id;
result.UserName = existingUser.UserName;
result.Type = existingUser.UserType;
}
else
{
result.Message = "Password didnot match";
}
}
}
catch (Exception ex)
{
result.Message = ex.Message;
}
return(result);
}
public IActionResult Post([FromBody] LoginRequestViewModel value)
{
try
{
if (ModelState.IsValid)
{
var loginstatus = _users.AuthenticateUsers(value.UserName,
EncryptionLibrary.EncryptText(value.Password));
if (loginstatus)
{
var userdetails = _users.GetUserDetailsbyCredentials(value.UserName,
EncryptionLibrary.EncryptText(value.Password));
if (userdetails != null)
{
// Jason Web Token (Jwt) security token handler
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, userdetails.UserId.ToString())
}),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
value.Token = tokenHandler.WriteToken(token);
// Remove password before returning
value.Password = null;
value.Usertype = userdetails.RoleId;
return(Ok(value));
}
else
{
value.Password = null;
value.Usertype = 0;
return(Ok(value));
}
}
value.Password = null;
value.Usertype = 0;
return(Ok(value));
}
value.Password = null;
value.Usertype = 0;
return(Ok(value));
}
catch (Exception)
{
throw;
}
}
public Usuario DeViewModelParaModel(LoginRequestViewModel viewModel)
{
Usuario model = new Usuario();
model.PreencherLogin(viewModel.Email, viewModel.Senha);
return(model);
}
public LoginResponseViewModel Obter(LoginRequestViewModel request)
{
Login requestModel = _loginMapper.DeViewModelParaModel(request);
Login responseModel = _loginService.Obter(requestModel);
LoginResponseViewModel response = _loginMapper.DeModelParaViewModel(responseModel);
return(response);
}
public ActionResult Login(LoginRequestViewModel loginRequestViewModel)
{
// Initialize
questStatus status = null;
LoginResponseViewModel loginResponseViewModel = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
loginResponseViewModel = new LoginResponseViewModel();
loginResponseViewModel.UserMessages[0] = new UserMessageModeler(status).UserMessage;
status.Message = null;
loginResponseViewModel.questStatus = status;
TempData["LoginResponseViewModel"] = loginResponseViewModel;
return(RedirectToAction("Index"));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize();
if (!questStatusDef.IsSuccess(status))
{
loginResponseViewModel = new LoginResponseViewModel();
loginResponseViewModel.UserMessages[0] = new UserMessageModeler(status).UserMessage;
status.Message = null;
loginResponseViewModel.questStatus = status;
TempData["LoginResponseViewModel"] = loginResponseViewModel;
return(RedirectToAction("Index"));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Login
*---------------------------------------------------------------------------------------------------------------------------------*/
UserSessionId userSessionId = null;
AccountModeler accountModeler = new AccountModeler(this.Request, this.UserSession);
status = accountModeler.Login(Request, loginRequestViewModel, out userSessionId);
if (!questStatusDef.IsSuccess(status))
{
loginResponseViewModel = new LoginResponseViewModel();
////loginResponseViewModel.UserMessages.Add(new UserMessageModeler(new questStatus(Severity.Error, "Invalid username or password")).UserMessage);
loginResponseViewModel.UserMessages.Add(new UserMessageModeler(new questStatus(status.Severity, status.Message)).UserMessage);
status.Message = null;
loginResponseViewModel.questStatus = status;
TempData["LoginResponseViewModel"] = loginResponseViewModel;
return(RedirectToAction("Index"));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Direct user to home page.
*---------------------------------------------------------------------------------------------------------------------------------*/
return(RedirectToAction("Index", "Home", new { _ctx = userSessionId.Id }));
}
public Login DeViewModelParaModel(LoginRequestViewModel viewModel)
{
Login model = new Login
{
Email = viewModel.Email,
Senha = viewModel.Senha
};
return(model);
}
public LoginResponseViewModel LogIn(LoginRequestViewModel request)
{
LoginResponseViewModel response = _loginAppService.Obter(request);
if (response != null && !string.IsNullOrEmpty(response.Nome))
{
_customAuthenticationStateProvider.LogIn(response);
}
return(response);
}
private async Task <ClaimsIdentity> Authenticate(LoginRequestViewModel viewModel)
{
User user = await _accountService.Authenticate(viewModel.Username, viewModel.Password);
if (user == null)
{
return(null);
}
return(BuildClaimsIdentity(user));
}
public LoginResponseViewModel Login(LoginRequestViewModel login)
{
var result = _clientBusiness.Login(_mapper.Map <Client>(login));
var loginViewModel = _mapper.Map <LoginResponseViewModel>(result);
if (result != null)
{
loginViewModel.Claims = _clientBusiness.GetClaims(result.Id).ToList();
}
return(loginViewModel);
}
private void Login()
{
if (string.IsNullOrWhiteSpace(txtUserName.Text))
{
MessageBox.Show("Username is required");
return;
}
if (string.IsNullOrWhiteSpace(txtPassword.Text))
{
MessageBox.Show("password is required");
return;
}
var loginrequest = new LoginRequestViewModel()
{
UserName = txtUserName.Text,
Password = txtPassword.Text
};
var result = Services.UserService.Login(loginrequest);
if (result.Status)
{
switch (result.Type)
{
case Common.UserType.Student:
StudentDashboard student = new StudentDashboard(result);
student.Show();
break;
case Common.UserType.Teacher:
TeacherDashboard teacher = new TeacherDashboard(result);
teacher.Show();
break;
case Common.UserType.Parent:
break;
case Common.UserType.Admin:
AdminDashboard admin = new AdminDashboard(result);
admin.Show();
break;
default:
break;
}
this.Hide();
}
else
{
MessageBox.Show(result.Message);
}
}
public IActionResult Login([FromBody] LoginRequestViewModel request)
{
var user = _userRepository.GetByUsername(request.Username);
if (user != null && user.Password == request.Password)
{
var token = _authenticationService.GenerateBearerToken(user);
return(Ok(token));
}
return(Unauthorized("Wrong username or password"));
}
public async Task <ActionResult <LoginResponseViewModel> > LoginAsync([FromBody] LoginRequestViewModel request, CancellationToken cancellationToken)
{
var response = await _loginGateway.LoginAsync(_mapper.Map <LoginRequest>(request), cancellationToken);
if (string.IsNullOrWhiteSpace(response?.Token))
{
return(Ok(new LoginResponseViewModel("LoginAsync failed", false)));
}
Cookies.SetUserToken(Response, response.Token);
return(Ok(new LoginResponseViewModel($"Welcome {request.Username}", true)));
}
public async Task <IActionResult> authenticate([FromBody] LoginRequestViewModel request)
{
var resultToken = await _userService.Authencate(request);
if (string.IsNullOrEmpty(resultToken))
{
return(BadRequest("Username or password incorrect"));
}
else
{
return(Ok(resultToken));
}
}
public async Task <dynamic> Post([FromBody] LoginRequestViewModel req)
{
_logger.Log(new LogInformation
{
Module = CrossCuttingLayer.Logging.Constants.TokenModule,
UserId = _userContextAccessor.UserId,
Message = CrossCuttingLayer.Logging.Constants.MethodInvokedMessage
});
var applicationUser = await _user.Service.ValidateUser(req, 1);
//await _user.Service.ValidateUser(req, 1); //_userContextAccessor.UserId
return(applicationUser);
}
public ActionResult Authenticate(LoginRequestViewModel loginRequestViewModel)
{
// Initialize
questStatus status = null;
UserMessageModeler userMessageModeler = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize();
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Login
*---------------------------------------------------------------------------------------------------------------------------------*/
UserSessionId userSessionId = null;
AccountModeler accountModeler = new AccountModeler(this.Request, this.UserSession);
status = accountModeler.Login(Request, loginRequestViewModel, out userSessionId);
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
BaseUserSessionViewModel baseUserSessionViewModel = new BaseUserSessionViewModel();
baseUserSessionViewModel._ctx = userSessionId.Id;
baseUserSessionViewModel.questStatus = new questStatus(Severity.Success, "Successfully authenticated");
return(Json(baseUserSessionViewModel, JsonRequestBehavior.AllowGet));
}
public async void Login_LoginModelError()
{
//Arrange
var mockLoginRequest = new LoginRequestViewModel();
_accountController.ModelState.AddModelError("LoginName", "Username field is required");
_accountController.ModelState.AddModelError("Password", "Password field is required");
//Act
var result = await _accountController.Login(mockLoginRequest);
//Assert
Assert.True(((ViewResult)result).ViewData.ModelState["LoginName"].Errors.Count > 0);
Assert.True(((ViewResult)result).ViewData.ModelState["Password"].Errors.Count > 0);
}
public async Task <IActionResult> Login([FromBody] LoginRequestViewModel model)
{
LoginInteractor loginRequestInteractor = new LoginInteractor(_authenticationService, _accountRepository, _jwtFactory, _jwtOptions);
var requestMessage = new LoginRequestMessage(model.Email, model.Password);
var responseMessage = await loginRequestInteractor.Handle(requestMessage);
var presenter = new LoginResponsePresenter();
var viewModel = presenter.Handle(responseMessage);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(new OkObjectResult(viewModel));
}
public async Task <string> Authencate(LoginRequestViewModel request)
{
var user = await _userManager.FindByNameAsync(request.UserName);
if (user == null)
{
return(null);
}
var result = await _signInManager.PasswordSignInAsync(user, request.Password, request.RemenberMe, true);
if (!result.Succeeded)
{
return(null);
}
var roles = await _userManager.GetRolesAsync(user);
var claims = new[]
{
new Claim("Email", user.Email),
new Claim("FristName", user.FristName),
new Claim("Id", user.Id.ToString()),
new Claim("Roles", string.Join(";", roles))
};
//var tokenHandler = new JwtSecurityTokenHandler();
//var key = Encoding.ASCII.GetBytes(_config["AppSettings:Secret"]);
//var tokenDescriptor = new SecurityTokenDescriptor
//{
// Subject = new ClaimsIdentity(claims),
// Expires = DateTime.UtcNow.AddDays(7),
// SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
//};
//var token = tokenHandler.CreateToken(tokenDescriptor);
//return tokenHandler.WriteToken(token);
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken("abc",
"abc",
claims,
expires: DateTime.Now.AddHours(3),
signingCredentials: creds);
return(new JwtSecurityTokenHandler().WriteToken(token));
//throw new NotImplementedException();
}
public HttpResponseMessage Login([FromBody] LoginRequestViewModel request)
{
var result = new ResultViewModel <User>();
try
{
var user = AutofacConfig.Resolve <IUserService>().Login(request.Username, request.Password);
result.Code = "200";
result.Message = "OK";
result.Data = user;
}
catch (Exception e)
{
Console.WriteLine(e);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
public IActionResult GetToken([FromBody] LoginRequestViewModel loginRequestDto)
{
var login = Mapper.Map <LoginDto>(loginRequestDto);
var state = _userService.Login(login);
if (state == -1 || state == -2)
{
return(Ok(new ResponseViewModel(StatusCodeEnum.AccountError, "账号或密码错误")));
}
var tokenString = _tokenService.WriteToken(new UserModel()
{
DomainAccount = loginRequestDto.Account
});
return(Ok(new DataResponseViewModel()
{
Data = new { errorMessage = "", token = tokenString }
}));
}
public async Task <IActionResult> Login([FromBody] LoginRequestViewModel viewModel)
{
if (ModelState.IsValid)
{
ClaimsIdentity identity = await Authenticate(viewModel);
if (identity == null)
{
return(Unauthorized());
}
JwtSecurityToken jwtSecurityToken = BuildToken(_jwtSettings, identity);
LoginResponseViewModel response = new LoginResponseViewModel(new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken), jwtSecurityToken.ValidTo, jwtSecurityToken.Claims);
return(Success(response));
}
return(Error(ModelState));
}
public async Task <string> Authenticate(LoginRequestViewModel viewModel)
{
var json = JsonConvert.SerializeObject(viewModel);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var client = _httClientFactory.CreateClient();
client.BaseAddress = new Uri("http://apieshop.somee.com");
var response = await client.PostAsync("/api/User/authenticate", httpContent);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var token = await response.Content.ReadAsStringAsync();
return(token);
}
else
{
var status = response.StatusCode;
return(status.ToString());
}
}
public IActionResult Login([FromBody] LoginRequestViewModel request)
{
if (request == null)
{
return(BadRequest(new ErrorViewModel("Please provide credintials")));
}
if (string.IsNullOrWhiteSpace(request.Email))
{
return(BadRequest(new ErrorViewModel($"Please provide '{nameof(request.Email)}'")));
}
if (string.IsNullOrWhiteSpace(request.Password))
{
return(BadRequest(new ErrorViewModel($"Please provide '{nameof(request.Password)}'")));
}
var user = _userService.GetUser(request.Email);
if (user == null)
{
// use same message for "unknown user" and "wrong password" to make hacking harder
return(BadRequest(new ErrorViewModel("Incorrect login")));
}
var errorMessage = _userService.LoginPassword(user, request.Password, string.Empty);
if (!string.IsNullOrEmpty(errorMessage))
{
return(BadRequest(new ErrorViewModel(errorMessage)));
}
return(Ok(new TokenResponseViewModel
{
AccessToken = _userService.GenerateJsonWebToken(user),
ExpiresIn = 100,
RefreshToken = Guid.NewGuid().ToString(),
TokenType = "Bearer"
}));
}
public async Task <IActionResult> Login(LoginRequestViewModel model)
{
if (ModelState.IsValid)
{
try
{
LoginResponseViewModel response = _accountManager.Login(model);
if (response != null)
{
var claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, response.Id.ToString()),
new Claim(ClaimTypes.Name, response.LoginName),
};
var claimsIdentity = new ClaimsIdentity(
claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties()
{
IsPersistent = true
};
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
return(RedirectToAction("Index", "Home"));
}
}
catch (AppException app)
{
ModelState.AddModelError(string.Empty, app.Message);
}
}
return(View());
}
