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));
}
