private RequestTokenResult RetrieveRequestToken(Uri callBackUri)
{
if (callBackUri == null ||
string.IsNullOrEmpty(callBackUri.AbsoluteUri))
{
throw new ArgumentNullException("callBackUri");
}
IRestResponse response;
try
{
var restClient = _restClientFactory.CreateRestClient(BaseUrl);
restClient.Authenticator = OAuth1Authenticator.ForRequestToken(_consumerKey, _consumerSecret,
callBackUri.AbsoluteUri);
var request = new RestRequest("!api/1.0/oauth/request_token", Method.POST);
response = restClient.Execute(request);
}
catch (Exception exception)
{
throw new AuthenticationException("Failed to obtain a Request Token from BitBucket.", exception);
}
if (response == null ||
response.StatusCode != HttpStatusCode.OK)
{
throw new AuthenticationException(
string.Format(
"Failed to obtain a Request Token from BitBucket OR the the response was not an HTTP Status 200 OK. Response Status: {0}. Response Description: {1}",
response == null ? "-- null response --" : response.StatusCode.ToString(),
response == null ? string.Empty : response.StatusDescription));
}
// Grab the params which should have the request token info.
var querystringParameters = HttpUtility.ParseQueryString(response.Content);
var oAuthToken = querystringParameters[OAuthTokenKey];
var oAuthTokenSecret = querystringParameters[OAuthTokenSecretKey];
// Cache the TokenSecret, for later.
_memoryCache.Add(oAuthToken, oAuthTokenSecret, DateTime.Now.AddMinutes(CacheExpiryInMinutes));
if (string.IsNullOrEmpty(oAuthToken) ||
string.IsNullOrEmpty(oAuthTokenSecret))
{
throw new AuthenticationException(
"Retrieved a Twitter Request Token but it doesn't contain both the oauth_token and oauth_token_secret parameters.");
}
return(new RequestTokenResult
{
OAuthToken = oAuthToken,
OAuthTokenSecret = oAuthTokenSecret
});
}
public PatchPipeline(IGameRepository gameRepository, IRestClientFactory restClientFactory,
IOptionsMonitor <Settings> options, ILogger <PatchPipeline> log)
{
_gameRepository = gameRepository;
_log = log;
_client = restClientFactory.CreateRestClient(options.CurrentValue.StaticDataEndpoint, string.Empty);
}
public MatchGenerator(IRestClientFactory restClientFactory, IGameRepository gameRepository,
IRiotModelMapper riotModelMapper, IOptionsMonitor <Settings> options)
{
_client = restClientFactory.CreateRestClient(options.CurrentValue.RiotApiUrl, options.CurrentValue.RiotApiToken);
_gameRepository = gameRepository;
_riotModelMapper = riotModelMapper;
}
public EddnPlugin(ISettingsProvider settingsProvider, IPlayerStateHistoryRecorder playerStateRecorder, IRestClientFactory restClientFactory)
{
this.settingsProvider = settingsProvider ?? throw new ArgumentNullException(nameof(settingsProvider));
this.playerStateRecorder = playerStateRecorder ?? throw new ArgumentNullException(nameof(playerStateRecorder));
eventConverter = new EddnEventConverter(playerStateRecorder);
settingsProvider.SettingsChanged += (o, e) => ReloadSettings();
apiFacade = new EddnApiFacade(restClientFactory.CreateRestClient(EddnUrl));
ReloadSettings();
}
public InaraPlugin(IPlayerStateHistoryRecorder playerStateRecorder, ISettingsProvider settingsProvider, IRestClientFactory restClientFactory)
: base(settingsProvider)
{
RestClient = restClientFactory.CreateRestClient(InaraApiUrl);
this.playerStateRecorder = playerStateRecorder;
eventConverter = new InaraEventConverter(this.playerStateRecorder);
this.settingsProvider = settingsProvider;
settingsProvider.SettingsChanged += (o, e) => ReloadSettings();
ReloadSettings();
}
public InaraPlugin(IPlayerStateHistoryRecorder playerStateRecorder, ISettingsProvider settingsProvider, IRestClientFactory restClientFactory, IUserNotificationInterface notificationInterface)
: base(settingsProvider)
{
RestClient = restClientFactory.CreateRestClient(InaraApiUrl);
this.playerStateRecorder = playerStateRecorder;
this.notificationInterface = notificationInterface;
EventConverter = new InaraEventConverter(this.playerStateRecorder);
settingsProvider.SettingsChanged += (o, e) => ReloadSettings();
ReloadSettings();
}
public EdsmPlugin(ISettingsProvider settingsProvider, IPlayerStateHistoryRecorder playerStateRecorder, IRestClientFactory restClientFactory, IUserNotificationInterface notificationInterface)
: base(settingsProvider)
{
RestClient = restClientFactory.CreateRestClient(EdsmApiUrl);
EventConverter = new EdsmEventConverter(playerStateRecorder);
ignoredEvents =
RestClient.GetAsync("discard")
.ContinueWith((t) => t.IsFaulted ? new HashSet <string>() : new HashSet <string>(JArray.Parse(t.Result).ToObject <string[]>()));
settingsProvider.SettingsChanged += (o, e) => ReloadSettings();
ReloadSettings();
this.notificationInterface = notificationInterface;
}
public EdsmPlugin(ISettingsProvider settingsProvider, IPlayerStateHistoryRecorder playerStateRecorder, IRestClientFactory restClientFactory)
: base(settingsProvider)
{
RestClient = restClientFactory.CreateRestClient(EdsmApiUrl);
this.playerStateRecorder = playerStateRecorder ?? throw new ArgumentNullException(nameof(playerStateRecorder));
eventConverter = new EdsmEventConverter(playerStateRecorder);
ignoredEvents =
RestClient.GetAsync("discard")
.ContinueWith((t) => t.IsFaulted ? new HashSet <string>() : new HashSet <string>(JArray.Parse(t.Result).ToObject <string[]>()));
settingsProvider.SettingsChanged += (o, e) => ReloadSettings();
ReloadSettings();
}
/// <summary>
/// Initializes a new instance of the <see cref="ACMEClient"/> class.
/// </summary>
/// <param name="endpoint">The selected endpoint of the ACME server.</param>
/// <param name="rsaKey">Encryption key for account.</param>
/// <param name="accountId">Account id.</param>
/// <param name="restClientFactory">An instance of a <see cref="IRESTClient"/> for API requests.</param>
public ACMEClient(string endpoint, RSA rsaKey, string accountId, IRestClientFactory restClientFactory)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
this.endpoint = new Uri(endpoint);
this.rsaKey = rsaKey ?? throw new ArgumentNullException(nameof(rsaKey));
jws = new Jws(rsaKey, accountId);
client = restClientFactory.CreateRestClient(jws);
}
public async Task <T> ExecuteAsync <T>(
IRestRequest request,
Uri requestUri,
CancellationToken cancellationToken) where T : new()
{
var client = _clientFactory.CreateRestClient(requestUri);
var response =
await
client.ExecuteTaskAsync <T>(request, cancellationToken);
if (response.ErrorException != null)
{
throw new YarnRestAPIException("Executing REST API failed", response.ErrorException);
}
try
{
// HTTP status code greater than 300 is unexpected here.
// See if the server sent a error response and throw suitable
// exception to user.
if (response.StatusCode >= HttpStatusCode.Ambiguous)
{
Log.Log(Level.Error, "RESTRequest failed. StatusCode: {0}; Response: {1}", response.StatusCode, response.Content);
var errorResponse = JsonConvert.DeserializeObject <Error>(response.Content);
throw new YarnRestAPIException {
Error = errorResponse
};
}
}
catch (Exception exception)
{
throw new YarnRestAPIException("Unhandled exception in deserializing error response.", exception);
}
return(response.Data);
}
public void GetAccessTokenAsync(string clientId,
string clientSecret,
string code,
Action <string> callback,
Action <GitHubException> onError)
{
Requires.ArgumentNotNull(clientId, "clientId");
Requires.ArgumentNotNull(clientSecret, "clientSecret");
Requires.ArgumentNotNull(code, "code");
Requires.ArgumentNotNull(callback, "callback");
Requires.ArgumentNotNull(onError, "onError");
var request = new RestRequest {
Resource = "/access_token",
Method = Method.POST
};
request.AddParameter("client_id", clientId);
request.AddParameter("client_secret", clientSecret);
request.AddParameter("code", code);
var client = _factory.CreateRestClient(Constants.AuthorizeUrl);
client.ExecuteAsync(
request,
(r, h) => {
var response = new GitHubResponse(r);
GitHubException ex = null;
if (_processor.TryProcessResponseErrors(response, out ex))
{
onError(ex);
return;
}
var parameters = response.Content.Split('&');
var accessToken = parameters.Where(p => p.StartsWith("access_token="))
.Select(p => p.Substring(("access_token=").Length))
.FirstOrDefault();
Debug.Assert(accessToken != null, "");
callback(accessToken);
});
}
public VSTSService(IRestClientFactory restClientFactory, IVSTSServiceConfig vstsServiceConfig)
{
this.restClient = restClientFactory.CreateRestClient();
this.vstsServiceConfig = vstsServiceConfig;
}
private GitHubRequestAsyncHandle CallApiAsync <TGitHubResponse, TRestResponse>(
GitHubRequest request,
Func <TRestResponse, TGitHubResponse> responseFactory,
Func <IRestClient,
IRestRequest,
Action <TRestResponse, RestRequestAsyncHandle>,
RestRequestAsyncHandle> restClientExecFunc,
Action <TGitHubResponse> callback,
Action <GitHubException> onError)
where TGitHubResponse : IGitHubResponse
where TRestResponse : IRestResponse
{
Requires.ArgumentNotNull(request, "request");
Requires.ArgumentNotNull(callback, "callback");
Requires.ArgumentNotNull(onError, "onError");
var restRequest = new RestRequest {
Resource = request.Resource,
Method = request.Method.ToRestSharpMethod(),
RequestFormat = DataFormat.Json,
JsonSerializer = new JsonSerializer()
};
foreach (var p in request.Parameters)
{
restRequest.AddParameter(p.Name, p.Value);
}
#if WINDOWS_PHONE
if (restRequest.Method == RestSharp.Method.GET)
{
// The implementation of HttpWebRequest in WP7 automatically caches all
// all responses. Therefore, we add a query param with a unique value
// to each request to ensure that we always GET fresh data.
// see http://bit.ly/e3JNzE
restRequest.AddParameter("ngithub_wp7_nocache", DateTime.UtcNow.Ticks);
}
#endif
if (request.Body != null)
{
restRequest.AddBody(request.Body);
}
var baseUrl = (request.Version == API.v3) ? Constants.ApiV3Url : Constants.ApiV2Url;
var restClient = _factory.CreateRestClient(baseUrl);
restClient.Authenticator = Authenticator;
var handle = restClientExecFunc(
restClient,
restRequest,
(r, h) => {
var response = responseFactory(r);
GitHubException ex = null;
if (_processor.TryProcessResponseErrors(response, out ex))
{
onError(ex);
return;
}
callback(response);
});
return(new GitHubRequestAsyncHandle(request, handle));
}
