public ResponseDto <SignInResultDto> SignIn([FromBody] SignInDto signInDto)
{
return(new ResponseDto <SignInResultDto>
{
Data = _usersRepository.SignIn(signInDto)
});
}
public async Task <SignedInDto> SignIn(SignInDto signIn)
{
if (signIn == null)
{
throw new ArgumentException(nameof(signIn));
}
if (string.IsNullOrWhiteSpace(signIn.Email) || string.IsNullOrWhiteSpace(signIn.Password))
{
ThrowUnauthorized();
}
var result = await _signInManager.PasswordSignInAsync(signIn.Email, signIn.Password, false, false);
if (!result.Succeeded)
{
ThrowUnauthorized();
}
var user = await _dbContext.Users
.Include(_ => _.Roles)
.SingleOrDefaultAsync(r => r.UserName == signIn.Email);
return(await GetToken(user));
}
public async Task <IActionResult> Login(SignInDto model)
{
var employee = _context.Users.FirstOrDefault(x => x.Email == model.Email);
if (ModelState.IsValid && employee != null)
{
var token = GetToken(employee);
await _signinManager.SignInAsync(employee, model.RememberMe);
var roles = await _manager.GetRolesAsync(employee);
return(Ok(new DashBoardDto
{
FirstName = employee.FirstName,
LastName = employee.LastName,
Email = employee.Email,
PhotoUrl = employee.Photo,
Token = token,
Department = _context.Departments.FirstOrDefault(x => x.Id == employee.DepartmentId).Name,
Role = roles.ToList()
}));
}
return(Ok("Incorrect Credentials"));
}
public async Task <HttpBaseResult> SignIn([FromBody] SignInDto dto)
{
var result = await _signInManager.PasswordSignInAsync(dto.UserName, dto.Password, dto.RememberMe, true);
if (result.Succeeded)
{
return(new HttpBaseResult
{
Message = "登录成功",
NoticeMode = NoticeMode.Success
});
}
else
{
if (result.IsLockedOut)
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(new HttpBaseResult
{
Message = "账号已锁定20分钟",
NoticeMode = NoticeMode.Warning
});
}
else
{
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(new HttpBaseResult
{
Message = "密码错误",
NoticeMode = NoticeMode.Info
});
}
}
}
public async Task <RefreshAccessToken> IsAuthenticated(SignInDto request)
{
var user = appDbContext.Users.SingleOrDefault(u => u.UserName == request.Username);
if (user == null)
{
return(null);
}
var loggedin = await _signInManager.CheckPasswordSignInAsync(user, request.Password, true);
if (!loggedin.Succeeded)
{
return(null);
}
var claims = new[]
{
new Claim(ClaimTypes.Name, request.Username),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString())
};
var jwtToken = _tokenService.GenerateAccessToken(claims);
var refreshToken = _tokenService.GenerateRefreshToken();
user.WebRefreshToken = refreshToken;
appDbContext.SaveChanges();
return(new RefreshAccessToken {
AccessToken = jwtToken, RefreshToken = refreshToken
});
}
public async Task <Result <AuthenticatedClientDto> > SignInAgentAsync(SignInDto dto)
{
var agentTask = dto.IsEmailAddress
? _unitOfWork.Agents.GetWithDepoAsync(a => a.Email == dto.EmailOrPhoneNumber)
: _unitOfWork.Agents.GetWithDepoAsync(a => a.PhoneNumber == dto.EmailOrPhoneNumber);
var agent = await agentTask;
if (agent is null)
{
throw new NotFoundException("کاربر مورد نظر یافت نشد. لطفا ورودی خود را چک کنید.");
}
if (!_passwordService.Verify(dto.Password, agent.Password))
{
throw new BadRequestException("password", "پسوورد اشتباه می باشد.");
}
var expire = _authSetting.AgentExpireInDays < 0
? (DateTime?)null
: DateTime.UtcNow.AddDays(_authSetting.AgentExpireInDays);
var token = GenerateToken(GetAgentClaimsIdentity(agent), expire);
return(Result <AuthenticatedClientDto> .Success(data :
new AuthenticatedClientDto(new AgentDto
{
Id = agent.Id,
Lastname = agent.PersonName.Lastname,
Name = agent.PersonName.Firstname,
PhoneNumber = agent.PhoneNumber
}, token)));
}
public JsonResponse SignIn([FromBody] SignInDto dto)
{
if (dto.Email == null || dto.Password == null || dto.Verify == null || dto.VerifyId == null)
{
return(BadResponse("参数提供不完整"));
}
//判断验证码是否输入正确
if (!TokenHelper.CheckVerify(dto.VerifyId, dto.Verify))
{
return(BadResponse("验证码错误"));
}
//检查用户名密码是否正确
UserInfo model = new UserInfo();
model = UserInfoBll.GetModelByEmail(dto.Email);
if (model == null)
{
return(BadResponse("用户不存在", null));
}
//检查用户是否登录，若有登录信息则刷新时间
//判断用户是否登录
if (!TokenHelper.CheckLoginStateByUserId(model.Id))
{
LoginState loginState = new LoginState
{
UserId = model.Id,
StartTime = DateTime.Now
};
LoginStateBll.Insert(loginState);
}
return(OkResponse(null));
}
public async Task <IActionResult> Signin(SignInDto data)
{
try
{
var loginData = await _authService.Login(data.Email, data.Password);
if (loginData == null)
{
return(Unauthorized());
}
var token = _authService.GetToken(loginData.Id, loginData.Email);
var authData = new AuthDto //from user model
{
Name = loginData.Name,
Email = loginData.Email,
MobileNo = loginData.MobileNo,
CreatedAt = loginData.CreatedAt
};
return(Ok(new AuthReturnDto
{
User = authData,
Token = token
}));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <UserTokenDto> > PostAsync([FromBody] SignInDto sign)
{
var result = await _signInManager.PasswordSignInAsync(sign.UName, sign.Pwd, false, lockoutOnFailure : true);
var token = String.Empty;
_logger.LogInformation($"login with UserName:[{sign.UName}]");
_logger.LogDebug($"login with UserName:[{sign.UName}],Password:[{sign.Pwd}]");
if (result.Succeeded)
{
var dateTime = DateTime.Now.AddDays(1);
var user = await _userManager.FindByNameAsync(sign.UName);
HttpContext.User.AddIdentity(new ClaimsIdentity(new List <Claim> {
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id)
}));
token = GeneratorToken(dateTime);
var seconds = (dateTime.Ticks - DateTime.UnixEpoch.Ticks) / TimeSpan.TicksPerSecond;
_logger.LogInformation($"login success!");
_logger.LogDebug($"token overtime {dateTime}");
return(new UserTokenDto
{
Id = user.Id,
UserName = user.UserName,
Phone = user.PhoneNumber,
Email = user.Email,
Token = token,
Seconds = (long)TimeSpan.FromDays(1).TotalSeconds
});
}
return(BadRequest());
}
public async Task <IActionResult> SignIn([FromBody] SignInDto model)
{
if (ModelState.IsValid)
{
var findEmail = await _userManager.FindByEmailAsync(model.Email);
if (findEmail is not null)
{
var comparePassword = await _userManager.CheckPasswordAsync(findEmail, model.Password);
if (comparePassword)
{
return(Ok(new Response {
Success = "true", Message = "You are successfully verified"
}));
}
return(Unauthorized(new Response {
Success = "false", Message = "You are not authorized"
}));
}
return(BadRequest(new Response {
Success = "false ", Message = "The email is not in the database"
}));
}
return(BadRequest(new Response {
Success = "False", Message = "Invalid Data"
}));
}
public async Task <Result <AuthenticatedClientDto> > SignInAdminAsync(SignInDto dto)
{
var adminTask = dto.IsEmailAddress
? _unitOfWork.Admins.SingleOrDefaultAsync(a => a.Email == dto.EmailOrPhoneNumber)
: _unitOfWork.Admins.SingleOrDefaultAsync(a => a.PhoneNumber == dto.EmailOrPhoneNumber);
var admin = await adminTask;
if (admin is null)
{
throw new NotFoundException("کاربر مورد نظر یافت نشد. لطفا ورودی خود را چک کنید.");
}
if (!_passwordService.Verify(dto.Password, admin.Password))
{
throw new BadRequestException("password", "پسوورد اشتباه می باشد.");
}
var token = GenerateToken(GetAdminClaimsIdentity(admin),
DateTime.UtcNow.AddDays(_authSetting.AdminExpireInDays));
return(Result <AuthenticatedClientDto> .Success(data :
new AuthenticatedClientDto(new AdminDto
{
Id = admin.Id,
Lastname = admin.PersonName.Lastname,
Name = admin.PersonName.Firstname,
PhoneNumber = admin.PhoneNumber,
Email = admin.Email,
Number = admin.Telephone
}, token)));
}
public ISignInResponse SignIn(SignInDto signInDto)
{
var user = ValidateSignIn(signInDto);
user.LastLoginOn = _systemClock.GetCurrentTime();
user.LastUpdatedOn = _systemClock.GetCurrentTime();
var token = JwtHelper.GenerateJSONWebToken(_config, user);
user.Token = Hash.Create(token, user.Salt);
_repository.User.Update(user);
_repository.Save();
var response = new SignInResponse
{
Id = user.Id,
Token = token,
CreationOn = user.CreationOn,
LastLoginOn = user.LastLoginOn,
LastUpdatedOn = user.LastUpdatedOn
};
return(response);
}
public async Task <ActionResult <UserTokenDto> > SignIn([FromBody] SignInDto model)
{
var user = await _tokenService.VerifyUserCredentials(model);
var claims = new[]
{
new Claim("id", user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.Role, user.Role.Name)
};
var jwt = _tokenService.GenerateJwt(claims);
var refreshToken = await _tokenService.GenerateRefreshToken(user);
var userTokenDto = new UserTokenDto
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Role = user.Role.Name,
Token = new TokenDto {
JWT = jwt, RefreshToken = refreshToken
}
};
return(Ok(userTokenDto));
}
public async Task <IActionResult> SignIn([FromBody] SignInDto dto)
{
var user = await _userManager.FindByEmailAsync(dto.Email);
if (user is null)
{
return(Ok(new AuthDto {
Succeeded = false, Error = "We cannot find an account with that email address"
}));
}
var res = await _userManager.CheckPasswordAsync(user, dto.Password);
if (!res)
{
return(Ok(new AuthDto {
Succeeded = false, Error = "Your password is incorrect"
}));
}
var claims = await _userManager.GetClaimsAsync(user);
var token = _tokenService.GenerateToken(claims, 60);
return(Ok(new AuthDto {
AuthToken = token, Succeeded = true
}));
}
public async Task <TokenDto> SignIn(SignInDto signInDto)
{
var user = await userRepository.FindByLoginAsync(signInDto.Email);
TokenDto tokenDto = new TokenDto();
if (user == null || user.StatusOfVerification == "Processing" || user.StatusOfVerification == "Blocked")
{
tokenDto.Code = 401;
return(tokenDto);
}
if (signInDto.Email != user.Email || !VerifyPassword(signInDto.Password, user.HashPassword, user.Salt))
{
tokenDto.Code = 401;
return(tokenDto);
}
//Return two tokens Access, Refresh
tokenDto.Name = user.FirstName;
tokenDto.Code = 200;
tokenDto.AccessToken = token.GenerateToken(user);
tokenDto.RefreshToken = token.RefreshGenerateToken();
//Save To database Refresh token
RefreshTokens refreshToken = new RefreshTokens(tokenDto.RefreshToken, user.Id, true);
refreshRepository.Create(refreshToken);
await refreshRepository.SaveChangesAsync();
return(tokenDto);
}
public async Task <IActionResult> SignIn(SignInDto model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.Username);
if (user != null)
{
var identityResult = await _uSignInManager.PasswordSignInAsync
(model.Username, model.Password, model.RememberMe, false);
if (identityResult.Succeeded)
{
var rollar = await _userManager.GetRolesAsync(user);
if (rollar.Contains("Admin"))
{
return(RedirectToAction("Index", "Home", new { area = "Admin" }));
}
else
{
return(RedirectToAction("Index", "Home", new { area = "Member" }));
}
}
}
ModelState.AddModelError("", "İstifadəçi Adı və ya Şifrə xətalı");
}
return(View("SignIn", model));
}
public SignInViewModel(NavigationService navigationService, IRestApiService apiService)
{
_navigationService = navigationService ?? throw new NullReferenceException();
_apiService = apiService ?? throw new NullReferenceException();
var valid = this.WhenAnyValue(x => x.Email, x => x.Password, (email, password) =>
new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$").IsMatch(email) &&
new Regex(@"([a-zA-Z0-9]{6,})").IsMatch(password));
SignInCommand = ReactiveCommand.CreateFromTask(async() => {
var dto = new SignInDto {
Email = this.Email, Password = this.Password
};
try
{
var res = await _apiService.SignIn(dto);
if (res.Succeeded == true)
{
var container = App.Container.Resolve <ApplicationDataContainer>();
container.Values["AuthToken"] = "Bearer " + res.AuthToken;
_navigationService.Navigate_App(typeof(MainPageView));
return;
}
await new MessageDialog($"Error: {res.Error}").ShowAsync();
}
catch (Exception e)
{
await new MessageDialog(e.Message).ShowAsync();
}
}, valid);
}
public IActionResult SignIn([FromBody] SignInDto value)
{
try
{
var signInResponse = _authenticationService.SignIn(value);
return(Ok(signInResponse));
}
catch (ArgumentNullException ex)
{
_logger.LogError(ex, ex.Message);
return(new CustomErrorResult(StatusCodes.Status400BadRequest, ex.Message));
}
catch (UnexistentEmailException ex)
{
_logger.LogError(ex, ex.Message);
return(new CustomErrorResult(StatusCodes.Status404NotFound, ex.Message));
}
catch (InvalidPasswordException ex)
{
_logger.LogError(ex, ex.Message);
return(new CustomErrorResult(StatusCodes.Status401Unauthorized, ex.Message));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(new CustomErrorResult(StatusCodes.Status500InternalServerError, ex.Message));
}
}
private void GivenSignInDto(string email, string password)
{
_signInDto = new SignInDto
{
Email = email,
Password = password
};
}
public async Task <SignInResult> SignInAsync(SignInDto signInDto)
{
var user = await _userManager.FindByNameAsync(signInDto.UserName);
var result = await _loginManager.PasswordSignInAsync(signInDto.UserName, signInDto.Password, signInDto.IsPersistent, false);
return(result);
}
public async Task <IActionResult> SignIn([FromBody] SignInDto signInDto)
{
if (await DoLogin(signInDto))
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> Login(SignInDto signInDto)
{
await _authService.Login(signInDto.UserName, signInDto.Password);
var token = _jwtHandler.GetToken(signInDto.UserName, _role);
return(Ok(token));
}
public async Task <UserInfo> Login(SignInDto dto)
{
var userInfo = await new LoginCommand(dto).Login();
userInfo.Token = JwtManager.GenerateToken(userInfo, out var expiresOn, 180, userInfo.CompanyId);
userInfo.ExpiresOn = expiresOn;
return(userInfo);
}
public async Task <IActionResult> SignIn(SignInDto signInDto)
{
var signInResult = await authorizationService.SignIn(signInDto);
if (signInResult.Code == (int)HttpStatusCode.Unauthorized)
{
return(Unauthorized(resourceManager.GetString("EmailPassword")));
}
return(Ok(signInResult));
}
public async Task <JsonWebToken> SignInAsync(SignInDto dto)
{
var user = await _userRepository.GetAsync(dto.Email.ToLowerInvariant());
if (user is null)
{
throw new InvalidCredentialsException();
}
if (_passwordHasher.VerifyHashedPassword(default, user.Password, dto.Password) ==
public async Task <SignInResultDto> SignIn([FromBody] SignInDto userInfo)
{
// SignInManager adds cookies to the response when it
// successfully authenticates the user. We rely on JWT
// so we delete the cookie.
var result = await accountService.SignIn(userInfo);
Response.Cookies.Delete(".AspNetCore.Identity.Application");
return(result);
}
public async Task <IActionResult> SignIn([FromBody] SignInDto data)
{
try {
var user = await _userService.SignIn(data);
return(Json(await CreateToken(user)));
}
catch (ValidationException ex) {
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <SignInSecurityTokenDto> > SignInAsync([FromBody] SignInDto input)
{
// Act.
TokenContext context = await _signInService.PasswordSignInAsync(input.Email, input.Password);
// Map.
var output = _mapper.Map <SignInSecurityTokenDto>(context);
// Return.
return(Ok(output));
}
public void SignIn(SignInDto model)
{
var userData = Guid.NewGuid().ToString();
var ticket = new FormsAuthenticationTicket(1, model.UserName, DateTime.Now, DateTime.Now.AddMinutes(15), model.RememberMe, userData);
var encryptedTicket = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket)
{
HttpOnly = true
};
HttpContext.Current.Response.Cookies.Add(cookie);
}
public IHttpActionResult SignIn(SignInDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (_authService.CheckUserAuth(dto.Username, dto.Password))
{
return(Ok(new AccountInfoDto(_authService.AuthorizedAccount())));
}
return(ServerError(_authService as EwhEntityBase));
}