private static async Task MainAsync()
{
var client = new HttpClient();
var discoveryResponse = await client.GetDiscoveryDocumentAsync(Authority);
if (discoveryResponse.IsError)
{
throw new ApplicationException(discoveryResponse.Error);
}
Console.WriteLine("Successful endpoint discovery");
// request token
var tokenRequest = new PasswordTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
ClientId = ClientId,
ClientSecret = ClientSecret,
Scope = ClientScope,
UserName = UserName,
Password = UserPassword
};
var tokenResponse = await client.RequestPasswordTokenAsync(tokenRequest);
if (tokenResponse.IsError)
{
throw new ApplicationException(tokenResponse.Error);
}
Console.WriteLine($"Identity Response Code: {(int)tokenResponse.HttpStatusCode} {tokenResponse.HttpStatusCode}");
Console.WriteLine($"Token Response:\n{tokenResponse.Json}\n\n");
// request userInfo
var userInfoRequest = new UserInfoRequest
{
Address = discoveryResponse.UserInfoEndpoint,
Token = tokenResponse.AccessToken
};
var userInfoResponse = await client.GetUserInfoAsync(userInfoRequest);
Console.WriteLine($"UserInfo Response Code: {(int)userInfoResponse.HttpStatusCode} {userInfoResponse.HttpStatusCode}");
if (userInfoResponse.IsError)
{
Console.WriteLine($"UserInfo Error Response: {userInfoResponse.Error}");
throw new Exception(userInfoResponse.Error);
}
Console.WriteLine("User Claims:");
foreach (var claim in userInfoResponse.Claims)
{
Console.WriteLine($"{claim.Type}: {claim.Value}");
}
}
private PasswordTokenRequest CreatePasswordTokenRequest(string address, string userName, string password)
{
var request = new PasswordTokenRequest()
{
Address = address,
ClientCredentialStyle = ClientCredentialStyle.AuthorizationHeader,
ClientId = this._option.ClientId,
ClientSecret = this._option.ClientSecret,
UserName = userName,
Password = password,
Scope = string.Join(" ", this._option.Scopes),
};
return(request);
}
protected virtual Task <PasswordTokenRequest> CreatePasswordTokenRequestAsync(DiscoveryDocumentResponse discoveryResponse, IdentityClientConfiguration configuration)
{
var request = new PasswordTokenRequest {
Address = discoveryResponse.TokenEndpoint,
Scope = configuration.Scope,
ClientId = configuration.ClientId,
ClientSecret = configuration.ClientSecret,
UserName = configuration.UserName,
Password = configuration.UserPassword
};
AddParametersToRequestAsync(configuration, request);
return(Task.FromResult(request));
}
public static TokenResponse LoginUsingIdentityServer(string is4ip, string clientId, string clientSecret, string scope, string username, string password)
{
var client = new HttpClient();
PasswordTokenRequest tokenRequest = new PasswordTokenRequest()
{
Address = is4ip,
ClientId = clientId,
ClientSecret = clientSecret,
UserName = username,
Password = password,
Scope = scope
};
return(client.RequestPasswordTokenAsync(tokenRequest).Result);
}
async Task <TokenResponse> GetAccessTokenUsingUsernameAndPassword(DiscoveryDocumentResponse disco)
{
var tokenClient = new HttpClient();
var pwdReq = new PasswordTokenRequest
{
ClientId = "consoleApp",
ClientSecret = "Console_App",
Address = disco.TokenEndpoint,
UserName = "******",
Password = "******",
Scope = "accountApi"
};
return(await tokenClient.RequestPasswordTokenAsync(pwdReq));
}
public async Task <TokenStore> GetToken(string userName, string password)
{
if (_currentToken == null || string.IsNullOrWhiteSpace(_currentToken.RefreshToken))
{
_logger.LogDebug("Token does not exist or is invalid");
var request = new PasswordTokenRequest
{
Address = TokenUrl,
GrantType = OidcConstants.GrantTypes.Password,
Scope = Scope,
UserName = userName,
Password = password
};
request.Headers.Add(AuthHeaderName, BasicAuthHeader);
var client = _clientFactory.CreateClient(Constants.TokenServiceClientName);
var result = await client.RequestPasswordTokenAsync(request);
var tokenStore = new TokenStore(result);
_store.AddOrUpdate(tokenStore);
_currentToken = tokenStore;
}
else if (_currentToken.Expired)
{
_logger.LogDebug("Token has expired, requesting new token from refresh token");
var refreshRequest = new RefreshTokenRequest
{
Address = TokenUrl,
GrantType = OidcConstants.GrantTypes.RefreshToken,
Scope = RefreshTokenScope,
RefreshToken = _currentToken.RefreshToken
};
refreshRequest.Headers.Add(AuthHeaderName, BasicAuthHeader);
var client = _clientFactory.CreateClient(Constants.TokenServiceClientName);
var refreshResult = await client.RequestRefreshTokenAsync(refreshRequest);
var tokenStore = new TokenStore(refreshResult);
_store.AddOrUpdate(tokenStore);
_currentToken = tokenStore;
}
return(_currentToken);
}
private async Task <TokenResponse> LoginGetAccesstoken(HttpClient client, string clientid,
string ClientSecret, string UserName, string Password,
string TokenEndpoint)
{
var ptr = new PasswordTokenRequest();
ptr.Address = TokenEndpoint;
ptr.ClientId = clientid;
ptr.ClientSecret = ClientSecret;
ptr.UserName = UserName;
ptr.Password = Password;
var tokenResponse = await client.RequestPasswordTokenAsync(ptr);
return(tokenResponse);
}
static async Task <TokenResponse> GetUserToken()
{
var client = new HttpClient();
var passwordTokenRequest = new PasswordTokenRequest
{
Address = "http://localhost:5000/connect/token",
ClientId = "carbon",
ClientSecret = "21B5F798-BE55-42BC-8AA8-0025B903DC3B",
UserName = "******",
Password = "******",
Scope = "api1"
};
var response = await client.RequestPasswordTokenAsync(passwordTokenRequest);
return(response);
}
public static void Main(string[] args)
{
var passwordRequest = new PasswordTokenRequest
{
Address = "http://bnu-vtec012:7600/auth/realms/master/protocol/openid-connect/token",
ClientId = "producer-api",
ClientSecret = "54835680-02b3-4477-a5bc-a5b3cafe223d",
UserName = "******",
Password = "******",
Scope = "openid profile email updated_at groups",
};
var passwordResponse = _client.RequestPasswordTokenAsync(passwordRequest).Result;
var random = new Random();
try
{
for (int index = 0; index < 10000; ++index)
{
var request = new
{
Url = "http://localhost:5004/api/contabilizacao",
Body = new
{
RequestID = Guid.NewGuid(),
IDEmpresa = $"{random.Next(0, 10_000)}-msg_index:{index}",
IDFilial = random.Next(0, 10_000),
DataEmissao = new DateTime(1980, 1, 1).AddDays(random.Next(0, 11_000)),
DataEntrada = new DateTime(1980, 1, 1).AddDays(random.Next(0, 11_000)),
TipoRegistro = random.Next(0, 10_000),
//Tag = "sucesso"
//Tag = "erro-aleatorio-de-infra"
Tag = "erro-msg-invalida"
},
};
_client.SetBearerToken(passwordResponse.AccessToken);
var httpResponse = _client.PostAsync(request.Url, ContentHelper.GetStringContent(request.Body)).Result;
Console.WriteLine($"Mensagem {request.Body.RequestID} índice {index} enviada com sucesso");
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
public async Task <IActionResult> ResourceOwnerPasswordLogin([FromBody][Required] LoginModel model)
{
try
{
var configuration = await _oidcOptions.ConfigurationManager.GetConfigurationAsync(default(CancellationToken));
var client = _httpClientFactory.CreateClient();
var request = new PasswordTokenRequest
{
Address = configuration.TokenEndpoint,
ClientId = _oidcOptions.ClientId,
ClientSecret = _oidcOptions.ClientSecret,
UserName = model.UserName,
Password = model.Password,
Scope = OpenIdConnectDefaults.AuthenticationScheme
};
request.Parameters.Add("resource", _oidcOptions.ClientId);
var response = await client.RequestPasswordTokenAsync(request);
if (response.IsError)
{
_logger.LogWarning($"Error RequestPasswordTokenAsync: {response.Error}, {response.ErrorDescription} ");
return(StatusCode(StatusCodes.Status401Unauthorized));
}
var properties = new AuthenticationProperties();
if (_oidcOptions.SaveTokens)
{
properties.UpdateTokenValue("access_token", response.AccessToken);
properties.UpdateTokenValue("refresh_token", response.RefreshToken);
DateTime newExpiresAt = DateTime.UtcNow + TimeSpan.FromSeconds(response.ExpiresIn);
properties.UpdateTokenValue("expires_at", newExpiresAt.ToString("o", CultureInfo.InvariantCulture));
}
var principal = ValidateAndDecode(response.AccessToken, configuration.SigningKeys, configuration.Issuer, _oidcOptions.ClientId);
await HttpContext.SignInAsync(principal, properties);
return(StatusCode(StatusCodes.Status200OK));
}
catch (Exception ex)
{
_logger.LogWarning("Error ResourceOwnerPasswordLogin: {error}", ex);
return(StatusCode(StatusCodes.Status401Unauthorized));
}
}
public async Task <bool> CreateClient(ClientApiDto clientApi)
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(IdentityEndpoint.Discovery);
if (disco.IsError)
{
return(false);
}
// request token
var req = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = IdentityEndpoint.ClientID,
ClientSecret = IdentityEndpoint.Secret,
Scope = IdentityEndpoint.Scopes,
UserName = IdentityEndpoint.UserName,
Password = IdentityEndpoint.Password
};
var tokenResponse = await client.RequestPasswordTokenAsync(req);
if (tokenResponse.IsError)
{
return(false);
}
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var dataJson = JsonSerializer.Serialize(clientApi);
var stringContent = new StringContent(dataJson, Encoding.UTF8, "application/json");
var response = await apiClient.PostAsync(IdentityEndpoint.ClientUri, stringContent);
if (response.IsSuccessStatusCode)
{
var resDeserialize = await JsonHelper.Deserialize <ClientApiDto>(response, defaultOptions);
clientApi.Id = resDeserialize.Id;
}
return(response.IsSuccessStatusCode);
}
/// <summary>
/// Makes an object that represents a requestUrl, to an Identity Server, for access by this
/// API on behalf of a User, as identified by the User's username/password credentials.
/// </summary>
/// <param name="tokenEndpoint">The URI of the target Identity Server's Token EndPoint.</param>
/// <param name="username">The Username of the requesting User.</param>
/// <param name="password">the Password of the requesting User.</param>
/// <returns>A new requestUrl object.</returns>
///
private PasswordTokenRequest MakeApiAccessTokenRequest(string tokenEndpoint,
string username,
string password)
{
var request = new PasswordTokenRequest
{
Address = tokenEndpoint,
ClientId = "AccountsCli.ro",
ClientSecret = _clientSecret,
Scope = $"{ApplicationScopes.USER_MANAGEMENT_API } {ApplicationScopes.ACCOUNTS_API} offline_access openid profile",
UserName = username,
Password = password
};
return(request);
}
protected virtual Task <PasswordTokenRequest> CreatePasswordTokenRequestAsync(string tokenEndpoint, IdentityClientConfiguration configuration)
{
var request = new PasswordTokenRequest
{
Address = tokenEndpoint,
Scope = configuration.Scope,
ClientId = configuration.ClientId,
ClientSecret = configuration.ClientSecret,
UserName = configuration.UserName,
Password = configuration.UserPassword
};
IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage?.Invoke(request);
AddParametersToRequestAsync(configuration, request);
return(Task.FromResult(request));
}
private async Task <TokenResponse> RequestPasswordTokenAsync()
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(AppSettings.Authority);
var passwordTokenRequest = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = AppSettings.ClientId,
ClientSecret = AppSettings.ClientSecret,
Scope = AppSettings.Scope,
UserName = AppSettings.UserUsername,
Password = AppSettings.UserPassword
};
return(await client.RequestPasswordTokenAsync(passwordTokenRequest));
}
public async Task <APIToken> GetIdentityToken(LoginViewModel user)
{
string tokenEndPoint = await GetTokenEndPoint();
var req = new PasswordTokenRequest
{
Address = tokenEndPoint,
ClientId = "identity.client",
ClientSecret = "anothersecret",
Scope = "IdentityServerApi",
UserName = user.UserName,
Password = user.Password
};
return(await GetToken(req));
}
private static async Task <string> GetTokenAsync()
{
using (var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost:44362")
})
{
var document = await httpClient.GetDiscoveryDocumentAsync();
if (!document.IsError)
{
var tokenEndpoint = document.TokenEndpoint;
//Task<TokenResponse> RequestAuthorizationCodeTokenAsync(AuthorizationCodeTokenRequest)
//Task<TokenResponse> RequestClientCredentialsTokenAsync(ClientCredentialsTokenRequest)
//Task<TokenResponse> RequestDeviceTokenAsync(DeviceTokenRequest)
//Task<TokenResponse> RequestPasswordTokenAsync(PasswordTokenRequest)
//Task<TokenResponse> RequestRefreshTokenAsync(RefreshTokenRequest)
//Task<TokenResponse> RequestTokenAsync(TokenRequest)
var request = new PasswordTokenRequest
{
RequestUri = new Uri(tokenEndpoint),
ClientId = "EmergencyResponseService_App",
UserName = "******",
Password = "******"
};
request.Headers.Add("__tenant", "39fe0e34-6c58-c5d7-ed25-0b0c9275a1f0");
var tokenResponse = await httpClient.RequestPasswordTokenAsync(request);
if (!tokenResponse.IsError)
{
ValidToken(tokenResponse.AccessToken);
Console.WriteLine(tokenResponse);
return($"{tokenResponse.TokenType} {tokenResponse.AccessToken}");
}
}
}
return("");
}
public async Task User_authenticated()
{
var discoveryDocument = await _client.GetDiscoveryDocumentAsync();
Assert.False(discoveryDocument.IsError);
using var request = new PasswordTokenRequest()
{
Address = discoveryDocument.TokenEndpoint,
ClientId = "PublicApi",
UserName = "******",
Password = "******"
};
var response = await _client.RequestPasswordTokenAsync(request);
Assert.False(response.IsError, response.Error);
Assert.NotNull(response.AccessToken);
}
public async Task <TokenResponse> GetToken()
{
Console.WriteLine("Getting access token");
var request = new PasswordTokenRequest
{
Address = IdentityServerUrl,
GrantType = "Password",
ClientId = MessagingClientId,
ClientSecret = MessagingClientSecret,
Scope = MessagingApiId,
UserName = _username,
Password = _password
};
return(await _client.RequestPasswordTokenAsync(request));
}
public async Task GivenAnUserIsLoggedInWithUsernameAndPassword(Table table)
{
var discoveryAddress = Configuration.GetValue <string>("DiscoveryAddress");
using var client = new HttpClient();
using var discoveryDocumentRequest = new DiscoveryDocumentRequest
{
Policy = new DiscoveryPolicy { RequireHttps = false },
Address = discoveryAddress,
};
var discoveryDocument = await client.GetDiscoveryDocumentAsync(discoveryDocumentRequest);
if (discoveryDocument.IsError)
{
Console.WriteLine(discoveryDocument.Error);
return;
}
var user = table.CreateSet <UserTable>().First();
using var passwordTokenRequest = new PasswordTokenRequest
{
Address = discoveryDocument.TokenEndpoint,
ClientId = "PasswordClient",
ClientSecret = "PasswordSecret",
UserName = user.Username,
Password = user.Password,
Scope = user.Scope,
};
TokenResponse tokenResponse = await client.RequestPasswordTokenAsync(passwordTokenRequest);
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
return;
}
context[ScenarioContextKeys.AccessToken] = tokenResponse.AccessToken;
}
static async Task MainAsync(string[] args)
{
/* Discover endpoints from metadata */
using (var client = new HttpClient())
{
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:18000");
if (disco.IsError)
{
Console.WriteLine(disco.Error);
}
else
{
Console.WriteLine("Discovery document it was successfully.");
}
/* Create request */
var tokenRequest = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "onlinestoreclient",
ClientSecret = "onlinestoreclientsecret1",
UserName = "******",
Password = "******"
};
var tokenResponse = await client.RequestPasswordTokenAsync(tokenRequest);
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
}
else
{
Console.WriteLine("Connection for '{0}' user was successfully.", tokenRequest.UserName);
}
}
Console.ReadLine();
}
static async Task Main(string[] args)
{
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000");
if (disco.IsError)
{
throw new Exception(disco.Error);
}
//ClientCredentialsTokenRequest tokenRequest = new ClientCredentialsTokenRequest
//{
// Address=disco.TokenEndpoint,
// ClientId= "client",
// ClientSecret= "Secret",
// Scope= "api1"
//};
//TokenResponse tokenResponse = await client.RequestClientCredentialsTokenAsync(tokenRequest);
PasswordTokenRequest tokenRequest = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = "pwd_client",
ClientSecret = "Secret",
Scope = "api1",
UserName = "******",
Password = "******"
};
TokenResponse tokenResponse = await client.RequestPasswordTokenAsync(tokenRequest);
if (tokenResponse.IsError)
{
Console.WriteLine(tokenResponse.Error);
}
client.SetBearerToken(tokenResponse.AccessToken);
string result = await client.GetStringAsync("http://localhost:5001/api/values");
Console.WriteLine(result);
Console.WriteLine("Hello World!");
Console.ReadKey();
}
protected virtual async Task <PasswordTokenRequest> CreatePasswordTokenRequestAsync(IdentityClientConfiguration configuration)
{
var discoveryResponse = await GetDiscoveryResponse(configuration);
var request = new PasswordTokenRequest
{
Address = discoveryResponse.TokenEndpoint,
Scope = configuration.Scope,
ClientId = configuration.ClientId,
ClientSecret = configuration.ClientSecret,
UserName = configuration.UserName,
Password = configuration.UserPassword
};
IdentityModelHttpRequestMessageOptions.ConfigureHttpRequestMessage?.Invoke(request);
await AddParametersToRequestAsync(configuration, request);
return(request);
}
public async Task <APIToken> GetAPIToken(LoginViewModel user)
{
string tokenEndPoint = await GetTokenEndPoint();
var req = new PasswordTokenRequest
{
Address = tokenEndPoint,
ClientId = "api.client",
ClientSecret = "secret",
Scope = "api1",
UserName = user.UserName,
Password = user.Password,
};
APIToken token = await GetToken(req);
_context.HttpContext.Response.Cookies.Append("UserName", user.UserName);
return(token);
}
public static async Task <TokenResponse> GetMastpenCustomerTokenAsync(string userName, string password)
{
using (var client = new HttpClient())
{
var settings = ClientSettingsMocker.GetMastpenIdentityClientSettings(userName, password);
var disco = await client.GetDiscoveryDocumentAsync(settings.Url);
var req = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = settings.ClientId,
ClientSecret = settings.ClientSecret,
UserName = settings.UserName,
Password = settings.Password
};
var vv = await client.RequestPasswordTokenAsync(req);
return(vv);
}
}
private async Task <TokenResponse> RequestTokenAsync(string userName, string password)
{
var httpClient = _httpClientFactory.CreateClient(_options.AuthorityHttpClientName);
var tokenEndpoint = await _options.GetTokenEndpointAsync(httpClient).ConfigureAwait(false);
var tokenRequest = new PasswordTokenRequest
{
Address = tokenEndpoint,
GrantType = _options.GrantType,
ClientId = _options.ClientId,
ClientSecret = _options.ClientSecret,
Scope = _options.Scope,
UserName = userName,
Password = password
};
tokenRequest.Parameters.AddRange(_options.ExtraTokenParameters);
var tokenResponse = await httpClient.RequestPasswordTokenAsync(tokenRequest).ConfigureAwait(false);
return(tokenResponse);
}
public async Task <bool> UpdateResource(ApiResourceApiDto resourceApiDto)
{
// discover endpoints from metadata
var client = new HttpClient();
var disco = await client.GetDiscoveryDocumentAsync(IdentityEndpoint.Discovery);
if (disco.IsError)
{
return(false);
}
// request token
var req = new PasswordTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = IdentityEndpoint.ClientID,
ClientSecret = IdentityEndpoint.Secret,
Scope = IdentityEndpoint.Scopes,
UserName = IdentityEndpoint.UserName,
Password = IdentityEndpoint.Password
};
var tokenResponse = await client.RequestPasswordTokenAsync(req);
if (tokenResponse.IsError)
{
return(false);
}
var apiClient = new HttpClient();
apiClient.SetBearerToken(tokenResponse.AccessToken);
var dataJson = JsonSerializer.Serialize(resourceApiDto);
var stringContent = new StringContent(dataJson, Encoding.UTF8, "application/json");
var response = await apiClient.PutAsync(IdentityEndpoint.ResourceUri, stringContent);
return(response.IsSuccessStatusCode);
}
public static async Task <System.Net.Http.HttpClient> CreateAuthClientAsync(this WebApplicationFactory <Startup> factory)
{
var apiClient = factory.CreateClient();
// auth to STS
var srvConfiguration = (IConfiguration)factory.Server.Host.Services.GetService(typeof(IConfiguration));
var srvIdentityUrl = srvConfiguration["IdentityServiceUrl"];
using (var identityClient = new System.Net.Http.HttpClient())
{
identityClient.BaseAddress = new Uri(srvIdentityUrl);
var discoveryResponse = await identityClient.GetDiscoveryDocumentAsync();
if (discoveryResponse.IsError)
{
throw new Exception($"Identity service at {srvIdentityUrl} failed or not running. {discoveryResponse.Error}", discoveryResponse.Exception);
}
// use custom local account password for testing purpose
var request = new PasswordTokenRequest();
request.Address = discoveryResponse.TokenEndpoint;
request.ClientCredentialStyle = ClientCredentialStyle.PostBody;
request.Scope = "data";
request.ClientId = "api.client.test";
request.ClientSecret = srvConfiguration["TestUser:ClientSecret"];
request.UserName = srvConfiguration["TestUser:Name"];
request.Password = srvConfiguration["TestUser:Password"];
var tokenResponse = await identityClient.RequestPasswordTokenAsync(request);
if (tokenResponse.IsError)
{
throw new Exception($"Authentication failed! {tokenResponse.Error} {tokenResponse.ErrorDescription}", tokenResponse.Exception);
}
apiClient.SetBearerToken(tokenResponse.AccessToken);
}
return(apiClient);
}
/// <summary>
/// Obtains an Access Token from an Identity Server using username/password credentials that were
/// known or obtained by the client. To be used by native clients only.
/// </summary>
/// <param name="request">Represents the user's login credentials.</param>
/// <returns>
/// A <c>TokenResponse</c> instance containing the user's Access Token and (if supported by
/// this Identity Server for this Client) a Refresh Token.
/// </returns>
///
private async Task <TokenResponse> RequestAccessTokenAsync(PasswordTokenRequest request)
{
TokenResponse tokenResponse;
using (var client = new HttpClient())
{
// Use this requestUrl for clients that cannot host a login page and must obtain (or just know) the credentials themselves.
tokenResponse = await client.RequestPasswordTokenAsync(request);
}
// if (tokenResponse.IsError)
// {
// Console.WriteLine(tokenResponse.Error);
// }
// else
// {
// Console.WriteLine(tokenResponse.Json);
// Console.WriteLine("\n\n");
// }
return(tokenResponse);
}
public async Task <ActionResult> GetTokenForMobileAppAsync(String username, String password)
{
Boolean isDoctor = false;
AspNetUsers user = _context.AspNetUsers.Where(a => a.UserName == username).FirstOrDefault();
//Get userID first.
if (user != null)
{
isDoctor = true;
}
// Call API to get the token
var apiClientCredentials = new PasswordTokenRequest
{
Address = Messages.AUTH_IP_ADDRESS_URL + "/connect/token",
ClientId = "ro.client",
ClientSecret = "secret",
// This is the scope our Protected API requires.
Scope = "openid email profile doctalk_auth_api",
UserName = username,
Password = password
};
var client = new HttpClient();
// 1. Authenticates and get an access token from Identity Server
var tokenResponse = await client.RequestPasswordTokenAsync(apiClientCredentials);
var result_token = tokenResponse.Json;
result_token.Add("isDoctor", isDoctor);
if (tokenResponse.IsError)
{
Console.WriteLine("Cannot get the data");
return(StatusCode(500));
}
return(Ok(result_token));
}
/// <summary>
/// Request the resource owner credentials.
/// </summary>
/// <param name="userName">Contains the user name.</param>
/// <param name="password">Contains the user password.</param>
/// <param name="scopes">Contains the scopes.</param>
/// <param name="cancellationToken">Contains a cancellation token.</param>
/// <returns>Returns a <see cref="TokenResponse"/> object.</returns>
protected async Task <TokenResponse> RequestResourceOwnerPasswordAsync(string userName, string password, string scopes, CancellationToken cancellationToken)
{
TokenResponse result;
using (HttpClient client = new HttpClient())
{
var config = new PasswordTokenRequest
{
Address = this.TokenEndpoint,
ClientId = this.Config.ClientId,
Scope = scopes,
ClientSecret = this.Config.ClientSecret,
UserName = userName,
Password = password
};
result = await client.RequestPasswordTokenAsync(config, cancellationToken)
.ConfigureAwait(false);
}
return(result);
}
