protected virtual Dictionary <string, string> headersForRequest(HTTPVerb httpVerb, Dictionary <string, string> headers = null)
{
headers = headers ?? new Dictionary <string, string>();
switch (httpVerb)
{
case HTTPVerb.GET:
headers.Add("METHOD", "GET");
break;
case HTTPVerb.POST:
headers.Add("METHOD", "POST");
break;
case HTTPVerb.PUT:
headers.Add("METHOD", "PUT");
headers.Add("X-HTTP-Method-Override", "PUT");
break;
case HTTPVerb.DELETE:
headers.Add("METHOD", "DELETE");
headers.Add("X-HTTP-Method-Override", "DELETE");
break;
}
return(headers);
}
public void graphRequest(string path, HTTPVerb verb, Dictionary <string, object> parameters, Action <string, object> completionHandler)
{
if (this.shouldSendRequest())
{
base.surrogateMonobehaviour.StartCoroutine(this.send(path, verb, parameters, completionHandler));
}
else
{
try
{
Type type = typeof(Facebook).Assembly.GetType("FacebookAndroid");
if (type != null)
{
MethodInfo method = type.GetMethod("babysitRequest", BindingFlags.Static | BindingFlags.NonPublic);
if (method != null)
{
Action action = delegate
{
this.surrogateMonobehaviour.StartCoroutine(this.send(path, verb, parameters, completionHandler));
};
method.Invoke(null, new object[]
{
verb == HTTPVerb.POST,
action
});
}
}
}
catch (Exception)
{
}
}
}
public void graphRequest(string path, HTTPVerb verb, Dictionary <string, object> parameters, Action <string, object> completionHandler)
{
if (shouldSendRequest())
{
surrogateMonobehaviour.StartCoroutine(send(path, verb, parameters, completionHandler));
}
else
{
// if we have an auth helper we will use it because we are not logged in
// auth helpers are classes in the FacebookBinding and FacebookAndroid files
try
{
#if UNITY_IPHONE
var type = typeof(Facebook).Assembly.GetType("FacebookBinding");
#else
var type = typeof(Facebook).Assembly.GetType("FacebookAndroid");
#endif
// this will pass for iOS and Android when the SocialNetworking Plugin is present
if (type != null)
{
var method = type.GetMethod("babysitRequest", BindingFlags.Static | BindingFlags.NonPublic);
if (method != null)
{
Action action = () => { surrogateMonobehaviour.StartCoroutine(send(path, verb, parameters, completionHandler)); };
method.Invoke(null, new object[] { verb == HTTPVerb.POST, action });
}
}
}
catch (Exception)
{}
}
}
protected virtual IEnumerator send(string path, HTTPVerb httpVerb, Dictionary <string, object> parameters, Action <string, object> onComplete)
{
if (path.StartsWith("/"))
{
path = path.Substring(1);
}
WWW www = processRequest(path, httpVerb, parameters);
yield return(www);
if (debugRequests)
{
Debug.Log("response error: " + www.error);
Debug.Log("response text: " + www.text);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Response Headers:\n");
foreach (KeyValuePair <string, string> responseHeader in www.responseHeaders)
{
stringBuilder.AppendFormat("{0}: {1}\n", responseHeader.Key, responseHeader.Value);
}
Debug.Log(stringBuilder.ToString());
}
if (onComplete != null)
{
processResponse(www, onComplete);
}
www.Dispose();
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The http verb.</param>
/// <param name="userAgent">The http user agent.</param>
/// <param name="networkCredentials">The network credentials.</param>
/// <remarks></remarks>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, String userAgent, NetworkCredential networkCredentials)
{
if (requestUri == null)
{
throw new ArgumentNullException("requestUri");
}
this.RequestUri = requestUri;
this.Verb = verb;
this.userAgent = userAgent;
this.UseOAuth = false;
if (networkCredentials != null)
{
this.networkCredentials = networkCredentials;
}
this.Parameters = new Dictionary <string, object>();
if (string.IsNullOrEmpty(this.RequestUri.Query))
{
return;
}
foreach (Match item in Regex.Matches(this.RequestUri.Query, @"(?<key>[^&?=]+)=(?<value>[^&?=]+)"))
{
this.Parameters.Add(item.Groups["key"].Value, item.Groups["value"].Value);
}
this.RequestUri = new Uri(this.RequestUri.AbsoluteUri.Replace(this.RequestUri.Query, ""));
}
private bool MakeRequest(string targetPoint, HTTPVerb targetAction, out string data)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(targetPoint);
request.Method = targetAction.ToString();
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
try
{
using (Stream responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (StreamReader reader = new StreamReader(responseStream))
{
data = reader.ReadToEnd();
}
}
else
{
data = "";
return(false);
}
}
}
catch
{
data = "";
return(false);
}
}
return(true);
}
public ICoffeeFunction GetFunctionFromRequest(HTTPVerb verb)
{
var functionDict = GetFunctionDictionary();
return(functionDict.ContainsKey(verb)
? (ICoffeeFunction)Activator.CreateInstance(functionDict[verb])
: null);
}
protected async Task <TOut> InvokeMethodAsync <TOut, TBody>(string serviceName, string serviceEndpoint,
HTTPVerb type, IDictionary <string, string> queryParameters = null, TBody body = null) where TBody : class
{
var httpExtension = GenerateExtension(type, queryParameters: queryParameters);
return(await DaprClient.InvokeMethodAsync <TBody, TOut>(serviceName, serviceEndpoint, body,
httpExtension));
}
/// <summary>
/// Initializes a new instance of the <see cref="TwitterCommand<T>"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="endPoint">The end point.</param>
/// <param name="tokens">The tokens.</param>
/// <param name="optionalProperties">The optional properties.</param>
protected TwitterCommand(HTTPVerb method, string endPoint, OAuthTokens tokens, OptionalProperties optionalProperties)
{
this.RequestParameters = new Dictionary <string, object>();
this.Verb = method;
this.Tokens = tokens;
this.OptionalProperties = optionalProperties ?? new OptionalProperties();
this.SetCommandUri(endPoint);
}
/// <summary>
/// Initializes a new instance of the <see cref="NCDCCommand<T>"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="endPoint">The end point.</param>
/// <param name="token">The token.</param>
/// <param name="optionalProperties">The optional properties.</param>
/// <remarks></remarks>
protected NCDCCommand(HTTPVerb method, string endPoint, string token, NCDCOptions optionalProperties)
{
this.RequestParameters = new Dictionary <string, object>();
this.Verb = method;
this.Token = token;
this.NCDCOptions = optionalProperties ?? new NCDCOptions();
NCDCUtilities.CurrentToken = this.Token;
this.SetCommandUri(endPoint);
}
public static string GetHttpVerbName(HTTPVerb verb)
{
switch (verb)
{
default:
case HTTPVerb.GET: return(UnityWebRequest.kHttpVerbGET);
case HTTPVerb.POST: return(UnityWebRequest.kHttpVerbPOST);
}
}
protected override IEnumerator send( string path, HTTPVerb httpVerb, Dictionary<string,object> parameters, Action<string, object> onComplete )
{
if( parameters == null )
parameters = new Dictionary<string, object>();
// add the access token if we dont have one in the dictionary
if( !parameters.ContainsKey( "access_token" ) )
parameters.Add( "access_token", accessToken );
return base.send( path, httpVerb, parameters, onComplete );
}
public NCDCWebRequest(Uri uri, HTTPVerb hTTPVerb, string token, string userAgent = "")
{
if (uri == null)
{
throw new ArgumentNullException("requestUri");
}
// TODO: Complete member initialization
this.RequestUri = uri;
this.Verb = hTTPVerb;
this.Token = token;
this.UserAgent = userAgent;
this.Parameters = new Dictionary <string, object>();
}
private async Task <string> GetResourceId(EntryComponent entry, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(entry.Request.IfNoneExist) && !entry.Request.Url.Contains("?", StringComparison.Ordinal))
{
if (entry.Request.Method == HTTPVerb.POST)
{
return(entry.FullUrl);
}
return(entry.Request.Url);
}
else
{
string resourceType = null;
StringValues conditionalQueries;
HTTPVerb requestMethod = (HTTPVerb)entry.Request.Method;
bool conditionalCreate = requestMethod == HTTPVerb.POST;
bool condtionalUpdate = requestMethod == HTTPVerb.PUT;
if (condtionalUpdate)
{
string[] conditinalUpdateParameters = entry.Request.Url.Split("?");
resourceType = conditinalUpdateParameters[0];
conditionalQueries = conditinalUpdateParameters[1];
}
else if (conditionalCreate)
{
resourceType = entry.Request.Url;
conditionalQueries = entry.Request.IfNoneExist;
}
IReadOnlyCollection <SearchResultEntry> matchedResults = await _referenceResolver.GetExistingResourceId(entry.Request.Url, resourceType, conditionalQueries, cancellationToken);
int?count = matchedResults?.Count;
if (count > 1)
{
// Multiple matches: The server returns a 412 Precondition Failed error indicating the client's criteria were not selective enough
throw new PreconditionFailedException(string.Format(Api.Resources.ConditionalOperationInBundleNotSelectiveEnough, conditionalQueries));
}
if (count == 1)
{
return(entry.Resource.TypeName + "/" + matchedResults.First().Resource.ResourceId);
}
}
return(string.Empty);
}
protected override IEnumerator send(string path, HTTPVerb httpVerb, Dictionary <string, object> parameters, Action <string, object> onComplete)
{
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
// add the access token if we dont have one in the dictionary
if (!parameters.ContainsKey("access_token"))
{
parameters.Add("access_token", accessToken);
}
return(base.send(path, httpVerb, parameters, onComplete));
}
protected override IEnumerator send(string path, HTTPVerb httpVerb, Dictionary <string, object> parameters, Action <string, object> onComplete)
{
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
if (!parameters.ContainsKey("access_token"))
{
parameters.Add("access_token", this.accessToken);
}
if (httpVerb == HTTPVerb.PUT || httpVerb == HTTPVerb.DELETE)
{
parameters.Add("method", httpVerb.ToString());
}
return(base.send(path, httpVerb, parameters, onComplete));
}
private HTTPExtension GenerateExtension(HTTPVerb type, IDictionary <string, string> queryParameters = null)
{
var httpExtension = new HTTPExtension
{
ContentType = "application/json",
Verb = type
};
httpExtension.Headers.Add("Authorization", $"Bearer {TokenManager.Token}");
if (queryParameters != null)
{
httpExtension.QueryString = queryParameters;
}
return(httpExtension);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The verb.</param>
/// <param name="tokens">The tokens.</param>
/// <param name="userAgent">The user agent.</param>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, OAuthTokens tokens, string userAgent = "")
: this(requestUri, verb, userAgent, null)
{
this.Tokens = tokens;
if (tokens != null)
{
if (string.IsNullOrEmpty(this.Tokens.ConsumerKey) || string.IsNullOrEmpty(this.Tokens.ConsumerSecret))
{
throw new ArgumentException("Consumer key and secret are required for OAuth requests.");
}
if (string.IsNullOrEmpty(this.Tokens.AccessToken) ^ string.IsNullOrEmpty(this.Tokens.AccessTokenSecret))
{
throw new ArgumentException("The access token is invalid. You must specify the key AND secret values.");
}
this.UseOAuth = true;
}
}
public void restRequest(string method, HTTPVerb verb, Dictionary <string, object> parameters, Action <string, object> completionHandler)
{
// ensure we return json
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
if (!parameters.ContainsKey("format"))
{
parameters.Add("format", "json");
}
// we have to rejigger the baseUrl temporarily here
var path = "method/" + method;
var oldBaseUrl = _baseUrl;
_baseUrl = "https://api.facebook.com/";
surrogateMonobehaviour.StartCoroutine(send(path, verb, parameters, completionHandler));
_baseUrl = oldBaseUrl;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The verb.</param>
/// <param name="tokens">The tokens.</param>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, OAuthTokens tokens)
: this(requestUri, verb, string.Empty, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PagedTimelineCommand"/> class.
/// </summary>
/// <param name="httpMethod">The HTTP method.</param>
/// <param name="endPoint">The end point.</param>
/// <param name="tokens">The tokens.</param>
/// <param name="optionalProperties">The optional properties.</param>
protected PagedTimelineCommand(HTTPVerb httpMethod, string endPoint, OAuthTokens tokens, OptionalProperties optionalProperties)
: base(httpMethod, endPoint, tokens, optionalProperties)
{
}
public EndPointPlugin(string URL, HTTPVerb verb = HTTPVerb.ALL)
{
Url = URL;
Verb = verb; // HTTPVerb.ALL;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The http verb.</param>
/// <param name="KeepAlive">if set to <c>true</c> the <see cref="System.Net.HttpWebRequest"/> will be instructed to keep the connection alive.</param>
/// <param name="UserAgent">The http user agent.</param>
/// <param name="NetworkCredentials">The network credentials.</param>
/// <remarks></remarks>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, String UserAgent, NetworkCredential NetworkCredentials)
{
if (requestUri == null)
throw new ArgumentNullException("requestUri");
this.RequestUri = requestUri;
this.Verb = verb;
this.UserAgent = UserAgent;
this.UseOAuth = false;
if (NetworkCredentials != null)
this.NetworkCredentials = NetworkCredentials;
this.Parameters = new Dictionary<string, object>();
if (string.IsNullOrEmpty(this.RequestUri.Query)) return;
foreach (Match item in Regex.Matches(this.RequestUri.Query, @"(?<key>[^&?=]+)=(?<value>[^&?=]+)"))
{
this.Parameters.Add(item.Groups["key"].Value, item.Groups["value"].Value);
}
object scopeParams = null;
if (this.Parameters.TryGetValue("scope", out scopeParams))
{
string paramVal = scopeParams as String;
if (!string.IsNullOrEmpty(paramVal))
{
paramVal = paramVal.Replace("+", " ");
this.Parameters["scope"] = (object)paramVal;
}//end if
}//end if
this.RequestUri = new Uri(this.RequestUri.AbsoluteUri.Replace(this.RequestUri.Query, ""));
}
/// <summary>
/// Prepares the OAuth parameters.
/// </summary>
/// <param name="baseUrl">The base URL.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="verb">The verb.</param>
/// <param name="consumerKey">The consumer key.</param>
/// <param name="consumerSecret">The consumer secret.</param>
/// <param name="token">The token.</param>
/// <param name="tokenSecret">The token secret.</param>
/// <returns>
///
/// </returns>
private static Dictionary<string, string> PrepareOAuthParameters(string baseUrl, Dictionary<string, string> parameters, HTTPVerb verb, string consumerKey, string consumerSecret, string token, string tokenSecret)
{
Dictionary<string, string> combinedParameters = new Dictionary<string, string>();
if (parameters != null)
{
// Copy the given parameters into a new collection, as to not modify the source collection
foreach (KeyValuePair<string, string> item in parameters)
{
combinedParameters.Add(item.Key, item.Value);
}
}
// Add the OAuth parameters
combinedParameters.Add("oauth_version", "1.0");
combinedParameters.Add("oauth_nonce", GenerateNonce());
combinedParameters.Add("oauth_timestamp", GenerateTimeStamp());
combinedParameters.Add("oauth_signature_method", "HMAC-SHA1");
combinedParameters.Add("oauth_consumer_key", consumerKey);
combinedParameters.Add("oauth_consumer_secret", consumerSecret);
if (!string.IsNullOrEmpty(token))
{
combinedParameters.Add("oauth_token", token);
}
if (!string.IsNullOrEmpty(tokenSecret))
{
combinedParameters.Add("oauth_token_secret", tokenSecret);
}
AddSignatureToParameters(
new Uri(baseUrl),
combinedParameters,
verb,
consumerSecret,
tokenSecret);
return combinedParameters;
}
public void graphRequest( string path, HTTPVerb verb, Dictionary<string, object> parameters, Action<string, object> completionHandler )
{
surrogateMonobehaviour.StartCoroutine( send( path, verb, parameters, completionHandler ) );
}
public RESTClient(string Uri, string content, HTTPVerb verb)
{
EndPoint = Uri;
this.Content = content;
HttpMethod = verb;
}
/// <summary>
/// Generates and adds a signature to parameters.
/// </summary>
/// <param name="url">The base URL.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="verb">The HTTP verb to perform.</param>
/// <param name="consumerSecret">The consumer secret.</param>
/// <param name="tokenSecret">The token secret.</param>
private static void AddSignatureToParameters(
Uri url,
Dictionary<string, string> parameters,
HTTPVerb verb,
string consumerSecret,
string tokenSecret)
{
string normalizedUrl = NormalizeUrl(url);
// Get the oauth parameters from the parameters
Dictionary<string, string> baseStringParameters =
(from p in parameters
where !(p.Key.EndsWith("_secret", StringComparison.OrdinalIgnoreCase) &&
p.Key.StartsWith("oauth_", StringComparison.OrdinalIgnoreCase) &&
!p.Key.EndsWith("_verifier", StringComparison.OrdinalIgnoreCase))
select p).ToDictionary(p => p.Key, p => p.Value);
string signatureBase = string.Format(
CultureInfo.InvariantCulture,
"{0}&{1}&{2}",
verb.ToString().ToUpper(CultureInfo.InvariantCulture),
EncodeForUrl(normalizedUrl),
UrlEncode(baseStringParameters));
HMACSHA1 hmacsha1 = new HMACSHA1();
string key = string.Format(
CultureInfo.InvariantCulture,
"{0}&{1}",
EncodeForUrl(consumerSecret),
EncodeForUrl(tokenSecret));
hmacsha1.Key = Encoding.ASCII.GetBytes(key);
string result = Convert.ToBase64String(
hmacsha1.ComputeHash(
Encoding.ASCII.GetBytes(signatureBase)));
// Add the signature to the oauth parameters
parameters.Add("oauth_signature", result);
#if DEBUG
System.Diagnostics.Debug.WriteLine("----------- OAUTH SIGNATURE GENERATION -----------");
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "url.PathAndQuery = \"{0}\"", url.PathAndQuery));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "httpMethod = \"{0}\"", verb.ToString()));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "consumerSecret = \"{0}\"", consumerSecret));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "tokenSecret = \"{0}\"", tokenSecret));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "normalizedUrl = \"{0}\"", normalizedUrl));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "signatureBase = \"{0}\"", signatureBase));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "key = \"{0}\"", key));
System.Diagnostics.Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "signature = \"{0}\"", result));
System.Diagnostics.Debug.WriteLine("--------- END OAUTH SIGNATURE GENERATION ----------");
#endif
}
// #if !LITE && !SILVERLIGHT
// /// <summary>
// /// Gets the access token during callback.
// /// </summary>
// /// <param name="consumerKey">The consumer key.</param>
// /// <param name="consumerSecret">The consumer secret.</param>
// /// <returns>
// /// Access tokens returned by the Twitter API
// /// </returns>
// public static OAuthTokenResponse GetAccessTokenDuringCallback(string consumerKey, string consumerSecret)
// {
//
// HttpContext context = HttpContext.Current;
// if (context == null || context.Request == null)
// {
// throw new ApplicationException("Could not located the HTTP context. GetAccessTokenDuringCallback can only be used in ASP.NET applications.");
// }
//
// string requestToken = context.Request.QueryString["oauth_token"];
// string verifier = context.Request.QueryString["oauth_verifier"];
//
// if (string.IsNullOrEmpty(requestToken))
// {
// throw new ApplicationException("Could not locate the request token.");
// }
//
// if (string.IsNullOrEmpty(verifier))
// {
// throw new ApplicationException("Could not locate the verifier value.");
// }
//
// return GetAccessToken(consumerKey, consumerSecret, requestToken, verifier);
// }
//
// /// <summary>
// /// Adds the OAuth Echo header to the supplied web request.
// /// </summary>
// /// <param name="request">The request.</param>
// /// <param name="tokens">The tokens.</param>
// public static void AddOAuthEchoHeader(WebRequest request, OAuthTokens tokens)
// {
// WebRequestBuilder builder = new WebRequestBuilder(
// new Uri("https://api.twitter.com/1/account/verify_credentials.json"),
// HTTPVerb.POST,
// tokens,
// "");
//
// builder.PrepareRequest();
//
// request.Headers.Add("X-Verify-Credentials-Authorization", builder.GenerateAuthorizationHeader());
// request.Headers.Add("X-Auth-Service-Provider", "https://api.twitter.com/1/account/verify_credentials.json");
// }
//#endif
#endregion Other
#if !SILVERLIGHT
public static OAuthTokenResponse GetRequestToken(string consumerKey, string consumerSecret, string callbackAddress, WebProxy proxy, string requestTokenUrl, HTTPVerb httpVerb)
{
if (string.IsNullOrEmpty(consumerKey))
{
throw new ArgumentNullException("consumerKey");
}
if (string.IsNullOrEmpty(consumerSecret))
{
throw new ArgumentNullException("consumerSecret");
}
if (string.IsNullOrEmpty(callbackAddress))
{
throw new ArgumentNullException("callbackAddress", @"You must always provide a callback url when obtaining a request token. For PIN-based authentication, use ""oob"" as the callback url.");
}
WebRequestBuilder builder = new WebRequestBuilder(
new Uri(requestTokenUrl),
httpVerb,
new OAuthTokens { ConsumerKey = consumerKey, ConsumerSecret = consumerSecret },
"") { Proxy = proxy };
if (!string.IsNullOrEmpty(callbackAddress))
{
builder.Parameters.Add("oauth_callback", callbackAddress);
}
string responseBody = null;
try
{
HttpWebResponse webResponse = builder.ExecuteRequest();
Stream responseStream = webResponse.GetResponseStream();
if (responseStream != null) responseBody = new StreamReader(responseStream).ReadToEnd();
}
catch (WebException wex)
{
throw new Exception(wex.Message, wex);
}
Match matchedValues = Regex.Match(responseBody,
@"oauth_token=(?<token>[^&]+)|oauth_token_secret=(?<secret>[^&]+)|oauth_verifier=(?<verifier>[^&]+)");
return new OAuthTokenResponse
{
Token = matchedValues.Groups["token"].Value,
TokenSecret = matchedValues.Groups["secret"].Value,
VerificationString = matchedValues.Groups["verifier"].Value
};
}
public void graphRequest(string path, HTTPVerb verb, Dictionary <string, object> parameters, Action <string, object> completionHandler)
{
surrogateMonobehaviour.StartCoroutine(send(path, verb, parameters, completionHandler));
}
public void graphRequest( string path, HTTPVerb verb, Action<string, object> completionHandler )
{
graphRequest( path, verb, null, completionHandler );
}
protected virtual WWW processRequest(string path, HTTPVerb httpVerb, Dictionary <string, object> parameters)
{
StringBuilder stringBuilder = new StringBuilder();
if (!path.StartsWith("http"))
{
stringBuilder.Append(_baseUrl).Append(path);
}
else
{
stringBuilder.Append(path);
}
bool flag = httpVerb != HTTPVerb.GET;
WWWForm wWWForm = ((!flag) ? null : new WWWForm());
if (parameters != null && parameters.Count > 0)
{
if (flag)
{
foreach (KeyValuePair <string, object> parameter in parameters)
{
if (parameter.Value is string)
{
wWWForm.AddField(parameter.Key, parameter.Value as string);
}
else if (parameter.Value is byte[])
{
wWWForm.AddBinaryData(parameter.Key, parameter.Value as byte[]);
}
}
}
else
{
bool flag2 = true;
if (path.Contains("?"))
{
flag2 = false;
}
foreach (KeyValuePair <string, object> parameter2 in parameters)
{
if (parameter2.Value is string)
{
stringBuilder.AppendFormat("{0}{1}={2}", (!flag2) ? "&" : "?", WWW.EscapeURL(parameter2.Key), WWW.EscapeURL(parameter2.Value as string));
flag2 = false;
}
}
}
}
if (debugRequests)
{
Debug.Log("url: " + stringBuilder.ToString());
}
Dictionary <string, string> dictionary = null;
if (flag)
{
IDictionary headersFromForm = getHeadersFromForm(wWWForm);
if (headersFromForm != null)
{
dictionary = new Dictionary <string, string>();
if (headersFromForm.Contains("Content-Type"))
{
dictionary.Add("Content-Type", headersFromForm["Content-Type"].ToString());
}
if (debugRequests)
{
Debug.Log("Found a POST request. Fetching headers from WWWForm and starting with these as a base: ");
Utils.logObject(dictionary);
}
}
}
return((!flag) ? new WWW(stringBuilder.ToString()) : new WWW(stringBuilder.ToString(), wWWForm.data, headersForRequest(httpVerb, dictionary)));
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The http verb.</param>
/// <param name="userAgent">The http user agent.</param>
/// <param name="networkCredentials">The network credentials.</param>
/// <remarks></remarks>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, String userAgent, NetworkCredential networkCredentials)
{
if (requestUri == null)
throw new ArgumentNullException("requestUri");
this.RequestUri = requestUri;
this.Verb = verb;
this.userAgent = userAgent;
this.UseOAuth = false;
if (networkCredentials != null)
this.networkCredentials = networkCredentials;
this.Parameters = new Dictionary<string, object>();
if (string.IsNullOrEmpty(this.RequestUri.Query)) return;
foreach (Match item in Regex.Matches(this.RequestUri.Query, @"(?<key>[^&?=]+)=(?<value>[^&?=]+)"))
{
this.Parameters.Add(item.Groups["key"].Value, item.Groups["value"].Value);
}
this.RequestUri = new Uri(this.RequestUri.AbsoluteUri.Replace(this.RequestUri.Query, ""));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override TwitterResponse<string> BeginRequest(HTTPVerb overrideVerb = HTTPVerb.GET)
{
return this.ExecuteRequest(overrideVerb);
}
public async Task GivenABundleWithMultipleCalls_WhenProcessed_ThenANotificationWillBeEmitted(BundleType type, HTTPVerb method1, HTTPVerb method2, int code200s, int code404s)
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = type,
Entry = new List <EntryComponent>
{
new EntryComponent
{
Request = new RequestComponent
{
Method = method1,
Url = "unused1",
},
Resource = new Patient(),
},
new EntryComponent
{
Request = new RequestComponent
{
Method = method2,
Url = "unused2",
},
Resource = new Patient(),
},
},
};
_router.When(r => r.RouteAsync(Arg.Any <RouteContext>()))
.Do(RouteAsyncFunction);
BundleMetricsNotification notification = null;
await _mediator.Publish(Arg.Do <BundleMetricsNotification>(note => notification = note), Arg.Any <CancellationToken>());
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
BundleResponse bundleResponse = await _bundleHandler.Handle(bundleRequest, default);
var bundleResource = bundleResponse.Bundle.ToPoco <Hl7.Fhir.Model.Bundle>();
Assert.Equal(type == BundleType.Batch ? BundleType.BatchResponse : BundleType.TransactionResponse, bundleResource.Type);
Assert.Equal(2, bundleResource.Entry.Count);
await _mediator.Received().Publish(Arg.Any <BundleMetricsNotification>(), Arg.Any <CancellationToken>());
Assert.Equal(type == BundleType.Batch ? AuditEventSubType.Batch : AuditEventSubType.Transaction, notification.FhirOperation);
var results = notification.ApiCallResults;
Assert.Equal(code200s, results["200"]);
if (code404s > 0)
{
Assert.Equal(code404s, results["404"]);
}
else
{
Assert.Equal(1, results.Keys.Count);
}
}
public static OAuthTokenResponse GetAccessToken(string consumerKey, string consumerSecret, string requestToken, string accessTokenSecret, string verifier, string accessTokenUrl, HTTPVerb httpVerb, ServiceType serviceType)
{
if (string.IsNullOrEmpty(consumerKey))
{
throw new ArgumentNullException("consumerKey");
}
if (string.IsNullOrEmpty(consumerSecret))
{
throw new ArgumentNullException("consumerSecret");
}
if (string.IsNullOrEmpty(requestToken))
{
throw new ArgumentNullException("requestToken");
}
WebRequestBuilder builder = new WebRequestBuilder(
new Uri(accessTokenUrl),
httpVerb,
//new OAuthTokens { ConsumerKey = consumerKey, ConsumerSecret = consumerSecret },
new OAuthTokens { ConsumerKey = consumerKey, ConsumerSecret = consumerSecret, AccessToken = requestToken, AccessTokenSecret = accessTokenSecret },
"");
if (!string.IsNullOrEmpty(verifier))
{
builder.Parameters.Add("oauth_verifier", verifier);
}
builder.Parameters.Add("oauth_token", requestToken);
string responseBody;
try
{
HttpWebResponse webResponse = builder.ExecuteRequest();
responseBody = new StreamReader(webResponse.GetResponseStream()).ReadToEnd();
}
catch (WebException wex)
{
throw new Exception(wex.Message, wex);
}
OAuthTokenResponse response = new OAuthTokenResponse();
response.Token = Regex.Match(responseBody, @"oauth_token=([^&]+)").Groups[1].Value;
response.TokenSecret = Regex.Match(responseBody, @"oauth_token_secret=([^&]+)").Groups[1].Value;
if (serviceType == ServiceType.Twitter)
{
response.UserId = long.Parse(Regex.Match(responseBody, @"user_id=([^&]+)").Groups[1].Value, CultureInfo.CurrentCulture);
response.ScreenName = Regex.Match(responseBody, @"screen_name=([^&]+)").Groups[1].Value;
} else if (serviceType == ServiceType.DropBox)
{
response.UserId = long.Parse(Regex.Match(responseBody, @"uid=([^&]+)").Groups[1].Value, CultureInfo.CurrentCulture);
}//end if
return response;
}
/// <summary>
/// Creates and executes an OAuth signed HTTP request.
/// </summary>
/// <param name="baseUrl">The base URL.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="verb">The HTTP verb to perform.</param>
/// <param name="consumerKey">The consumer key.</param>
/// <param name="consumerSecret">The consumer secret.</param>
/// <param name="token">The access or request token.</param>
/// <param name="tokenSecret">The token secret.</param>
/// <returns>
/// A new instance of the <see cref="System.Net.HttpWebRequest"/> class.
/// </returns>
internal static HttpWebResponse ExecuteRequest(
string baseUrl,
Dictionary<string, string> parameters,
HTTPVerb verb,
string consumerKey,
string consumerSecret,
string token,
string tokenSecret,
WebProxy proxy)
{
Dictionary<string, string> combinedParameters = PrepareOAuthParameters(
baseUrl,
parameters,
verb,
consumerKey,
consumerSecret,
token,
tokenSecret);
HttpWebResponse response;
if (verb == HTTPVerb.POST)
{
baseUrl = AppendParametersForPOST(baseUrl, combinedParameters);
}
else
{
string querystring = GenerateGetQueryString(combinedParameters);
if (!string.IsNullOrEmpty(querystring))
{
baseUrl = string.Concat(baseUrl, "?", querystring);
}
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(baseUrl);
request.Method = verb.ToString();
request.UserAgent = string.Format(CultureInfo.InvariantCulture, "Twitterizer");
request.Headers.Add("Authorization", GenerateAuthorizationHeader(combinedParameters));
if (proxy != null)
request.Proxy = proxy;
if (verb == HTTPVerb.POST)
{
request.ContentType = "application/x-www-form-urlencoded";
}
#if DEBUG
Console.WriteLine("----- Headers -----");
foreach (string key in request.Headers.AllKeys)
{
Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} = {1}\n", key, request.Headers[key]));
}
Console.WriteLine("----- End Of Headers -----");
#endif
response = (HttpWebResponse)request.GetResponse();
return response;
}
public void ProcessRequest(HttpContext context)
{
StringBuilder log = new StringBuilder();
string screenName = "";
try
{
string query = "";
UriBuilder urlBuilder = new UriBuilder("https://api.twitter.com/" + context.Server.UrlDecode(context.Request.QueryString["query"]));
// Adds query strings to the url.
// some headers may not be copied because they can't be used with clients other than twitter
foreach (var queryString in context.Request.QueryString.AllKeys)
{
switch (queryString)
{
case "u":
case "p":
case "query":
case "earned":
case "pc":
break;
default:
query += string.Format("&{0}={1}", queryString, context.Request.QueryString[queryString]);
break;
}
}
if (query.Length > 1)
{
query = query.Substring(1);
}
urlBuilder.Query = query;
log.AppendLine(query);
log.AppendLine("URL: " + urlBuilder.Uri.ToString());
OAuthTokens tokens = new OAuthTokens();
tokens.ConsumerKey = ConfigurationManager.AppSettings["TwitterConsumerKey"];
tokens.ConsumerSecret = ConfigurationManager.AppSettings["TwitterConsumerSecret"];
JToken accessToken;
String userFileName = context.Server.MapPath("/App_Data/Users/" + context.Request.QueryString["u"] + "." + context.Request.QueryString["p"]);
if (File.Exists(userFileName))
{
using (StreamReader str = new StreamReader(userFileName))
{
accessToken = JObject.Parse(str.ReadToEnd());
;
}
tokens.AccessToken = (string)accessToken.SelectToken("AccessToken");
tokens.AccessTokenSecret = (string)accessToken.SelectToken("AccessSecret");
screenName = (string)accessToken.SelectToken("ScreenName");
log.AppendLine("User FOUND!");
}
else
{
log.AppendLine("User NOT FOUND");
context.Response.StatusCode = 404;
return;
}
//check if the request is xAuth, if it is, simulates the xAuth result for fooling Twitter for iPhone.
if (context.Request.QueryString["query"].Contains("oauth/access_token"))
{
string xAuthResponse = string.Format("oauth_token={0}&oauth_token_secret={1}&user_id={2}&screen_name={3}&x_auth_expires=0",
(string)accessToken.SelectToken("AccessToken"),
(string)accessToken.SelectToken("AccessSecret"),
(string)accessToken.SelectToken("UserId"),
(string)accessToken.SelectToken("ScreenName"));
context.Response.Write(xAuthResponse);
screenName = (string)accessToken.SelectToken("ScreenName");
return;
}
HTTPVerb verb = HTTPVerb.GET;
switch (context.Request.HttpMethod)
{
case "GET":
verb = HTTPVerb.GET;
break;
case "POST":
verb = HTTPVerb.POST;
break;
case "DELETE":
verb = HTTPVerb.DELETE;
break;
}
if (context.Request.Headers["Authorization"] == null)
{
tokens = null;
log.AppendLine("Request NOT authenticated");
}
WebRequestBuilder webreq = new WebRequestBuilder(urlBuilder.Uri, verb, tokens);
webreq.Multipart = (context.Request.ContentType.Contains("multipart"));
if (verb != HTTPVerb.GET)
{
// adds body parameters to request
foreach (var key in context.Request.Form.AllKeys)
{
webreq.Parameters.Add(key, context.Request.Form[key]);
}
foreach (var fileKey in context.Request.Files.AllKeys)
{
webreq.Parameters.Add(fileKey, context.Request.Form[fileKey]);
}
}
ServicePointManager.Expect100Continue = false;
HttpWebRequest req = webreq.PrepareRequest();
try
{
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
log.AppendLine("get Response");
StreamReader strReader = new StreamReader(resp.GetResponseStream());
String response = strReader.ReadToEnd();
if (ConfigurationManager.AppSettings["debugMode"] == "true")
{
log.AppendLine(response);
}
// replaces images url to use TwiX to load them
response = Regex.Replace(response, @"(((http:\\/\\/www)|(http:\\/\\/)|(https:\\/\\/www)|(https:\\/\\/)|(www))[-a-zA-Z0-9@:%_\\\+.~#?&//=]+)\.(jpg|jpeg|gif|png|bmp|tiff|tga|svg)", delegate(Match match)
{
string v = match.ToString();
return(ConfigurationManager.AppSettings["baseUrl"] + "image/" + shFunctions.encryptBase64Url(DES.Encrypt(v.Replace(@"\/", "/").Replace("_normal", ""), shFunctions.key) + ".jpg"));
});
strReader.Close();
context.Response.ClearContent();
context.Response.Write(response);
}
catch (WebException webex)
{
if (webex.Status == WebExceptionStatus.ProtocolError)
{
context.Response.StatusCode = (int)((HttpWebResponse)webex.Response).StatusCode;
}
log.AppendLine("ERROR: " + webex.Message);
return;
}
}
catch (Exception ee) {
log.AppendLine("Error: " + ee.Message);
log.AppendLine("stack: " + ee.StackTrace);
}
if (ConfigurationManager.AppSettings["log"] == "true")
{
writeLogToFile(log.ToString(), screenName, context.Request.HttpMethod, context);
}
//throw new Exception(context.Request.QueryString.ToString());
}
public void graphRequest(string path, HTTPVerb verb, Action <string, object> completionHandler)
{
graphRequest(path, verb, null, completionHandler);
}
/// <summary>
/// Prepares the request. It is not nessisary to call this method unless additional configuration is required.
/// </summary>
/// <returns>A <see cref="HttpWebRequest"/> object fully configured and ready for execution.</returns>
public HttpWebRequest PrepareRequest()
{
SetupOAuth();
formData = null;
string contentType = string.Empty;
if (!Multipart)
{ //We don't add the parameters to the query if we are multipart-ing
AddQueryStringParametersToUri();
}
else
{
string dataBoundary = "--------------------r4nd0m";
contentType = "multipart/form-data; boundary=" + dataBoundary;
formData = GetMultipartFormData(Parameters, dataBoundary);
this.Verb = HTTPVerb.POST;
}
HttpWebRequest request;
request = (HttpWebRequest)WebRequest.Create(this.RequestUri);
if (this.UseCompression == true)
request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
else
request.AutomaticDecompression = DecompressionMethods.None;
if (this.Proxy != null)
request.Proxy = Proxy;
if (!this.UseOAuth && this.networkCredentials != null)
{
request.Credentials = this.networkCredentials;
request.UseDefaultCredentials = false;
}
else
{
request.UseDefaultCredentials = true;
}
request.Method = this.Verb.ToString();
request.ContentLength = Multipart ? ((formData != null) ? formData.Length : 0) : 0;
request.UserAgent = (string.IsNullOrEmpty(userAgent)) ? string.Format(CultureInfo.InvariantCulture, "EasyTwitter/{0}", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version) : userAgent;
request.ServicePoint.Expect100Continue = false;
if (this.UseOAuth)
{
request.Headers.Add("Authorization", GenerateAuthorizationHeader());
}
if (Multipart)
{ //Parameters are not added to the query string, post them in the request body instead
request.ContentType = contentType;
using (Stream requestStream = request.GetRequestStream())
{
if (formData != null)
{
requestStream.Write(formData, 0, formData.Length);
}
}
}
return request;
}
/// <summary>
/// Gets the request token.
/// </summary>
/// <param name="consumerKey">The consumer key.</param>
/// <param name="consumerSecret">The consumer secret.</param>
/// <param name="callbackAddress">The callback address. For PIN-based authentication "oob" should be supplied.</param>
/// <returns></returns>
public static OAuthTokenResponse GetRequestToken(string consumerKey, string consumerSecret, string callbackAddress, string requestTokenUrl, HTTPVerb httpVerb)
{
if (string.IsNullOrEmpty(consumerKey))
{
throw new ArgumentNullException("consumerKey");
}
if (string.IsNullOrEmpty(consumerSecret))
{
throw new ArgumentNullException("consumerSecret");
}
if (string.IsNullOrEmpty(callbackAddress))
{
throw new ArgumentNullException("callbackAddress", @"You must always provide a callback url when obtaining a request token. For PIN-based authentication, use ""oob"" as the callback url.");
}
WebRequestBuilder builder = new WebRequestBuilder(
new Uri(requestTokenUrl),
httpVerb,
new OAuthTokens { ConsumerKey = consumerKey, ConsumerSecret = consumerSecret },
"");
if (!string.IsNullOrEmpty(callbackAddress))
{
builder.Parameters.Add("oauth_callback", callbackAddress);
}
string responseBody = null;
try
{
HttpWebResponse webResponse = builder.ExecuteRequest();
Stream responseStream = webResponse.GetResponseStream();
if (responseStream != null) responseBody = new StreamReader(responseStream).ReadToEnd();
}
catch (WebException wex)
{
throw new Exception(wex.Message, wex);
}
return new OAuthTokenResponse
{
Token = ParseQuerystringParameter("oauth_token", responseBody),
TokenSecret = ParseQuerystringParameter("oauth_token_secret", responseBody),
VerificationString = ParseQuerystringParameter("oauth_verifier", responseBody)
};
}
/// <summary> /// /// </summary> /// <param name="overrideVerb"></param> /// <returns></returns> protected abstract TwitterResponse<string> BeginRequest(HTTPVerb overrideVerb = HTTPVerb.GET);
public void graphRequest( string path, HTTPVerb verb, Dictionary<string, object> parameters, Action<string, object> completionHandler )
{
// in the editor, we allow requests to be sent as long as we have an access token
#if UNITY_EDITOR
if( ( accessToken != null && accessToken.Length > 0 ) || shouldSendRequest() )
#else
if( shouldSendRequest() )
#endif
{
surrogateMonobehaviour.StartCoroutine( send( path, verb, parameters, completionHandler ) );
}
else
{
// if we have an auth helper we will use it because we are not logged in
// auth helpers are classes in the FacebookBinding and FacebookAndroid files
try
{
#if UNITY_IPHONE
var type = typeof( Facebook ).Assembly.GetType( "FacebookBinding" );
#elif UNITY_ANDROID
var type = typeof( Facebook ).Assembly.GetType( "FacebookAndroid" );
#endif
#if UNITY_IPHONE || UNITY_ANDROID
// this will pass for iOS and Android when the SocialNetworking Plugin is present
if( type != null )
{
var method = type.GetMethod( "babysitRequest", BindingFlags.Static | BindingFlags.NonPublic );
if( method != null )
{
Action action = () => { surrogateMonobehaviour.StartCoroutine( send( path, verb, parameters, completionHandler ) ); };
method.Invoke( null, new object[] { verb == HTTPVerb.POST, action } );
}
}
#endif
}
catch( Exception )
{}
}
}
/// <summary>
///
/// </summary>
/// <param name="overrideVerb"></param>
/// <returns></returns>
protected virtual TwitterResponse<string> ExecuteRequest(HTTPVerb overrideVerb)
{
this.Verb = overrideVerb;
if (String.IsNullOrEmpty(this.Method))
throw new ArgumentNullException("Method");
WebRequestBuilder builder = new WebRequestBuilder(
new Uri(this.BaseUri + this.Method),
this.Verb,
this.Tokens);
string responseBody = String.Empty;
try
{
if (this.AdditionalParameters.Count > 0)
{
foreach (var item in this.AdditionalParameters)
builder.Parameters.Add(item.Key, item.Value);
if(this.Verb==HTTPVerb.POST)
builder.Multipart = true;
}
HttpWebResponse webResponse = builder.ExecuteRequest();
Stream responseStream = webResponse.GetResponseStream();
if (responseStream != null) responseBody = new StreamReader(responseStream).ReadToEnd();
}
catch (WebException wex)
{
TwitterStatus status = TwitterStatus.GeneralError; ;
if (wex.Status == WebExceptionStatus.ProtocolError)
{
switch(((HttpWebResponse)wex.Response).StatusCode)
{
case HttpStatusCode.BadRequest:
status = TwitterStatus.BadRequest;
break;
case HttpStatusCode.Unauthorized:
status = TwitterStatus.Unauthorized;
break;
case HttpStatusCode.NotFound:
status = TwitterStatus.FileNotFound;
break;
case HttpStatusCode.NotAcceptable:
status = TwitterStatus.NotAcceptable;
break;
default:
status = TwitterStatus.GeneralError;
break;
}
}
return new TwitterResponse<string>()
{
Status = status,
ObjectResponse = String.Empty
};
}
return new TwitterResponse<string>()
{
Status = TwitterStatus.Success,
ObjectResponse = responseBody
};
}
public Endpoint(string URL, HTTPVerb verb = HTTPVerb.ALL)
{
Url = URL;
Type = ContentType.HTML;
Verb = verb; // HTTPVerb.ALL;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The verb.</param>
/// <param name="tokens">The tokens.</param>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, OAuthTokens tokens)
: this(requestUri, verb, string.Empty, null)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRequestBuilder"/> class.
/// </summary>
/// <param name="requestUri">The request URI.</param>
/// <param name="verb">The verb.</param>
/// <param name="tokens">The tokens.</param>
/// <param name="userAgent">The user agent.</param>
public WebRequestBuilder(Uri requestUri, HTTPVerb verb, OAuthTokens tokens, string userAgent = "")
: this(requestUri, verb, userAgent, null)
{
this.Tokens = tokens;
if (tokens != null)
{
if (string.IsNullOrEmpty(this.Tokens.ConsumerKey) || string.IsNullOrEmpty(this.Tokens.ConsumerSecret))
{
throw new ArgumentException("Consumer key and secret are required for OAuth requests.");
}
if (string.IsNullOrEmpty(this.Tokens.AccessToken) ^ string.IsNullOrEmpty(this.Tokens.AccessTokenSecret))
{
throw new ArgumentException("The access token is invalid. You must specify the key AND secret values.");
}
this.UseOAuth = true;
}
}
public void restRequest( string method, HTTPVerb verb, Dictionary<string, object> parameters, Action<string, object> completionHandler )
{
// ensure we return json
if( parameters == null )
parameters = new Dictionary<string,object>();
if( !parameters.ContainsKey( "format" ) )
parameters.Add( "format", "json" );
// we have to rejigger the baseUrl temporarily here
var path = "method/" + method;
var oldBaseUrl = _baseUrl;
_baseUrl = "https://api.facebook.com/";
surrogateMonobehaviour.StartCoroutine( send( path, verb, parameters, completionHandler ) );
_baseUrl = oldBaseUrl;
}
