public new IAsyncResult BeginGetResponse (AsyncCallback callback, object state)
{
var result = new NetAsyncResult (state);
xhr = new XmlHttpRequest ();
xhr.ReadyStateChange += e =>
{
if (this.xhr.readyState == this.xhr.DONE) {
callback (result);
}
};
if (Method == null)
{
Method = "GET";
}
xhr.Open (Method, this.uri.AbsoluteUri);
if (this._headers != null) {
for (int i = 0; i < this.Headers.Count; i++) {
var key = this.Headers.GetKey (i);
xhr.SetRequestHeader (key, this.Headers[key]);
}
}
if (this._requestStream != null)
{
var sr = new System.IO.StreamReader (this._requestStream);
var requestDataStr = sr.ReadToEnd();
xhr.Send(requestDataStr);
} else {
xhr.Send ();
}
return result;
}
private static XmlHttpResponse ProxyRequest(
XmlHttpRequest xmlHttpRequest,
X509Certificate2 clientCert)
{
var httpKeyUri = HttpKeyUri.BuildHttpKeyUri(xmlHttpRequest.url);
HttpWebRequest webRequest = ThaliClientToDeviceHubUtilities.CreateThaliWebRequest(httpKeyUri, clientCert);
webRequest.Method = xmlHttpRequest.method;
// There are multiple headers that cannot be set directly via webRequest.Headers. I only catch
// two below that seem of some reasonable use.
foreach (var headerNameValue in xmlHttpRequest.headers)
{
if (headerNameValue.Key.Equals("Accept", StringComparison.OrdinalIgnoreCase))
{
webRequest.Accept = headerNameValue.Value;
}
else if (headerNameValue.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase))
{
webRequest.ContentType = headerNameValue.Value;
}
else
{
webRequest.Headers.Add(headerNameValue.Key, headerNameValue.Value);
}
}
if (string.IsNullOrWhiteSpace(xmlHttpRequest.requestText))
{
return ProcessResponse(xmlHttpRequest.transactionId, webRequest);
}
var bodyAsBytes = Encoding.UTF8.GetBytes(xmlHttpRequest.requestText);
webRequest.GetRequestStream().Write(bodyAsBytes, 0, bodyAsBytes.Count());
var response = ProcessResponse(xmlHttpRequest.transactionId, webRequest);
return response;
}
public ClientHttpWebRequest(Uri uri)
{
this.requestUri = uri;
this.request = new XmlHttpRequest();
this.Method = "GET"; // Default method is GET
this.request.OnReadyStateChange = this.OnStateChanged;
}
public IHttpRequestAsyncHandle AsPostAsync(Action <IHttpResponse> action, string httpMethod)
{
if (monoBehaviour == null)
{
throw new InvalidOperationException("The MonoBehaviour property must be set before invoking WebGLHttpRequest.AsPostAsync()");
}
XmlHttpRequest webRequest = PutPostInternalAsync(httpMethod.ToUpperInvariant(), action);
return(new WebGLHttpRequestAsyncHandle(webRequest));
}
public IApiRequest CreateRequest(string MethodName, DataItemCollection Parameters)
{
XmlHttpRequest request = new XmlHttpRequest();
XmlHttpMethodCall method = new XmlHttpMethodCall();
method.MethodName = MethodName;
method.Parameters = (Parameters ?? method.Parameters);
request.MethodCall = method;
return(request);
}
public void HashShouldNotBeSent()
{
var sync = new Object();
var resourceProvider = Mocks.ResourceProvider("http://data", "hello");
var xhr = new XmlHttpRequest(resourceProvider, () => sync, null, (s, s1) => new Request(s1, UriHelper.GetUri(s)));
xhr.Open("GET", "http://data#some", false);
xhr.Send();
Assert.AreEqual("hello", xhr.Response);
}
XmlHttpRequest Send(string type, string data)
{
var sync = new Object();
var resourceProvider = Mocks.ResourceProvider("http://data", data);
var xhr = new XmlHttpRequest(resourceProvider, () => sync, null, (s, s1) => new Request(s1, UriHelper.GetUri(s)));
xhr.Open("GET", "http://data", false);
xhr.ResponseType = type;
xhr.Send();
return(xhr);
}
private void LogHttpRequest(XmlHttpRequest request)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("HttpRequest ").Append(RequestId).AppendLine();
stringBuilder.Append("Uri: ").AppendLine(request.Url.AbsoluteUri);
stringBuilder.Append("Method: ").AppendLine(request.Method);
stringBuilder.AppendLine("Headers:");
foreach (string key in request.RequestHeaders.Keys)
{
stringBuilder.Append(key).Append(": ").AppendLine(request.RequestHeaders[key]);
}
logger.DebugFormat("{0:g}", stringBuilder);
}
private void PreparePostBody(XmlHttpRequest webRequest)
{
if (HasFiles || AlwaysMultipartFormData)
{
webRequest.ContentType = GetMultipartFormContentType();
}
else if (HasParameters)
{
webRequest.ContentType = "application/x-www-form-urlencoded";
RequestBody = EncodeParameters();
}
else if (HasBody)
{
webRequest.ContentType = RequestContentType;
}
}
public ApiResponse ExecuteRequest(IApiRequest request)
{
XmlHttpRequest httpRequest = (XmlHttpRequest)request;
string requestRaw = httpRequest.Serialize();
SetLastRequestRaw(requestRaw);
HttpResponse response = HttpTools.GetResponseFromPost(this.ApiUrl, requestRaw);
string strResponseText = response.ResponseText;
SetLastResponseRaw(strResponseText);
return(GetResponseFromXml(strResponseText));
}
public ApiResponse ExecuteRequestWithUpload(IApiRequest ApiRequest, string UploadFileName, string UploadFieldName, string UploadFileContentType, System.Collections.Specialized.NameValueCollection PostData)
{
XmlHttpRequest xmlHttpRequest = (XmlHttpRequest)ApiRequest;
string xmlMessage = xmlHttpRequest.Serialize();
SetLastRequestRaw(xmlMessage);
PostData.Add("XMLMessage", xmlMessage);
System.Net.HttpWebResponse response = HttpTools.HttpUploadFile(this.ApiUrl, UploadFileName, UploadFieldName, UploadFileContentType, PostData);
string strResponseText = response.GetResponseText();
SetLastResponseRaw(strResponseText);
return(GetResponseFromXml(strResponseText));
}
private XmlHttpRequest PutPostInternalAsync(string method, Action <IHttpResponse> callback)
{
XmlHttpRequest xmlHttpRequest = null;
try
{
xmlHttpRequest = ConfigureWebRequest(method, Url);
PreparePostBody(xmlHttpRequest);
LogHttpRequest(xmlHttpRequest);
WriteRequestBodyAsync(xmlHttpRequest, callback);
}
catch (Exception ex)
{
Debug.LogException(ex);
ExecuteCallback(CreateErrorResponse(ex), callback);
}
return(xmlHttpRequest);
}
private void AppendHeaders(XmlHttpRequest webRequest)
{
foreach (HttpHeader header in Headers)
{
if (string.Equals(header.Name, "Accept", StringComparison.OrdinalIgnoreCase))
{
webRequest.RequestHeaders.Add(header.Name, header.Value + ";q=0.9,*/*;q=0.8");
}
else if (_restrictedHeaderActions.ContainsKey(header.Name))
{
_restrictedHeaderActions[header.Name](webRequest, header.Value);
}
else
{
webRequest.RequestHeaders.Add(header.Name, header.Value);
}
}
}
private static void pollJira()
{
clearPollTimer();
pollNowButton.Disabled = true;
string url =
serverUrl
+ "/sr/jira.issueviews:searchrequest-xml/temp/SearchRequest.xml?jqlQuery=project+%3D+"
+ projectKey
+ "+AND+"
+ currentFilter.FilterDef
+ "&tempMax=1000";
labelInfo.InnerHTML = "Polling JIRA server...";
req = new XmlHttpRequest();
req.Open("GET", getAuthenticatedUrl(url));
req.OnReadyStateChange = onReadyStateChange;
req.Send();
}
/// <summary>
/// Gets a location of an address from Google Maps
/// </summary>
/// <param name="strAddress"></param>
/// <returns></returns>
public Location GetLocation(string strAddress)
{
Location resultLocation = null;
XmlHttpRequest xmlHttp = new XmlHttpRequest();
Dictionary <string, string> parameters = GetGeoLocationQueryParameteres(strAddress);
Task <string> strJSONResponse = null;
try
{
// does the http request
strJSONResponse = xmlHttp.DoGetRequestAsync(_baseURL, parameters);
GoogleGeoCodeResponse googleResponse = JsonConvert.DeserializeObject <GoogleGeoCodeResponse>(strJSONResponse.Result);
if (googleResponse.status == "OK")
{
if (googleResponse.results.Length == 1)
{
resultLocation = new Location();
resultLocation.City = (googleResponse.GetAddressComponent("locality") != null ?
googleResponse.GetAddressComponent("locality").long_name :
(
googleResponse.GetAddressComponent("postal_town") != null ?
googleResponse.GetAddressComponent("postal_town").long_name :
null)
);
resultLocation.Latitude = decimal.Parse(googleResponse.results[0].geometry.location.lat.Replace(".", ","));
resultLocation.Longitude = decimal.Parse(googleResponse.results[0].geometry.location.lng.Replace(".", ","));
resultLocation.Address1 = googleResponse.results[0].formatted_address;
resultLocation.Country = googleResponse.GetAddressComponent("country").long_name;
}
}
}
catch (Exception ex)
{
throw ex;
}
return(resultLocation);
}
private void CORS()
{
xhr = new XmlHttpRequest();
try
{
xhr.Open(HttpVerb.Get, _url);
xhr.OnReadyStateChange = delegate()
{
if (xhr.ReadyState == ReadyState.Loaded)
{
LoadData(xhr.ResponseText);
}
};
xhr.Send();
}
catch (Exception err)
{
_message = err.Message;
State = StateType.Error;
throw (err);
}
}
/// <summary>
/// Loads up the artists events
/// </summary>
/// <param name="artist"></param>
/// <returns></returns>
private List <Event> LoadEvents(Artist artist)
{
int currentPage = 1;
int totalPages = 1;
XmlHttpRequest xmlHttp = new XmlHttpRequest();
Dictionary <string, string> parameters = GetEventsInfoParameteres(artist.Name);
XmlDocument xmlDoc = null;
Task <string> strXmlStr = null;
List <Event> eventList = new List <Event>();
try
{
while (currentPage <= totalPages)
{
// updates the page current parameter
parameters["page_number"] = currentPage.ToString();
// does the http request
strXmlStr = xmlHttp.DoGetRequestAsync(_eventsDataBaseURL, parameters);
// loads up de text into the XmlDocument
xmlDoc = new XmlDocument();
xmlDoc.LoadXml(strXmlStr.Result);
// parses the XML Doc
totalPages = ParseEventsXml(xmlDoc, ref eventList);
currentPage++;
}
}
catch (Exception ex)
{
throw ex;
}
return(eventList);
}
private void WriteRequestBodyAsync(XmlHttpRequest webRequest, Action <IHttpResponse> callback)
{
if (HasBody || HasFiles || AlwaysMultipartFormData)
{
if (RequestBodyBytes != null)
{
webRequest.Send(RequestBodyBytes);
}
else if (RequestBody != null)
{
webRequest.SendText(RequestBody);
}
else
{
webRequest.Send();
}
monoBehaviour.StartCoroutine(GetResponse(callback, webRequest));
}
else
{
webRequest.Send();
monoBehaviour.StartCoroutine(GetResponse(callback, webRequest));
}
}
public void ResponseTypeArrayBuffer()
{
var sync = new Object();
var resourceProvider = Mocks.ResourceProvider("http://data", new byte[] { 10, 1, 0 });
var xhr = new XmlHttpRequest(resourceProvider, () => sync, null, (s, s1) => new Request(s1, UriHelper.GetUri(s)));
xhr.Open("GET", "http://data", false);
xhr.ResponseType = "arraybuffer";
xhr.Send();
Assert.IsInstanceOf <ArrayBuffer>(xhr.Response);
var buffer = (ArrayBuffer)xhr.Response;
Assert.AreEqual(3, buffer.ByteLength);
var barr = new Int8Array(buffer);
Assert.AreEqual(10, barr[0]);
Assert.AreEqual(1, barr[1]);
Assert.AreEqual(0, barr[2]);
Assert.Throws <Exception>(() =>
{
var x = xhr.ResponseText;
});
}
public override void LoadData(string path)
{
table = new Table();
XmlHttpRequest xhr = new XmlHttpRequest();
xhr.Open(HttpVerb.Get, path);
xhr.OnReadyStateChange = delegate()
{
if (xhr.ReadyState == ReadyState.Loaded)
{
table.LoadFromString(xhr.ResponseText, false, true, true);
ComputeDateDomainRange(-1, -1);
if (DynamicData && AutoUpdate)
{
DynamicUpdate();
}
dataDirty = true;
dirty = true;
}
};
xhr.Send();
}
/// <summary>
/// Loads the artist's albums from lastFM
/// </summary>
/// <param name="artistResult"></param>
private void LoadAlbumInfo(Artist artist, Album album)
{
XmlHttpRequest xmlHttp = new XmlHttpRequest();
Dictionary <string, string> parameters = GetAlbumInfoParameteres(artist, album);
XmlDocument xmlDoc = null;
Task <string> strXmlStr = null;
try
{
// does the http request
strXmlStr = xmlHttp.DoGetRequestAsync(_baseURL, parameters);
// loads up de text into the XmlDocument
xmlDoc = new XmlDocument();
xmlDoc.LoadXml(strXmlStr.Result);
// parses the XML Doc into the artist structure
ParseAlbumXml(artist, album, xmlDoc);
}
catch (Exception ex)
{
throw ex;
}
}
private static XmlDocument GetResponse(string soapXmlPacket, string action, Action <object> asyncCallback)
{
bool isAsync = (asyncCallback != null);
string xml = getSoapEnvelope(soapXmlPacket);
Exception msg = null;
XmlHttpRequest xmlHttpRequest = new XmlHttpRequest();
xmlHttpRequest.Open("POST", GetServerUrl() + "/XRMServices/2011/Organization.svc/web", isAsync);
xmlHttpRequest.SetRequestHeader("SOAPAction", "http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/" + action);
xmlHttpRequest.SetRequestHeader("Content-Type", "text/xml; charset=utf-8");
// This is only needed when debugging via localhost - and accessing the CRM webservices cross domain in chrome
if (WithCredentials)
{
Script.Literal("{0}.withCredentials = true;", xmlHttpRequest);
}
if (isAsync)
{
xmlHttpRequest.OnReadyStateChange = delegate()
{
if (xmlHttpRequest == null)
{
return;
}
if (xmlHttpRequest.ReadyState == ReadyState.Loaded)
{
// Capture the result
XmlDocument resultXml = xmlHttpRequest.ResponseXml;
Exception errorMsg = null;
if (xmlHttpRequest.Status != 200)
{
errorMsg = GetSoapFault(resultXml);
}
// Tidy Up
Script.Literal("delete {0}", xmlHttpRequest);
xmlHttpRequest = null;
if (errorMsg != null)
{
asyncCallback(errorMsg);
}
else
{
// Callback
asyncCallback(resultXml);
}
}
};
xmlHttpRequest.Send(xml);
return(null);
}
else
{
xmlHttpRequest.Send(xml);
// Capture the result
XmlDocument resultXml = xmlHttpRequest.ResponseXml;
// Check for errors.
if (xmlHttpRequest.Status != 200)
{
msg = GetSoapFault(resultXml);
}
// Tidy Up
Script.Literal("delete {0};", xmlHttpRequest);
xmlHttpRequest = null;
if (msg != null)
{
throw msg;
}
else
{
// Return
return(resultXml);
}
}
}
private void AddRange(XmlHttpRequest r, string range)
{
r.RequestHeaders.Add("Range", range);
}
private void AppendCookies(XmlHttpRequest webRequest)
{
}
private static XmlHttpResponse ExecuteProvisionLocalHubToRemoteHub(
XmlHttpRequest xmlHttpRequest,
X509Certificate2 clientCert)
{
var remoteHubHttpKeyUri = DiscoverRootCertIfNeeded(HttpKeyUri.BuildHttpKeyUri(xmlHttpRequest.url), clientCert);
var localHubHttpKeyUri = HttpKeyUri.BuildHttpKeyUri(xmlHttpRequest.requestText);
ThaliClientToDeviceHubUtilities.ProvisionKeyInPrincipalDatabase(remoteHubHttpKeyUri.ServerPublicKey, remoteHubHttpKeyUri.Host, remoteHubHttpKeyUri.Port, localHubHttpKeyUri.ServerPublicKey, clientCert);
return new XmlHttpResponse
{
status = 200,
transactionId = xmlHttpRequest.transactionId,
responseText = remoteHubHttpKeyUri.AbsoluteUri
};
}
private static XmlHttpResponse ExecuteProvisionLocalClientToLocalHub(
XmlHttpRequest xmlHttpRequest,
X509Certificate2 clientCert)
{
var hubHttpKeyUri = DiscoverRootCertIfNeeded(HttpKeyUri.BuildHttpKeyUri(xmlHttpRequest.url), clientCert);
ThaliClientToDeviceHubUtilities.ProvisionThaliClient(
hubHttpKeyUri.ServerPublicKey,
hubHttpKeyUri.Host,
hubHttpKeyUri.Port,
clientCert);
return new XmlHttpResponse { status = 200, transactionId = xmlHttpRequest.transactionId, responseText = hubHttpKeyUri.AbsoluteUri };
}
public static object ProcessMessage(XmlHttpRequest xmlHttpRequest, X509Certificate2 clientCert)
{
Debug.Assert(xmlHttpRequest != null && clientCert != null);
if (xmlHttpRequest.type != XmlHttpRequest.typeValue)
{
return
ProcessHostError(
"The type of the incoming request was " + xmlHttpRequest.type + " and not "
+ XmlHttpRequest.typeValue + " as required.",
xmlHttpRequest);
}
try
{
switch (xmlHttpRequest.method)
{
case ProvisionClientToHub:
return ExecuteProvisionLocalClientToLocalHub(xmlHttpRequest, clientCert);
case ProvisionLocalHubToRemoteHub:
return ExecuteProvisionLocalHubToRemoteHub(xmlHttpRequest, clientCert);
default:
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = ProxyRequest(xmlHttpRequest, clientCert);
stopwatch.Stop();
Debug.WriteLine("Method: " + xmlHttpRequest.method + ", elapsed Time: " + stopwatch.ElapsedMilliseconds + ", id: " + xmlHttpRequest.transactionId);
return result;
}
}
catch (Exception e)
{
return ProcessHostError("Received exception: " + e.Message, xmlHttpRequest);
}
}
public static object ProcessHostError(string errorMessage, XmlHttpRequest xmlHttpRequest)
{
var xmlHttpResponse = new XmlHttpResponse
{
transactionId =
xmlHttpRequest != null
? xmlHttpRequest.transactionId
: null,
status = 502,
responseText = errorMessage
};
xmlHttpResponse.headers.Add("content-type", "text/plain");
return xmlHttpResponse;
}
public WebGLHttpRequestAsyncHandle(XmlHttpRequest webRequest)
{
_webRequest = webRequest;
}
