public async Task <IActionResult> Post(SigninDto signinDto) { if (!ModelState.IsValid) { return(BadRequest()); } var userIsExist = await _userManager.FindByEmailAsync(signinDto.Email); if (userIsExist != null) { var result = await _signinManager.PasswordSignInAsync(signinDto.Email, signinDto.Password, false, false); if (!result.Succeeded) { return(BadRequest()); } var user = await _userManager.FindByNameAsync(signinDto.Email); return(Ok(_unitOfWork.Users.CreateToken(user))); } else { var user = _mapper.Map <IdentityUser>(signinDto); var result = await _userManager.CreateAsync(user, signinDto.Password); if (!result.Succeeded) { return(BadRequest(result.Errors)); } await _signinManager.SignInAsync(user, isPersistent : false); return(Ok(_unitOfWork.Users.CreateToken(user))); } return(BadRequest()); }
public async Task <IActionResult> LoginAsync([FromBody] SigninDto dto, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations, [FromServices] IApplicationUserService userService, [FromServices] IValidator <SigninDto> validatorSignin) { await HttpContext.SignOutAsync(IdentityConstants.ApplicationScheme); var validated = await validatorSignin.ValidateAsync(dto); if (!validated.IsValid) { return(UnprocessableEntity(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct())); } var result = await _signInManager.PasswordSignInAsync(dto.Email, dto.Password, true, false); if (result.Succeeded) { var user = (await userService.GetAllIncludingAsync((e => e.Phones))).SingleOrDefault(e => e.Email.ToUpper() == dto.Email.ToUpper()); if (user == null) { return(NotFound(new { message = "User Not Found", statusCode = 404 })); } user.LastLogin = DateTime.Now; await userService.UpdateAsync(user, user.Id); var response = this._mapper.Map <ApplicationUserDto>(user); var objectToken = user.GenerateToken(tokenConfigurations, signingConfigurations); return(Ok(new { user = response, token = objectToken })); } return(UnprocessableEntity(new { message = "Invalid e-mail or password", statusCode = 422 })); }
public async Task <IActionResult> SigninAsync([FromBody] SigninDto signinDto, [FromServices] IValidator <SigninDto> validator) { var validated = await validator.ValidateAsync(signinDto); if (!validated.IsValid) { return(BadRequest(validated.Errors.Select(e => new { message = e.ErrorMessage, statusCode = e.ErrorCode }).Distinct())); } var result = await _authService.AuthenticateAsync(signinDto); // busca no cache if (!result.Succeeded) { return(BadRequest(new { message = "Invalid e-mail or password", StatusCode = 401 })); } // generate token var user = await _authService.FindAsync(signinDto); user.Last_Login = DateTime.Now; var data = _mapper.Map <UserDto>(user); return(Ok(new { message = "user logged!", Token = _jwt.GenerateToken(user).AccessToken, StatusCode = 200, Data = data })); }
public async Task <ApplicationResult <Member> > IsValidateAsync(SigninDto dto) { var member = _memberRepository.GetFirstOrDefault(predicate: x => x.Account == dto.Account); if (member == null) { return(ApplicationResult <Member> .Failed(new ApplicationError { Code = nameof(Member.Account), Description = "會員不存在!!" })); } if (member.Account != dto.Account) { var failed = ApplicationResult <Member> .Failed( new ApplicationError { Code = nameof(member.Password), Description = "輸入密碼錯誤!!" } ); failed.Data = _mapper.Map <Member>(member); return(failed); } var success = ApplicationResult <Member> .Success; success.Data = _mapper.Map <Member>(member); return(success); }
public IActionResult Signin([FromBody] CredentialsModel credentials) { if (CheckFieldsError()) { return(BadRequest(ErrorResponse.CreateErrorResponse("Invalid fields", 3))); } if (credentials == null || string.IsNullOrWhiteSpace(credentials.Email) || string.IsNullOrWhiteSpace(credentials.Password)) { return(BadRequest(ErrorResponse.CreateErrorResponse("Missing fields", 4))); } UserEntity user = _userService.Signin(credentials.Email, credentials.Password); if (user != null) { SigninDto dto = new SigninDto { UserId = user.UserId, FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, Password = user.Password, Phones = user.Phones }; return(Ok(Crosscutting.Response.CreateResponse(dto))); } else { return(Ok(ErrorResponse.CreateErrorResponse("Invalid e-mail or password", 5))); } }
public async Task <User> FindAsync(SigninDto dto) { var cache = _repositoryFacade.GetCache(dto.email.ToString()); UserDto userDto = JsonConvert.DeserializeObject <UserDto>(cache); if (userDto.email.ToString() == dto.email.ToString()) { User map = _mapper.Map <User>(userDto); return(map); } User user = await _userManager.FindByEmailAsync(dto.email); return(user); }
public async Task <IActionResult> Signin(SigninDto data) { try { var loginData = await _authenticationService.Login(data.UserName.ToLower(), data.Password); if (loginData == null) { return(Unauthorized()); } var claims = new [] { new Claim(ClaimTypes.NameIdentifier, loginData.Id.ToString()), new Claim(ClaimTypes.Name, loginData.UserName) }; var privateKey = _config.Value.Token; var key = new SymmetricSecurityKey( Encoding.UTF8.GetBytes(privateKey) ); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(claims), Expires = DateTime.Now.AddDays(7), SigningCredentials = creds }; var tokenHandler = new JwtSecurityTokenHandler(); var token = tokenHandler.CreateToken(tokenDescriptor); var user = _mapper.Map <AuthDto>(loginData); return(Ok(new AuthReturnDto { User = user, Token = tokenHandler.WriteToken(token) })); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public ActionResult SigninAPI(SigninDto signinRequest) { signinRequest = SanitizeSigninDto.Sanitize(signinRequest); if (signinRequest.Errored) { return(BadRequest(signinRequest.ErrorMessages)); } //Authenticate and retrieve token var authenticator = new Authenticater(); authenticator.AuthenticateSignin(signinRequest.Password, signinRequest.Email); if (authenticator.Errored) { return(BadRequest(authenticator.ErrorMessages)); } return(Ok(authenticator.Token)); }
public async Task <IActionResult> SigninAsync(SigninDto dto) { var result = await _homeService.IsValidateAsync(dto); if (result.Succeeded) { _logger.LogInformation("會員 {0} 登入成功", dto.Account); return(Ok(result.Data)); } _logger.LogInformation("會員 {0} 登入失敗", dto.Account); foreach (var error in result.Errors) { ModelState.AddModelError(error.Code, error.Description); } return(ValidationProblem()); }
public ActionResult SignIn(SigninDto Vm) { var db = new StatementDbContext(); var user = db.Users .Where(a => a.UserName == Vm.Username && a.Password == Vm.Password) .FirstOrDefault(); if (user == null) { ModelState.AddModelError("Username", "Username or Password is incorrect ...!"); return(View()); } Session["UserId"] = user.Id; return(RedirectToAction("List", "Customer")); }
public async Task <IActionResult> SignIn([FromBody] SigninDto model) => Ok(await _accountRepository.SignIn(model.Email, model.Password));
public async Task <SignInResult> AuthenticateAsync(SigninDto dto) { return(await _signInManager.PasswordSignInAsync(dto.email, dto.password, true, false)); }