public void RequestClientCredentialsToken_ServiceUnavailable_ThrowsAsync() { // Arrange var request = new ClientCredentialsTokenRequest(); // Assert Assert.ThrowsAsync <IdokladUnavailableException>(async() => await _serviceUnavailableClient.RequestClientCredentialsTokenAsync(request)); }
public HttpHandler(IHttpClientFactory httpClientFactory, IConfiguration config, ClientCredentialsTokenRequest tokenRequest, IUnmockablesWrapper unmockablesWrapper) { _httpClientFactory = httpClientFactory; _config = config; _tokenRequest = tokenRequest; _unmockablesWrapper = unmockablesWrapper; }
private static void Main(string[] args) { var teste = new MyClass1 { casa = "teste", opa = 1, update = DateTime.UtcNow, sub = new SubClass1 { home = "casa", lastdate = DateTime.Now, oxi = 3 } }; //Bruno Lambert //client-credentials application const string CLIENT_ID = "0fbfaafa-c74b-4da2-9307-6fdcdc5cf58b"; const string CLIENT_SECRET = "OLGSXm1Gf0MV8QfHASnepdXOLnIaBFBvMurCTGD5XnO7n3zAy1nX7AwOQ0lOtqjDYwDK783B9mY3jpCv"; const string SCOPE = "peoplemgmt-ho"; var httpClient = new HttpClient(); var discovery = httpClient.GetDiscoveryDocumentAsync("https://login-ho.sdasystems.org").Result; var clientCredentialsTokenRequest = new ClientCredentialsTokenRequest() { ClientId = CLIENT_ID, ClientSecret = CLIENT_SECRET, Scope = SCOPE, Address = discovery.TokenEndpoint, }; var tokens = httpClient.RequestClientCredentialsTokenAsync(clientCredentialsTokenRequest).Result; // ---------------------------------------------------------------------------------------------------------- // var apiConfig = new Configuration() { AccessToken = tokens.AccessToken, BasePath = "http://localhost:60736/",//-dev,-ho //BasePath = "https://ws-peoplemgmt-ho.sdasystems.org/bra/",//-dev,-ho }; //PhoneTypeTest(apiConfig); //LegalEntityTest(apiConfig); //CountryTest(apiConfig); //EmergencyContactTest(apiConfig); //AddressTest(apiConfig); NaturalPersonTest(apiConfig); //AddressTypeTest(apiConfig); //AllergyTypeTeste(apiConfig); //DisabilityTypeTeste(apiConfig); //ZipPostalCodeAddressTest(apiConfig); Console.WriteLine("-- END --"); Console.ReadLine(); }
public async Task <IActionResult> Index() { // discover endpoints from metadata var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5011"); JsonSerializerSettings settings = new JsonSerializerSettings(); settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; //_logger.LogDebug("client.GetDiscoveryDocumentAsync=>{0}", JsonConvert.SerializeObject(disco, settings)); if (disco.IsError) { return(Json(disco.Error)); } var AuthorizationCodeTokenRequest = new AuthorizationCodeTokenRequest { Address = disco.AuthorizeEndpoint, ClientId = "mvc_client", ClientSecret = "secret", RedirectUri = "https://localhost:8001/signin-oidc" }; var temp = await client.RequestAuthorizationCodeTokenAsync(AuthorizationCodeTokenRequest); var ClientCredentialsTokenRequest = new ClientCredentialsTokenRequest { Address = disco.TokenEndpoint, ClientId = "client", ClientSecret = "secret", Scope = "api1" }; // request token var tokenResponse = await client.RequestClientCredentialsTokenAsync(ClientCredentialsTokenRequest); //_logger.LogDebug("client.RequestClientCredentialsTokenAsync=>{0}", JsonConvert.SerializeObject(tokenResponse)); if (tokenResponse.IsError) { return(Json(tokenResponse.Error)); } //return Json(tokenResponse.Json); // call api var apiClient = new HttpClient(); apiClient.SetBearerToken(tokenResponse.AccessToken); var response = await apiClient.GetAsync("https://localhost:6001/api/identity"); if (!response.IsSuccessStatusCode) { return(Json(response.StatusCode)); } else { var content = await response.Content.ReadAsStringAsync(); return(Json(content)); } }
public IdentityServerClient( HttpClient httpClient, ClientCredentialsTokenRequest tokenRequest, ILogger <IdentityServerClient> logger) { _httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient)); _tokenRequest = tokenRequest ?? throw new ArgumentNullException(nameof(tokenRequest)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
private static void Main(string[] args) { var teste = new MyClass1 { casa = "teste", opa = 1, update = DateTime.UtcNow, sub = new SubClass1 { home = "casa", lastdate = DateTime.Now, oxi = 3 } }; //client-credentials application const string CLIENT_ID = "CLIENT_ID"; const string CLIENT_SECRET = "CLIENT_SECRET"; const string SCOPE = "peoplemgmt"; ; var httpClient = new HttpClient(); var discovery = httpClient.GetDiscoveryDocumentAsync("https://login-ho.sdasystems.org").Result; var clientCredentialsTokenRequest = new ClientCredentialsTokenRequest() { ClientId = CLIENT_ID, ClientSecret = CLIENT_SECRET, Scope = SCOPE, Address = discovery.TokenEndpoint, }; var tokens = httpClient.RequestClientCredentialsTokenAsync(clientCredentialsTokenRequest).Result; // ---------------------------------------------------------------------------------------------------------- // var apiConfig = new Configuration() { AccessToken = tokens.AccessToken, BasePath = "http://localhost:60736/",//-dev,-ho }; //DocumentTypeTest(apiConfig); //PhoneTypeTest(apiConfig); //LegalEntityTest(apiConfig); //CountryTest(apiConfig); //DiseaseTest(apiConfig); //EmergencyContactTest(apiConfig); AddressTest(apiConfig); //NaturalPersonTest(apiConfig); //AddressTypeTest(apiConfig); //AllergyTypeTeste(apiConfig); //DisabilityTypeTeste(apiConfig); //ZipPostalCodeAddressTest(apiConfig); Console.WriteLine("-- END --"); Console.ReadLine(); }
public IdentityServerClient( HttpClient httpClient, ClientCredentialsTokenRequest tokenRequest, ILogger <IdentityServerClient> logger) { _httpClient = Guard.IsNotNull(httpClient, nameof(httpClient)); _tokenRequest = Guard.IsNotNull(tokenRequest, nameof(tokenRequest)); _logger = Guard.IsNotNull(logger, nameof(logger)); }
/// <inheritdoc /> public virtual async Task <ClientCredentialsTokenRequest> GetClientCredentialsRequestAsync(string clientName, ClientAccessTokenParameters parameters) { ClientCredentialsTokenRequest requestDetails; // if a named client configuration was passed in, try to load it if (string.Equals(clientName, AccessTokenManagementDefaults.DefaultTokenClientName)) { // if only one client configuration exists, load that if (_clientAccessTokenManagementOptions.Clients.Count == 1) { _logger.LogDebug("Reading token client configuration from single configuration entry."); requestDetails = _clientAccessTokenManagementOptions.Clients.First().Value; } // otherwise fall back to the scheme configuration else { _logger.LogDebug("Constructing token client configuration from OpenID Connect handler."); var(options, configuration) = await GetOpenIdConnectSettingsAsync(_userAccessTokenManagementOptions.SchemeName); requestDetails = new ClientCredentialsTokenRequest { Address = configuration.TokenEndpoint, ClientId = options.ClientId, ClientSecret = options.ClientSecret }; if (!string.IsNullOrWhiteSpace(_clientAccessTokenManagementOptions.DefaultClient.Scope)) { requestDetails.Scope = _clientAccessTokenManagementOptions.DefaultClient.Scope; } if (!string.IsNullOrWhiteSpace(_clientAccessTokenManagementOptions.DefaultClient.Resource)) { requestDetails.Resource.Add(_clientAccessTokenManagementOptions.DefaultClient.Resource); } var assertion = await CreateAssertionAsync(clientName); if (assertion != null) { requestDetails.ClientAssertion = assertion; } } } else { if (!_clientAccessTokenManagementOptions.Clients.TryGetValue(clientName, out requestDetails)) { throw new InvalidOperationException($"No access token client configuration found for client: {clientName}"); } } _logger.LogDebug("Returning token client configuration for client: {client}", clientName); return(requestDetails); }
private async Task <string> GetAccessTokenAsync(CancellationToken cancellationToken) { if (_accessToken != null && DateTime.UtcNow < _accessTokenExpiry) { return(_accessToken); } using (HttpClient client = new HttpClient()) { var discoveryRequest = new DiscoveryDocumentRequest { Address = _resource + "/identity", Policy = new DiscoveryPolicy { Authority = "https://identity.osisoft.com", ValidateEndpoints = false, ValidateIssuerName = false } }; var discoveryResponse = await client.GetDiscoveryDocumentAsync(discoveryRequest, cancellationToken); if (discoveryResponse.IsError) { throw new InvalidOperationException(discoveryResponse.Error); } var clientCredentialsTokenRequest = new ClientCredentialsTokenRequest { Address = discoveryResponse.TokenEndpoint, ClientId = _clientId, ClientSecret = _clientSecret, Scope = "ocsapi" }; DateTime now = DateTime.UtcNow; var tokenResponse = await client.RequestClientCredentialsTokenAsync(clientCredentialsTokenRequest, cancellationToken); if (discoveryResponse.IsError) { throw new InvalidOperationException(tokenResponse.Error); } if (string.IsNullOrEmpty(tokenResponse.AccessToken)) { throw new InvalidOperationException("Failed to acquire Access Token"); } _accessToken = tokenResponse.AccessToken; // Add a buffer of 30 seconds to the expiration delta. _accessTokenExpiry = now.AddSeconds(tokenResponse.ExpiresIn - 30); return(_accessToken); } }
private void SetupClientCredentialsTokenRequest() { tokenRequest = new ClientCredentialsTokenRequest { Address = originalAddress, ClientId = clientId, ClientSecret = clientSecret, Scope = originalScope }; }
public async Task <IActionResult> GetVersionOne() { // 1. "retrieve" our api credentials. This must be registered on Identity Server! var apiClientCredentials = new ClientCredentialsTokenRequest { Address = "http://localhost:5000/connect/token", ClientId = "client-app", ClientSecret = "secret", // This is the scope our Protected API requires. Scope = "read:entity" }; // creates a new HttpClient to talk to our IdentityServer (localhost:5000) var client = new HttpClient(); // just checks if we can reach the Discovery document. Not 100% needed but.. var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000"); if (disco.IsError) { Console.WriteLine(disco.Error); return(StatusCode(500)); } // 2. Authenticates and get an access token from Identity Server var tokenResponse = await client.RequestClientCredentialsTokenAsync(apiClientCredentials); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); return(StatusCode(500)); } // Another HttpClient for talking now with our Protected API var apiClient = new HttpClient(); // 3. Set the access_token in the request Authorization: Bearer <token> client.SetBearerToken(tokenResponse.AccessToken); // 4. Send a request to our Protected API var response = await client.GetAsync("http://localhost:5002/api/protected"); if (!response.IsSuccessStatusCode) { Console.WriteLine(response.StatusCode); return(StatusCode(500)); } var content = await response.Content.ReadAsStringAsync(); // All good! We have the data here return(Ok(content)); }
/// <inheritdoc/> public JWTModel AuthenticateAsUser(Uri tokenUri, ClientCredentialsTokenRequest tokenRequest) { this.logger.LogDebug($"Authenticating Direct Grant as User: {tokenRequest.Username}"); Task <IAuthModel> authenticating = this.ResourceOwnerPasswordGrant(tokenUri, tokenRequest); JWTModel jwtModel = (authenticating.Result as JWTModel) !; this.logger.LogDebug($"Finished authenticating User: {tokenRequest.Username}"); return(jwtModel); }
static async Task Main(string[] args) { var client = new HttpClient(); var discovery = await client.GetDiscoveryDocumentAsync("http://localhost:5000"); if (discovery.IsError) { Console.WriteLine(discovery.Error); return; } var request = new ClientCredentialsTokenRequest() { Address = discovery.TokenEndpoint, ClientId = "restClient", ClientSecret = "secret", Scope = "SearchApi", }; var userPwdRequest = new PasswordTokenRequest() { Address = discovery.TokenEndpoint, ClientId = "ApiClient", ClientSecret = "secret", UserName = "******", Password = "******", Scope = "SearchApi", }; var tokenResponse = await client.RequestClientCredentialsTokenAsync(request); // var tokenResponse = await client.RequestPasswordTokenAsync(userPwdRequest); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); return; } Console.WriteLine(tokenResponse.Json); Console.WriteLine("\n\n"); var apiClient = new HttpClient(); apiClient.SetBearerToken(tokenResponse.AccessToken); var response = await apiClient.GetAsync("http://localhost:5001/identity"); if (!response.IsSuccessStatusCode) { Console.WriteLine(response.StatusCode); } else { var content = await response.Content.ReadAsStringAsync(); Console.WriteLine(JArray.Parse(content)); } }
/// <summary> /// Sends a token request using the client_credentials grant type. /// </summary> /// <param name="scope">The scope (space separated string).</param> /// <param name="parameters">Extra parameters.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> public Task <TokenResponse> RequestClientCredentialsTokenAsync(string scope = null, Parameters parameters = null, CancellationToken cancellationToken = default) { var request = new ClientCredentialsTokenRequest { Scope = scope }; ApplyRequestParameters(request, parameters); return(_client().RequestClientCredentialsTokenAsync(request, cancellationToken)); }
private static async Task <TokenResponse> GetClientCredentialToken(ClientCredentialsTokenRequest request) { TokenResponse response = null; if (request != null) { response = await new HttpClient().RequestClientCredentialsTokenAsync(request); } return(response); }
/// <inheritdoc/> public JWTModel AuthenticateAsSystem(Uri tokenUri, ClientCredentialsTokenRequest tokenRequest) { this.logger.LogDebug($"Authenticating Service... {tokenRequest.ClientId}"); Task <IAuthModel> authenticating = this.ClientCredentialsGrant(tokenUri, tokenRequest); JWTModel jwtModel = (authenticating.Result as JWTModel) !; this.logger.LogDebug($"Finished authenticating Service. {tokenRequest.ClientId}"); return(jwtModel); }
protected override void ExecuteRequest(HttpContext context) { if (Request == null || string.IsNullOrWhiteSpace(Request.PasswordHash) || (string.IsNullOrWhiteSpace(Request.Login) && string.IsNullOrWhiteSpace(Request.EmailAddress))) { context.Response.StatusCode = StatusCodes.Status400BadRequest; return; } if (!_userRepository.CanSignIn(Request).GetAwaiter().GetResult()) { context.Response.StatusCode = StatusCodes.Status400BadRequest; return; } Dbo.User user; if (!string.IsNullOrEmpty(Request.EmailAddress)) { user = _userRepository.GetUserByLoginOrEmail(null, Request.EmailAddress).GetAwaiter().GetResult(); if (user != null) { Request.Login = user.Login; } } else { user = _userRepository.GetUserByLoginOrEmail(Request.Login, null).GetAwaiter().GetResult(); } string fullAddress = $"{HTTP}{address}:{port}"; var client = new HttpClient(); DiscoveryDocumentResponse discoDoc = client.GetDiscoveryDocumentAsync(fullAddress).GetAwaiter().GetResult(); ClientCredentialsTokenRequest clientCredentialsTokenRequest = new ClientCredentialsTokenRequest { Address = discoDoc.TokenEndpoint, ClientId = Request.Login, ClientSecret = Request.PasswordHash, Scope = "api1" }; TokenResponse tokenResponse = client.RequestClientCredentialsTokenAsync(clientCredentialsTokenRequest).GetAwaiter().GetResult(); string jsonAsString = tokenResponse.Json.ToString(); context.Response.StatusCode = (int)tokenResponse.HttpStatusCode; if (context.Response.StatusCode == StatusCodes.Status200OK) { user.LastLoginDate = DateTime.Now; _userRepository.Update(user); } context.Response.WriteAsync(jsonAsString).GetAwaiter().GetResult(); }
public void ShouldErrorIfNoAuthToken() { // Setup // Input Parameters string phn = "9735361219"; // Setup Configuration string endpoint = "https://test-endpoint"; Uri tokenUri = new Uri("https://localhost"); ClientCredentialsTokenRequest tokenRequest = new ClientCredentialsTokenRequest() { ClientId = "TEST_CLIENTID", ClientSecret = "TEST_CLIENT_SECRET", Password = "******", Username = "******", }; Dictionary <string, string> configurationParams = new Dictionary <string, string> { { "Salesforce:Endpoint", endpoint }, { "Salesforce:TokenUri", tokenUri.ToString() }, { "Salesforce:ClientAuthentication:ClientId", tokenRequest.ClientId }, { "Salesforce:ClientAuthentication:ClientSecret", tokenRequest.ClientSecret }, { "Salesforce:ClientAuthentication:Username", tokenRequest.Username }, { "Salesforce:ClientAuthentication:Password", tokenRequest.Password }, }; IConfiguration configuration = CreateConfiguration(configurationParams); // Setup Authentication Mock <IAuthenticationDelegate> mockAuthenticationDelegate = new Mock <IAuthenticationDelegate>(); mockAuthenticationDelegate .Setup(s => s.AuthenticateAsUser( It.Is <Uri>(x => x.ToString() == tokenUri.ToString()), It.Is <ClientCredentialsTokenRequest>(x => x.ClientId == tokenRequest.ClientId))) .Returns(() => new JWTModel()); // Setup class to be tested IMedicationRequestDelegate medDelegate = new SalesforeceDelegate( CreateLogger(), new Mock <IHttpClientService>().Object, configuration, mockAuthenticationDelegate.Object); // Test RequestResult <IList <MedicationRequest> > response = Task.Run(async() => await medDelegate.GetMedicationRequestsAsync(phn).ConfigureAwait(true)).Result; // Verify Assert.Equal(Common.Constants.ResultType.Error, response.ResultStatus); Assert.NotNull(response.ResultError); Assert.NotNull(response.ResultError?.ErrorCode); }
private static async Task <string> GetAccessTokenAsync(string scope) { WriteLine(); SetTextColorTo(Yellow); WriteLine($"IDENTITYSERVER4 HOST Response for '{scope}':-"); //Create HTTP client instance. var httpClient = new HttpClient(); //Get the discovery document by calling the extension method //present in HttpClientDiscoveryExtensions(namespace: IdentityModel.Client) var discoveryDoc = await httpClient.GetDiscoveryDocumentAsync(_Authority); if (discoveryDoc.IsError) { SetTextColorTo(Red); WriteLine("Error occurred while fetching discovery document."); WriteLine(); WriteLine($"Error: {discoveryDoc.Error}"); return(null); } //Create token request model var tokenRequestModel = new ClientCredentialsTokenRequest { Address = discoveryDoc.TokenEndpoint, ClientId = _ClientId, ClientSecret = _ClientSecret, //If Scope is not defined, all scopes are returned from the IdentityServer. Scope = scope }; //Since we are using ClientCredential for machine-to-machine interaction. var response = await httpClient.RequestClientCredentialsTokenAsync(tokenRequestModel); if (response.IsError) { SetTextColorTo(Red); WriteLine("Error occurred while requesting client credential token."); WriteLine(); WriteLine($"Error: {response.Error}"); return(null); } SetTextColorTo(Green); WriteLine(response.Json); return(response.AccessToken); }
public async Task <string> GetAccessToken() { var auth0Client = new AuthenticationApiClient(_authSettings.Domain); var tokenRequest = new ClientCredentialsTokenRequest() { ClientId = _authSettings.ClientId, ClientSecret = _authSettings.ClientSecret, Audience = _authSettings.Audience }; var tokenResponse = await auth0Client.GetTokenAsync(tokenRequest); return(tokenResponse.AccessToken); }
async Task <string> GetAccessToken() { var auth0Client = new AuthenticationApiClient(auth0Settings["Domain"]); var tokenRequest = new ClientCredentialsTokenRequest() { ClientId = auth0Settings["ClientId"], ClientSecret = auth0Settings["ClientSecret"], Audience = auth0Settings["Audience"] }; var tokenResponse = await auth0Client.GetTokenAsync(tokenRequest); return(tokenResponse.AccessToken); }
public async Task <HttpRequestMessage> Create(HttpMethod httpMethod, Uri uri, string requestScope) { var tokenRequest = new ClientCredentialsTokenRequest { Address = _tokenUrl, ClientId = _clientId, ClientSecret = _secret, Scope = requestScope }; var response = await _httpClient.RequestClientCredentialsTokenAsync(tokenRequest).ConfigureAwait(false); return(CreateWithAccessToken(httpMethod, uri, response.AccessToken)); }
async Task <TokenResponse> GetAccessTokenUsinClientCredentials(DiscoveryDocumentResponse disco) { var tokenClient = new HttpClient(); var clientReq = new ClientCredentialsTokenRequest { ClientId = "consoleApp", ClientSecret = "Console_App", Address = disco.TokenEndpoint, Scope = "accountApi" }; return(await tokenClient.RequestClientCredentialsTokenAsync(clientReq)); }
private static async Task Main() { // discover endpoints from metadata var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync("http://localhost:5000"); if (disco.IsError) { Console.WriteLine(disco.Error); return; } // request token var tokenRequest = new ClientCredentialsTokenRequest { Address = disco.TokenEndpoint, ClientId = "client", ClientSecret = "secret", Scope = "api1" }; var tokenResponse = await client.RequestClientCredentialsTokenAsync(tokenRequest); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); return; } Console.WriteLine("================================================== tokenResponse.Json"); Console.WriteLine(tokenResponse.Json); Console.WriteLine("\n\n"); // call api var apiClient = new HttpClient(); apiClient.SetBearerToken(tokenResponse.AccessToken); var apiUrl = "http://localhost:9000/identity"; var response = await apiClient.GetAsync(apiUrl); Console.WriteLine("API: " + apiUrl); if (!response.IsSuccessStatusCode) { Console.WriteLine(response.StatusCode); return; } var content = await response.Content.ReadAsStringAsync(); Console.WriteLine("================================================== content"); Console.WriteLine(JArray.Parse(content)); }
static void Main(string[] args) { var serverBaseUrl = "http://integration-8-ugs-api.flycowdev.com"; IBrandApiClient client = new BrandApiClient(serverBaseUrl); var clientCredentials = new ClientCredentialsTokenRequest() { client_id = "BRAND_3", client_secret = "w0jdfZGyDB3gWFJqGsBCTO3E7liTDgYoVrCaP7t13JMzryNIuKA3G2", grant_type = "client_credentials", scope = "playerapi" }; TokenResponse brandTokenResponse = null; var task = Task.Run(async () => { Console.WriteLine("Getting brand authorization token...."); brandTokenResponse = await client.GetTokenAsync(clientCredentials); System.Console.WriteLine(JsonConvert.SerializeObject(brandTokenResponse)); }); task.Wait(); // Authorize a player var request = new AuthorizePlayerRequest() { ipaddress = "184.70.137.34", username = "******", userid = "1234567891", tag = "{\"aff\": \"123\"}", lang = "zh-CN", cur = "RMB", betlimitid = 1, loginurl = "http://ugslobby.com/login", cashierurl = "http://ugslobby.com/cashier", termsurl = "http://ugslobby.com/terms", helpurl = "http://ugslobby.com/help" }; task = Task.Run(async () => { Console.WriteLine("Authorizing player...."); var playerAuthResponse = await client.AuthorizePlayerAsync(request, brandTokenResponse.access_token); System.Console.WriteLine(JsonConvert.SerializeObject(playerAuthResponse)); }); task.Wait(); }
//static TokenResponse GetClientTokenAsync() //{ // var client = new TokenClient( // "http://localhost:5000/connect/token", // "silicon", // "F621F470-9731-4A25-80EF-67A6F7C5F4B8"); // return client.RequestClientCredentialsAsync("api1").Result; //} //static TokenResponse GetClientTokenAsync() //{ // var client = new TokenClient( // "http://localhost:5000/connect/token", // "silicon", // "F621F470-9731-4A25-80EF-67A6F7C5F4B8"); // return client.RequestClientCredentialsAsync("api1").Result; //} static async Task <TokenResponse> GetClientTokenAsync() { var client = new HttpClient(); var clientCredentialsTokenRequest = new ClientCredentialsTokenRequest { Address = "http://localhost:5000/connect/token", ClientId = "silicon", ClientSecret = "F621F470-9731-4A25-80EF-67A6F7C5F4B8", Scope = "api1" }; var response = await client.RequestClientCredentialsTokenAsync(clientCredentialsTokenRequest); return(response); }
/// <summary> /// Request an Access Token using the Client Credentials Grant flow. /// </summary> /// <param name="request">The <see cref="ClientCredentialsTokenRequest"/> containing the information of the request.</param> /// <returns>An <see cref="AccessTokenResponse"/> containing the token information</returns> public Task <AccessTokenResponse> GetTokenAsync(ClientCredentialsTokenRequest request) { return(Connection.PostAsync <AccessTokenResponse>("oauth/token", null, new Dictionary <string, object> { { "grant_type", "client_credentials" }, { "client_id", request.ClientId }, { "client_secret", request.ClientSecret }, { "audience", request.Audience } }, null, null, null, null)); }
public async Task <string> GetAccessToken(Auth0ConfigModel objAuth0ConfigModel) { string auth0Domain = objAuth0ConfigModel.Domain; AuthenticationApiClient authAPiclient = new AuthenticationApiClient(auth0Domain); ClientCredentialsTokenRequest tokenRequest = new ClientCredentialsTokenRequest { Audience = "https://dev-8todrv-h.au.auth0.com/api/v2/", ClientId = objAuth0ConfigModel.ClientId, ClientSecret = objAuth0ConfigModel.ClientSecret }; var tokenResponse = await authAPiclient.GetTokenAsync(tokenRequest); return(tokenResponse.AccessToken); }
public async Task GetClientCredentialsToken_NullClient_ReturnsTokenResponse() { //Arrange var wrapper = new UnmockablesWrapper(); var tokenRequest = new ClientCredentialsTokenRequest(); //Act var result = wrapper.RequestClientCredentialsTokenAsync(null, tokenRequest); //Assert Assert.NotNull(result); var response = await result as TokenResponse; Assert.NotNull(response); }
protected virtual Task <ClientCredentialsTokenRequest> CreateClientCredentialsTokenRequestAsync( DiscoveryDocumentResponse discoveryResponse, IdentityClientConfiguration configuration) { var request = new ClientCredentialsTokenRequest { Address = discoveryResponse.TokenEndpoint, Scope = configuration.Scope, ClientId = configuration.ClientId, ClientSecret = configuration.ClientSecret }; AddParametersToRequestAsync(configuration, request); return(Task.FromResult(request)); }
private async Task <TokenResponse> GetTokenResponse(HttpClient client, ClientCredentialsTokenRequest tokenRequest) { TokenResponse tokenResponse; try { return(await _unmockablesWrapper .RequestClientCredentialsTokenAsync(client, _tokenRequest)); } catch (Exception e) { return(null); } }
private void btnGetOAuthToken_Click(object sender, EventArgs e) { var clientCredentials = new ClientCredentialsTokenRequest() { client_id = txtClientId.Text, client_secret = txtClientSecret.Text, grant_type = cboGrantType.Text, scope = cboScope.Text }; TokenResponse brandTokenResponse = null; try { var task = Task.Run(async () => { brandTokenResponse = await _apiClient.GetTokenAsync(clientCredentials); }); task.Wait(); txtAccessToken.Text = brandTokenResponse.access_token; txtResponse.Text = JsonConvert.SerializeObject(brandTokenResponse); } catch (Exception ex) { ShowError(ex); } }