public static async Task PrintRequest(HttpRequestMessage request){
Debug ("REQUEST:");
Debug (request.ToString ());
if (request.Content != null) {
Debug (await request.Content.ReadAsStringAsync ());
}
}
protected override async Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken cancellationToken)
{
string requestString = request.ToString();
string requestBody = "";
if (request.Content != null)
requestBody = await request.Content.ReadAsStringAsync();
bool wasError;
//let other handlers process the request
return await base.SendAsync(request, cancellationToken)
.ContinueWith(task =>
{
string responseBody ="";
if (task.Result.Content != null)
responseBody = task.Result.Content.ReadAsStringAsync().Result;
wasError = task.Result.StatusCode >= HttpStatusCode.BadRequest;
Logger.Instance.WriteToLog("Request: " +
DateTime.UtcNow.ToString("G") + " " + requestString + "\r\n" + "Request body: " + requestBody, wasError);
Logger.Instance.WriteToLog("Response body: " +
DateTime.UtcNow.ToString("G") + " " + responseBody, wasError);
return task.Result;
});
}
public async Task<bool> getSessionCookieAsync()
{
Debug.WriteLine("I'm here");
HttpClient request = null;
HttpResponseMessage response = null;
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post,
ApplicationModel.Current.Domain + "/claroline/auth/login.php");
Debug.WriteLine("Message : " + message.ToString());
CallbackArgs args = new CallbackArgs() { login = ApplicationModel.Current.Login, password = ApplicationModel.Current.Password, operation = AllowedOperations.authenticate };
StringContent content = new StringContent(args.ToString());
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-www-form-urlencoded");
message.Content = content;
request = getClient();
response = await request.SendAsync(message);
Debug.WriteLine("getSessionCookie : " + response.StatusCode);
bool empty = String.IsNullOrEmpty(await response.Content.ReadAsStringAsync());
if (empty)
{
CookieCreation = DateTime.Now;
}
Debug.WriteLine("empty : " + empty.ToString());
return empty;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
var requestHeaders = request.ToString();
var requestBody = request.Content.ReadAsStringAsync().Result;
var fullRequest = requestHeaders + "\r\n\r\n" + requestBody + "\r\n\r\n";
return base.SendAsync(request, cancellationToken)
.ContinueWith(task =>
{
var response = task.Result;
if (task.Result.StatusCode == HttpStatusCode.InternalServerError || task.Result.StatusCode == HttpStatusCode.BadRequest)
{
var responseHeaders = task.Result.ToString();
var responseBody = task.Result.Content.ReadAsStringAsync().Result;
var fullResponse = responseHeaders + "\r\n\r\n" + responseBody;
response.Content = new StringContent(fullRequest + fullResponse);
}
return response;
}, cancellationToken);
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Utilidades.EscribirLog("Petición--------->>> "+request.ToString());
var response = await base.SendAsync(request, cancellationToken);
Utilidades.EscribirLog("Respuesta-------->>> " + response.ToString());
return response;
}
protected override async Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken cancellationToken)
{
Console.WriteLine(request.ToString());
var response = await base.SendAsync(request, cancellationToken);
var msg = string.Format("{0} {1}", response.StatusCode, response.ReasonPhrase);
Console.WriteLine(msg);
return response;
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Utils.WriteLog("Peticion -> " + request.ToString());
var reponse = await base.SendAsync(request, cancellationToken);
Utils.WriteLog("Respuesta -> " + reponse.ToString());
return reponse;
}
private static void Main(string[] args) {
var request =
new HttpRequestMessage(HttpMethod.Get,
new Uri("http://apress.com"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/html"));
request.Headers.Add("X-Name", "Microsoft");
Console.WriteLine(request.ToString());
Console.ReadLine();
}
public async Task SetRequestAsync(HttpRequestMessage request)
{
_requestLog.Headers = request.ToString();
if (request.Content != null)
{
_requestLog.Body = await request.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
}
_requestLog.StartedAt = DateTime.Now;
_stopwatch.Start();
}
public void Ctor_Default ()
{
var m = new HttpRequestMessage ();
Assert.IsNull (m.Content, "#1");
Assert.IsNotNull (m.Headers, "#2");
Assert.AreEqual (HttpMethod.Get, m.Method, "#3");
Assert.IsNotNull (m.Properties, "#4");
Assert.IsNull (m.RequestUri, "#5");
Assert.AreEqual (new Version (1, 1), m.Version, "#6");
Assert.AreEqual ("Method: GET, RequestUri: '<null>', Version: 1.1, Content: <null>, Headers:\r\n{\r\n}", m.ToString (), "#7");
}
protected override HttpRequestMessage ProcessRequest(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request != null)
{
this.logger.LogMessage(request.ToString(), Severity.Informational, Verbosity.Detailed);
if (request.Content != null)
{
this.logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Payload: {0} ", request.Content.ReadAsStringAsync().Result), Severity.Informational, Verbosity.Detailed);
}
}
return request;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) {
if (request.Method == HttpMethod.Trace) {
return Task<HttpResponseMessage>.Factory.StartNew(
() => {
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent(request.ToString(), Encoding.UTF8, "message/http");
return response;
});
}
return base.SendAsync(request, cancellationToken);
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Trace.WriteLine("Request:");
Trace.WriteLine(request.ToString());
if (request.Content != null)
Trace.WriteLine(await request.Content.ReadAsStringAsync());
var response = await base.SendAsync(request, cancellationToken);
Trace.WriteLine("Response:");
Trace.WriteLine(response.ToString());
if (response.Content != null)
Trace.WriteLine(await response.Content.ReadAsStringAsync());
return response;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var serialized = new HttpMessageContent(request).ReadAsByteArrayAsync().Result;
var ms = new MemoryStream(serialized);
var request2 = new HttpRequestMessage();
request2.Content = new ByteArrayContent(ms.ToArray());
request2.Content.Headers.Add("Content-Type", "application/http;msgtype=request");
var r3 = request2.Content.ReadAsHttpRequestMessageAsync(cancellationToken).Result;
Console.WriteLine(request.ToString());
Console.WriteLine(r3.ToString());
Console.WriteLine(r3.Content.ReadAsStringAsync().Result);
var response = new HttpResponseMessage(HttpStatusCode.Accepted);
return Task.FromResult(response);
}
static void Main(string[] args)
{
HttpRequestMessage request = new HttpRequestMessage();
Console.WriteLine(request.ToString());
string a = "dsfsadfa";
a = null;
string tokenDetailsString = string.Empty;
using (StreamReader sr = new StreamReader(""))
{
tokenDetailsString = sr.ReadToEnd();
}
}
protected override System.Threading.Tasks.Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
System.Threading.CancellationToken cancellationToken)
{
// CATCH THE REQUEST BEFORE SENDING TO THE ROUTING HANDLER
var headers = request.ToString();
var body = request.Content.ReadAsStringAsync().Result;
var fullRequest = headers + "\n" + body;
// SETUP A CALLBACK FOR CATCHING THE RESPONSE - AFTER ROUTING HANDLER, AND AFTER CONTROLLER ACTIVITY
return base.SendAsync(request, cancellationToken)
.ContinueWith(task =>
{
// GET THE COPY OF THE TASK, AND PASS TO A CUSTOM ROUTINE
ResponseHandler(task);
// RETURN THE ORIGINAL RESULT
var response = task.Result;
return response;
}, cancellationToken);
}
public void RecordAttendance(string requestPart, Action <bool>callback)
{
var request = new HttpRequestMessage (HttpMethod.Post, "api/workshop/attendance?StudentId=" + Info.StudentId + "&" + requestPart);
server.SendRequest (request, (string resultsRead) => {
try
{
Debug.WriteLine(request.ToString());
JObject results = JObject.Parse (resultsRead);
Debug.WriteLine(results.ToString());
callback(results["IsSuccess"].ToString().Equals("True"));
}
catch (Exception e)
{
}
});
}
/// <summary>
/// 以异步操作发送 HTTP 请求到内部管理器以发送到服务器。
/// </summary>
/// <param name="request">要发送到服务器的 HTTP 请求消息。</param>
/// <param name="cancellationToken">取消操作的取消标记。</param>
/// <returns>
/// 返回 <see cref="T:System.Threading.Tasks.Task`1" />。 表示异步操作的任务对象。
/// </returns>
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
log.Debug("Request:");
log.Debug(request.ToString());
if (request.Content != null)
{
log.Debug(await request.Content.ReadAsStringAsync());
}
HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
log.Debug("Response:");
log.Debug(response.ToString());
if (response.Content != null)
{
log.Debug(await response.Content.ReadAsStringAsync());
}
return response;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
Console.WriteLine("Request {0}", request.ToString());
if (request.Content != null)
{
Console.WriteLine("Request Content: {0}", request.Content.ReadAsStringAsync().Result);
}
base.SendAsync(request, cancellationToken).ContinueWith(
innerTask =>
{
if (innerTask.IsCanceled)
{
Console.WriteLine("Task is cancelled, no response.");
tcs.SetCanceled();
}
else if (innerTask.IsFaulted)
{
Console.WriteLine("Task is faulted, no response.");
tcs.SetException(innerTask.Exception.InnerExceptions);
}
else if (innerTask.IsCompleted)
{
var response = innerTask.Result;
Console.WriteLine("Response {0}", response.ToString());
if (response.Content != null)
{
Console.WriteLine("Respose Content: {0}", response.Content.ReadAsStringAsync().Result);
}
tcs.SetResult(innerTask.Result);
}
});
return tcs.Task;
}
public void SendRequest(string invocationId, HttpRequestMessage request)
{
Write("{0}: SendRequst {1}", invocationId, request.ToString());
}
private void btnSearch_Click(object sender, EventArgs e)
{
// setup variables for response time
DateTime responseReceived = new DateTime();
DateTime requestStarted = new DateTime();
try
{
Cursor = Cursors.WaitCursor;
ClearResponseTree();
// get the request url and request method
string graphRequest = tbRequestUrl.Text;
HttpMethod HttpRequestMethod;
switch (cmbHttpMethod.Text)
{
case "GET":
HttpRequestMethod = HttpMethod.Get;
break;
case "POST":
HttpRequestMethod = HttpMethod.Post;
break;
case "PUT":
HttpRequestMethod = HttpMethod.Put;
break;
case "HEAD":
HttpRequestMethod = HttpMethod.Head;
break;
case "OPTIONS":
HttpRequestMethod = HttpMethod.Options;
break;
default:
HttpRequestMethod = HttpMethod.Delete;
break;
}
// create the http request and add the access token in the header
HttpRequestMessage request = new HttpRequestMessage(HttpRequestMethod, graphRequest);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", result.AccessToken);
// check for diagnostics flag
if (Properties.Settings.Default.OutlookDiagnostics == "On")
{
AddRequestHeader("Prefer", "outlook.diagnostics");
}
// add headers to the request
foreach (DataGridViewRow row in dgRequestHeaders.Rows)
{
request.Headers.Add(row.Cells[0].Value.ToString(), row.Cells[1].Value.ToString());
}
// check for a request body
if (tbRequestBody.Text != "")
{
request.Content = new StringContent(tbRequestBody.Text, System.Text.Encoding.UTF8, "application/json");
}
logger.Log("REQUEST HEADER:");
logger.Log(request.Headers.ToString());
logger.Log("REQUEST:");
logger.Log(request.ToString());
// get the current time for response time calculation
requestStarted = DateTime.Now;
// start processing the response
HttpResponseMessage response = httpClient.SendAsync(request).Result;
// get the current time again to figure out the response time
responseReceived = DateTime.Now;
// calculate the number of milliseconds that the request took to complete
TimeSpan milliseconds = responseReceived.Subtract(requestStarted);
logger.Log("RESPONSE TIME = " + milliseconds);
// handle non-successful requests
if (!response.IsSuccessStatusCode)
{
string errorJsonContent = response.Content.ReadAsStringAsync().Result;
JObject jResult = JObject.Parse(errorJsonContent);
// check for odata error
if (jResult["odata.error"] != null)
{
throw new Exception((string)jResult["odata.error"]["message"]["value"]);
}
// check for null result
if (jResult[""] != null)
{
logger.Log("## null response ##");
}
// log non-odata errors
logger.Log("RESPONSE JSON CONTENT:");
logger.Log(jResult.ToString());
// display error details in the UI
TreeNode errorParent = TreeViewHelper.Json2Tree(jResult);
errorParent.Text = "Request failed.";
treeViewResult = errorParent.ToString();
tvw.Nodes.Add(errorParent);
// finally throw the exception to prevent further processing of the request
throw new WebException(response.StatusCode.ToString() + ": " + response.ReasonPhrase);
}
// process successful request
string content = response.Content.ReadAsStringAsync().Result;
logger.Log("RESPONSE HEADER:");
logger.Log(response.Headers.ToString());
logger.Log("RESPONSE:");
if (response.StatusCode == HttpStatusCode.Accepted || response.StatusCode == HttpStatusCode.Created)
{
// POST responses that are successful return 202 Accepted or 201 Created,
// there is no response body so let the user know it was successful
tvw.Nodes.Add(new TreeNode("Message created/sent succesfully."));
logger.Log("StatusCode = " + response.StatusCode.ToString());
}
else if (response.StatusCode == HttpStatusCode.OK)
{
// GET responses should have a return type of xml or json
if (content[0] == '<')
{
// check for an xml response and populate the tree
// this is mainly for the metadata query
XmlDocument dom = new XmlDocument();
dom.LoadXml(content);
tvw.Nodes.Clear();
tvw.Nodes.Add(new TreeNode(dom.DocumentElement.Name));
TreeNode tNode = new TreeNode();
tNode = tvw.Nodes[0];
TreeViewHelper.AddNode(dom.DocumentElement, tNode);
treeViewResult = dom.ToString();
logger.Log(dom.ToString());
}
else
{
// if it isn't xml it should be json, populate the tree
JObject jResult = JObject.Parse(content);
if (jResult["odata.error"] != null)
{
throw new Exception((string)jResult["odata.error"]["message"]["value"]);
}
if (jResult[""] != null)
{
logger.Log("");
}
tvw.Nodes.Clear();
TreeNode parent = TreeViewHelper.Json2Tree(jResult);
parent.Text = "Root Object";
tvw.Nodes.Add(parent);
logger.Log(jResult.ToString());
treeViewResult = jResult.ToString();
}
}
else
{
// log anything that is not an OK or Accepted response, but also not an error
logger.Log(response.StatusCode.ToString());
}
}
catch (Exception ex)
{
logger.Log("Exception: " + ex.Message);
}
finally
{
// clear the headers
dgRequestHeaders.Rows.Clear();
Cursor = Cursors.Default;
}
}
public ActionResult BookingMessage(HttpRequestMessage request)
{
ViewBag.Message = request.ToString();
return View();
}
protected override async System.Threading.Tasks.Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
{
// Replace the RequestUri so it's not malformed
if (!request.RequestUri.AbsolutePath.Contains("/oauth"))
{
Console.Write(request.ToString());
request.RequestUri = new Uri(request.RequestUri.AbsoluteUri.Replace("?access_token", "&access_token"));
}
return await base.SendAsync(request, cancellationToken);
}
public override string ToString() => httpRequestMessage.ToString();
public void Headers_Response ()
{
HttpRequestMessage message = new HttpRequestMessage ();
HttpRequestHeaders headers = message.Headers;
headers.Add ("Age", "vv");
Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#1");
headers.Clear ();
headers.TryAddWithoutValidation ("Age", "vv");
Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#2");
Assert.AreEqual ("Method: GET, RequestUri: '<null>', Version: 1.1, Content: <null>, Headers:\r\n{\r\nAge: vv\r\n}", message.ToString (), "#3");
}
private async Task<HttpResponseMessage> RunAsync(string URI, HttpMethod verbe, HttpContent content) {
// string pwdHash = sha256.getHashSha256(Pwd);
string pwdHash = Pwd.sha256();
var credentials = new NetworkCredential(User, pwdHash);
using (HttpClientHandler handler = new HttpClientHandler { PreAuthenticate = true, Credentials = credentials })
using (HttpClient clientREST = new HttpClient(handler) { MaxResponseContentBufferSize = 1000000 }) {
clientREST.BaseAddress = new Uri(this.BaseURI);
clientREST.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var byteArray = Encoding.ASCII.GetBytes(User + ":" + pwdHash);
HttpRequestMessage request = new HttpRequestMessage(verbe, URI);
request.Headers.CacheControl = new CacheControlHeaderValue() { NoCache = true };
clientREST.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
if (content != null) {
request.Content = content;
}
var stp = request.ToString();
HttpResponseMessage response = clientREST.SendAsync(request).Result;
//retourne le contenu de la réponse, si il s'agit d'une erreur, elle doit être traîtée
return response;
}
}
private static void Format(StringBuilder message, HttpRequestMessage request, string header)
{
HandleErrorHelper.AppendHeader(message, header);
message.AppendLine(request == null ? HandleErrorHelper.NULL : request.ToString());
message.AppendLine();
}
public void Headers_Response ()
{
HttpRequestMessage message = new HttpRequestMessage ();
HttpRequestHeaders headers = message.Headers;
headers.Add ("Age", "vv");
Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#1");
headers.Clear ();
headers.TryAddWithoutValidation ("Age", "vv");
Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#2");
// .NET encloses the "Age: vv" with two whitespaces.
var normalized = Regex.Replace (message.ToString (), @"\s", "");
Assert.AreEqual ("Method:GET,RequestUri:'<null>',Version:1.1,Content:<null>,Headers:{Age:vv}", normalized, "#3");
}
