public HttpResponseMessage Login(HttpRequestMessage request, [FromBody] LoginUserDTO loginUserDTO) { AccountsApiModel accountsWebApiModel = new AccountsApiModel(); TransactionalInformation transaction = new TransactionalInformation(); AccountsBusinessService accountsBusinessService; if (loginUserDTO.UserName == null) { loginUserDTO.UserName = ""; } if (loginUserDTO.Password == null) { loginUserDTO.Password = ""; } accountsBusinessService = new AccountsBusinessService(accountsDataService); User user = accountsBusinessService.Login( loginUserDTO.UserName, loginUserDTO.Password, out transaction); if (transaction.ReturnStatus == false) { accountsWebApiModel.ReturnMessage = transaction.ReturnMessage; accountsWebApiModel.ReturnStatus = transaction.ReturnStatus; accountsWebApiModel.ValidationErrors = transaction.ValidationErrors; var badResponse = Request.CreateResponse <AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel); return(badResponse); } ApplicationInitializationBusinessService initializationBusinessService; initializationBusinessService = new ApplicationInitializationBusinessService(applicationDataService); List <ApplicationMenu> menuItems = initializationBusinessService.GetMenuItems(true, out transaction); if (transaction.ReturnStatus == false) { accountsWebApiModel.ReturnMessage = transaction.ReturnMessage; accountsWebApiModel.ReturnStatus = transaction.ReturnStatus; var badResponse = Request.CreateResponse <AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel); return(badResponse); } accountsWebApiModel.ReturnStatus = transaction.ReturnStatus; accountsWebApiModel.IsAuthenicated = true; accountsWebApiModel.ReturnMessage.Add("Login successful."); accountsWebApiModel.MenuItems = menuItems; accountsWebApiModel.User = user; FormsAuthentication.SetAuthCookie(user.UserId.ToString(), createPersistentCookie: false); var response = Request.CreateResponse <AccountsApiModel>(HttpStatusCode.OK, accountsWebApiModel); return(response); }
public async Task <RegisterUserDTO> ValidateLogin(LoginUserDTO model) { var user = await DbContext.UserDatas.Where(u => u.Email == model.Email && u.Password == model.Password) .FirstOrDefaultAsync(); if (user != null) { return(Mapper.Map <RegisterUserDTO>(user)); } return(null); }
public async Task <IActionResult> Login(LoginUserDTO request) { ServiceResponse <string> response = await _authRepo.Login( request.Username, request.Password); if (!response.Success) { return(BadRequest(response)); } return(Ok(response)); }
public bool Insert(LoginUserDTO value) { User val = new User(); val = mapper.LoginUserDTOToUser(value); val.CreatedOn = DateTime.Now; val.ModifiedOn = DateTime.Now; house.Insert(val); return(true); }
public async Task <bool> ValidateUser(LoginUserDTO userDTO) { //_user = await _userManager.FindByNameAsync(userDTO.Email); //return (_user != null && await _userManager.CheckPasswordAsync(_user, userDTO.Password)); _user = await _userManager.FindByNameAsync(userDTO.Email); var validPassword = await _userManager.CheckPasswordAsync(_user, userDTO.Password); return(_user != null && validPassword); }
public LoginUserDTO GetUserLoginCredentials(string userName, string password) { LoginUserDTO user = new LoginUserDTO(); if (userName != null && password != null) { user.UserName = userName; user.Password = password; } return(user); }
public async Task LoginFailUserTest() { var request = new LoginUserDTO() { Login = "******", Password = "******" }; var response = await _client.GetAsync($"account/{request.Login}/{request.Password}"); var responseString = await response.Content.ReadAsStringAsync(); responseString.Should().BeEquivalentTo("INVALID_USER"); }
public async Task <ActionResult <SuccessfulLoginResult> > Login([FromBody] LoginUserDTO login) { Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(login.Email, login.Password, isPersistent : false, lockoutOnFailure : false); User user = await _userManager.FindByEmailAsync(login.Email); JwtSecurityToken token = await GenerateTokenAsync(user); // defined string serializedToken = new JwtSecurityTokenHandler().WriteToken(token); // serilize the token return(Ok(serializedToken)); }
public async Task <IActionResult> Login([FromBody] LoginUserDTO login) { if (ModelState.IsValid) { var res = await userService.LoginUser(login); switch (res) { case LoginUserResult.IncorrectData: return(JsonResponseStatus.NotFound(new { message = "حسابی با این مشخصات وجود ندارد" })); case LoginUserResult.NotActivated: return(JsonResponseStatus.Error(new { message = "حساب کاربری شما فعال نشده است" })); case LoginUserResult.Success: var user = await userService.GetUserByEmail(login.Email); var userRole = await userService.GetUserRoleById(user.Id); var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("JupiterJwtBearer")); var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256); var tokenOptions = new JwtSecurityToken( issuer: "https://localhost:5001", claims: new List <Claim> { new Claim(ClaimTypes.Name, user.Email), new Claim(ClaimTypes.Role, userRole), new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()) }, expires: DateTime.Now.AddDays(30), signingCredentials: signinCredentials ); var tokenString = new JwtSecurityTokenHandler().WriteToken(tokenOptions); return(JsonResponseStatus.Success(new { token = tokenString, expireTime = 30, firstName = user.FirstName, lastName = user.LastName, userId = user.Id, avatar = user.Avatar, role = userRole, email = user.Email, gender = user.Gender, })); } } return(JsonResponseStatus.Error()); }
public async Task <IActionResult> Login(LoginUserDTO user) { if (ModelState.IsValid) { var result = await _signManager.PasswordSignInAsync(user.UserName, user.Password, false, false); if (!result.Succeeded) { return(Login()); } } return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> UserLogin([FromBody] LoginUserDTO login) { try { var result = await _userService.Login(login); return(result is null || !result.Authenticated ? (IActionResult)NotFound() : Ok(result)); } catch (ArgumentException e) { return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message)); } }
public async Task <AuthResponce> LoginUserDTO_LogInAsync_Return_AuthResponce() { CreateDefaultApplicationUserServiceInstance(); var _fake = _fakeUsers[0]; var fakeLoginModel = new LoginUserDTO(); fakeLoginModel.Email = _fake.Email; fakeLoginModel.Password = RandomString(5); var authResponce = await _userService.LogInAsync(fakeLoginModel, RandomString(9)); Assert.NotNull(authResponce); return(authResponce); }
[Route("Authenticate")] // public IActionResult Authenticate([FromBody] LoginUserDTO registerUser) { var authenticatedUser = _userService.Authenticate(ref registerUser); if (authenticatedUser == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } return(Ok(GenerateUserWithToken(new UserDTO { Id = authenticatedUser.Id, UserName = authenticatedUser.UserName }))); }
//[ValidateAntiForgeryToken] public ActionResult RegisterUser([Bind(Include = "ID,Email,Password,FullName")] LoginUserDTO user) { if (ModelState.IsValid) { TempData["SuccessMessage"] = "Registration Successful"; _busiuser.Insert(user); return(RedirectToAction("Index", "Home")); } else { return(View("Create")); } }
public async Task <ActionResult> Login(LoginUserDTO dto) { var login = await userService.Login(dto, AuthenticationManager); if (login) { return(RedirectToAction("Index", "Home")); } else { return(View()); } }
public async Task <ServiceResult> Login(LoginUserDTO model) { ServiceResult result = new ServiceResult(); var logResult = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); if (logResult.Succeeded) { result.Status = ServiceResultStatus.Success; } return(result); }
public async Task <IActionResult> Login([FromBody] LoginUserDTO userDTO) { _logger.LogInformation($"Login Attempt for {userDTO.Email} "); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!await _authManager.ValidateUser(userDTO)) { return(Unauthorized()); } return(Accepted(new { Token = await _authManager.CreateToken() })); }
public async Task <IActionResult> SignIn(LoginUserDTO userData) { if (ModelState.IsValid) { string accessToken = await authenticationService.Authenticate(userData); if (string.IsNullOrEmpty(accessToken)) { return(BadRequest("Invalid username or password")); } return(Ok(accessToken)); } return(Conflict(ModelState)); }
/// <summary> /// Crea nuevo SessionToken y lo registra en la base de datos, si ya existía anteriormente actualiza su fecha de expiración. /// </summary> /// <param name="user">EL User al que corresponde el token</param> /// <param name="deviceIdentifier">Identificador del dispositivo que esta utilizando el usuario</param> /// <param name="expireHours">La cantidad de horas hasta que expira el token. Si es null no expirará.</param> /// <returns>El token creado</returns> public static SessionTokenDTO Create(LoginUserDTO user, string tokenKey, int?expireHours) { SessionTokenDTO sessionTokenDto = new SessionTokenDTO { /* Para mayor seguridad, se repite el totenKey dos veces al armar el token */ Token = AesEncryption.GetInstance().Encrypt(user.UserName + tokenKey + tokenKey), IdUser = user.UserName }; /* Genera el token en la BDD */ //sessionTokenDto = Create(sessionTokenDto); return(sessionTokenDto); }
public LoginUserDTO Get_LoginUser_Data(LoginUserSearchDTO searchModel) { log.MethodStart(); LoginUserDTO objReturn = new LoginUserDTO(); using (var trans = _db.Database.BeginTransaction()) { try { var objResult = _db.LoginUserDTOs.FromSqlRaw <LoginUserDTO>("sp_Check_UserLogin {0}, {1}", searchModel.usr_username, searchModel.usr_password).ToList(); if (objResult.Count > 0) { objReturn = objResult.FirstOrDefault(); _db.LogUserLogins.Add(new LogUserLogin() { log_usr_id = objReturn.usr_username, log_access_ip = searchModel.usr_clientIp, log_session_id = searchModel.usr_sessionId, log_login_timestamp = DateTime.Now, log_status = "Login" }); var objUserLogin = _db.TCUserLogins.FirstOrDefault(x => x.usr_username == searchModel.usr_username); if (objUserLogin != null) { objUserLogin.usr_accessFailedCount = 0; } _db.SaveChanges(); } trans.Commit(); } catch (Exception ex) { // TODO: Handle failure trans.Rollback(); } finally { trans.Dispose(); } } log.MethodFinish(); return(objReturn); }
public LoginedUserDTO LoginUser(LoginUserDTO loginUserDTO) { var list = UserRepository.Find(tempuser => (tempuser.Email == loginUserDTO.Email && tempuser.Password == loginUserDTO.Password)).ToList(); if (list.Count != 0) { User user = list.First(); var config = new MapperConfiguration(cfg => cfg.CreateMap <User, LoginedUserDTO>()); var mapper = config.CreateMapper(); LoginedUserDTO logineduser = mapper.Map <User, LoginedUserDTO>(user); return(logineduser); } return(null); }
public UserDTO Authenticate(ref LoginUserDTO registeredUser) { string userName = registeredUser.UserName, password = registeredUser.Password; var user = dbContext.Users.FirstOrDefault(x => x.UserName == userName && x.Password == password); if (user == null) { return(null); } return(new UserDTO { Id = user.Id, UserName = user.UserName }); }
public LoginUserDTO GetUserCredentials() { if (Preferences.Get("stored_user", string.Empty) != true.ToString()) { return(null); } var loginUser = new LoginUserDTO() { Username = Preferences.Get("username", string.Empty), Password = Preferences.Get("password", string.Empty) }; return(loginUser); }
public async Task <LoginResult> LoginAsync(LoginUserDTO loginUser) { using (var httpClient = new HttpClient()) { var response = await httpClient.PostAsync(_apiURL, new StringContent( JsonConvert.SerializeObject(loginUser), Encoding.UTF8, "application/json" )); var jsonResponse = await response.Content.ReadAsStringAsync(); return(JsonConvert.DeserializeObject <LoginResult>(jsonResponse)); } }
public bool PasswordValidation(LoginUserDTO credentials) { string name = credentials.UserName; string password = credentials.Password; User user = GetUserByUserName(name); if (user != null) { if (user.UserName == name && PasswordHashTool.VerifyHashedPassword(password, user.Password)) { return(true); } } return(false); }
public async Task <Tuple <LoginUserDTO, ExamCreate.ExamData, ExamDTO> > CreateExam( bool includeTags = true, bool isPrivate = false, string[] extraTags = null, LoginUserDTO loggedUser = null) { loggedUser = loggedUser ?? (await CreateUserAndLogin()).Item4; var examData = TestData.Exam.Create.NewExamData(includeTags, isPrivate, extraTags); client.Authorize(loggedUser.Token); var responseExam = await client.PostExamSuccesfully("/exams", new ExamCreate.Request() { Exam = examData }); client.Unauthorize(); return(Tuple.Create(loggedUser, examData, responseExam)); }
//POST : /api/ApplicationUser/Login public async Task <IActionResult> Login(LoginUserDTO model) { _logger.LogInfo($"Logging account with username {model.UserName}..."); var user = await _userManager.FindByNameAsync(model.UserName); if (user == null) { _logger.LogError($"Username or password is incorrect."); return(BadRequest(new { message = "Username or password is incorrect." })); } if (await _userManager.CheckPasswordAsync(user, model.Password)) { if (user.LockoutEnd >= DateTime.UtcNow) { _logger.LogError($"User have entered 3 invalid attempts"); user.AccessFailedCount = 0; return(Forbid()); } user.AccessFailedCount = 0; //Get role assigned to the user var role = await _userManager.GetRolesAsync(user); var options = new IdentityOptions(); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new[] { new Claim("UserID", user.Id), new Claim(options.ClaimsIdentity.RoleClaimType, role.FirstOrDefault()) }), Expires = DateTime.UtcNow.AddDays(1), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings.JWT_Secret)), SecurityAlgorithms.HmacSha256Signature) }; var tokenHandler = new JwtSecurityTokenHandler(); var securityToken = tokenHandler.CreateToken(tokenDescriptor); var token = tokenHandler.WriteToken(securityToken); return(Ok(new { token })); } await _userManager.AccessFailedAsync(user); // Register failed access return(BadRequest(new { message = "Incorrect password." })); }
public async Task <IActionResult> Login([FromBody] LoginUserDTO loginUser) { var user = await _dbContext.AuthenticateAsync(loginUser.Email, loginUser.Password); if (user != null) { return(Ok(new { token = _authProvider.GenerateNewToken(user), expiry = "30 minutes", userId = user.Id.ToString() })); } else { return(Unauthorized()); } }
public async Task <ActionResult <TokenDTO> > GetTokenAsync(string userId, LoginUserDTO loginUserDto) { try { var jwt = await _tokenService.GetTokenAsync(loginUserDto, userId); if (jwt.Token == null) { return(Unauthorized()); } return(jwt); } catch { return(Unauthorized()); } }
public async Task <ActionResult <ValidationResponseDTO> > SignInUser(LoginUserDTO loginUserDTO) { EntityUser user = await _userManager.FindByNameAsync(loginUserDTO.Username); if (user == null) { return(BadRequest("Invalid Username")); } var result = await _signInManager.CheckPasswordSignInAsync(user, loginUserDTO.Password, lockoutOnFailure : false); if (result.Succeeded) { return(ReturnValidation(user)); } return(BadRequest("Invalid Password")); }
//관리그룹,선생님,정회원,준회원 public LoginUserDTO GetLoginUserInfo(string user_id) { LoginUserDTO dto = null; try { StringBuilder query = new StringBuilder(); query.Append("select a.[user_id] as [UserID], a.[user_name] as [UserName], a.[nick_name] as [NickName], c.[title] as [Group] "); query.Append("from [xe_member] as a "); query.Append(" join [xe_member_group_member] as b "); query.Append(" on a.[member_srl]=b.[member_srl] "); query.Append(" join [xe_member_group] as c "); query.Append(" on b.[group_srl]=c.[group_srl] "); query.Append("where a.[user_id]=N'%USER_ID%' "); query.Replace("%USER_ID%", user_id); DataSet ds = null; SqlParameter[] param = null; ds = db.GetDataSet(query.ToString(), CommandType.Text, param); if (ds != null) { if (ds.Tables.Count > 0) { if (ds.Tables[0].Rows.Count > 0) { dto = new LoginUserDTO(); dto.UserID = ds.Tables[0].Rows[0]["UserID"].ToString(); dto.UserName = ds.Tables[0].Rows[0]["UserName"].ToString(); dto.NickName = ds.Tables[0].Rows[0]["NickName"].ToString(); dto.Group = ds.Tables[0].Rows[0]["Group"].ToString().ToUpper(); } } } } catch (Exception ex) { dto = null; } return dto; }