public override async Task <ResponseResult <TResponseParser> > Execute() { var webRequestBuilder = new ASWebRequestBuilder(); string xml = this.Parameters.BuildXml(this.CommandName); NetworkCredential credential = new NetworkCredential(this.Settings.Login, this.Settings.Password); string url = string.Format("{0}{1}?Cmd={2}&User={3}&DeviceId={4}&DeviceType={5}", this.Settings.HostName, ServerUrlDirectory, this.CommandName, this.Settings.Login, this.Settings.DeviceId, this.Settings.DeviceType); var headers = new Dictionary <string, string> { { "MS-ASProtocolVersion", this.Settings.ProtocolVersion }, { "X-MS-PolicyKey", this.Settings.PolicyKey.ToString() }, }; WebRequestResponse response = null; try { response = await webRequestBuilder.SendRequestAsync( url, HttpMethod.Post, ContentTypeWbXml, xml, headers, credential); // settings must be updated if a redirection occured string requestUri = response.Request.RequestUri.GetSchemeAndHost(); if (requestUri.TrimEnd('/') != this.Settings.HostName.TrimEnd('/')) { string oldHostName = this.Settings.HostName; this.Settings.HostName = requestUri; LogService.Log("ASCommandBase", $"Successfull redirection from {oldHostName} to {requestUri}"); } if (response.Response.IsSuccessStatusCode) { var parser = new TResponseParser(); parser.ParseResponse(this.CommandName, response); return(ResponseResult <TResponseParser> .Create(parser, requestUri)); } else { return(this.CreateResponseResult(null, response, requestUri)); } } catch (Exception ex) { return(this.CreateResponseResult(ex, response, url)); } }
public void ParseResponse(string commandName, WebRequestResponse response) { if (response.Response.StatusCode == HttpStatusCode.Unauthorized) { throw new CommandAuthorizationException(string.Format("Authorization failed: {0}", response.Response.ReasonPhrase)); } string xml = response.ResponseBody; XDocument xdoc = null; string xmlValidationErrorMessage; if (!EwsXmlHelper.IsValidXml(xml, out xmlValidationErrorMessage)) { if (this.RequireValidXml) { throw new CommandResponseXmlException(string.Format("Invalid xml content: {0}", xmlValidationErrorMessage)); } } else { xdoc = XDocument.Load(new StringReader(xml)); } this.ParseResponseCore(commandName, xdoc, response); }
private void ManageClientAcknowledgement(XElement collection, WebRequestResponse response) { var responses = collection.Element("Responses"); if (responses == null) { return; } // tasks added var adds = responses.Elements("Add"); if (adds != null) { foreach (var add in adds) { var status = add.Element("Status").Value; if (status == "1") { var clientId = int.Parse(add.Element("ClientId").Value); var serverId = add.Element("ServerId").Value; this.ServerAddedTasks++; this.ClientServerMapIds.Add(clientId, serverId); } else { TryTrackEvent("Add failed status " + status, response.RequestBody); if (InvalidStatusFound != null) { InvalidStatusFound(this, new EventArgs <string>($"Update task status failure: {status}")); } } } } // tasks changed var changes = responses.Elements("Change"); if (changes != null) { foreach (var change in changes) { var status = change.Element("Status").Value; // Manage status != 1 if (status == "1") { this.ServerModifiedTasks++; } else { TryTrackEvent("Update failed status " + status, response.RequestBody); } } } // task deleted, nothing because delete acknowledgement is not sent back }
public void ParseResponse(string commandName, WebRequestResponse response) { if (response.Response.StatusCode == HttpStatusCode.Unauthorized) { throw new CommandAuthorizationException(string.Format("Authorization failed: {0}", response.Response.ReasonPhrase)); } string xml = response.ResponseBody; string xmlValidationErrorMessage; if (!EwsXmlHelper.IsValidXml(xml, out xmlValidationErrorMessage)) { throw new CommandResponseXmlException(string.Format("Invalid xml content: {0}", xmlValidationErrorMessage)); } var root = XDocument.Load(new StringReader(xml)).Root; if (response.Response.IsSuccessStatusCode) { // read error section var error = root.XGetChild("Response/Error", NsEwsAutodiscover); if (error != null) { string errorCode = error.XGetChildValue <string>("ErrorCode", NsEwsAutodiscover); string message = error.XGetChildValue <string>("Message", NsEwsAutodiscover); string debugData = error.XGetChildValue <string>("DebugData", NsEwsAutodiscover); LogService.Log("AutoDiscoverResult", string.Format("Error response code: {0} message: {1} debug data: {2}", errorCode, message, debugData)); return; } // read protocols section var nodes = root.XGetChildrenOf("Response/Account", NsEwsOutlookAutodiscover); foreach (var node in nodes) { if (node.Name != null && node.Name.LocalName.Equals("Protocol", StringComparison.OrdinalIgnoreCase)) { var type = node.XGetChildValue <string>("Type", NsEwsOutlookAutodiscover); var ewsUrl = node.XGetChildValue <string>("EwsUrl", NsEwsOutlookAutodiscover); // read more about protocol type: http://blogs.technet.com/b/exchange/archive/2008/09/26/3406344.aspx if (type.Equals("exch", StringComparison.OrdinalIgnoreCase)) { this.InternalEwsUrl = ewsUrl; } else if (type.Equals("expr", StringComparison.OrdinalIgnoreCase)) { this.ExternalEwsUrl = ewsUrl; } } else if (node.Name != null && node.Name.LocalName.Equals("RedirectAddr", StringComparison.OrdinalIgnoreCase)) { this.RedirectEmailAddress = node.Value; } } } }
private void PopulateList <T>(ref List <T> list, WebRequestResponse response) { if (!response.Succeeded) { return; } list = new List <T>(response.ResponseArray <T>()); }
private void PopulateEventCode(WebRequestResponse response, UnityAction <EventCode> onEventCodeReceived) { if (!response.Succeeded) { return; } onEventCodeReceived?.Invoke(response.Response <EventCode>()); }
private async Task <WebRequestResponse> ProcessRequest(HttpResponseMessage response) { var ret = new WebRequestResponse(); ret.IsSuccess = response.IsSuccessStatusCode; ret.Reason = response.ReasonPhrase; ret.StatusCode = (int)response.StatusCode; ret.Content = await response.Content.ReadAsByteArrayAsync(); return(ret); }
public async Task <WebRequestResponse> ProcessRequest(UnityWebRequest request) { await request.SendWebRequest(); var ret = new WebRequestResponse(); ret.IsSuccess = !request.isNetworkError && !request.isHttpError; ret.Reason = request.error; ret.StatusCode = (int)request.responseCode; ret.Content = request.downloadHandler.data; return(ret); }
private void OnGetBranches(WebRequestResponse response) { if (!response.Succeeded) { return; } foreach (Branch branch in laGranLuchaManager.Branches) { Instantiate <BranchHandler>(branchPrefab, branchesContainer).Initialize(branch); } }
private void OnGetDrinks(WebRequestResponse response) { if (!response.Succeeded) { return; } foreach (Drink drink in laGranLuchaManager.Drinks) { foreach (Variant variant in drink.Variants) { Instantiate <CartItemHandler>(cartItemHandler, drinkContainer).Initialize(variant); } } }
private void OnGetFoods(WebRequestResponse response) { if (!response.Succeeded) { return; } foreach (Food food in laGranLuchaManager.Foods) { foreach (Variant variant in food.Variants) { Instantiate <CartItemHandler>(cartItemHandler, foodContainer).Initialize(variant); } } }
private async Task <ResponseResult <TResponseParser> > SendRequestAsync(string xml, string username, string password, bool secondTry = false) { WebRequestResponse response = null; try { response = await this.webRequestBuilder.SendRequestAsync( this.Settings.ServerUri, HttpMethod.Post, ContentTypeTextXml, xml, new Dictionary <string, string>(), new NetworkCredential(username, password)); if (response.Response.IsSuccessStatusCode) { var parser = new TResponseParser(); parser.ParseResponse(this.CommandName, response); return(ResponseResult <TResponseParser> .Create(parser, this.Settings.ServerUri)); } else if (!secondTry && response.Response.StatusCode == HttpStatusCode.Unauthorized && this.Settings.Email != null && this.Settings.Username != this.Settings.Email) { // one more try using email for authentication return(await this.SendRequestAsync(xml, this.Settings.Email, this.Settings.Password, true)); } else { return(this.CreateResponseResult(null, response, this.Settings.ServerUri)); } } catch (Exception ex) { return(this.CreateResponseResult(ex, response, this.Settings.ServerUri)); } }
protected ResponseResult <TResponseParser> CreateResponseResult(Exception exception, WebRequestResponse response, string uri) { string exceptionMessage = null; string statusCodeMessage = null; if (exception != null) { exceptionMessage += $"Exception: {exception.Message}"; if (!string.IsNullOrWhiteSpace(exception.InnerException?.Message)) { exceptionMessage += $" ({exception.InnerException.Message})."; } else { exceptionMessage += "."; } } if (response != null) { if (response.Response.StatusCode != HttpStatusCode.OK) { if (response.Response.StatusCode == HttpStatusCode.Unauthorized) { statusCodeMessage = "Got 'Unauthorized' response status code, check credentials (email, login, password) are correct."; } else { statusCodeMessage = $"Got '{response.Response.StatusCode}' response status code."; } } } HttpResponseMessage responseMessage = null; if (response != null && response.Response != null) { responseMessage = response.Response; } string message = exceptionMessage; if (statusCodeMessage != null) { if (message != null) { message += exceptionMessage; } else { message = statusCodeMessage; } } return(ResponseResult <TResponseParser> .Create( new CommandException($"Error while executing '{this.CommandName}'", message, exception, responseMessage), uri)); }
protected abstract void ParseResponseCore(string commandName, XDocument document, WebRequestResponse response);
private static void _req(string uri, HttpRequestMethod method, Dictionary <string, string> form, WebRequestResponse webReqResponse) { var webReq = (HttpWebRequest)NetWebRequest.Create(uri); webReq.Method = method.ToString(); webReq.ContentType = "application/x-www-form-urlencoded"; var reqData = Encoding.UTF8.GetBytes(_flattenForm(form)); webReq.ContentLength = reqData.Length; Worker.StartWorker((out object result) => { try { if (webReq.Method != "GET") { using (var stream = webReq.GetRequestStream()) { stream.Write(reqData, 0, reqData.Length); } } var response = (HttpWebResponse)webReq.GetResponse(); var webResponseData = new WebRequestResponseData(); bool success = ((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300; webResponseData.isSuccess = success; webResponseData.code = (int)response.StatusCode; webResponseData.data = new byte[0]; if (response != null) { using (var mem = new MemoryStream()) { using (var stream = response.GetResponseStream()) { while (true) { var data = stream.ReadByte(); if (data == -1) { break; } mem.WriteByte((byte)data); } webResponseData.data = mem.ToArray(); } } } result = webResponseData; response.Close(); } catch (WebException e) { var response = (HttpWebResponse)e.Response; var webResponseData = new WebRequestResponseData(); webResponseData.isSuccess = false; webResponseData.code = response != null ? (int)response.StatusCode : 404; webResponseData.data = new byte[0]; result = webResponseData; response?.Close(); } return(true); }, (e, result) => { if (e != null && !string.IsNullOrEmpty(e.Message)) { Console.WriteLine("WebRequest Error: " + e); } webReqResponse?.Invoke(result as WebRequestResponseData); }); }
public static void GET(string uri, Dictionary <string, string> form, WebRequestResponse OnComplete) { _req(uri, HttpRequestMethod.GET, form, OnComplete); }
public void ParseResponse(string commandName, WebRequestResponse response) { if (response.Response.StatusCode == HttpStatusCode.Unauthorized) { throw new CommandAuthorizationException(string.Format("Authorization failed: {0}", response.Response.ReasonPhrase)); } if (response.Response.IsSuccessStatusCode) { string xml = response.ResponseBody; string xmlValidationErrorMessage; if (!EwsXmlHelper.IsValidXml(xml, out xmlValidationErrorMessage)) { throw new CommandResponseXmlException(string.Format("Invalid xml content: {0}", xmlValidationErrorMessage)); } XDocument xdoc = XDocument.Load(new StringReader(xml)); var responseMessages = xdoc.Root.XGetChildrenOf(string.Format("Body/{0}Response/ResponseMessages", commandName)); var ewsResponseMessages = new List <EwsResponseMessage>(); foreach (var responseMessage in responseMessages) { var ewsResponseMessage = new EwsResponseMessage { Class = responseMessage.XGetAttributeValue <EwsResponseClass>("ResponseClass"), Code = responseMessage.XGetChildValue <string>("ResponseCode", true), Message = responseMessage.XGetChildValue <string>("MessageText", true), Content = responseMessage }; if (ewsResponseMessage.Class != EwsResponseClass.Success || ewsResponseMessage.Code != ResponseCodeNoError) { string message = string.Format("response is invalid (class: {0} code: {1} message: {2}) content: {3})", ewsResponseMessage.Class, ewsResponseMessage.Code, ewsResponseMessage.Message, responseMessage); Log(commandName, message); if (OnInvalidResponse != null) { OnInvalidResponse(this, new EventArgs <string>(message)); } } ewsResponseMessages.Add(ewsResponseMessage); } try { this.ParseResponseCore(ewsResponseMessages); } catch (Exception ex) { throw new CommandResponseException(string.Format("Failed to parse {0} response", commandName), ex); } } else { Log(commandName, string.Format("response does not have HTTP sucess status code (code: {0})", response.Response.StatusCode)); EwsFault fault = null; string xml; try { xml = response.ResponseBody; XDocument xdoc = XDocument.Load(new StringReader(xml)); fault = this.ExtractFault(xdoc); Log(commandName, string.Format("fault: " + fault)); } catch (Exception) { response.Response.Content.ReadAsStringAsync().ContinueWith(r => Log(commandName, string.Format("response: " + r.Result))); } throw new CommandResponseException(string.Format("Failed to read {0} response, fault: {1}", commandName, fault != null ? fault.ToString() : "unknown fault")); } }
protected override void ParseResponseCore(string commandName, XDocument document, WebRequestResponse response) { this.Status = document.Element("Provision").Element("Policies").Element("Policy").Element("Status").Value; this.PolicyKey = document.Element("Provision").Element("Policies").Element("Policy").Element("PolicyKey").Value; }
protected override void ParseResponseCore(string commandName, XDocument document, WebRequestResponse response) { if (document == null) { // no changes, leave the object as is this.Status = "1"; return; } if (document.Element("Sync").Elements("Status").Any()) { this.Status = document.Element("Sync").Element("Status").Value; LogService.LogFormat("SyncCommandResult", "General status not OK : {0}", this.Status); // we detect and are able to react to provisioning error status code if (!ActiveSyncErrorHelper.IsStatusProvisioningError(this.Status, null)) { if (Debugger.IsAttached) { Debugger.Break(); } if (InvalidStatusFound != null) { InvalidStatusFound(this, new EventArgs <string>($"Status: {this.Status}")); } } return; } var collection = document.Element("Sync").Element("Collections").Element("Collection"); this.SyncKey = collection.Element("SyncKey").Value; this.Status = collection.Element("Status").Value; this.MoreAvailable = collection.Elements("MoreAvailable").Any(); this.ManageServerChanges(collection); this.ManageClientAcknowledgement(collection, response); LogService.LogFormat("SyncCommandResult", "status: {0} sync key: {1} more: {2}", this.Status, this.SyncKey.TakeLast(5), this.MoreAvailable.ToString()); }
public WebRequestResponse DoGetRequest(WebRequestData requestData, Microsoft.Xrm.Sdk.ITracingService trace) { try { #region debug log this.LogPluginFeedback(new LogClass { Exception = "", Level = "debug", ClassName = this.GetType().ToString(), MethodName = System.Reflection.MethodBase.GetCurrentMethod().Name, Message = $"GETing Url:{requestData.Url}", ProcessId = "" }, trace); #endregion debug log } catch (Exception exc) { } WebRequestResponse wrResponse = new WebRequestResponse(); try { try { using (WebClient client = new WebClient()) { var webClient = new WebClient(); if (requestData.ContentType != "") { webClient.Headers[HttpRequestHeader.ContentType] = requestData.ContentType; } if (requestData.Authorization != "") { webClient.Headers[HttpRequestHeader.Authorization] = requestData.Authorization; } // var code = "key"; string serviceUrl = requestData.Url; wrResponse.Data = webClient.DownloadString(serviceUrl); if (wrResponse.Data != "") { wrResponse.IsSuccessful = true; //TODO:ELiminar para Produccion try { this.LogPluginFeedback(new LogClass { Exception = "", Level = "debug", ClassName = this.GetType().ToString(), MethodName = System.Reflection.MethodBase.GetCurrentMethod().Name, Message = $"Url:{requestData.Url} ResponseFromRequest:{wrResponse.Data}", ProcessId = "" }, trace); } catch (Exception e) { } } } } catch (WebException wex) { string error = ""; string statusCode = ""; if (wex.Response != null) { using (var errorResponse = (HttpWebResponse)wex.Response) { using (var reader = new StreamReader(errorResponse.GetResponseStream())) { error = reader.ReadToEnd(); } } } #region error log this.LogPluginFeedback(new LogClass { Exception = wex.ToString(), Level = "error", ClassName = this.GetType().ToString(), MethodName = System.Reflection.MethodBase.GetCurrentMethod().Name, Message = $"{error}", ProcessId = "" }, trace); #endregion error log wrResponse.Data = null; wrResponse.ErrorMessage = wex.ToString(); wrResponse.IsSuccessful = false; } } catch (Exception ex) { this.LogPluginFeedback(new LogClass { Exception = ex.ToString(), Level = "error", ClassName = this.GetType().ToString(), MethodName = System.Reflection.MethodBase.GetCurrentMethod().Name, Message = $"Excepción realizando el POST request", ProcessId = "" }, trace); trace.Trace($"MethodName: {new System.Diagnostics.StackTrace(ex).GetFrame(0).GetMethod().Name}|--|Exception: " + ex.ToString()); wrResponse.Data = null; wrResponse.IsSuccessful = false; wrResponse.ErrorMessage = ex.ToString(); } return(wrResponse); }
protected override void ParseResponseCore(string commandName, XDocument document, WebRequestResponse response) { XElement folderElement = document.Element("FolderSync"); if (folderElement != null) { XElement keyElement = folderElement.Element("SyncKey"); if (keyElement != null) { this.SyncKey = keyElement.Value; } XElement statusElement = folderElement.Element("Status"); if (statusElement != null) { this.Status = statusElement.Value; } FillFolderList(document, "Add", this.AddedFolders); FillFolderList(document, "Update", this.ModifiedFolders); FillFolderList(document, "Delete", this.DeletedFolders); } }