private static byte[] GetFormData <TSuccess, TError>( ref RequestResponseSummary <TSuccess, TError> summary, params FormParameter[] parms) { var sb = new StringBuilder(); bool firstTime = true; foreach (var parm in parms) { if (firstTime) { firstTime = false; } else { sb.Append("&"); } sb.Append(parm.Name); sb.Append("="); sb.Append(parm.Value); } summary.SerializedRequest = sb.ToString(); var formData = Encoding.Unicode.GetBytes(sb.ToString()); return(formData); }
private void BuildPayload <TSuccess, TError>( object payload, string serializedPayload, IEnumerable <FormParameter> formPameters, HttpWebRequest httpWebRequest, ref RequestResponseSummary <TSuccess, TError> summary ) { if (payload != null) { serializedPayload = _serializer.Serialize(payload); } if (!string.IsNullOrEmpty(serializedPayload)) { if (summary != null) { summary.SerializedRequest = serializedPayload; if (httpWebRequest.Headers.AllKeys.Any()) { var requestHeaders = new List <Header>(); foreach (var whr in httpWebRequest.Headers.AllKeys) { var header = new Header(); header.Name = whr; header.Value = httpWebRequest.Headers[whr]; requestHeaders.Add(header); } summary.RequestHeaders = requestHeaders; } } // TODO: Really make this an Async behavior var asyncResult = httpWebRequest.GetRequestStreamAsync(); using (var stream = new StreamWriter(asyncResult.Result)) { stream.Write(serializedPayload); } } if (formPameters != null && formPameters.Count() > 0) { var formData = GetFormData(ref summary, formPameters.ToArray()); // TODO: Really make this an Async behavior var asyncResult = httpWebRequest.GetRequestStreamAsync(); using (var stream = asyncResult.Result) { stream.Write(formData, 0, formData.Length); } } }
/// <summary> /// Processes the response. /// </summary> /// <returns>The response.</returns> /// <param name="summary">Summary.</param> /// <param name="response">Response.</param> /// <typeparam name="TSuccess">The 1st type parameter.</typeparam> /// <typeparam name="TError">The 2nd type parameter.</typeparam> private RequestResponseSummary <TSuccess, TError> ProcessResponse <TSuccess, TError>( ref RequestResponseSummary <TSuccess, TError> summary, WebResponse response) { var httpResponse = (HttpWebResponse)response; summary.Status = httpResponse.StatusCode; using (var streamReader = new StreamReader(httpResponse.GetResponseStream())) { var responseText = streamReader.ReadToEnd(); summary.SerializedResponse = responseText; if (response.Headers.AllKeys.Any()) { var responseHeaders = new List <Header>(); foreach (var wrh in response.Headers.AllKeys) { var header = new Header(); header.Name = wrh; header.Value = response.Headers[wrh]; responseHeaders.Add(header); } summary.ResponseHeaders = responseHeaders; } if (string.IsNullOrWhiteSpace(responseText)) { summary.Results = default(TSuccess); return(summary); } try { if (typeof(TSuccess).Name == "String") { summary.Results = (TSuccess)Convert.ChangeType(responseText.Trim(), typeof(TSuccess)); return(summary); } else { summary.Results = _deserializer.Deserialize <TSuccess>(responseText); return(summary); } } catch (Exception ex2) { summary.UnhandledError = ex2.Message; return(null); } } }
/// <summary> /// TODO: Could probably consolidate with ExecuteRestMethod if formParameters can be &= or multiparted. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="summary"></param> /// <param name="httpWebRequest"></param> /// <returns></returns> private static void SubmitResponseUsing <TSuccess, TError>( ref RequestResponseSummary <TSuccess, TError> summary, HttpWebRequest httpWebRequest ) { var asyncresponse = httpWebRequest.GetResponseAsync(); // TODO: Implement a true Async experience using (var response = asyncresponse.Result) { ProcessResponse <TSuccess, TError>( summary: ref summary, response: response); } }
private static void HandleWebException <TSuccess, TError>( ref RequestResponseSummary <TSuccess, TError> summary, string url, WebException ex) { if (ex.Response != null) { var httpResponse = (HttpWebResponse)ex.Response; summary.Status = httpResponse.StatusCode; using (var stream = httpResponse.GetResponseStream()) { string errorText = null; using (var reader = new StreamReader(stream)) { errorText = reader.ReadToEnd(); summary.SerializedResponse = errorText; } try { if (typeof(TError).Name == "String") { summary.Error = (TError)Convert.ChangeType(errorText, typeof(TError)); } else { var errorObject = _serializer.Deserialize <TError>(errorText); summary.Error = errorObject; return; } } catch (Exception ex2) { summary.UnhandledError = ex2.Message; return; } } } summary.Status = 0; summary.UnhandledError = ex.Message; }
/// <summary> /// Submits the request dispose. /// </summary> /// <param name="summary">Summary.</param> /// <param name="httpWebRequest">Http web request.</param> /// <typeparam name="TSuccess">The 1st type parameter.</typeparam> /// <typeparam name="TError">The 2nd type parameter.</typeparam> private static void SubmitRequestDispose <TSuccess, TError>( ref RequestResponseSummary <TSuccess, TError> summary, HttpWebRequest httpWebRequest) { var asyncResponse = httpWebRequest.GetResponseAsync(); // TODO: Should probably change this to suppor true Async behavior. var response = asyncResponse.Result; try { ProcessResponse <TSuccess, TError>( summary: ref summary, response: response); } finally { if (response != null) { response.Dispose(); } } }
private static void BuildPayload <TSuccess, TError>( object payload, string serializedPayload, List <FormParameter> formPameters, HttpWebRequest httpWebRequest, ref RequestResponseSummary <TSuccess, TError> summary ) { if (payload != null) { serializedPayload = _serializer.Serialize(payload); } if (!string.IsNullOrEmpty(serializedPayload)) { if (summary != null) { summary.SerializedRequest = serializedPayload; } // TODO: Really make this an Async behavior var asyncResult = httpWebRequest.GetRequestStreamAsync(); using (var stream = new StreamWriter(asyncResult.Result)) { stream.Write(serializedPayload); } } if (formPameters != null && formPameters.Count() > 0) { var formData = GetFormData(ref summary, formPameters.ToArray()); // TODO: Really make this an Async behavior var asyncResult = httpWebRequest.GetRequestStreamAsync(); using (var stream = asyncResult.Result) { stream.Write(formData, 0, formData.Length); } } }
/// <summary> /// Processes the response. /// </summary> /// <returns>The response.</returns> /// <param name="summary">Summary.</param> /// <param name="response">Response.</param> /// <typeparam name="TSuccess">The 1st type parameter.</typeparam> /// <typeparam name="TError">The 2nd type parameter.</typeparam> private static RequestResponseSummary <TSuccess, TError> ProcessResponse <TSuccess, TError>( ref RequestResponseSummary <TSuccess, TError> summary, WebResponse response) { var httpResponse = (HttpWebResponse)response; summary.Status = httpResponse.StatusCode; using (var streamReader = new StreamReader(httpResponse.GetResponseStream())) { var responseText = streamReader.ReadToEnd(); summary.SerializedResponse = responseText; if (string.IsNullOrWhiteSpace(responseText)) { summary.Results = default(TSuccess); return(summary); } try { if (typeof(TSuccess).Name == "String") { summary.Results = (TSuccess)Convert.ChangeType(responseText.Trim(), typeof(TSuccess)); return(summary); } else { summary.Results = _serializer.Deserialize <TSuccess>(responseText); return(summary); } } catch (Exception ex2) { summary.UnhandledError = ex2.Message; return(null); } } }
/// <summary> /// Executes the rest method. /// </summary> /// <returns>The rest method.</returns> /// <param name="uri">URI.</param> /// <param name="verb">Verb.</param> /// <param name="userAgent">User agent.</param> /// <param name="payload">Payload.</param> /// <param name="serializedPayload">Serialized payload.</param> /// <param name="parameters">Parameters.</param> /// <param name="headers">Headers.</param> /// <param name="username">Username.</param> /// <param name="password">Password.</param> /// <param name="accept">Accept.</param> /// <param name="cookieContainer">Cookie container.</param> /// <param name="contentType">Content type.</param> /// <typeparam name="TSuccess">The 1st type parameter.</typeparam> /// <typeparam name="TError">The 2nd type parameter.</typeparam> public static RequestResponseSummary <TSuccess, TError> ExecuteRestMethod <TSuccess, TError>( Uri uri, HttpVerbs verb, string userAgent, object payload = null, string serializedPayload = null, List <FormParameter> parameters = null, List <Header> headers = null, string username = null, string password = null, string accept = null, CookieContainer cookieContainer = null, string contentType = "application/json" ) { string url = uri.ToString(); string method = verb.ToString(); if (payload != null && !string.IsNullOrEmpty(serializedPayload) && parameters != null) { throw new ArgumentOutOfRangeException("payload, serializedPayload, and pameters are mutually exclusive."); } if (string.IsNullOrEmpty(url)) { throw new ArgumentNullException("url"); } var summary = new RequestResponseSummary <TSuccess, TError>(); try { var httpWebRequest = (HttpWebRequest)WebRequest.Create(url); ManageHeaders( httpWebRequest: httpWebRequest, method: method, headers: headers, username: username, password: password, accept: accept, contentType: contentType, userAgent: userAgent, cookieContainer: cookieContainer ); BuildPayload(payload, serializedPayload, parameters, httpWebRequest, ref summary); SubmitResponseUsing <TSuccess, TError>(ref summary, httpWebRequest); return(summary); } catch (WebException ex) { HandleWebException <TSuccess, TError>( summary: ref summary, url: url, ex: ex); return(summary); } catch (Exception ex) { summary.Results = default(TSuccess); summary.UnhandledError = ex.Message; summary.Status = 0; return(summary); } }
/// <summary> /// Submits the multipart form. /// </summary> /// <returns>The multipart form.</returns> /// <param name="uri">URI.</param> /// <param name="verb">Verb.</param> /// <param name="userAgent">User agent.</param> /// <param name="encoding">Encoding.</param> /// <param name="uploadFile">Upload file.</param> /// <param name="headers">Headers.</param> /// <param name="parameters">Parameters.</param> /// <param name="username">Username.</param> /// <param name="password">Password.</param> /// <param name="accept">Accept.</param> /// <param name="contentType">Content type.</param> /// <param name="cookieContainer">Cookie container.</param> /// <typeparam name="TSuccess">The 1st type parameter.</typeparam> /// <typeparam name="TError">The 2nd type parameter.</typeparam> public static RequestResponseSummary <TSuccess, TError> SubmitMultipartForm <TSuccess, TError>( Uri uri, HttpVerbs verb, string userAgent, Encoding encoding = null, string uploadFile = null, List <Header> headers = null, List <FormParameter> parameters = null, string username = null, string password = null, string accept = null, string contentType = "multipart/form-data", CookieContainer cookieContainer = null ) { var method = verb.ToString(); var summary = new RequestResponseSummary <TSuccess, TError>(); try { if (encoding == null) { encoding = Encoding.UTF8; } var httpWebRequest = WebRequest.Create(uri) as HttpWebRequest; if (httpWebRequest == null) { throw new NullReferenceException("request is not a http request"); } string formDataBoundary = "--" + DateTime.Now.ToString("ssfff"); contentType = string.Format("{0}; boundary={1}", contentType, formDataBoundary); ManageHeaders( httpWebRequest: httpWebRequest, method: method, headers: headers, username: username, password: password, accept: accept, contentType: contentType, userAgent: userAgent, cookieContainer: cookieContainer ); BuildMultiPartPayload( encoding: encoding, parameters: parameters, contentType: contentType, request: httpWebRequest, formDataBoundary: formDataBoundary); SubmitRequestDispose <TSuccess, TError>( summary: ref summary, httpWebRequest: httpWebRequest); return(summary); } catch (WebException ex) { HandleWebException <TSuccess, TError>( summary: ref summary, url: uri.ToString(), ex: ex); return(summary); } catch (Exception ex) { summary.SerializedResponse = ex.Message; summary.Status = 0; summary.UnhandledError = ex.Message; return(summary); } }