// Private Methods
private static TokenResponseModel CreateErrorResponseToken(string errorMessage, HttpStatusCode statusCode)
{
var errorToken = new TokenResponseModel
{
Token = null,
Username = null,
Role = null,
RefreshTokenExpiration = DateTime.Now,
RefreshToken = null,
Expiration = DateTime.Now,
ResponseInfo = CreateResponse(errorMessage, statusCode),
};
return(errorToken);
}
public async Task <TokenResponseModel?> CreateUserTokenAsync(string username, string password)
{
var userInfo = await _userProvider.GetUserAsync(username, password);
if (userInfo == null)
{
_logger.LogWarning("Could not find specific user");
return(null);
}
var expires = DateTime.Now.AddDays(365);
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_authSettings.Secret);
var identityClaims = new List <Claim>(new[]
{
new Claim(ClaimTypes.NameIdentifier, username),
new Claim(ClaimTypes.Name, userInfo.Name),
});
if (userInfo.Scopes != null)
{
foreach (var scope in userInfo.Scopes)
{
identityClaims.Add(new Claim("scope", scope));
}
}
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(identityClaims),
Expires = expires,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenDto = new TokenResponseModel
{
UserName = userInfo.UserName,
Name = userInfo.Name,
Scopes = userInfo.Scopes,
Expires = expires,
Token = tokenHandler.WriteToken(token)
};
return(tokenDto);
}
public async static Task <TokenResponseModel> GetToken(User user)
{
string json = JsonConvert.SerializeObject(user);
var content = new StringContent(json, UnicodeEncoding.UTF8, "application/json");
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.PostAsync("https://localhost:44316/api/accounts/token", content);
if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
throw new Exception(Application.Current.Resources["m_error_bad_signup"].ToString());
}
TokenResponseModel tokenResponseModel = JsonConvert.DeserializeObject <TokenResponseModel>(await response.Content.ReadAsStringAsync());
Resources.Token = tokenResponseModel.AccessToken;
return(tokenResponseModel);
}
private TokenResponseModel ConvertAndRefreshToken(string token)
{
var handler = new JwtSecurityTokenHandler();
token = token.Replace("Bearer ", "");
var jsonToken = handler.ReadToken(token);
var tokenCollection = handler.ReadToken(token) as JwtSecurityToken;
var header = tokenCollection.Claims.FirstOrDefault().Value;
var headerCollection = header.Split("+");
var email = headerCollection[0];
var isActive = headerCollection[1] == true.ToString();
var refreshedToken = Authorize(email, isActive);
var result = new TokenResponseModel(email, isActive, refreshedToken);
return(result);
}
public ActionResult TokenHistory(string token)
{
TokenResponseModel model = new TokenResponseModel();
int timeStamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
TokenHistoryRequest request = new TokenHistoryRequest();
request.MERCHANT = "OPU_TEST";
request.TIMESTAMP = timeStamp.ToString();
request.TOKEN = token;
Options options = new Options();
options.Url = "https://secure.payu.com.tr/order/token/v2/merchantToken/";
options.SecretKey = "SECRET_KEY";
model.TokenResponse = TokenHistoryRequest.Execute(request, options); //api çağrısının başlatıldığı kısmı temsil eder.
return(View(model));
}
// Getting a token based on credentials
public static void SetToken(string username, string password)
{
RestClient restClient = new RestClient(baseUrl);
RestRequest restRequest = new RestRequest(loginEndpoint, Method.GET);
restRequest.AddParameter("moodlewsrestformat", "json");
restRequest.AddParameter("username", username);
restRequest.AddParameter("password", password);
restRequest.AddParameter("service", service);
string requestResponse = restClient.Execute(restRequest).Content;
TokenResponseModel tokenResponse = JsonConvert.DeserializeObject <TokenResponseModel>(requestResponse);
token = tokenResponse.Token;
}
public static async Task <Result> RecaptchaTokenVerify(IHttpClientFactory clientFactory, GoogleSettings googleOptions, string token)
{
var tokenResponse = new TokenResponseModel()
{
Success = false
};
using (var client = clientFactory.CreateClient(HttpClientNames.GoogleRecaptcha))
{
var response = await client.GetStringAsync($"{googleOptions.RecaptchaVerifyApi}?secret={googleOptions.SecretKey}&response={token}");
tokenResponse = JsonConvert.DeserializeObject <TokenResponseModel>(response);
}
return((!tokenResponse.Success || tokenResponse.Score < (decimal)0.5)
? Result.Failure("Recaptcha token is invalid")
: Result.Ok());
}
public ActionResult TokenServiceCreateToken(string refNo)
{
TokenResponseModel model = new TokenResponseModel();
int timeStamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
TokenServiceCreateTokenRequest request = new TokenServiceCreateTokenRequest();
request.MERCHANT = "OPU_TEST";
request.REFNO = refNo;
request.TIMESTAMP = timeStamp.ToString();
Options options = new Options();
options.Url = "https://secure.payu.com.tr/order/token/v2/merchantToken/";
options.SecretKey = "SECRET_KEY";
model.TokenResponse = TokenServiceCreateTokenRequest.Execute(request, options);
return(View(model));
}
public TokenResponseModel Post([FromBody] CreateHeroRequest createHeroRequest)
{
TokenResponseModel token = null;
try
{
AOResult <HeroUnitModel> heroResult = _heroService.CreateHero(createHeroRequest);
if (heroResult.IsSuccess)
{
token = _tokenService.CreateTokenAsync(heroResult.Result.Name);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message + " hero not created");
}
return(token);
}
public GSTNResult <TokenResponseModel> RequestToken(string username, string otp)
{
TokenRequestModel model = new TokenRequestModel {
action = "AUTHTOKEN",
username = username
};
model.app_key = EncryptionUtils.RsaEncrypt(GSTNConstants.GetAppKeyBytes());
model.otp = EncryptionUtils.AesEncrypt(otp, GSTNConstants.GetAppKeyBytes());
var output = this.Post <TokenRequestModel, TokenResponseModel>(model);
this.username = username;
token = output.Data;
this.AuthToken = token.auth_token;
this.DecryptedKey = EncryptionUtils.AesDecrypt(token.sek, GSTNConstants.GetAppKeyBytes());
var Decipher = System.Text.Encoding.UTF8.GetString(DecryptedKey);
return(output);
}
public TokenResponseModel RenewAccessToken(RenewTokenInputType renewToken)
{
var result = new TokenResponseModel {
Message = "Success"
};
ClaimsPrincipal principal = GetClaimsFromExpiredToken(renewToken.AccessToken);
if (principal == null)
{
result.Message = "Invalid Token";
return(result);
}
string email = principal.Claims.Where(_ => _.Type == "Email").Select(_ => _.Value).FirstOrDefault();
if (string.IsNullOrEmpty(email))
{
result.Message = "Invalid Token";
return(result);
}
var user = _authContext.User
.Where(_ => _.EmailAddress == email && _.RefreshToken == renewToken.RefreshToken && _.RefershTokenExpiration > DateTime.Now).FirstOrDefault();
if (user == null)
{
result.Message = "Invalid Token";
return(result);
}
var userRoles = _authContext.UserRoles.Where(_ => _.UserId == user.UserId).ToList();
result.AccessToken = GetJWTAuthKey(user, userRoles);
result.RefreshToken = GenerateRefreshToken();
user.RefreshToken = result.RefreshToken;
user.RefershTokenExpiration = DateTime.Now.AddDays(7);
_authContext.SaveChanges();
return(result);
}
public GSTNResult <TokenResponseModel> RefreshToken()
{
RefreshTokenModel model = new RefreshTokenModel
{
action = "REFRESHTOKEN",
username = userid
};
model.app_key = EncryptionUtils.AesEncrypt(GSTNConstants.GetAppKeyBytes(), this.DecryptedKey);
model.auth_token = this.AuthToken;
var output = this.Post <RefreshTokenModel, TokenResponseModel>(model);
token = output.Data;
this.AuthToken = token.auth_token;
this.DecryptedKey = EncryptionUtils.AesDecrypt(token.sek, GSTNConstants.GetAppKeyBytes());
var Decipher = System.Text.Encoding.UTF8.GetString(DecryptedKey);
return(output);
}
public static TokenResponseModel GetJwt(UserModel usuario, List <Claim> extraClaims = null)
{
var utc0 = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
var now = DateTime.Now;
const int expireMinutes = 518400;
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, usuario.User),
new Claim("id", usuario.Id.ToString()),
new Claim("user", usuario.User),
new Claim("name", usuario.Name),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, ((int)now.Subtract(utc0).TotalSeconds).ToString(), ClaimValueTypes.Integer64)
};
if (extraClaims != null)
{
claims.AddRange(extraClaims);
}
var jwt = new JwtSecurityToken(
issuer: ValidIssuer,
audience: ValidAudiences?.FirstOrDefault(),
claims: claims,
notBefore: now,
expires: now.Add(TimeSpan.FromMinutes(expireMinutes)),
signingCredentials: new SigningCredentials(SigningKey(), SecurityAlgorithms.HmacSha256)
);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new TokenResponseModel
{
AccessToken = encodedJwt,
ExpiresAt = DateTime.UtcNow.AddDays(1),
RefreshToken = Guid.NewGuid().ToString()
};
response.AccessId = RefreshTokenManager?.Save(new TokenItemModel(usuario, response.AccessToken, response.RefreshToken, response.ExpiresAt));
return(response);
}
private async Task <Models.APIResponse <TokenResponseModel> > CreateEncodedJwtToken(CommonUser user)
{
var claims = new[]
{
new Claim(JWTClaim.Sid, user.Id.ToString()),
new Claim(JWTClaim.Sub, user.Email),
new Claim(JWTClaim.Jti, await _jwtOptions.JtiGenerator()),
new Claim(JWTClaim.Iat, ToUnixEpochDate(_jwtOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
new Claim(JWTClaim.SystemPermission, ((int)user.Permission).ToString())
};
// Create the JWT security token and encode it.
var jwt = new JwtSecurityToken(
issuer: _jwtOptions.Issuer,
audience: _jwtOptions.Audience,
claims: claims,
notBefore: _jwtOptions.NotBefore,
expires: _jwtOptions.Expiration,
signingCredentials: _jwtOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var now = DateTime.UtcNow;
var expires = now.AddMonths(6);
var tokenReponse = new TokenResponseModel {
Token = encodedJwt,
Expires = expires.ToUnixTime(),
FirstName = user.FirstName,
LastName = user.LastName,
Id = user.Id,
Email = user.Email,
Permission = user.Permission
};
if (!string.IsNullOrWhiteSpace(user.ProfileImageKey))
{
tokenReponse.ProfileImageUrl = AppSettings.AmazonS3Url + user.ProfileImageKey;
}
return(new APIResponse <TokenResponseModel> {
Data = tokenReponse
});
}
void LoginToGoogle()
{
string access_token;
LoginServices loginservice = new LoginServices();
var auth = new OAuth2Authenticator(
clientId: "549020993769-tn974vfkrovsr1k4g65135k6m02vec6j.apps.googleusercontent.com",
scope: "https://www.googleapis.com/auth/userinfo.email",
authorizeUrl: new Uri("https://accounts.google.com/o/oauth2/auth"),
redirectUrl: new Uri("http://bunchy.com/oauth2callback"),
getUsernameAsync: null);
auth.Completed += (sender, e) =>
{
e.Account.Properties.TryGetValue("access_token", out access_token);
access_token_return = access_token;
Console.WriteLine(access_token);
_TokenResponse = BunchyAuth(access_token_return, "google");
e.Account.Username = _TokenResponse.Username;
if (e.Account.Username == "New User")
{
AccountStore.Create(this).Save(e.Account, "google");
var newuserintent = new Intent(this, typeof(NewUserActivity));
StartActivity(newuserintent);
}
else
{
AccountStore.Create(this).Save(e.Account, "google");
var rideintent = new Intent(this, typeof(RidesActivity));
StartActivity(rideintent);
}
//textView.Text = access_token;
};
//_TokenResponse = await loginservice.LoginExternal(access_token,"google");
var intent = auth.GetUI(this);
StartActivity(intent);
}
public async Task <TokenResponseModel> sigIn(Usuario entidad)
{
try
{
string json = JsonConvert.SerializeObject(entidad, Formatting.Indented,
new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
HttpClientHandler handler = new HttpClientHandler();
var httpClient = new HttpClient(handler);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, Path_Servicio.obtenerUrl() + "token");
//request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", Hefesoft.Standard.Static.Variables_Globales.Bearer);
request.Content = new StringContent("grant_type=password&username="******"&password="******"application/x-www-form-urlencoded");
MediaTypeHeaderValue contentType = request.Content.Headers.ContentType;
contentType.MediaType = "application/json";
request.Content.Headers.ContentType = contentType;
if (handler.SupportsTransferEncodingChunked())
{
request.Headers.TransferEncodingChunked = true;
}
HttpResponseMessage response = await httpClient.SendAsync(request);
var resultadoString = response.Content.ReadAsStringAsync().Result;
TokenResponseModel tokenResponse = (TokenResponseModel)JsonConvert.DeserializeObject(resultadoString, typeof(TokenResponseModel));
Hefesoft.Standard.Static.Variables_Globales.Bearer = tokenResponse.AccessToken;
return(tokenResponse);
}
catch (Exception ex)
{
throw ex;
}
}
// Creating JWT Authentication Token
private async Task <TokenResponseModel> GenerateNewToken(ApplicationUser user, LoginViewModel model)
{
var key = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_appSettings.Secret));
var roles = await _userManager.GetRolesAsync(user);
var tokenHandler = new JwtSecurityTokenHandler();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(JwtRegisteredClaimNames.Sub, model.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.NameIdentifier, user.Id),
new Claim(ClaimTypes.Role, roles.FirstOrDefault()),
new Claim("LoggedOn", DateTime.Now.ToString(CultureInfo.InvariantCulture)),
}),
SigningCredentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature),
Issuer = _appSettings.Site,
Audience = _appSettings.Audience,
Expires = (string.Equals(roles.FirstOrDefault(), "Admin", StringComparison.CurrentCultureIgnoreCase)) ? DateTime.UtcNow.AddMinutes(60) : DateTime.UtcNow.AddMinutes(Convert.ToDouble(_appSettings.ExpireTime))
};
var userClaims = await _userManager.GetClaimsAsync(user);
var token = tokenHandler.CreateToken(tokenDescriptor);
var authToken = new TokenResponseModel
{
Token = token.ToString(),
Expiration = token.ValidTo,
Role = roles.FirstOrDefault(),
Username = user.UserName,
UserId = user.Id,
ResponseInfo = CreateResponse("Auth Token Created", HttpStatusCode.OK)
};
return(authToken);
}
public async Task <TokenResponseModel> Login(string username, string password)
{
//HttpWebRequest request = new HttpWebRequest(new Uri("http://192.168.56.1:1524/token"));
HttpWebRequest request = new HttpWebRequest(new Uri("http://bunchyapi.azurewebsites.net/token"));
request.Method = "POST";
string postString = String.Format("username={0}&password={1}&grant_type=password", "craig", "pword");
//Log.Info("bunchy",postString);
byte[] bytes = Encoding.UTF8.GetBytes(postString);
using (Stream requestStream = await request.GetRequestStreamAsync())
{
requestStream.Write(bytes, 0, bytes.Length);
}
try
{
HttpWebResponse httpResponse = (HttpWebResponse)(await request.GetResponseAsync());
string json;
using (Stream responseStream = httpResponse.GetResponseStream())
{
json = new StreamReader(responseStream).ReadToEnd();
}
TokenResponseModel tokenResponse = JsonConvert.DeserializeObject <TokenResponseModel>(json);
//App.UserPreferences.SetString("Token",tokenResponse.AccessToken);
//App.UserPreferences.SetString("UserName",username);
//App.RegisterUser.RegisterWithGCMAndriod();
return(tokenResponse);
}
catch (Exception ex)
{
//Log.Info("bunchy",ex.Message);
TokenResponseModel tokenResponse = new TokenResponseModel();
tokenResponse.AccessToken = null;
return(tokenResponse);
}
}
public TokenResponseModel Login(LoginInputType loginInput)
{
var result = new TokenResponseModel {
Message = "Success"
};
if (string.IsNullOrEmpty(loginInput.Email) ||
string.IsNullOrEmpty(loginInput.Password))
{
result.Message = "Invalid Credentials";
return(result);
}
var user = _authContext.User.Where(_ => _.EmailAddress == loginInput.Email).FirstOrDefault();
if (user == null)
{
result.Message = "Invalid Credentials";
return(result);
}
if (!ValidatePasswordHash(loginInput.Password, user.Password))
{
result.Message = "Invalid Credentials";
return(result);
}
var roles = _authContext.UserRoles.Where(_ => _.UserId == user.UserId).ToList();
result.AccessToken = GetJWTAuthKey(user, roles);
result.RefreshToken = GenerateRefreshToken();
user.RefreshToken = result.RefreshToken;
user.RefershTokenExpiration = DateTime.Now.AddDays(7);
_authContext.SaveChanges();
return(result);
}
/// <summary>
/// Gets a Token from the Token Service
/// </summary>
/// <param name="authentication">The authentication body</param>
/// <returns></returns>
public async Task <TokenResponseModel> GetTokenAsync(AuthenticationModel authentication)
{
try
{
var client = CreateClient();
var response = await client.PostAsync <string>(
"/token",
JsonConvert.SerializeObject(authentication),
new TextMediaFormatter());
var tokenResponse = new TokenResponseModel
{
StatusCode = response.StatusCode
};
var responseText = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
return(new TokenResponseModel
{
StatusCode = response.StatusCode,
AuthToken = responseText
});
}
else
{
return(new TokenResponseModel
{
StatusCode = response.StatusCode,
Message = responseText
});
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <bool> Login(string username, string password, string facebookAccessToken)
{
try
{
string url = WebApiUrlToken;
HttpWebRequest request = new HttpWebRequest(new Uri(url));
request.Timeout = Timeout;
request.Method = "POST";
string postString = String.Format("username={0}&password={1}&grant_type=password",
System.Net.WebUtility.UrlEncode(username),
System.Net.WebUtility.UrlEncode(password));
if (string.IsNullOrEmpty(facebookAccessToken) == false)
{
postString += "&facebookToken=" + System.Net.WebUtility.UrlEncode(facebookAccessToken);
}
byte[] bytes = Encoding.UTF8.GetBytes(postString);
using (Stream requestStream = await request.GetRequestStreamAsync())
{
requestStream.Write(bytes, 0, bytes.Length);
}
HttpWebResponse httpResponse = (HttpWebResponse)(await request.GetResponseAsync());
string json;
using (Stream responseStream = httpResponse.GetResponseStream())
{
json = new StreamReader(responseStream).ReadToEnd();
}
TokenResponseModel tokenResponse = JsonConvert.DeserializeObject <TokenResponseModel>(json);
keyChain.AccessToken = tokenResponse.AccessToken;
return(true);
}
catch (Exception exc)
{
LastException = exc;
keyChain.AccessToken = null;
return(false);
}
}
public async Task <JsonResult> TokenVerify(string token)
{
var verified = true;
TokenResponseModel tokenResponse = new TokenResponseModel()
{
Success = false
};
using (var client = _clientFactory.CreateClient())
{
var response = await client.GetStringAsync($"{googleRecaptchaVerifyApi}?secret={googleSecretKey}&response={token}");
tokenResponse = JsonConvert.DeserializeObject <TokenResponseModel>(response);
}
// Recaptcha V3 Verify Api send score 0-1. If score is low such as less than 0.5, you can think that it is a bot and return false.
// If token is not success then return false
if (!tokenResponse.Success || tokenResponse.Score < (decimal)0.5)
{
verified = false;
}
return(Json(verified));
}
public object Login(Login login)
{
TokenResponseModel token = new TokenResponseModel();
string pass = Crypto.SHA256(login.Password);
if (!ModelState.IsValid)
{
return(new HttpResponseException(HttpStatusCode.BadRequest).ToString());
}
else if (db.Logins.Where(x => x.UserName == login.UserName).ToList().Count() == 0)
{
token.AccessToken = null;
token.Username = null;
token.UserId = 0;
token.resultMessage = "Failed";
token.result = false;
return(token);
}
else if (db.Logins.Where(x => x.UserName == login.UserName && x.Password == pass).ToList().Count() == 0)
{
token.AccessToken = null;
token.Username = null;
token.UserId = 0;
token.resultMessage = "Failed";
token.result = false;
return(token);
}
else
{
int id = db.Logins.Where(x => x.UserName == login.UserName).Select(x => x.UserId).Single();
string s = JwtManager.GenerateToken(login.UserName);
token.AccessToken = s;
token.Username = login.UserName;
token.UserId = id;
token.resultMessage = "Successful";
token.result = true;
return(token);
}
}
/// <summary>
/// Gets a Token from the Token Service
/// </summary>
/// <param name="authentication">The authentication body</param>
/// <returns></returns>
public async Task<TokenResponseModel> GetTokenAsync(AuthenticationModel authentication)
{
try
{
var response = await this.client.PostAsync<string>(
"/token",
TokenCryptoManager.Instance.Encrypt(JsonConvert.SerializeObject(authentication)),
new TextMediaFormatter());
var tokenResponse = new TokenResponseModel
{
StatusCode = response.StatusCode
};
var responseText = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.OK)
{
return new TokenResponseModel
{
StatusCode = response.StatusCode,
AuthToken = responseText
};
}
else
{
return new TokenResponseModel
{
StatusCode = response.StatusCode,
Message = responseText
};
}
}
catch (Exception ex)
{
throw ex;
}
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestMessage req, TraceWriter log)
{
try
{
log.Info("C# HTTP trigger function processed a request.");
var data = await RequestDecoder.Decode <TokenCreatePostModel>(req);
var response = new TokenResponseModel
{
id = data.email,
name = GetName(data.email),
iconURL = Gravatar.GetImageUrl(data.email),
password = new Jwt(data.email).Encode()
};
return(req.CreateResponse(HttpStatusCode.OK, response));
}
catch (HttpResponseException error)
{
return(error.Response);
}
}
private async void loginButton_Click(object sender, EventArgs e)
{
using (var client = new HttpClient())
{
client.BaseAddress = this.URI_TOKEN;
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("username", this.textBoxUserName.Text),
new KeyValuePair <string, string>("password", this.textBoxPassword.Text),
new KeyValuePair <string, string>("grant_type", "password")
});
var result = client.PostAsync("/Token", content).Result;
if (result.IsSuccessStatusCode)
{
string jsonMessage;
using (Stream responseStream = await result.Content.ReadAsStreamAsync())
{
jsonMessage = new StreamReader(responseStream).ReadToEnd();
}
TokenResponseModel tokenResponse = (TokenResponseModel)JsonConvert.DeserializeObject(jsonMessage, typeof(TokenResponseModel));
if (tokenResponse != null)
{
this.parent.Bearer = tokenResponse.AccessToken;
this.parent.StatusLabel = String.Format("Logged user: {0}", this.textBoxUserName.Text);
this.parent.SetAvailability = true;
MessageBox.Show(String.Format("Welcome, {0}!", this.textBoxUserName.Text), "Login");
}
}
else
{
MessageBox.Show(result.ReasonPhrase, "Error");
}
}
}
public async Task <JsonResultData> Login([FromBody] UserLoginModel model)
{
var result = await _signInManager
.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
var user = await _customerService.GetUserByTermAsync(model.Email);
var token = GenerateToken(user);
var tokenResponse = new TokenResponseModel
{
User = user,
AccessToken = token,
ExpiresIn = (int)TimeSpan.FromDays(1).TotalSeconds
};
return(JsonResultData.Success(tokenResponse));
}
return(JsonResultData.Error("Username or password isn't correct."));
}
public async Task <TokenResponseModel> SignInAsync(UserSignInModel signInModel)
{
var user = await _userManager.FindByNameAsync(signInModel.Email);
if (user is null)
{
throw new CustomExeption(Constants.Error.LOGIN_FAILD_NO_USER_WITH_THIS_EMAIL,
StatusCodes.Status400BadRequest);
}
var signIn = await _signInManager.PasswordSignInAsync(signInModel.Email, signInModel.Password, false, false);
if (!signIn.Succeeded)
{
throw new CustomExeption(Constants.Error.LOGIN_FAILD_WRONG_PASSWORD, StatusCodes.Status400BadRequest);
}
var roleList = await _userManager.GetRolesAsync(user);
if (roleList is null)
{
throw new Exception($"{Constants.Error.ERROR_NO_USERROLE} {StatusCodes.Status500InternalServerError}");
}
bool isRoleAdmin = roleList.Any(s => s.Contains("admin"));
var result = new TokenResponseModel();
if (isRoleAdmin)
{
result.AccessToken = _jwtProvider.GenerateJwt(signInModel.Email, "admin");
return(result);
}
result.AccessToken = _jwtProvider.GenerateJwt(signInModel.Email, "user");
return(result);
}
public async Task <IActionResult> Token([FromBody] AuthorizationCodeGrantRequestModel model)
{
if ("authorization_code".Equals(model.GrantType, StringComparison.OrdinalIgnoreCase))
{
var message = new AccessTokenRequestMessage(model.Code)
{
ClientId = model.ClientId,
ClientSecret = model.ClientSecret,
Code = model.Code,
RedirectUri = model.ClientSecret
};
var result = await _sagaBus.SendAsync <AccessTokenRequestMessage, OAuth20Result>(message);
switch (result.State)
{
case OAuth20State.AuthorizationCodeGenerated:
return(BadRequest());
case OAuth20State.Finished:
return(Ok(TokenResponseModel.FromOAuth20Result(result)));
}
}
return(BadRequest());
}
public async Task GivenTokenRequest_WhenGetToken_ThenGetTokenSuccessful()
{
//?Given
var request = new TokenRequestModel();
var tokenReponse = new TokenResponse();
var expected = new TokenResponseModel();
_tokenManager.Setup(x => x.GetToken(It.IsAny <TokenRequest>()))
.ReturnsAsync(tokenReponse)
.Verifiable();
_mapper.Setup(x => x.Map <TokenResponseModel>(tokenReponse))
.Returns(expected);
//?When
var actual = await _authController.GetToken(request);
//?Then
Assert.IsAssignableFrom <OkObjectResult>(actual);
Assert.Equal(((OkObjectResult)actual).Value, expected);
_tokenManager.Verify();
_mapper.Verify();
}
public TokenResponseModel SignIn(string username)
{
var accessToken = new AccessTokenModel()
{
Token = CreateAccessToken(username),
TokenType = "bearer",
ExpiresIn = ExpirationTimeInSeconds
};
var refreshToken = new RefreshTokenModel()
{
Token = GetNewRefreshToken(username)
};
_refreshTokens.Add(refreshToken);
var response = new TokenResponseModel()
{
AccessToken = accessToken,
RefreshToken = refreshToken.Token
};
return(response);
}
public void OnAuthenticated(TokenResponseModel tokenResponse)
{
Console.WriteLine("User authenticated");
bearerToken = "Bearer " + tokenResponse.AccessToken;
}
