private async void SignInButton_Click(object sender, EventArgs e)
{
try
{
if (!ValidateInputs())
{
return;
}
var dto = new TokenRequestDto()
{
Username = usernameEditText.Text,
Password = passwordEditText.Text
};
progressBar.Visibility = ViewStates.Visible;
var tokenDto = await _authService.SignInAsync(dto);
if (tokenDto != null && tokenDto.Token != null)
{
SaveToken(tokenDto.Token);
}
progressBar.Visibility = ViewStates.Invisible;
}
catch (Exception ex)
{
progressBar.Visibility = ViewStates.Invisible;
_dialogService.ShowError(this, ex);
}
}
public async Task <TokenResponseDto> GetAccessTokenAsync(TokenRequestDto request)
{
var user = await _userManager.FindByNameAsync(request.UserName);
if (user == null)
{
throw new AuthException(AuthErrors.InvalidCredentials);
}
if (!await _userManager.CheckPasswordAsync(user, request.Password))
{
throw new AuthException(AuthErrors.InvalidCredentials);
}
// generate refresh token
var refreshToken = GenerateRefreshToken();
user.AddRefreshToken(refreshToken);
await _userManager.UpdateAsync(user);
var roles = await _userManager.GetRolesAsync(user);
return(new TokenResponseDto()
{
AccessToken = _jwtGenerator.GenerateJwtToken(user, roles.ToList()),
RefreshToken = refreshToken
});
}
public async Task <TokenResponse> CreateToken([FromBody] TokenRequestDto model)
{
// Validate user credentials and return token
IActionResult response = Unauthorized();
if (model == null)
{
throw new Exception("request details required");
}
if (string.IsNullOrEmpty(model.Username) || string.IsNullOrEmpty(model.Username))
{
throw new Exception("Incomplete credentials");
}
var result = await _identityService.GetUserAccountAsync(model);
if (result.Status == AuthStatus.Authenticated)
{
// return Json(JwtSecurityTokenHelper.CreateToken(Configuration, result.UserDetails));
return(JwtSecurityTokenHelper.CreateToken(Configuration, result.UserDetails));
// return await ApiResponseResult(JwtSecurityTokenHelper.CreateToken(Configuration, result.UserDetails), "Token created");
}
return(new TokenResponse
{
Token = "",
Status = System.Net.HttpStatusCode.OK,
UserDetails = result.UserDetails
});
}
public async Task CreateToken_WhenCalledWithValidArgs_ReturnsOkWithToken()
{
// Arrange
var login = new TokenRequestDto()
{
Username = "******", Password = "******"
};
_mockSignInManager
.Setup(m => m.PasswordSignInAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>()))
.ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Success);
_mockUserManager.Setup(m => m.FindByNameAsync(It.IsAny <string>())).ReturnsAsync(_user);
// Act
var result = await _sut.CreateToken(login);
// Assert
var okResult = Assert.IsAssignableFrom <OkObjectResult>(result);
var cResult = Assert.IsAssignableFrom <TokenCreationResultDto>(okResult.Value);
Assert.NotNull(cResult);
Assert.NotNull(cResult.Token);
Assert.NotNull(cResult.Token.Value);
}
public async Task <IActionResult> ValidateToken([FromBody] TokenRequestDto tokenRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Invalid payload."
}
}));
}
var result = await VerifyToken(tokenRequest);
if (result is null)
{
return(BadRequest("Token is invalid."));
}
if (!result.Success)
{
return(BadRequest($"Token is invalid: {result.Errors.FirstOrDefault()}"));
}
return(Ok("Token is valid."));
}
public async Task <IActionResult> RefreshToken([FromBody] TokenRequestDto tokenRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Invalid payload."
}
}));
}
var result = await VerifyToken(tokenRequest, true);
if (result is null)
{
return(BadRequest(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Invalid token."
}
}));
}
return(Ok(result));
}
public async Task <IActionResult> Auth(TokenRequestDto tokenRequestDto)
{
switch (tokenRequestDto.GrantType)
{
case "password":
var result = await _utilities.GenerateNewTokenAsync(tokenRequestDto);
if (result.status)
{
return(Ok(tokenRequestDto));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + result.message);
return(Unauthorized(result.message));
}
case "refresh_token":
var res = await _utilities.RefreshAccessTokenAsync(tokenRequestDto);
if (res.status)
{
return(Ok(tokenRequestDto));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + res.message);
return(Unauthorized(res.message));
}
default:
return(Unauthorized("خطا در اعتبار سنجی دوباره"));
}
}
public async Task <ActionResult> Token([FromBody] TokenRequestDto request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(
await _authService.GetAccessTokenAsync(request)
));
}
public async Task <IActionResult> Auth([FromBody] TokenRequestDto tokenRequestDto)
{
if (tokenRequestDto == null)
{
return(new StatusCodeResult(500));
}
//return Ok("You're retarded c**t");
return(await GetToken(tokenRequestDto));
}
public ActionResult <ExamplePartnerTokenDto> Token([FromForm] TokenRequestDto request)
{
var token = new ExamplePartnerTokenDto
{
CustomerAccountId = "RandomAccountId",
PartnerApiRefreshToken = "PartnerApiRefreshToken"
};
return(Ok(token));
}
private async void SignInButton_Click(object sender, EventArgs e)
{
try
{
if (!ValidateInputs())
{
return;
}
var dto = new TokenRequestDto()
{
Username = usernameEditText.Text.Trim(),
Password = passwordEditText.Text
};
_progressBarHelper.Show();
var tokenCreationResultDto = await _authHelper.SignInAsync(dto);
_progressBarHelper.Hide();
if (tokenCreationResultDto != null)
{
if (tokenCreationResultDto.Succeeded &&
tokenCreationResultDto.Token?.Value != null)
{
await Helpers.Utilities.InitUserAndDeviceInfoAsync(tokenCreationResultDto.Token);
await SyncService.Instance.SyncAsync();
StartActivity(typeof(TasksActivity));
FinishAffinity();
return;
}
else if (tokenCreationResultDto.ErrorType == TokenCreationErrorType.EmailNotConfirmed)
{
_dialogHelper.ShowError(this, "Email address not confirmed. Please confirm your email."
, (o, ev) => ShowConfirmationCodeInputDialog(tokenCreationResultDto.ValidationData));
return;
}
}
_dialogHelper.ShowError(this, "Username or password is incorrect.");
}
catch (Exception ex)
{
Log.WriteLine(LogPriority.Error, "Planner Error", ex.Message);
_progressBarHelper.Hide();
_dialogHelper.ShowError(this, ex);
}
}
public async Task <TokenResponseDto> RefreshAccessTokenAsync(TokenRequestDto tokenRequestDto)
{
string ip = _http.HttpContext.Connection != null
? _http.HttpContext.Connection.RemoteIpAddress != null
?
_http.HttpContext.Connection.RemoteIpAddress.ToString()
:
"noIp"
: "noIp";
var refreshToken = await _db._TokenRepository.GetAsync(p =>
p.ClientId == _tokenSetting.ClientId && p.Value == tokenRequestDto.RefreshToken &&
p.Ip == ip
);
if (refreshToken == null)
{
return(new TokenResponseDto()
{
status = false,
message = "خطا در اعتبار سنجی خودکار"
});
}
if (refreshToken.ExpireTime < DateTime.Now)
{
return(new TokenResponseDto()
{
status = false,
message = "خطا در اعتبار سنجی خودکار"
});
}
var user = await _userManager.FindByIdAsync(refreshToken.UserId);
if (user == null)
{
return(new TokenResponseDto()
{
status = false,
message = "خطا در اعتبار سنجی خودکار"
});
}
var response = await CreateAccessTokenAsync(user, refreshToken.Value);
return(new TokenResponseDto()
{
status = true,
token = response.token
});
}
public async Task CreateToken_WhenCalledWithInvalidCreds_ReturnsBadRequest()
{
// Arrange
var login = new TokenRequestDto();
_mockSignInManager
.Setup(m => m.PasswordSignInAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>()))
.ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Failed);
// Act
var result = await _sut.CreateToken(login);
// Assert
Assert.IsAssignableFrom <BadRequestObjectResult>(result);
}
public async Task <TokenResponseDto> GenerateNewTokenAsync(TokenRequestDto tokenRequestDto)
{
var user = await _userManager.FindByNameAsync(tokenRequestDto.UserName);
if (user != null && await _userManager.CheckPasswordAsync(user, tokenRequestDto.Password))
{
//create new token
var newRefreshToken = CreateRefreshToken(_tokenSetting.ClientId, user.Id, tokenRequestDto.IsRemember);
//remove older tokens
var oldRefreshToken = await _db.Tokens.Where(p => p.UserId == user.Id).ToListAsync();
if (oldRefreshToken.Any())
{
foreach (var ort in oldRefreshToken)
{
_db.Tokens.Remove(ort);
}
}
//add new refresh token to db
_db.Tokens.Add(newRefreshToken);
await _db.SaveChangesAsync();
var accessToken = await CreateAccessTokenAsync(user, newRefreshToken.Value);
return(new TokenResponseDto()
{
token = accessToken.token,
refresh_token = accessToken.refresh_token,
status = true,
user = user
});
}
else
{
return(new TokenResponseDto()
{
status = false,
message = "کاربری با این یوزر و پس وجود ندارد"
});
}
}
public async Task CreateToken_WhenEmailNotConfirmed_ReturnsBadRequestWithUserId()
{
// Arrange
var login = new TokenRequestDto();
_mockSignInManager
.Setup(m => m.PasswordSignInAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>()))
.ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Failed);
_mockUserManager.Setup(m => m.FindByNameAsync(It.IsAny <string>())).ReturnsAsync(_userWithNotConfirmedEmail);
// Act
var result = await _sut.CreateToken(login);
// Assert
var brResult = Assert.IsAssignableFrom <BadRequestObjectResult>(result);
var cResult = Assert.IsAssignableFrom <TokenCreationResultDto>(brResult.Value);
Assert.Equal(_userWithNotConfirmedEmail.Id, cResult.ValidationData);
}
public async Task <ActionResult <TokenResponseDto> > GenerateToken([FromQuery] TokenRequestDto request)
{
var user = await _mediator.Send(new GetLoginUserQuery(request.UserName, request.Password));
if (user == null)
{
_logger.LogWarning("User is null");
return(Ok(new TokenResponseDto(null, "")));
}
var refreshToken = _tokenFactory.GenerateToken();
await _mediator.Publish(new UpdateUserRefreshTokenCommand(
user.Id,
refreshToken,
Request.HttpContext.Connection.RemoteIpAddress?.ToString()));
return(Ok(new TokenResponseDto(
await _jwtFactory.GenerateEncodedToken(user),
refreshToken,
true)));
}
public async Task <IActionResult> CreateToken([FromBody] TokenRequestDto login)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(TokenCreationResultDto.Failed(TokenCreationErrorType.InvalidUsernameOrPassword)));
}
var user = await _userManager.FindByNameAsync(login.Username);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user, login.Password, false, false);
if (result.Succeeded)
{
var tokenString = BuildToken(user);
return(Ok(TokenCreationResultDto.Success(new TokenDto()
{
Value = tokenString,
ApplicationUserId = user.Id,
Username = user.UserName,
Email = user.Email
})));
}
if (!user.EmailConfirmed)
{
return(BadRequest(TokenCreationResultDto.Failed(TokenCreationErrorType.EmailNotConfirmed, user.Id)));
}
}
return(BadRequest(TokenCreationResultDto.Failed(TokenCreationErrorType.InvalidUsernameOrPassword)));
}
catch (Exception ex)
{
_logger.LogError("Threw exception while creating Token: {@ex}", ex);
return(StatusCode((int)HttpStatusCode.InternalServerError, TokenCreationResultDto.Failed(TokenCreationErrorType.ServerError)));
}
}
public async Task <IActionResult> Login(TokenRequestDto tokenRequestDto)
{
switch (tokenRequestDto.GrantType)
{
case "password":
var result = await _utilities.GenerateNewTokenAsync(tokenRequestDto);
if (result.status)
{
var userForReturn = _mapper.Map <UserForDetailedDto>(result.user);
return(Ok(new LoginResponseDto
{
token = result.token,
refresh_token = result.refresh_token,
user = userForReturn
}));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + result.message);
return(Unauthorized("1x111keyvanx11"));
}
case "refresh_token":
var res = await _utilities.RefreshAccessTokenAsync(tokenRequestDto);
if (res.status)
{
return(Ok(res));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + res.message);
return(Unauthorized("0x000keyvanx00"));
}
default:
return(Unauthorized("خطا در اعتبار سنجی دوباره"));
}
}
private async Task <TokenResponseDto> GetManagementTokenAsync()
{
var tokenRequest = new TokenRequestDto()
{
ClientId = _authOptions.ClientId,
ClientSecret = _authOptions.ClientSecret,
Audience = new Uri(new Uri(_authOptions.Instance), "/api/v2/").ToString(),
GrantType = "client_credentials"
};
var tokenRequestJson = new StringContent(JsonConvert.SerializeObject(tokenRequest), Encoding.UTF8,
"application/json");
using var httpResponse =
await _httpClient.PostAsync($"oauth/token", tokenRequestJson);
var responseAsString = await httpResponse.Content.ReadAsStringAsync();
var authToken = JsonConvert.DeserializeObject <TokenResponseDto>(responseAsString);
return(authToken);
}
public virtual async Task <ActionResult <AccessToken> > Login([FromForm] TokenRequestDto login)
{
if (!login.grant_type.Equals("password", StringComparison.OrdinalIgnoreCase))
{
throw new Exception("OAuth flow is not correct.");
}
var user = _userService.FindByPhoneAsync(login.username)
?? await _userService.FindByEmailAsync(login.username)
?? await _userService.FindByNameAsync(login.username);
if (user == null)
{
return(new NotFoundObjectResult("Wrong Username or password"));
}
var isValidUserData = await _userService.CheckPasswordAsync(user, login.password);
if (!isValidUserData)
{
return(new NotFoundObjectResult("Wrong Username or password"));
}
var isActiveUser = await _userService.IsUserStatusConfirmedAsync(user);
if (!isActiveUser)
{
return(new NotFoundObjectResult("User is not active"));
}
await _userService.UpdateSecurityStampAsync(user);
var token = await _service.GenerateToken(user);
return(token);
}
public async Task <IActionResult> RevokeToken([FromBody] TokenRequestDto tokenRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Invalid payload."
}
}));
}
var username = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var user = await _userManager.FindByNameAsync(username);
if (user is not null)
{
var token = await _context.RefreshTokens
.FirstOrDefaultAsync(x =>
x.UserId == user.Id &&
x.Token == tokenRequest.RefreshToken
);
if (token is not null)
{
token.IsRevoked = true;
await _context.SaveChangesAsync();
return(Ok());
}
}
return(BadRequest());
}
public async Task <IActionResult> CreateToken(TokenRequestDto tokenRequestDto)
{
var token = await _tokenService.CreateTokenAsync(tokenRequestDto);
return(Json(token));
}
/// <summary>
/// Verifies the JWT token
/// </summary>
/// <returns>A new, valid token or reason of error.</returns>
private async Task <AuthResult> VerifyToken(TokenRequestDto tokenRequest, bool refreshIfExpired = false)
{
var jwtTokenHandler = new JwtSecurityTokenHandler();
var storedRefreshToken = _context.RefreshTokens
.AsNoTracking()
.FirstOrDefault(x => x.Token == tokenRequest.RefreshToken);
ClaimsPrincipal principal = null;
try {
// validate token
principal = jwtTokenHandler.ValidateToken(tokenRequest.Token, _tokenParams, out var validatedToken);
//////
// everything until catch block happens if token is technically valid
//////
var jwtId = principal.Claims.SingleOrDefault(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
if (storedRefreshToken.JwtId != jwtId)
{
return(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Provided token doesn't match saved token."
}
});
}
// verify encryption
if (validatedToken is JwtSecurityToken jwtSecurityToken)
{
var hasCorrectAlgo = jwtSecurityToken.Header.Alg.Equals(SecurityAlgorithms.Aes256KeyWrap, StringComparison.InvariantCultureIgnoreCase);
var hasCorrectEncr = jwtSecurityToken.Header.Enc.Equals(SecurityAlgorithms.Aes256CbcHmacSha512, StringComparison.InvariantCultureIgnoreCase);
if (!hasCorrectAlgo || !hasCorrectEncr)
{
return(null);
}
}
if (storedRefreshToken.IsRevoked)
{
return(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Token has been revoked."
}
});
}
// still try to check if expired (exception isn't thrown sometimes?)
var expirationDateTimestamp = long.Parse(principal.Claims.FirstOrDefault(x => x.Type == JwtRegisteredClaimNames.Exp).Value);
var expirationDate = UnixTimeStampToDateTime(expirationDateTimestamp);
if (expirationDate > DateTime.UtcNow)
{
throw new SecurityTokenExpiredException();
}
// everything went well - bounce back
return(new AuthResult()
{
Success = true,
Token = tokenRequest.Token,
RefreshToken = tokenRequest.RefreshToken
});
} catch (SecurityTokenExpiredException) {
if (!refreshIfExpired)
{
return(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"Token expired."
}
});
}
// generate new token only if requested refresh token exists
if (storedRefreshToken == null)
{
return(new AuthResult()
{
Success = false,
Errors = new List <string>()
{
"No such refresh token exists."
}
});
}
storedRefreshToken.IsUsed = true;
_context.RefreshTokens.Update(storedRefreshToken);
await _context.SaveChangesAsync();
var dbUser = await _userManager.FindByIdAsync(storedRefreshToken.UserId.ToString());
string jwtId = "";
if (principal is null)
{
jwtId = jwtTokenHandler.ReadJwtToken(tokenRequest.Token).Id;
}
else
{
jwtId = principal.Claims.SingleOrDefault(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
}
return(await GenerateJwtTokenAsync(dbUser, tokenRequest.RefreshToken, jwtId));
} catch (Exception ex) {
_logger.LogError(ex.ToString());
return(null);
}
}
public Task <string> CreateTokenAsync(TokenRequestDto tokenRequestDto)
{
//todo(max): check public key; check if card credentials are valid (https://developer.visa.com/capabilities/pav/docs-how-to#section1)
return(Task.FromResult("token"));
}
private async Task <IActionResult> GetToken(TokenRequestDto tokenRequestDto)
{
try {
// Check if there's an user with the given email
var user = await UserManager.FindByEmailAsync(tokenRequestDto.Email);
// or username
if (user == null)
{
user = await UserManager.FindByNameAsync(tokenRequestDto.Email);
}
if (user == null ||
!await UserManager.CheckPasswordAsync(user, tokenRequestDto.Password))
{
// User doesn't exists or password mismatch.
return(new UnauthorizedResult());
}
// Email and password matches. Create and return the JWT token.
DateTime now = DateTime.UtcNow;
// Add the registered claims for JWT.
var claims = new List <Claim> {
new Claim(JwtRegisteredClaimNames.Sub, user.Id),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, new DateTimeOffset(now).ToUnixTimeSeconds().ToString()),
new Claim("Username", user.UserName)
// TODO:
// Add additional claims here.
};
// Get user claims from database.
var claimsFromDb = new List <Claim>(await UserManager.GetClaimsAsync(user));
claims.AddRange(claimsFromDb);
var tokenExpirationMins = Configuration.GetValue <int>("Auth:Jwt:TokenExpirationInMinutes");
var issuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Auth:Jwt:Key"]));
var token = new JwtSecurityToken(
issuer: Configuration["Auth:Jwt:Issuer"],
audience: Configuration["Auth:Jwt:Audience"],
claims: claims,
notBefore: now,
expires: now.Add(TimeSpan.FromMinutes(tokenExpirationMins)),
signingCredentials: new SigningCredentials(issuerSigningKey, SecurityAlgorithms.HmacSha256)
);
var encodedToken = new JwtSecurityTokenHandler().WriteToken(token);
// Build and return the response.
var response = new TokenResponseDto()
{
Token = encodedToken,
Expiration = tokenExpirationMins
};
return(Ok(response));
}
catch {
return(new UnauthorizedResult());
}
}
public Task <TokenCreationResultDto> SignInAsync(TokenRequestDto loginDto)
{
return(_httpService.PostForResultAsync <TokenCreationResultDto>("Auth/CreateToken", loginDto, true));
}
public async Task <IActionResult> RevokeToken([FromBody][Required] TokenRequestDto model)
{
await SessionService.RevokeRefreshToken(model.Token, IpAddress());
return(Ok());
}
/// <summary>
/// Acquires a token from the details in the CCRepository. If Amount is greater than 0 a pre-auth will be placed for that amount.
/// </summary>
/// <param name="ccRepositoryToken">CCRepository Token GUID</param>
/// <param name="currencyCode">Currency Code</param>
/// <param name="orderReference">Order Reference</param>
/// <param name="amount">Pre-Auth Value</param>
/// <param name="channelShortName">Channel Short Name</param>
/// <param name="shortName">Business Short Name</param>
/// <returns>Success / Failure</returns>
public bool GetToken(string ccRepositoryToken, string currencyCode, string orderReference, decimal amount, string channelShortName, string shortName)
{
Logger.LogInfo(string.Format("GetToken: CCRepositoryToken {0} | CurrencyCode {1} | OrderReference {2} | Amount {3} | ChannelShortName {4}", ccRepositoryToken, currencyCode, orderReference, amount, channelShortName));
var request = new TokenRequestDto
{
CCRepositoryToken = ccRepositoryToken,
CurrencyCode = currencyCode,
OrderReference = orderReference,
SourceEnum = SourceEnumDto.PMS,
Amount = amount,
ChannelShortName = channelShortName,
ShortName = shortName
};
var result = CallPostEndPoint<StatusResponseDto, TokenRequestDto>(GetTokenUrl, request);
return result.IsSuccess;
}
public async Task <TokenResponseDto> GenerateNewTokenAsync(TokenRequestDto tokenRequestDto, bool needPassword)
{
if (needPassword)
{
var user = await _db._UserRepository.GetUserByUserNameAsync
(tokenRequestDto.UserName);
if (user != null && await _userManager.CheckPasswordAsync(user, tokenRequestDto.Password))
{
//create new token
var newRefreshToken = CreateRefreshToken(_tokenSetting.ClientId, user.Id, tokenRequestDto.IsRemember);
//remove older tokens
var oldRefreshToken = await _db._TokenRepository.GetManyAsync(p => p.UserId == user.Id);
if (oldRefreshToken.Any())
{
foreach (var ort in oldRefreshToken)
{
_db._TokenRepository.Delete(ort);
}
}
//add new refresh token to db
_db._TokenRepository.Insert(newRefreshToken);
_db.Save();
var accessToken = await CreateAccessTokenAsync(user, newRefreshToken.Value);
return(new TokenResponseDto()
{
token = accessToken.token,
refresh_token = accessToken.refresh_token,
status = true,
user = user
});
}
else
{
return(new TokenResponseDto()
{
status = false,
message = "کاربری با این یوزر و پس وجود ندارد"
});
}
}
else
{
var user = await _db._UserRepository.GetUserByUserNameAsync
(tokenRequestDto.UserName);
if (user != null)
{
//create new token
var newRefreshToken = CreateRefreshToken(_tokenSetting.ClientId, user.Id, tokenRequestDto.IsRemember);
//remove older tokens
var oldRefreshToken = await _db._TokenRepository.GetManyAsync(p => p.UserId == user.Id);
if (oldRefreshToken.Any())
{
foreach (var ort in oldRefreshToken)
{
_db._TokenRepository.Delete(ort);
}
}
//add new refresh token to db
_db._TokenRepository.Insert(newRefreshToken);
_db.Save();
var accessToken = await CreateAccessTokenAsync(user, newRefreshToken.Value);
return(new TokenResponseDto()
{
token = accessToken.token,
refresh_token = accessToken.refresh_token,
status = true,
//user = user
});
}
else
{
return(new TokenResponseDto()
{
status = false,
message = "کاربری با این یوزر و پس وجود ندارد"
});
}
}
}
//[ProducesResponseType(typeof(ApiReturn<LoginResponseDto>), StatusCodes.Status201Created)]
//[ProducesResponseType(typeof(ApiReturn<string>), StatusCodes.Status400BadRequest)]
public async Task <IActionResult> Login(TokenRequestDto tokenRequestDto)
{
ApiReturn <LoginResponseDto> model = new ApiReturn <LoginResponseDto> {
Status = true
};
switch (tokenRequestDto.GrantType)
{
case "password":
var result = await _utilities.GenerateNewTokenAsync(tokenRequestDto, true);
if (result.status)
{
var userForReturn = _mapper.Map <UserForDetailedDto>(result.user);
//userForReturn.Provider = tokenRequestDto.Provider;
model.Message = "ورود با موفقیت انجام شد";
model.Result = new LoginResponseDto
{
token = result.token,
refresh_token = result.refresh_token,
user = userForReturn
};
return(Ok(model));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + result.message);
errorModel.Message = "1x111keyvanx11";
return(Unauthorized(errorModel));
}
case "social":
var socialresult = await _utilities.GenerateNewTokenAsync(tokenRequestDto, false);
if (socialresult.status)
{
//var userForReturn = _mapper.Map<UserForDetailedDto>(socialresult.user);
//userForReturn.Provider = tokenRequestDto.Provider;
model.Message = "ورود با رفرش توکن با موفقیت انجام شد";
model.Result = new LoginResponseDto
{
token = socialresult.token,
refresh_token = socialresult.refresh_token,
user = _mapper.Map <UserForDetailedDto>(socialresult.user)
};
return(Ok(model));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + socialresult.message);
errorModel.Message = "1x111keyvanx11";
return(Unauthorized(errorModel));
}
case "refresh_token":
var res = await _utilities.RefreshAccessTokenAsync(tokenRequestDto);
if (res.status)
{
model.Message = "ورود با رفرش توکن با موفقیت انجام شد";
model.Result = new LoginResponseDto
{
token = res.token,
refresh_token = res.refresh_token,
user = _mapper.Map <UserForDetailedDto>(res.user)
};
return(Ok(model));
}
else
{
_logger.LogWarning($"{tokenRequestDto.UserName} درخواست لاگین ناموفق داشته است" + "---" + res.message);
errorModel.Message = "0x000keyvanx00";
return(Unauthorized(errorModel));
}
default:
errorModel.Message = "خطا در اعتبار سنجی";
return(Unauthorized(errorModel));
}
}
