public static HttpClient GetHttpClient(Dynamics settings) { string resourceUrl = settings.ResourceUrl; string authContextUrl = settings.AuthContextUrl; //HRCMS string clientId = settings.ClientId; string clientSecret = settings.ClientSecret; string tenantId = settings.TenantId; string apiVersion = settings.ApiVersion; string webApiUrl = $"{resourceUrl}/api/data/v{apiVersion}/"; try { HttpMessageHandler messageHandler; messageHandler = new OAuthMessageHandler(resourceUrl, clientId, clientSecret, tenantId, authContextUrl, new HttpClientHandler()); HttpClient httpClient = new HttpClient(messageHandler) { BaseAddress = new Uri(webApiUrl), Timeout = new TimeSpan(0, 2, 0) //2 minutes }; return(httpClient); } catch (Exception) { throw; } }
/// <summary> /// Returns an HttpClient configured with an OAuthMessageHandler /// </summary> /// <param name="connectionString">The connection string to use.</param> /// <param name="clientId">The client id to use when authenticating.</param> /// <param name="redirectUrl">The redirect Url to use when authenticating</param> /// <param name="version">The version of Web API to use. Defaults to version 9.1 </param> /// <returns>An HttpClient you can use to perform authenticated operations with the Web API</returns> public static HttpClient GetHttpClient(string connectionString, string clientId, string redirectUrl, string version = "v9.1") { string url = GetParameterValueFromConnectionString(connectionString, "Url"); string username = GetParameterValueFromConnectionString(connectionString, "Username"); string password = GetParameterValueFromConnectionString(connectionString, "Password"); try { HttpMessageHandler messageHandler = new OAuthMessageHandler(url, clientId, redirectUrl, username, password, new HttpClientHandler()); HttpClient httpClient = new HttpClient(messageHandler) { BaseAddress = new Uri(string.Format("{0}/api/data/{1}/", url, version)), Timeout = new TimeSpan(0, 2, 0) //2 minutes }; return(httpClient); } catch (Exception ex) { throw; } }
/// <summary> /// Get an AccessToken for the user with the given email and password. /// </summary> /// <param name="emailAddress">The email address for the user.</param> /// <param name="password">The password for the user.</param> /// <param name="cancellationToken"></param> /// <returns>The AccessToken if the user is authenticated. Null if the user is not authenticated.</returns> public async Task <AccessToken> GetAuthTokenAsync(string emailAddress, string password, CancellationToken cancellationToken = default(CancellationToken)) { // // Acquire an access token // const string authUrl = AuthUrl + "/access_token"; var parameters = new Dictionary <string, string> { { "x_auth_username", emailAddress }, { "x_auth_password", password }, { "x_auth_mode", "client_auth" } }; var handler = new OAuthMessageHandler(_consumerKey, _consumerSecret); var client = new HttpClient(handler); var response = await client.PostAsync(authUrl, new FormUrlEncodedContent(parameters), cancellationToken).ConfigureAwait(false); if (response.IsSuccessStatusCode == false) { return(null); } var tokenBase = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var splitted = tokenBase.Split('&').Select(s => s.Split('=')).ToLookup(xs => xs[0], xs => xs[1]); AccessToken = new AccessToken(splitted["oauth_token"].First(), splitted["oauth_token_secret"].First()); return(AccessToken); }
/// <summary> /// Internal method to load up the HttpClient stuff /// </summary> private void LoadClient() { //Default to full access UseSandbox = false; var handler = new HttpClientHandler(); if (_proxy != null) { handler.Proxy = _proxy; handler.UseProxy = true; } _httpHandler = handler; if (UserLogin != null) { _oauthHandler = new OAuthMessageHandler(_httpHandler, _apiKey, _apisecret, UserLogin.Token, UserLogin.Secret); } else { _oauthHandler = new OAuthMessageHandler(_httpHandler, _apiKey, _apisecret); } _httpClient = new HttpClient(_oauthHandler); _httpClient.DefaultRequestHeaders.Add("User-Agent", "DropNetRT"); if (_httpClient.DefaultRequestHeaders.Any(h => h.Key == "Connection")) { _httpClient.DefaultRequestHeaders.Remove("Connection"); } }
public Task <TokenResponse <RequestToken> > GetRequestToken(string requestTokenUrl, IEnumerable <KeyValuePair <string, string> > parameters = null, HttpContent postValue = null) { //Precondition.NotNull(requestTokenUrl, "requestTokenUrl"); var handler = new OAuthMessageHandler("un9HyMLftXRtDf89jP", "AaDM9yyXLmTemvM2nVahzBFYS9JG62a6", token: null, optionalOAuthHeaderParameters: parameters); return(GetTokenResponse(requestTokenUrl, handler, postValue, (key, secret) => new RequestToken(key, secret))); }
/// <summary> /// Initializes a new instance of the <see cref="Client" /> class. /// </summary> /// <param name="apikey">The apikey.</param> /// <param name="appSecret">The app secret.</param> public Client(string apikey, string appSecret) { _messageHandler = new OAuthMessageHandler(new HttpClientHandler(), apikey, appSecret, new UserLogin()); _client = new HttpClient(_messageHandler) { BaseAddress = new Uri(BaseUrl) }; }
public CrmAuth(AdOption azureAdOptions) { _azureAdOptions = azureAdOptions; // Target deployment: CRM online => use OAuthMessageHandler ClientHandler = new OAuthMessageHandler(this, new HttpClientHandler()); _context = new AuthenticationContext(_azureAdOptions.Instance + _azureAdOptions.TenantId); }
public async Task <string> ComputeOAuthVersionAsync(HttpRequestMessage request) { using (OAuthMessageHandler msgHandler = new OAuthMessageHandler( _apiKey, _clientSecret, _authToken, _authTokenSecret)) { return(await GetOAuthParameterFromHandlerAsync(msgHandler, request, "oauth_version")); } }
private HttpClient GenerateOAuthHttpClient(OAuthToken oauthToken) { OAuthMessageHandler handler = new OAuthMessageHandler(oauthToken.ApiKey, oauthToken.Secret, oauthToken.Token, oauthToken.TokenSecret); HttpClient client = new HttpClient(handler); // Make sure we request JSON data client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); return(client); }
public async Task <string> ComputeOAuthVersionAsync(HttpRequestMessage request, string nonce, string timestamp, OAuthVersion version) { using (OAuthMessageHandler msgHandler = new OAuthMessageHandler( _apiKey, _clientSecret, _authToken, _authTokenSecret, new TestOAuthProvider( nonce, timestamp, version))) { return(await GetOAuthParameterFromHandlerAsync(msgHandler, request, "oauth_version")); } }
/// <summary> /// 构造IFD HTTP客户端 /// </summary> /// <param name="cacheManager"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> private HttpClient BuildOnIfd(ICacheManager cacheManager) { if (cacheManager == null) { throw new ArgumentNullException(nameof(cacheManager)); } var httpMessageHandler = new OAuthMessageHandler(_dynamics365Config.ADFS_URI, _dynamics365Config.Resource, _dynamics365Config.ClientId, _dynamics365Config.RedirectUri, $"{_dynamics365Config.DomainName}\\{_dynamics365Config.UserName}", _dynamics365Config.Password, cacheManager, new HttpClientHandler()); ; return(GetNewHttpClient(httpMessageHandler, _dynamics365Config.WebApiAddress)); }
/// <summary> /// 构造IFD HTTP客户端 /// </summary> /// <param name="distributedCache"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> private HttpClient BuildOnIfd(IDistributedCache distributedCache) { if (distributedCache == null) { throw new ArgumentNullException(nameof(distributedCache)); } var httpMessageHandler = new OAuthMessageHandler(_dynamics365Options.ADFS_URI, _dynamics365Options.Resource, _dynamics365Options.ClientId, _dynamics365Options.RedirectUri, $"{_dynamics365Options.DomainName}\\{_dynamics365Options.UserName}", _dynamics365Options.Password, distributedCache, new HttpClientHandler()); ; return(GetNewHttpClient(httpMessageHandler, _dynamics365Options.WebApiAddress)); }
private async Task <string> GetOAuthParameterFromHandlerAsync(OAuthMessageHandler handler, HttpRequestMessage request, string requestedParameter) { var testHandler = new TestHttpMessageHandler(); handler.InnerHandler = testHandler; using (var httpClient = new HttpClient(handler, disposeHandler: false)) { await httpClient.SendAsync(request); } var request2 = testHandler.SentMessages.Single(); var authHeaderParameter = request.Headers.Authorization.Parameter; // extract the parameter string[] elems = authHeaderParameter.Split(','); return(elems.SingleOrDefault(x => x.StartsWith($"{requestedParameter}="))?.Split('=')[1]); }
/// <summary> /// Establises the connection to Dynamics 365 Api /// </summary> /// <param name="crmApiUrl"> CRM Api url</param> /// <param name="redirectUrl"> redirect uri registered in Azure AAD App</param> /// <param name="clientId"> clientId(AppId) of registered Azure AAD App</param> /// <param name="clientSecret">clientSecret of registered Azure AAD App</param> /// <param name="tenentId">Tenent Id of Azure AAD endpoint</param> private CrmApiService(WebApiConfiguration configuration) { ThrowIf.ArgumentNull("WebApiConfiguration can't be null", configuration, configuration.CRMApiEndpointUri); _configuration = configuration; try { HttpMessageHandler messageHandler = new OAuthMessageHandler(configuration, new HttpClientHandler()); HttpCrmClient = new HttpClient(messageHandler) { Timeout = new TimeSpan(0, 2, 0) //2 minutes }; HttpCrmClient.BaseAddress = new Uri($"{configuration.CRMApiEndpointUri.TrimEnd('/')}/"); _whoAmI = GetWhoAmIRequest(); } catch (Exception) { throw; } }
public CDSWebApiService(CDSWebApiServiceConfig config) { this.config = config; HttpMessageHandler messageHandler = new OAuthMessageHandler(config, new HttpClientHandler()); httpClient = new HttpClient(messageHandler) { BaseAddress = new Uri(config.Url + $"/api/data/v{config.Version}/") }; httpClient.Timeout = TimeSpan.FromSeconds(config.TimeoutInSeconds); httpClient.DefaultRequestHeaders.Add("OData-MaxVersion", "4.0"); httpClient.DefaultRequestHeaders.Add("OData-Version", "4.0"); httpClient.DefaultRequestHeaders.Accept.Add( new MediaTypeWithQualityHeaderValue("application/json")); if (config.CallerObjectId != Guid.Empty) { httpClient.DefaultRequestHeaders.Add("CallerObjectId", config.CallerObjectId.ToString()); } }
public async Task <TokenResponse <T> > GetTokenResponse <T>(string url, OAuthMessageHandler handler, HttpContent postValue, Func <string, string, T> tokenFactory) where T : Token { var client = new HttpClient(handler); var response = await client.PostAsync(AuthorizeTokenUrl, postValue ?? new FormUrlEncodedContent(Enumerable.Empty <KeyValuePair <string, string> >())).ConfigureAwait(false); var tokenBase = await response.Content.ReadAsStringAsync().ConfigureAwait(false); if (response.StatusCode != System.Net.HttpStatusCode.OK) { throw new HttpRequestException(response.StatusCode + ":" + tokenBase); // error message } var splitted = tokenBase.Split('&').Select(s => s.Split('=')).ToLookup(xs => xs[0], xs => xs[1]); var token = tokenFactory(splitted["oauth_token"].First().UrlDecode(), splitted["oauth_token_secret"].First().UrlDecode()); var extraData = splitted.Where(kvp => kvp.Key != "oauth_token" && kvp.Key != "oauth_token_secret") .SelectMany(g => g, (g, value) => new { g.Key, Value = value }) .ToLookup(kvp => kvp.Key, kvp => kvp.Value); return(new TokenResponse <T>(token, extraData)); }
private async Task <string> GetOAuthParameterFromHandlerAsync(OAuthMessageHandler handler, HttpRequestMessage request, string requestedParameter) { var testHandler = new TestHttpMessageHandler(); handler.InnerHandler = testHandler; using (var httpClient = new HttpClient(handler, disposeHandler: false)) { await httpClient.SendAsync(request); } var request2 = testHandler.SentMessages.Single(); var authHeaderParameter = request.Headers.Authorization.Parameter; // extract the parameter string[] elems = authHeaderParameter.Split(','); string parameter = elems.SingleOrDefault(x => x.StartsWith($"{requestedParameter}="))?.Split('=')[1]; // we might not have the parameter here. if (parameter == null) { return(null); } // we are now ensuring that the parameters are contained within double quotes. Assert.Equal('"', parameter[0]); Assert.Equal('"', parameter[parameter.Length - 1]); // if we only have 2 characters, they are both double quotes, so return empty string if (parameter.Length == 2) { return(string.Empty); } // for the purposes of the test, extract the double quotes return(parameter.Substring(1, parameter.Length - 2)); }