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);
}
}
