public async Task <IActionResult> Login(LoginAccountViewModel model)
{
if (ModelState.IsValid)
{
AppIdentityUser userLogin = await _userManager.FindByEmailAsync(model.Email);
if (userLogin == null)
{
return(NotFound());
}
var result = await _signInManager.PasswordSignInAsync(user : userLogin,
password : model.Password,
isPersistent : model.IsRemember,
lockoutOnFailure : false);
if (result.Succeeded)
{
if (!String.IsNullOrEmpty(model.ReturnUrl))
{
return(Redirect(model.ReturnUrl));
}
return(RedirectToAction(actionName: "Index", controllerName: "Home"));
}
ModelState.AddModelError("", "Something was wrong, please check again");
}
return(View(model));
}
public async Task <ActionResult> Login(LoginAccountViewModel loginAccount)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
var result = await _signInManager.PasswordSignInAsync(loginAccount.Email, loginAccount.Password, false, true);
if (!result.Succeeded)
{
return(BadRequest("Usuário ou senha inválidos"));
}
var user = await _userManager.FindByEmailAsync(loginAccount.Email);
var token = await GenerateJwt(loginAccount.Email);
var userObj = new
{
token,
user = new
{
user.UserName,
user.Email,
user.Id
}
};
return(Ok(userObj));
}
public ActionResult Login(LoginAccountViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var response = _membershipService.LoginUser(model.ConvertToLoginUserRequest());
if (!response.HasIssues && response.UserLogin.IsAuthenticated)
{
var authCookie = SetLoginCookie(response);
Response.Cookies.Add(authCookie);
return(RedirectToLocal(returnUrl));
}
model.HasIssues = true;
model.ErrorMessage = !string.IsNullOrEmpty(response.ErrorMessage)
? response.ErrorMessage
: "Sorry we could not authenticate you. Please try again.";
return(View(model));
}
public async Task <IActionResult> Login([FromBody] LoginAccountViewModel model)
{
var targetAccount = accountRepository.GetByUserName(model.Username);
if (targetAccount == null)
{
return(BadRequest("Le compte n'existe pas."));
}
var hasher = new PasswordHasher <Account>();
var result = hasher.VerifyHashedPassword(targetAccount, targetAccount.PasswordHash, model.Password);
if (result != PasswordVerificationResult.Success)
{
return(BadRequest("Mot de passe incorrect."));
}
await accountRepository.LogIn(targetAccount);
LoginAccountViewModel dd = new LoginAccountViewModel();
dd.Username = model.Username;
dd.Password = model.Password;
return(Ok(dd));
}
public async Task <IActionResult> Login(LoginAccountViewModel model)
{
HttpClient client = _client.Initiale();
client.DefaultRequestHeaders.Accept.Clear();
var response = await client.PostAsJsonAsync("https://comptes-api.azurewebsites.net/api/ComptesAPI/Login", model);
if (response.IsSuccessStatusCode)
{
var claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.Name, model.Username));
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
try
{
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, claimsPrincipal);
}
catch (Exception ex)
{
}
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <IActionResult> Login(LoginAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
if (user.IsActive)
{
var result = await _signInManager.PasswordSignInAsync(user, model.Password, isPersistent : model.IsRemember, lockoutOnFailure : false);
if (result.Succeeded)
{
if (await _userManager.IsInRoleAsync(user, "Lái xe"))
{
return(RedirectToAction(actionName: "Mobile", controllerName: "Home", new { area = "Driver" }));
}
return(RedirectToAction(actionName: "Index", controllerName: "Home"));
}
}
else
{
ModelState.AddModelError("", "Tài khoản đã bị khóa");
return(View(model));
}
}
}
ModelState.AddModelError("", "Đăng nhập không thành công, xin mời kiểm tra lại");
return(View(model));
}
public async Task <IActionResult> Find([FromBody] LoginAccountViewModel model)
{
IActionResult res = Unauthorized();
var user = await _accountService.FindUser(model);
return(Ok(user));
}
public async Task AutologinUserAsync(RegisterAccountViewModel model)
{
var loginModel = new LoginAccountViewModel();
loginModel.Email = model.Email;
loginModel.Password = model.Password;
await GetUserAsync(loginModel);
}
public LoginPage(User CurrentUser = null)
{
InitializeComponent();
BindingContext = viewModel = new LoginAccountViewModel();
userManager = UserManager.DefaultManager;
if (CurrentUser != null)
{
viewModel.MailAdress = CurrentUser.MailAdress;
}
}
public async Task GetUserAsync(LoginAccountViewModel model)
{
var url = "/Account/login";
var json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _httpService.ExecuteQuery(url, HttpOperationMode.POST, httpContent);
var testToken = await _httpService.ProcessToken(response);
CrossSecureStorage.Current.SetValue("securityToken", testToken);
}
public async Task <IActionResult> Login([FromBody] LoginAccountViewModel model)
{
IActionResult res = Unauthorized();
var token = await _accountService.SignIn(model);
if (token != null)
{
return(Ok(token));
}
return(res);
}
public async Task <EditAccountViewModel> GetUserInfo(LoginAccountViewModel model)
{
var url = "/Account/getInfo";
var json = JsonConvert.SerializeObject(model);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _httpService.ExecuteQuery(url, HttpOperationMode.POST, httpContent);
var parsedResult = await _httpService.ProcessJson <EditAccountViewModel>(response);
return(parsedResult);
}
public ActionResult Login(string returnUrl)
{
ViewBag.ReturnUrl = returnUrl;
var model = new LoginAccountViewModel
{
HasIssues = false,
ErrorMessage = string.Empty
};
return(View(model));
}
public async Task<TokenResult> GetAccessToken(LoginAccountViewModel userInfo)
{
var user = await GetUserByUserNameOrEmail(userInfo);
if (user == null)
{
return new TokenResult(null);
}
UpdateUserStatus(user, UserAvailabilityStatus.Online);
var userRole = await GetFirstUserRole(user);
var identity = GetIdentity(user, userRole);
var token = TokenGenerator.GenerateSecurityToken(identity);
return new TokenResult(user, userRole, token);
}
public async Task <EditAccountViewModel> FindUser(LoginAccountViewModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
var editUser = new EditAccountViewModel();
editUser.Email = user.Email;
editUser.FirstName = user.FirstName;
editUser.LastName = user.LastName;
editUser.UserImage = user.UserImage;
if (user == null)
{
throw new ApplicationException("User is not found.");
}
return(editUser);
}
public async void Task_Login_BadRequestResult()
{
//Arrange
var controller = new ComptesAPIController(repository);
string username = RandomString(7);
var account = new LoginAccountViewModel()
{
Username = "******",
Password = "******",
};
//Act
var data = await controller.Login(account);
//Assert
Assert.IsType <BadRequestObjectResult>(data);
}
public async Task <IActionResult> Login([FromBody] LoginAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (!result.Succeeded)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState)));
}
User user = await _userManager.FindByEmailAsync(model.Email);
var isAdmin = await _userManager.IsInRoleAsync(user, Roles.Admin.ToString().ToLower());
return(Ok(isAdmin));
}
public async Task <IActionResult> Login([FromBody] LoginAccountViewModel model)
{
try
{
var result = await _accountServise.Login(model);
return(Ok(result));
}
catch (BusinessLogicException exception)
{
return(BadRequest(exception.Message));
}
catch (Exception exception)
{
_logger.LogInformation(exception.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <ResponseLoginAccount> Login(LoginAccountViewModel model)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (!result.Succeeded)
{
throw new BusinessLogicException("Wrong login or password");
}
User user = _userManager.Users.SingleOrDefault(r => r.Email == model.Email);
var token = GenerateJwtToken(model.Email, user);
var roleToken = new ResponseLoginAccount()
{
Role = user.Role,
Token = token
};
return(roleToken);
}
public async Task <string> SignIn(LoginAccountViewModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
throw new ApplicationException("User is not found.");
}
var isEmailConfirm = await _userManager.IsEmailConfirmedAsync(user);
if (!isEmailConfirm)
{
throw new ApplicationException("Email is not confirmed");
}
var token = await GetToken(user);
return(token);
}
public async Task <IActionResult> Create(RegisterAccountViewModel model)
{
HttpClient client = _client.Initiale();
client.DefaultRequestHeaders.Accept.Clear();
var response = await client.PostAsJsonAsync("https://comptes-api.azurewebsites.net/api/ComptesAPI/AddAccount", model);
if (response.IsSuccessStatusCode)
{
LoginAccountViewModel loginModel = new LoginAccountViewModel();
loginModel.Username = model.Username;
loginModel.Password = model.Password;
response = await client.PostAsJsonAsync("https://comptes-api.azurewebsites.net/api/ComptesAPI/Login", loginModel);
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
}
return(BadRequest());
}
public static LoginUserRequest ConvertToLoginUserRequest(this LoginAccountViewModel model)
{
return(Mapper.Map <LoginAccountViewModel, LoginUserRequest>(model));
}
public ActionResult Login(LoginAccountViewModel account)
{
IAuthenticated authenticated = null;
if (ModelState.IsValid)
{
RestClient client = RemoteConfig.Client;
RestRequest request = RemoteConfig.AUTHENTICATE.Request;
request.AddParameter("email", account.Email);
request.AddParameter("password", account.Password);
IRestResponse response = client.Execute(request);
try
{
JObject jObject = JObject.Parse(response.Content);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
String token = (String)jObject["token"];
request = RemoteConfig.USER.Request;
request.AddHeader("Authorization", $"JWT {token}");
response = client.Execute(request);
try
{
jObject = JObject.Parse(response.Content);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
JToken jToken = jObject["user"];
authenticated = new AuthUser(new User
{
Id = (String)jToken["_id"],
FirstName = (String)jToken["firstName"],
LastName = (String)jToken["lastName"],
Email = (String)jToken["email"],
// TODO createdAt, convert string to date
}, token);
}
}
catch
{
Debug.WriteLine("exception");
}
}
else
{
ModelState.AddModelError("password", (String)jObject["message"]);
}
}
catch
{
ModelState.AddModelError("password", "Unable issue the server for authentication");
}
}
if (authenticated != null)
{
Session[Reference.KEY_USER_SESSION] = authenticated as IAuthenticated;
return(RedirectToAction("Index", "Default"));
}
return(View());
}
public async Task <TokenResult> GetAccessToken([FromBody] LoginAccountViewModel model)
{
return(await userService.GetAccessToken(model));
}
private async Task<User> GetUserByUserNameOrEmail(LoginAccountViewModel userInfo)
{
var user = await userManager.FindByEmailAsync(userInfo.Login);
return user ?? await userManager.FindByNameAsync(userInfo.Login);
}
