/// <summary>
/// <para>
/// Extends <see cref="HttpClient"/> by adding a method that can serialize and
/// transmit a <b>cadence-proxy</b> reply to a proxy request message.
/// </para>
/// <note>
/// This method ensures that the reply message's <see cref="ProxyReply.RequestId"/>
/// matches the request's <see cref="ProxyRequest.RequestId"/> before sending the
/// reply.
/// </note>
/// </summary>
/// <typeparam name="TRequest">The request message type.</typeparam>
/// <typeparam name="TReply">The reply message type.</typeparam>
/// <param name="client">The HTTP client.</param>
/// <param name="request">The request being responsed to.</param>
/// <param name="reply">The reply message.</param>
/// <returns>The <see cref="HttpResponse"/>.</returns>
public async static Task <HttpResponseMessage> SendReplyAsync <TRequest, TReply>(this HttpClient client, TRequest request, TReply reply)
where TRequest : ProxyRequest
where TReply : ProxyReply
{
Covenant.Requires <ArgumentNullException>(request != null, nameof(request));
Covenant.Requires <ArgumentNullException>(reply != null, nameof(reply));
Covenant.Requires <ArgumentException>(reply.Type == request.ReplyType, $"Reply message type [{reply.Type}] is not a suitable response for a [{request.Type}] request.", nameof(request));
reply.RequestId = request.RequestId;
var stream = reply.SerializeAsStream();
try
{
var content = new ByteArrayContent(stream.GetBuffer(), 0, (int)stream.Length);
content.Headers.ContentType = new MediaTypeHeaderValue(ProxyMessage.ContentType);
var httpRequest = new HttpRequestMessage(HttpMethod.Put, "/")
{
Content = content
};
return(await client?.SendAsync(httpRequest));
}
finally
{
MemoryStreamPool.Free(stream);
}
}
public static Task <HttpResponseMessage> PatchAsJsonAsync <T>(this HttpClient client, string requestUri, T value)
{
var content = new ObjectContent <T>(value, new JsonMediaTypeFormatter());
using var request = new HttpRequestMessage(HttpMethod.Patch, requestUri)
{
Content = content
};
return(client?.SendAsync(request));
}
/// <summary>
/// Reads the contents of a document from an HTTP source.
/// </summary>
/// <param name="requestMessage">The HTTP request message.</param>
/// <returns>The document contents from the HTTP source.</returns>
public async Task <string> ReadFromDocumentAsync(HttpRequestMessage requestMessage)
{
if (requestMessage == null)
{
throw new ArgumentNullException(nameof(requestMessage), "Value cannot be null.");
}
requestMessage.Method ??= HttpMethod.Get; // default is GET
using var httpResponseMessage = await _httpClient?.SendAsync(requestMessage);
var fileContents = await httpResponseMessage?.Content?.ReadAsStringAsync();
return(!httpResponseMessage.IsSuccessStatusCode ? throw new Exception(fileContents) : fileContents);
}
/// <summary>
/// Reads the contents of a document from an HTTP source.
/// </summary>
/// <param name="requestMessage">The HTTP request message.</param>
/// <returns>The document contents from the HTTP source.</returns>
public async Task <string> ReadFromDocumentAsync(HttpRequestMessage requestMessage)
{
UtilityFunctions.CheckArgumentNull(requestMessage, nameof(requestMessage));
requestMessage.Method ??= HttpMethod.Get; // default is GET
using var httpResponseMessage = await _httpClient?.SendAsync(requestMessage);
if (httpResponseMessage == null)
{
throw new InvalidOperationException("Invalid HttpRequestMessage provided");
}
return(await httpResponseMessage.Content?.ReadAsStringAsync());
}
private async Task ExchangeCodeForToken(string code)
{
//now what do we do with the code - we need to exchange it for tokens
Dictionary <string, object> oAuthMetadata = await GetOAuthMetadata(AppConfig.JohnDeereWellKnownUrl);
string tokenEndpoint = oAuthMetadata["token_endpoint"].ToString();
var queryParameters = new Dictionary <string, string>();
queryParameters.Add("grant_type", "authorization_code");
queryParameters.Add("code", code);
queryParameters.Add("redirect_uri", "cottonutil://localhost/callback");
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("authorization", $"Basic {GetBase64EncodedClientCredentials()}");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, tokenEndpoint)
{
Content = new FormUrlEncodedContent(queryParameters)
};
HttpResponseMessage response = await client.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
Token accessToken = JsonConvert.DeserializeObject <Token>(responseContent);
//need to save access token info
using (IUnitOfWorkDataProvider dp = AppStorage.GetUnitOfWorkDataProvider())
{
dp.Settings.UpsertSettingWithKey(SettingKeyType.JDAccessToken, accessToken.access_token);
dp.Settings.UpsertSettingWithKey(SettingKeyType.JDAccessTokenExpires, DateTime.UtcNow.AddSeconds(accessToken.expires_in).ToString());
dp.Settings.UpsertSettingWithKey(SettingKeyType.JDRefreshToken, accessToken.refresh_token);
dp.Settings.UpsertSettingWithKey(SettingKeyType.JDCredentialDateTime, DateTime.UtcNow.ToString());
dp.SaveChanges();
}
string organizationAccessUrl = await NeedsOrganizationAccess();
//if we received an organizationsAccessUrl we need to open a browser for user to give permission
//once completed browser will redirect to the call back
if (organizationAccessUrl != null)
{
ClearAuthResponseText();
ProcessStartInfo sInfo = new ProcessStartInfo(organizationAccessUrl);
Process.Start(sInfo);
}
else
{
if (openProcess != null && !openProcess.HasExited)
{
openProcess.CloseMainWindow();
if (this.ParentForm != null)
{
this.ParentForm.Focus();
}
}
verifyConnection();
}
}
private async Task<Version> SendRequestAndGetRequestVersionAsync(Version requestVersion)
{
Version receivedRequestVersion = null;
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
var request = new HttpRequestMessage(HttpMethod.Get, url);
request.Version = requestVersion;
using (var client = new HttpClient())
{
Task<HttpResponseMessage> getResponse = client.SendAsync(request);
await LoopbackServer.AcceptSocketAsync(server, async (s, stream, reader, writer) =>
{
string statusLine = reader.ReadLine();
while (!string.IsNullOrEmpty(reader.ReadLine())) ;
if (statusLine.Contains("/1.0"))
{
receivedRequestVersion = new Version(1, 0);
}
else if (statusLine.Contains("/1.1"))
{
receivedRequestVersion = new Version(1, 1);
}
else
{
Assert.True(false, "Invalid HTTP request version");
}
await writer.WriteAsync(
$"HTTP/1.1 200 OK\r\n" +
$"Date: {DateTimeOffset.UtcNow:R}\r\n" +
"Content-Length: 0\r\n" +
"\r\n");
s.Shutdown(SocketShutdown.Send);
});
using (HttpResponseMessage response = await getResponse)
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
});
return receivedRequestVersion;
}
/// <summary>
/// Sends an HTTP request to the given URL, and receives the response.
/// Note: This does not do a check to see if the currently stored creds are valid.
/// </summary>
/// <param name="url">The destination URL.</param>
/// <param name="method">The desired HTTP Request Method.</param>
/// <param name="data">The data to include in the message body.</param>
/// <param name="contentType">The Content-Type of the request. Default value is "application/json"</param>
/// <param name="timeout">How long to wait for the request to complete. Default wait time is 3 seconds.</param>
/// <returns>Returns the response text on success. Throws a WebException on failure.</returns>
private string SendHttpWebRequest(string url, HttpMethod method, string data, string contentType = "application/json", int timeout = 3000)
{
try
{
// CREATE REQUEST
using (HttpClient httpClient = new HttpClient())
{
HttpRequestMessage msg = new HttpRequestMessage(method, new Uri(url));
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
if (data != null)
{
msg.Content = new StringContent(data, Encoding.ASCII, contentType);
}
else if (!method.Equals(HttpMethod.Get))
{
msg.Content = new StringContent("", Encoding.ASCII, contentType);
}
// TODO: Does this work when creds are null?
// answer: no
//if (this.isAuthroized)
//{
// httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes("oy5ct3rjz7dob56syzaa65npbpumuvjm6d26fzdlupvighy2c4kq")));//":6cc3meg6fhnkbz22qocgetkndxrfjca76emcnanjodgiooir3xoq")));
//}
// GET RESPONSE
HttpResponseMessage resp = httpClient.SendAsync(msg).Result;
if (!resp.IsSuccessStatusCode)
{
throw new WebException("Error contacting serer. " + resp.ReasonPhrase);
}
return resp.Content.ReadAsStringAsync().Result;
}
}
catch (System.Net.WebException e)
{
this.LogTextBox.Text += "\r\n" + e.Message;
return null;
}
}
public static QueueResult NewQueue(PlexObject content, MyPlex.Server server)
{
//return object
var q = new QueueResult();
try
{
//connection details for the server
var ip = server.address;
var port = server.port;
const string protocol = @"http";
//Constants
const string type = @"VIDEO";
const int shuffle = 0;
const int repeat = 0;
const int continuous = 0;
const int own = 1;
//Dynamic
var uri = $"server://{server.machineIdentifier}/com.plexapp.plugins.library{content.ApiUri}";
//assemble URLs
var baseUri = $"{protocol}://{ip}:{port}";
const string resource = @"playQueues";
//HTTP request client
using (var httpClient = new HttpClient())
{
//new HTTP post request
using (var request = new HttpRequestMessage(new HttpMethod("POST"),
$"{baseUri}/{resource}?type={type}&shuffle={shuffle}" +
$"&repeat={repeat}&continuous={continuous}" +
$"&own={own}&uri={uri}"))
{
//add Plex client ID (unique GUID)
request.Headers.TryAddWithoutValidation("X-Plex-Client-Identifier",
GuidHandler.GetGlobalGuid().ToString());
//Plex authentication token
request.Headers.TryAddWithoutValidation("X-Plex-Token", server.accessToken);
//send the request and store the response
var response = httpClient.SendAsync(request).Result;
//did we succeed?
if (response.IsSuccessStatusCode)
{
//is the content valid?
if (response.Content != null)
{
//get the XML response string
var r = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
//XML class processor
var deserialiser = new XmlSerializer(typeof(MediaContainer));
//XML string reader
var stringReader = new StringReader(r);
//deserialised MediaContainer
var result = (MediaContainer)deserialiser.Deserialize(stringReader);
//close streams
stringReader.Close();
//setup QueueResult variables
q.QueueId = result.playQueueID.ToString();
q.QueueSuccess = true;
q.QueueObject = result;
q.QueueUri = $"/playQueues/{result.playQueueID}?own=1&window=200";
//UIMessages.Info(d.playQueueID);
//UIMessages.Info(q.QueueId);
}
}
}
}
}
catch (Exception ex)
{
//log the error
LoggingHelpers.RecordException(ex.Message, @"QueueAddError");
//alert the user
UIMessages.Error($"Error obtaining a new PlayQueue:\n\n{ex}");
}
//return QueueResult
return(q);
}
private async Task ProcessHttpRequest(
Uri proxyHostUri,
HttpProtocols protocol,
string contentString,
bool useContentLength,
int expectedCode,
bool cancelResponse,
bool contentRead,
Func <HttpResponseMessage, Task> responseAction = null)
{
using var handler = new SocketsHttpHandler()
{
Expect100ContinueTimeout = TimeSpan.FromSeconds(60)
};
handler.UseProxy = false;
handler.AllowAutoRedirect = false;
handler.SslOptions.RemoteCertificateValidationCallback = delegate { return(true); };
using var client = new HttpClient(handler);
using var message = new HttpRequestMessage(HttpMethod.Post, proxyHostUri);
message.Version = protocol == HttpProtocols.Http2 ? HttpVersion.Version20 : HttpVersion.Version11;
message.Headers.ExpectContinue = true;
var content = Encoding.UTF8.GetBytes(contentString);
using var contentStream = new MemoryStream(content);
message.Content = new StreamContent(contentStream);
if (useContentLength)
{
message.Content.Headers.ContentLength = content.Length;
}
else
{
message.Headers.TransferEncodingChunked = true;
}
if (!cancelResponse)
{
using var response = await client.SendAsync(message);
Assert.Equal(expectedCode, (int)response.StatusCode);
if (contentRead)
{
Assert.Equal(content.Length, contentStream.Position);
}
else
{
Assert.Equal(0, contentStream.Position);
}
if (responseAction != null)
{
await responseAction(response);
}
}
else
{
var exception = await Assert.ThrowsAsync <HttpRequestException>(() => client.SendAsync(message));
Assert.Equal(typeof(IOException), exception.InnerException.GetType());
Assert.Equal(content.Length, contentStream.Position);
}
}
public async Task SendRequest_UriPathHasReservedChars_ServerReceivedExpectedPath()
{
await LoopbackServer.CreateServerAsync(async (server, rootUrl) =>
{
var uri = new Uri($"http://{rootUrl.Host}:{rootUrl.Port}/test[]");
_output.WriteLine(uri.AbsoluteUri.ToString());
var request = new HttpRequestMessage(HttpMethod.Get, uri);
string statusLine = string.Empty;
using (var client = new HttpClient())
{
Task<HttpResponseMessage> getResponse = client.SendAsync(request);
List<string> receivedRequest = await LoopbackServer.ReadRequestAndSendResponseAsync(server);
using (HttpResponseMessage response = await getResponse)
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(receivedRequest[0].Contains(uri.PathAndQuery), $"statusLine should contain {uri.PathAndQuery}");
}
}
});
}
public async Task SendAsync_SendRequestUsingNoBodyMethodToEchoServerWithContent_NoBodySent(
string method,
bool secureServer)
{
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(
new HttpMethod(method),
secureServer ? Configuration.Http.SecureRemoteEchoServer : Configuration.Http.RemoteEchoServer)
{
Content = new StringContent(ExpectedContent)
};
using (HttpResponseMessage response = await client.SendAsync(request))
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && method == "TRACE")
{
// [ActiveIssue(9023, PlatformID.Windows)]
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
else
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
TestHelper.VerifyRequestMethod(response, method);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.False(responseContent.Contains(ExpectedContent));
}
}
}
}
protected override Page DowloadContent(Request request, ISpider spider)
{
Site site = spider.Site;
HttpResponseMessage response = null;
var proxy = site.GetHttpProxy();
request.PutExtra(Request.Proxy, proxy);
try
{
var httpMessage = GenerateHttpRequestMessage(request, site);
response = NetworkCenter.Current.Execute("http", m =>
{
HttpClient httpClient = _httpClientPool.GetHttpClient(proxy);
var message = (HttpRequestMessage)m;
var requestTask = httpClient.SendAsync(message);
requestTask.Wait(site.Timeout);
if (requestTask.Status == TaskStatus.RanToCompletion)
{
return(requestTask.Result);
}
else
{
return(new HttpResponseMessage(HttpStatusCode.RequestTimeout));
}
}, httpMessage);
response.EnsureSuccessStatusCode();
if (!site.AcceptStatCode.Contains(response.StatusCode))
{
throw new DownloadException($"下载 {request.Url} 失败. Code {response.StatusCode}");
}
var httpStatusCode = response.StatusCode;
request.PutExtra(Request.StatusCode, httpStatusCode);
Page page;
if (!MediaTypes.Contains(response.Content.Headers.ContentType.MediaType))
{
if (!site.DownloadFiles)
{
spider.Log($"Miss request: {request.Url} because media type is not text.", LogLevel.Debug);
return(new Page(request, site.ContentType, null)
{
IsSkip = true
});
}
else
{
page = SaveFile(request, response, spider);
}
}
else
{
page = HandleResponse(request, response, httpStatusCode, site);
}
// need update
page.TargetUrl = request.Url.ToString();
//page.SetRawText(File.ReadAllText(@"C:\Users\Lewis\Desktop\taobao.html"));
// 这里只要是遇上登录的, 则在拨号成功之后, 全部抛异常在Spider中加入Scheduler调度
// 因此如果使用多线程遇上多个Warning Custom Validate Failed不需要紧张, 可以考虑用自定义Exception分开
// 结束后要置空, 这个值存到Redis会导致无限循环跑单个任务
request.PutExtra(Request.CycleTriedTimes, null);
//#if !NET_CORE
// httpWebRequest.ServicePoint.ConnectionLimit = int.MaxValue;
//#endif
return(page);
//正常结果在上面已经Return了, 到此处必然是下载失败的值.
//throw new SpiderExceptoin("Download failed.");
}
catch (DownloadException)
{
throw;
}
catch (HttpRequestException he)
{
throw new DownloadException(he.Message);
}
catch (Exception e)
{
Page page = new Page(request, site.ContentType, null)
{
Exception = e
};
return(page);
}
finally
{
// 先Close Response, 避免前面语句异常导致没有关闭.
try
{
//ensure the connection is released back to pool
//check:
//EntityUtils.consume(httpResponse.getEntity());
response?.Dispose();
}
catch (Exception e)
{
spider.Log("Close response fail.", LogLevel.Warn, e);
}
}
}
public static async Task <DoResponse> SendRequest(DoRequest request)
{
// Check if initialized
if (!initialized)
{
throw new Exception("Cannot make requests to DigitalOcean while uninitialized");
}
// Declare a retry counter
int retries = 3;
while (true)
{
try
{
// Create the request message
HttpRequestMessage message = new HttpRequestMessage(request.Method, request.Url);
message.Content = new StringContent(JsonConvert.SerializeObject(request));
// Send the request
using (HttpResponseMessage response = await httpClient.SendAsync(message))
using (HttpContent content = response.Content)
{
if (!response.IsSuccessStatusCode)
{
// Read in the error
string json = await content.ReadAsStringAsync();
try
{
// Create a new DoErrorResponse object
DoErrorResponse errorResponse = JsonConvert.DeserializeObject <DoErrorResponse>(json);
// Check if this is a retry error
if (response.StatusCode == HttpStatusCode.ServiceUnavailable && errorResponse.Message == "Failed to forward the request you made, please try again.")
{
// Add another retry
retries++;
}
throw new Exception($"DigitalOcean request not a success ({response.StatusCode}, \"{errorResponse.Message}\")");
}
catch (JsonReaderException)
{
throw new Exception($"DigitalOcean request not a success ({response.StatusCode}, bad json returned)");
}
}
if (response.StatusCode == HttpStatusCode.NoContent)
{
return(new DoNoContentResponse());
}
else
{
// Read in the error
string json = await content.ReadAsStringAsync();
// Deserialize the response object
return((DoResponse)JsonConvert.DeserializeObject(json, request.ResponseType));
}
}
}
catch (Exception e)
{
// Decrement the retries
retries--;
// Check the number of retries
if (retries <= 0)
{
throw new Exception("HTTP request failure", e);
}
Console.WriteLine("WARNING: DigitalOcean request failed, waiting 5 seconds (retries remaining = " + retries + ")");
Console.WriteLine(e.ToString());
// Wait for 5 seconds
Thread.Sleep(5000);
}
}
}
public async System.Threading.Tasks.Task <ICustomActivityResult> Execute()
{
HttpClient client = new HttpClient();
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications);
UriBuilder UriBuilder = new UriBuilder(endPoint);
UriBuilder.Path = "/santaba/rest" + uriBuilderPath;
UriBuilder.Query = AyehuHelper.queryStringBuilder(queryStringArray);
HttpRequestMessage myHttpRequestMessage = new HttpRequestMessage(new HttpMethod(httpMethod), UriBuilder.ToString());
string data = postData;
if (string.IsNullOrEmpty(postData) == false)
{
if (omitJsonEmptyorNull)
{
data = AyehuHelper.omitJsonEmptyorNull(postData);
}
myHttpRequestMessage.Content = new StringContent(data, Encoding.UTF8, "application/json");
}
var epoch = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
var authHeaderValue = string.Format("LMv1 {0}:{1}:{2}", accessid, GenerateSignature(epoch, httpMethod, data, uriBuilderPath, password1), epoch);
client.DefaultRequestHeaders.Add("Authorization", authHeaderValue);
HttpResponseMessage response = client.SendAsync(myHttpRequestMessage).Result;
switch (response.StatusCode)
{
case HttpStatusCode.NoContent:
case HttpStatusCode.Created:
case HttpStatusCode.Accepted:
case HttpStatusCode.OK:
{
if (string.IsNullOrEmpty(response.Content.ReadAsStringAsync().Result) == false)
{
return(this.GenerateActivityResult(response.Content.ReadAsStringAsync().Result, Jsonkeypath));
}
else
{
return(this.GenerateActivityResult("Success"));
}
}
default:
{
if (string.IsNullOrEmpty(response.Content.ReadAsStringAsync().Result) == false)
{
throw new Exception(response.Content.ReadAsStringAsync().Result);
}
else if (string.IsNullOrEmpty(response.ReasonPhrase) == false)
{
throw new Exception(response.ReasonPhrase);
}
else
{
throw new Exception(response.StatusCode.ToString());
}
}
}
}
public static T SendRequest<T>(Setting setting, HttpRequest r, HttpMethod method, string path, string body)
{
var oaHost = r.Headers["Aps-Controller-Uri"].ToString();
if (oaHost == "")
throw new WebException("Header 'Aps-Controller-Uri' is not found");
var url = oaHost + path;
string header;
var oauthBase = new OAuthBase();
var timestamp = oauthBase.GenerateTimeStamp();
var nonce = oauthBase.GenerateNonce();
var consumerKey = setting.Config["oauth_key"];
var consumerSecret = setting.Config["oauth_secret"];
string normalizedUrl;
string normalizedRequestParameters;
// generating signature based on requst parameters
var sig = oauthBase.GenerateSignature(
new Uri(url),
consumerKey,
consumerSecret,
string.Empty, string.Empty,
method.ToString(),
timestamp,
nonce,
out normalizedUrl, out normalizedRequestParameters);
header = string.Format(
"oauth_consumer_key=\"{0}\"" +
",oauth_signature_method=\"HMAC-SHA1\"" +
",oauth_timestamp=\"{1}\"" +
",oauth_nonce=\"{2}\"" +
",oauth_version=\"1.0\"" +
",oauth_signature=\"{3}\"",
consumerKey, timestamp, nonce, sig);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(url);
var request = new HttpRequestMessage(method, url);
request.Headers.Authorization = new AuthenticationHeaderValue("OAuth", header);
request.Headers.Add("Aps-Transaction-Id", r.Headers["Aps-Transaction-Id"].ToString());
request.Content = new StringContent(body, Encoding.UTF8, "application/json");
setting.Logger.LogInformation("OA BEGIN HOST {0}", r.Headers["Aps-Controller-Uri"].ToString());
setting.Logger.LogInformation("OA Aps-Transaction-Id: {0}", r.Headers["Aps-Transaction-Id"].ToString());
setting.Logger.LogInformation("OA REQUEST {0} to {1}", method.ToString(), url);
setting.Logger.LogInformation("OA BODY: {0}", body);
using (var response = client.SendAsync(request).Result)
using (var content = response.Content)
{
if (response.IsSuccessStatusCode)
{
var result = content.ReadAsStringAsync().Result;
setting.Logger.LogInformation("OA RESPONSE OK: {0}", result);
return JsonConvert.DeserializeObject<T>(result);
}
else
{
var result = content.ReadAsStringAsync().Result;
setting.Logger.LogInformation("OA RESPONSE FAIL: {0}", result);
var error = string.Format("Call to OA failed. URL: {0} RESPONSE: {1}",
url, result);
throw new WebException(error);
}
}
}
}
/// <summary>
/// Execute an Analytics query
/// </summary>
/// <remarks>
/// Executes an Analytics query for data.
/// Please refer to<see href="https://docs.microsoft.com/azure/azure-monitor/logs/api/overview">this example</see> for using POST.
/// with an Analytics query.
/// </remarks>
/// <param name='query'>
/// The query to execute.
/// </param>
/// <param name='timespan'>
/// Optional. The timespan over which to query data. This is an ISO8601 time
/// period value. This timespan is applied in addition to any that are
/// specified in the query expression.
/// </param>
/// <param name='workspaces'>
/// A list of workspaces that are included in the query.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="ErrorResponseException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <QueryResults> > QueryWithHttpMessagesAsync(string query, System.TimeSpan?timespan = default(System.TimeSpan?), IList <string> workspaces = default(IList <string>), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (WorkspaceId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "this.WorkspaceId");
}
if (query == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "query");
}
QueryBody body = new QueryBody();
if (query != null || timespan != null || workspaces != null)
{
body.Query = query;
body.Timespan = timespan;
body.Workspaces = workspaces;
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("body", body);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "Query", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "workspaces/{workspaceId}/query").ToString();
_url = _url.Replace("{workspaceId}", System.Uri.EscapeDataString(WorkspaceId));
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (body != null)
{
_requestContent = SafeJsonConvert.SerializeObject(body, SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
try
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ErrorResponse _errorBody = SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, DeserializationSettings);
if (_errorBody != null)
{
ex.Body = _errorBody;
}
}
catch (JsonException)
{
// Ignore the exception
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <QueryResults>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <QueryResults>(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// translates the text input
/// </summary>
/// <param name="sourceLang"></param>
/// <param name="targetLang"></param>
/// <param name="textToTranslate"></param>
/// <param name="categoryId"></param>
/// <param name="format"></param>
/// <returns></returns>
internal string Translate(string sourceLang, string targetLang, string textToTranslate, string categoryId,
string format)
{
//convert our language codes
var sourceLc = convertLangCode(sourceLang);
var targetLc = convertLangCode(targetLang);
//check to see if token is null
if (_authToken == null)
{
_authToken = GetAuthToken();
}
//check to see if token expired and if so, get a new one
if (DateTime.Now.CompareTo(_tokenExpiresAt) >= 0)
{
_authToken = GetAuthToken();
}
var translatedText = string.Empty;
try
{
//search for words like this <word>
var rgx = new Regex("(\\<\\w+[üäåëöøßşÿÄÅÆĞ]*[^\\d\\W\\\\/\\\\]+\\>)");
var words = rgx.Matches(textToTranslate);
if (words.Count > 0)
{
textToTranslate = ReplaceCharacters(textToTranslate, words);
}
const string host = "https://api.cognitive.microsofttranslator.com";
const string path = "/translate?api-version=3.0";
var languageParams = string.Format("&from={0}&to={1}&textType={2}", sourceLc, targetLc, "html");
var uri = string.Concat(host, path, languageParams);
var body = new object[]
{
new
{
Text = textToTranslate
}
};
var requestBody = JsonConvert.SerializeObject(body);
using (var httpClient = new HttpClient())
{
using (var httpRequest = new HttpRequestMessage())
{
httpRequest.Method = HttpMethod.Post;
httpRequest.Content = new StringContent(requestBody, Encoding.UTF8, "application/json");
httpRequest.RequestUri = new Uri(uri);
httpRequest.Headers.Add("Authorization", _authToken);
var response = httpClient.SendAsync(httpRequest).Result;
var responseBody = response.Content.ReadAsStringAsync().Result;
var responseTranslation = JsonConvert.DeserializeObject <List <TranslationResponse> >(responseBody);
translatedText = responseTranslation[0].Translations[0].Text;
}
}
}
catch (WebException exception)
{
var mesg = ProcessWebException(exception, PluginResources.MsApiFailedGetLanguagesMessage);
throw new Exception(mesg);
}
return(translatedText);
}
public async Task PostAsync_ResponseContentRead_RequestContentDisposedAfterResponseBuffered()
{
using (var client = new HttpClient())
{
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
bool contentDisposed = false;
Task<HttpResponseMessage> post = client.SendAsync(new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new DelegateContent
{
SerializeToStreamAsyncDelegate = (contentStream, contentTransport) => contentStream.WriteAsync(new byte[100], 0, 100),
TryComputeLengthDelegate = () => Tuple.Create<bool, long>(true, 100),
DisposeDelegate = _ => contentDisposed = true
}
}, HttpCompletionOption.ResponseContentRead);
await LoopbackServer.AcceptSocketAsync(server, async (s, stream, reader, writer) =>
{
// Read headers from client
while (!string.IsNullOrEmpty(await reader.ReadLineAsync())) ;
// Send back all headers and some but not all of the response
await writer.WriteAsync($"HTTP/1.1 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 10\r\n\r\n");
await writer.WriteAsync("abcd"); // less than contentLength
// The request content should not be disposed of until all of the response has been sent
await Task.Delay(1); // a little time to let data propagate
Assert.False(contentDisposed, "Expected request content not to be disposed");
// Send remaining response content
await writer.WriteAsync("efghij");
s.Shutdown(SocketShutdown.Send);
// The task should complete and the request content should be disposed
using (HttpResponseMessage response = await post)
{
Assert.True(contentDisposed, "Expected request content to be disposed");
Assert.Equal("abcdefghij", await response.Content.ReadAsStringAsync());
}
return null;
});
});
}
}
public async Task SendAsync_SendRequestUsingMethodToEchoServerWithNoContent_MethodCorrectlySent(
string method,
bool secureServer)
{
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(
new HttpMethod(method),
secureServer ? Configuration.Http.SecureRemoteEchoServer : Configuration.Http.RemoteEchoServer);
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
TestHelper.VerifyRequestMethod(response, method);
}
}
}
/// <summary>
/// 获取相应对象
/// </summary>
/// <returns></returns>
public async Task <HttpResponseMessage> GetResponse()
{
var timer = Stopwatch.StartNew();
long pre = 0,
setheader = 0,
setbody = 0,
res = 0,
acceptcookie = 0,
acceptheader = 0,
error = 0,
end = 0;
if (Encoding == null)
{
Encoding = Encoding.UTF8;
}
if (PreRequest != null)
{
await PreRequest.ConfigureAwait(false);
PreRequest = null;
pre = timer.ElapsedMilliseconds;
timer.Restart();
}
ResponseCode = 0;
Exception = null;
Uri uri = GetFullUrl();
Trace.WriteLine(uri.ToString(), "HttpRequest.Url");
var cancel = new CancellationTokenSource(Timeout);
try
{
_Abort = cancel.Cancel;
var message = new HttpRequestMessage(GetHttpMethod(), uri);
if (Cookie?.Count > 0)
{
message.Headers.Add("Cookie", Cookie.GetCookieHeader(uri));
}
if (KeepAlive)
{
message.Headers.Connection.Add("keep-alive");
}
if (_FormBody != null)
{
var formdata = FormBody.GetBytes(Encoding);
message.Content = new ByteArrayContent(formdata);
message.Content.Headers.Add("Content-Type", FormBody.ContentType);
message.Content.Headers.ContentType.CharSet = Encoding.WebName;
//message.Headers.TryAddWithoutValidation("Content-Type", "charset=" + Encoding.WebName);
setbody = timer.ElapsedMilliseconds;
timer.Restart();
}
if (_Headers?.Count > 0)
{
foreach (var item in _Headers)
{
var arr = item.Value as IEnumerable <string>;
if (arr != null)
{
if (!message.Headers.TryAddWithoutValidation(item.Key, arr) &&
message.Content != null)
{
message.Content.Headers.TryAddWithoutValidation(item.Key, arr);
}
}
else
{
var str = item.Value as string ?? item.Value + "";
if (!message.Headers.TryAddWithoutValidation(item.Key, str) &&
message.Content != null)
{
message.Content.Headers.TryAddWithoutValidation(item.Key, str);
}
}
}
setheader = timer.ElapsedMilliseconds;
timer.Restart();
}
var response = await HttpClient.SendAsync(message, cancel.Token);
_Abort = null;
res = timer.ElapsedMilliseconds;
timer.Restart();
if (AcceptCookie && response.Headers.Contains("Set-Cookie"))
{
var setcookies = response.Headers.GetValues("Set-Cookie");
foreach (var cookie in setcookies)
{
Cookie.SetCookies(uri, cookie);
}
acceptcookie = timer.ElapsedMilliseconds;
timer.Restart();
}
if (AcceptHeader)
{
Headers.Clear();
foreach (var head in response.Headers)
{
Headers.Add(head.Key, head.Value);
}
foreach (var head in response.Content.Headers)
{
Headers.Add(head.Key, head.Value);
}
acceptheader = timer.ElapsedMilliseconds;
timer.Restart();
}
ResponseCode = response.StatusCode;
return(response);
}
catch (Exception ex)
{
error = timer.ElapsedMilliseconds;
timer.Restart();
if (ex is TaskCanceledException && _Abort != null)
{
ex = new TimeoutException("请求已超时");
}
Trace.WriteLine(ex.Message, "HttpRequest.Error");
Exception = ex;
ResponseCode = 0;
return(null);
}
finally
{
cancel?.Dispose();
_Abort = null;
setbody = timer.ElapsedMilliseconds;
timer.Stop();
Trace.WriteLine(ResponseCode, "HttpRequest.StatusCode");
Trace.WriteLine(
$"pre={pre}; setheader={setheader}; setbody={setbody}; response={res}; acceptcookie={acceptcookie}; acceptheader={acceptheader}; error={error}; end={end}",
"HttpRequest.Timing");
}
}
public async Task SendAsync_RequestVersion20_ResponseVersion20(Uri server)
{
_output.WriteLine(server.AbsoluteUri.ToString());
var request = new HttpRequestMessage(HttpMethod.Get, server);
request.Version = new Version(2, 0);
var handler = new HttpClientHandler();
using (var client = new HttpClient(handler))
{
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(new Version(2, 0), response.Version);
}
}
}
private async Task <bool> LoginARELUser(string name, string pass)
{
var client = new HttpClient();
client.BaseAddress = new Uri("https://arel.eisti.fr");
var request = new HttpRequestMessage(HttpMethod.Post, "/oauth/token");
//request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
var byteArray = new UTF8Encoding().GetBytes(loader.GetString("APIKey"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(byteArray));
var formData = new List <KeyValuePair <string, string> >();
formData.Add(new KeyValuePair <string, string>("grant_type", "password"));
formData.Add(new KeyValuePair <string, string>("username", name));
formData.Add(new KeyValuePair <string, string>("password", pass));
formData.Add(new KeyValuePair <string, string>("scope", "read"));
formData.Add(new KeyValuePair <string, string>("format", "xml"));
request.Content = new FormUrlEncodedContent(formData);
var response = await client.SendAsync(request);
string resultat = await response.Content.ReadAsStringAsync();
if (resultat.IndexOf("tok") > -1) //si on trouve tok (en) dans la sortie c'est que c'est bon
{
localSettings.Values["token"] = GetToken(resultat, "access_token"); //on save le token
return(true);
}
else
{
string erreur = response.StatusCode.ToString();
switch (response.StatusCode)
{
case (HttpStatusCode.BadRequest):
erreur = "Identifiants incorrects";
break;
case (HttpStatusCode.Unauthorized):
erreur = "Accès refusé";
break;
case (HttpStatusCode.Forbidden):
erreur = "Ressource interdite";
break;
case (HttpStatusCode.InternalServerError):
erreur = "Erreur Serveur";
break;
case (HttpStatusCode.NotFound):
erreur = "Endpoint introuvable.";
break;
default:
break;
}
DataStorage.saveData("erreurLogin", erreur);
return(false);
}
}
public async Task SendAsync_HttpRequestMsgResponseHeadersRead_StatusCodeOK()
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Configuration.Http.SecureRemoteEchoServer);
using (var client = new HttpClient())
{
using (HttpResponseMessage response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead))
{
string responseContent = await response.Content.ReadAsStringAsync();
_output.WriteLine(responseContent);
TestHelper.VerifyResponseBody(
responseContent,
response.Content.Headers.ContentMD5,
false,
null);
}
}
}
public async Task <string> ExecuteLoadDataCommand()
{
string _Result = "OK";
string url = "";
string baseUrl = "";
if (Mode == ActiveProcessesPageMode.UsersProcesses)
{
baseUrl = Secrets.ApiAddress + "GetUsersOpenProcesses?token=" + Secrets.TenantToken + $"&UserId={RuntimeSettings.UserId}";
if (FilterString != null)
{
url = $"{baseUrl}&query={FilterString}";
}
else
{
url = baseUrl;
}
}
else if (Mode == ActiveProcessesPageMode.AllProcesses)
{
baseUrl = Secrets.ApiAddress + "GetProcesses?token=" + Secrets.TenantToken + "&query=IsCompleted=false and IsSuccessfull=false";
if (FilterString != null)
{
HidePlanned = false;
url = $"{baseUrl} AND {FilterString}";
}
else
{
url = baseUrl;
}
}
else
{
baseUrl = Secrets.ApiAddress + "GetProcesses?token=" + Secrets.TenantToken + "&query=ActionTypeId=2 and IsCompleted=false and IsSuccessfull=false";
if (FilterString != null)
{
HidePlanned = false;
url = $"{baseUrl} AND {FilterString}";
}
else
{
url = baseUrl;
}
}
DataService ds = new DataService();
Items = new List <Process>();
IsWorking = true;
try
{
HttpClient httpClient = new HttpClient(new NativeMessageHandler()
{
Timeout = new TimeSpan(0, 0, 20), EnableUntrustedCertificates = true, DisableCaching = true
});
var request = new HttpRequestMessage(HttpMethod.Get, url);
HttpResponseMessage responseMsg = await Static.Functions.GetPostRetryAsync(() => httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Get, url)), TimeSpan.FromSeconds(3));
//var responseMsg = await httpClient.SendAsync(request);
string output = await ds.readStream(responseMsg);
if (responseMsg.IsSuccessStatusCode)
{
Items = JsonConvert.DeserializeObject <List <Process> >(output);
}
else
{
_Result = responseMsg.ReasonPhrase;
}
}
catch (Exception ex)
{
IsWorking = false;
_Result = "Nie można połączyć się z serwerem. Prawdopodobnie utraciłeś połączenie internetowe. Upewnij się, że masz połączenie z internetem i spróbuj jeszcze raz";
Static.Functions.CreateError(ex, "No connection", nameof(this.ExecuteLoadDataCommand), this.GetType().Name);
throw;
}
PopulateListbox();
IsWorking = false;
return(_Result);
}
public async Task SendAsync_RequestVersion20_ResponseVersion20IfHttp2Supported(Uri server)
{
// We don't currently have a good way to test whether HTTP/2 is supported without
// using the same mechanism we're trying to test, so for now we allow both 2.0 and 1.1 responses.
var request = new HttpRequestMessage(HttpMethod.Get, server);
request.Version = new Version(2, 0);
using (var client = new HttpClient())
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(
response.Version == new Version(2, 0) ||
response.Version == new Version(1, 1),
"Response version " + response.Version);
}
}
/// <summary>
/// Retrieve an item of type <typeparamref name="T" /> from the Blizzard Community
/// or Game Data API.
/// </summary>
/// <typeparam name="T">
/// The return type.
/// </typeparam>
/// <param name="requestUri">
/// The URI the request is sent to.
/// </param>
/// <param name="arrayName">
/// The name of the array to deserialize to prevent the use of JSON root objects.
/// </param>
/// <returns>
/// The JSON response, deserialized to an object of type <typeparamref name="T" />.
/// </returns>
protected async Task <RequestResult <T> > Get <T>(string requestUri, string?arrayName = null) where T : class
{
// Acquire a new OAuth token if we don't have one. Get a new one if it's expired.
if (_token == null || DateTime.UtcNow >= _tokenExpiration)
{
_token = await GetOAuthToken().ConfigureAwait(false);
_tokenExpiration = DateTime.UtcNow.AddSeconds(_token.ExpiresIn).AddSeconds(-30);
}
// Add an authentication header with the token.
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token.AccessToken);
// Retrieve the response.
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
using var response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false);
if (response.IsSuccessStatusCode && response.Content != null)
{
var stream = await response.Content.ReadAsStreamAsync();
var json = await StreamToStringAsync(stream);
if (string.IsNullOrEmpty(json))
{
var requestError = JsonConvert.DeserializeObject <RequestError>(json);
return(requestError);
}
try
{
if (arrayName != null)
{
json = JObject.Parse(json).SelectToken(arrayName).ToString();
}
RequestResult <T> requestResult = JsonConvert.DeserializeObject <T>(json, new JsonSerializerSettings
{
ContractResolver = new BaseClientContractResolver(),
MissingMemberHandling = MissingMemberHandling.Error
});
return(requestResult);
}
catch (JsonReaderException ex)
{
var requestError = new RequestError
{
Code = string.Empty,
Detail = ex.Message,
Type = typeof(JsonReaderException).ToString()
};
return(new RequestResult <T>(requestError));
}
}
// If not then it is most likely a problem on our end due to an HTTP error.
var message = $"Response code {(int) response.StatusCode} ({response.ReasonPhrase}) does not indicate success. Request: {requestUri}";
throw new HttpRequestException(message);
}
public static async Task<string> SendGraphGetRequest(AuthenticationResult authResult, string api, string query, string tenant, string adminClientId, string adminClientSecret)
{
var authContext = new Microsoft.IdentityModel.Clients.ActiveDirectory.AuthenticationContext("https://login.microsoftonline.com/" + tenant);
var credential = new Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential(adminClientId, adminClientSecret);
// Here you ask for a token using the web app's clientId as the scope, since the web app and service share the same clientId.
// AcquireTokenSilentAsync will return a token from the token cache, and throw an exception if it cannot do so.
//var authContext = new AuthenticationContext(authority, new NaiveSessionCache(userObjectId));
//// We don't care which policy is used to access the TaskService, so let's use the most recent policy
//var mostRecentPolicy = authTicket.Identity.FindFirst(AcrClaimType).Value;
//var result = await authContext.AcquireTokenSilentAsync(new string[] { clientId }, credential, UserIdentifier.AnyUser, mostRecentPolicy);
//// First, use ADAL to acquire a token using the app's identity (the credential)
//// The first parameter is the resource we want an access_token for; in this case, the Graph API.
var result = authContext.AcquireToken("https://graph.windows.net", credential);
// For B2C user managment, be sure to use the beta Graph API version.
var http = new HttpClient();
var url = "https://graph.windows.net/" + tenant + api + "?" + "api-version=beta";
if (!string.IsNullOrEmpty(query))
{
url += "&" + query;
}
//Console.ForegroundColor = ConsoleColor.Cyan;
//Console.WriteLine("GET " + url);
//Console.WriteLine("Authorization: Bearer " + result.AccessToken.Substring(0, 80) + "...");
//Console.WriteLine("");
// Append the access token for the Graph API to the Authorization header of the request, using the Bearer scheme.
var request = new HttpRequestMessage(HttpMethod.Get, url);
//request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authResult.Token);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", result.AccessToken);
var response = await http.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
string error = await response.Content.ReadAsStringAsync();
object formatted = JsonConvert.DeserializeObject(error);
throw new WebException("Error Calling the Graph API: \n" + JsonConvert.SerializeObject(formatted, Formatting.Indented));
}
//Console.ForegroundColor = ConsoleColor.Green;
//Console.WriteLine((int)response.StatusCode + ": " + response.ReasonPhrase);
//Console.WriteLine("");
return await response.Content.ReadAsStringAsync();
}
/// <param name='id'>
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse> ApiValuesByIdDeleteWithHttpMessagesAsync(int id, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("id", id);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "ApiValuesByIdDelete", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/Values/{id}").ToString();
_url = _url.Replace("{id}", System.Uri.EscapeDataString(SafeJsonConvert.SerializeObject(id, SerializationSettings).Trim('"')));
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("DELETE");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
private static async Task<ProxyResult> StartAsync(TcpListener listener, bool requireAuth, bool expectCreds)
{
ProxyResult result = new ProxyResult();
var headers = new Dictionary<string, string>();
Socket clientSocket = null;
Stream clientStream = null;
StreamReader clientReader = null;
string url = null;
try
{
// Get and parse the incoming request.
Func<Task> getAndReadRequest = async () => {
clientSocket = await listener.AcceptSocketAsync().ConfigureAwait(false);
clientStream = new NetworkStream(clientSocket, ownsSocket: false);
clientReader = new StreamReader(clientStream, Encoding.ASCII);
headers.Clear();
url = clientReader.ReadLine().Split(' ')[1];
string line;
while (!string.IsNullOrEmpty(line = clientReader.ReadLine()))
{
string[] headerParts = line.Split(':');
headers.Add(headerParts[0].Trim(), headerParts[1].Trim());
}
};
await getAndReadRequest().ConfigureAwait(false);
// If we're expecting credentials, look for them, and if we didn't get them, send back
// a 407 response. Optionally, process a new request that would expect credentials.
if (requireAuth && !headers.ContainsKey("Proxy-Authorization"))
{
// Send back a 407
await clientSocket.SendAsync(
new ArraySegment<byte>(Encoding.ASCII.GetBytes("HTTP/1.1 407 Proxy Auth Required\r\nProxy-Authenticate: Basic\r\n\r\n")),
SocketFlags.None).ConfigureAwait(false);
clientSocket.Shutdown(SocketShutdown.Send);
clientSocket.Dispose();
if (expectCreds)
{
// Wait for a new connection that should have an auth header this time and parse it.
await getAndReadRequest().ConfigureAwait(false);
}
else
{
// No credentials will be coming in a subsequent request.
return default(ProxyResult);
}
}
// Store any auth header we may have for later comparison.
string authValue;
if (headers.TryGetValue("Proxy-Authorization", out authValue))
{
result.AuthenticationHeaderValue = Encoding.UTF8.GetString(Convert.FromBase64String(authValue.Substring("Basic ".Length)));
}
// Forward the request to the server.
var request = new HttpRequestMessage(HttpMethod.Get, url);
foreach (var header in headers) request.Headers.Add(header.Key, header.Value);
using (HttpClient outboundClient = new HttpClient())
using (HttpResponseMessage response = await outboundClient.SendAsync(request).ConfigureAwait(false))
{
// Transfer the response headers from the server to the client.
var sb = new StringBuilder($"HTTP/{response.Version.ToString(2)} {(int)response.StatusCode} {response.ReasonPhrase}\r\n");
foreach (var header in response.Headers.Concat(response.Content.Headers))
{
sb.Append($"{header.Key}: {string.Join(", ", header.Value)}\r\n");
}
sb.Append("\r\n");
byte[] headerBytes = Encoding.ASCII.GetBytes(sb.ToString());
await clientStream.WriteAsync(headerBytes, 0, headerBytes.Length).ConfigureAwait(false);
// Forward the content from the server, both to the client and to a memory stream which we'll use
// to return the data from the proxy.
var resultBody = new MemoryStream();
using (Stream responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
byte[] buffer = new byte[0x1000];
int bytesRead = 0;
while ((bytesRead = responseStream.Read(buffer, 0, buffer.Length)) > 0)
{
await clientStream.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false);
resultBody.Write(buffer, 0, bytesRead);
}
}
// Return the result
result.ResponseContent = resultBody.ToArray();
return result;
}
}
finally
{
clientSocket.Dispose();
listener.Stop();
}
}
private async Task<Version> SendRequestAndGetResponseVersionAsync(Version requestVersion, Uri server)
{
var request = new HttpRequestMessage(HttpMethod.Get, server);
if (requestVersion != null)
{
request.Version = requestVersion;
}
else
{
// The default value for HttpRequestMessage.Version is Version(1,1).
// So, we need to set something different to test the "unknown" version.
request.Version = new Version(0,0);
}
using (var client = new HttpClient())
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
return response.Version;
}
}
public async Task <byte[]> GetReport2(string ReportName, List <Tuple <string, string> > Parametros, ExportFormat Format, string OtherSetting)
{
string paramets = "";
string ConfigRep = "&rs:Command=Render&rs:Format=" + GetExportFormatString(Format) + OtherSetting;
foreach (Tuple <string, string> param in Parametros)
{
paramets += "&" + param.Item1 + "=" + param.Item2;
}
string URL = _baseURL + ReportName + ConfigRep + paramets;
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
clientHandler.Credentials = UserNTL;
using (HttpClient client = new HttpClient(clientHandler))
{
client.Timeout = TimeSpan.FromMinutes(10);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, URL);
var informacionAMandar = JsonConvert.SerializeObject(Parametros,
Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
request.Content = new StringContent(informacionAMandar, Encoding.UTF8, "application/json");//CONTENT-TYPE header
HttpResponseMessage response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
Stream fStream = await response.Content.ReadAsStreamAsync();
return(ReadFully(fStream));
}
else
{
new ExceptionGeneral("respuesta del servidor Incorrecta !"); return(null);
}
}
//using (HttpClient client = new HttpClient())
//{
// var response = await client.GetAsync(URL, HttpCompletionOption.ResponseHeadersRead);
// response.EnsureSuccessStatusCode();
// using (var stream = await response.Content.ReadAsStreamAsync())
// using (var streamReader = new StreamReader(stream))
// using (var jsonReader = new JsonTextReader(streamReader))
// {
// return ReadFully(jsonReader);
// //do some deserializing http://www.newtonsoft.com/json/help/html/Performance.htm
// }
//}
//public async Task<byte[]> GetReportAsync(string ReportName, List<Tuple<string, string>> Parametros, ExportFormat Format,string OtherSetting)
//{
// string paramets= "";
// string ConfigRep = "&rs:Command=Render&rs:Format="+ GetExportFormatString(Format) +OtherSetting;
// foreach (Tuple<string, string> param in Parametros)
// paramets += "&"+param.Item1 + "=" + param.Item2;
// string URL = _baseURL + ReportName + ConfigRep+ paramets;
// try
// {
// using (var handler = new HttpClientHandler { Credentials = UserNTL })
// using (var client = new HttpClient(handler))
// {
// var result = await client.GetAsync(_baseURL);
// if (result.IsSuccessStatusCode)
// {
// var Filebyte = result.Content.ReadAsStringAsync().Result;
// return Filebyte;
// }
// else { new ExceptionGeneral("respuesta del servidor Incorrecta !"); return null; }
// }
// }
// catch (Exception ex)
// {
// throw;
// }
//}
}
private async Task <RequestToken> ObtainRequestTokenAsync(
string consumerKey,
string consumerSecret,
string callBackUri,
AuthenticationProperties properties)
{
Logger.LogVerbose("ObtainRequestToken");
log.LogDebug("ObtainRequestTokenAsync called with consumerKey " + consumerKey + " and callBackUri " + callBackUri);
var nonce = Guid.NewGuid().ToString("N");
var authorizationParts = new SortedDictionary <string, string>
{
{ "oauth_callback", callBackUri },
{ "oauth_consumer_key", consumerKey },
{ "oauth_nonce", nonce },
{ "oauth_signature_method", "HMAC-SHA1" },
{ "oauth_timestamp", GenerateTimeStamp() },
{ "oauth_version", "1.0" }
};
var parameterBuilder = new StringBuilder();
foreach (var authorizationKey in authorizationParts)
{
parameterBuilder.AppendFormat("{0}={1}&", UrlEncoder.UrlEncode(authorizationKey.Key), UrlEncoder.UrlEncode(authorizationKey.Value));
}
parameterBuilder.Length--;
var parameterString = parameterBuilder.ToString();
var canonicalizedRequestBuilder = new StringBuilder();
canonicalizedRequestBuilder.Append(HttpMethod.Post.Method);
canonicalizedRequestBuilder.Append("&");
canonicalizedRequestBuilder.Append(UrlEncoder.UrlEncode(RequestTokenEndpoint));
canonicalizedRequestBuilder.Append("&");
canonicalizedRequestBuilder.Append(UrlEncoder.UrlEncode(parameterString));
var signature = ComputeSignature(consumerSecret, null, canonicalizedRequestBuilder.ToString());
authorizationParts.Add("oauth_signature", signature);
var authorizationHeaderBuilder = new StringBuilder();
authorizationHeaderBuilder.Append("OAuth ");
foreach (var authorizationPart in authorizationParts)
{
authorizationHeaderBuilder.AppendFormat(
"{0}=\"{1}\", ", authorizationPart.Key, UrlEncoder.UrlEncode(authorizationPart.Value));
}
authorizationHeaderBuilder.Length = authorizationHeaderBuilder.Length - 2;
var request = new HttpRequestMessage(HttpMethod.Post, RequestTokenEndpoint);
request.Headers.Add("Authorization", authorizationHeaderBuilder.ToString());
var response = await _httpClient.SendAsync(request, Context.RequestAborted);
response.EnsureSuccessStatusCode();
string responseText = await response.Content.ReadAsStringAsync();
var responseParameters = new FormCollection(FormReader.ReadForm(responseText));
if (string.Equals(responseParameters["oauth_callback_confirmed"], "true", StringComparison.Ordinal))
{
return(new RequestToken {
Token = Uri.UnescapeDataString(responseParameters["oauth_token"]), TokenSecret = Uri.UnescapeDataString(responseParameters["oauth_token_secret"]), CallbackConfirmed = true, Properties = properties
});
}
return(new RequestToken());
}
public async Task SendAsync_ReadFromSlowStreamingServer_PartialDataReturned()
{
// TODO: This is a placeholder until GitHub Issue #2383 gets resolved.
const string SlowStreamingServer = "http://httpbin.org/drip?numbytes=8192&duration=15&delay=1&code=200";
int bytesRead;
byte[] buffer = new byte[8192];
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Get, SlowStreamingServer);
using (HttpResponseMessage response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead))
{
Stream stream = await response.Content.ReadAsStreamAsync();
bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
}
_output.WriteLine("Bytes read from stream: {0}", bytesRead);
Assert.True(bytesRead < buffer.Length, "bytesRead should be less than buffer.Length");
}
}
public async Task <HTTPResult <T> > HttpCallAsync <T>(NetworkCredential cred, string action, HttpMethod method, string content = null, CancellationTokenSource tokenSource = default)
{
HttpClientHandler authtHandler = new HttpClientHandler {
Credentials = cred ?? CredentialCache.DefaultCredentials
};
try
{
using (HttpClient client = new HttpClient(authtHandler))
{
client.Timeout = TimeSpan.FromMinutes(10);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var requestMessage = new HttpRequestMessage
{
RequestUri = new Uri(_baseUri, action),
Method = method
};
if ((method == HttpMethod.Post || method == HttpMethod.Put) && !string.IsNullOrWhiteSpace(content))
{
requestMessage.Content = new StringContent(content, System.Text.Encoding.UTF8, "application/json");
}
CancellationToken token = tokenSource == null ? default : tokenSource.Token;
using (HttpResponseMessage message = await client.SendAsync(requestMessage, token))
{
var status = new HTTPCode {
statusCode = (int)message.StatusCode, reason = message.ReasonPhrase
};
if (message.IsSuccessStatusCode)
{
using (var mc = message.Content)
{
return(new HTTPResult <T>(status, await mc.ReadAsAsync <T>(token)));
// return Tuple.Create(await mc.ReadAsAsync<T>(token), status);
}
}
return(new HTTPResult <T>(status, default(T))); // Tuple.Create(default(T), status);
}
}
}
catch (Exception ex)
{
return(new HTTPResult <T>(new HTTPCode {
statusCode = 400, reason = "Exception"
}, default(T))); //Tuple.Create(default(T), new HTTPCode { statusCode = 400, reason = "Exception" });
}
}
private async Task PostUsingAuthHelper(
Uri serverUri,
string requestBody,
HttpContent requestContent,
NetworkCredential credential,
bool preAuthenticate)
{
var handler = new HttpClientHandler();
handler.PreAuthenticate = preAuthenticate;
handler.Credentials = credential;
using (var client = new HttpClient(handler))
{
// Send HEAD request to help bypass the 401 auth challenge for the latter POST assuming
// that the authentication will be cached and re-used later when PreAuthenticate is true.
var request = new HttpRequestMessage(HttpMethod.Head, serverUri);
HttpResponseMessage response;
using (response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
// Now send POST request.
request = new HttpRequestMessage(HttpMethod.Post, serverUri);
request.Content = requestContent;
requestContent.Headers.ContentLength = null;
request.Headers.TransferEncodingChunked = true;
using (response = await client.PostAsync(serverUri, requestContent))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
string responseContent = await response.Content.ReadAsStringAsync();
_output.WriteLine(responseContent);
TestHelper.VerifyResponseBody(
responseContent,
response.Content.Headers.ContentMD5,
true,
requestBody);
}
}
}
public async static Task WatchTeamSite(IList<string> keys)
{
try
{
//var watch = new System.Diagnostics.Stopwatch();
//watch.Start();
var batchRequestContent = new BatchRequestContent();
// 1. construct a Batch request
foreach (var key in keys)
{
if (teamSitesDeltaLinks[key] == null)
teamSitesDeltaLinks[key] = new DeltaLinks()
{
LastSyncDate = DateTime.UtcNow.Ticks / 100000000,
DeltaLink = graphClient.Groups[key].Drive.Root
.Request()
.RequestUrl + "?$select=LastModifiedDateTime"
};
var request = new HttpRequestMessage(HttpMethod.Get, teamSitesDeltaLinks[key].DeltaLink);
var requestStep = new BatchRequestStep($"{key}", request, null);
batchRequestContent.AddBatchRequestStep(requestStep);
}
//3. Submit request
var batchRequest = new HttpRequestMessage(HttpMethod.Post, "https://graph.microsoft.com/v1.0/$batch");
batchRequest.Content = batchRequestContent;
await graphClient.AuthenticationProvider.AuthenticateRequestAsync(batchRequest);
var httpClient = new HttpClient();
var batchResponse = await httpClient.SendAsync(batchRequest);
// 3. Process response
var batchResponseContent = new BatchResponseContent(batchResponse);
var responses = await batchResponseContent.GetResponsesAsync();
foreach (var response in responses)
{
if (!response.Value.IsSuccessStatusCode)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Issue on response {response.Value}");
Console.ResetColor();
continue;
}
//Console.WriteLine(response.Key);
var deltaResponse = JsonConvert.DeserializeObject<DeltaResponse>
(await response.Value.Content.ReadAsStringAsync());
teamSitesDeltaLinks[response.Key].DeltaLink = deltaResponse.DeltaLink;
if (!firstCall)
foreach (var drive in deltaResponse.DriveItems)
await ProcessChangesAsync(drive, teamSitesDeltaLinks[response.Key].LastSyncDate);
}
//watch.Stop();
//Console.WriteLine($"Checking Teams completed on {watch.ElapsedMilliseconds / 1000} seconds");
libraryDeltaCalls++;
}
catch (Exception exc)
{
AddException(exc, "WatchTeamSite");
if (exc.InnerException.Message.Contains("Authentication failed"))
{
Console.WriteLine($"retry again due {exc.InnerException.Message}");
await Task.Delay(500);
await WatchTeamSite(keys);
}
else
{
Console.WriteLine(exc.Message);
Console.WriteLine(exc.InnerException.Message);
Console.WriteLine(exc.StackTrace);
}
}
}
public async Task PostAsync_ResponseHeadersRead_RequestContentDisposedAfterRequestFullySentAndResponseHeadersReceived()
{
using (var client = new HttpClient())
{
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
var trigger = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
bool contentDisposed = false;
Task<HttpResponseMessage> post = client.SendAsync(new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new DelegateContent
{
SerializeToStreamAsyncDelegate = async (contentStream, contentTransport) =>
{
await contentStream.WriteAsync(new byte[50], 0, 50);
await trigger.Task;
await contentStream.WriteAsync(new byte[50], 0, 50);
},
TryComputeLengthDelegate = () => Tuple.Create<bool, long>(true, 100),
DisposeDelegate = _ => contentDisposed = true
}
}, HttpCompletionOption.ResponseHeadersRead);
await LoopbackServer.AcceptSocketAsync(server, async (s, stream, reader, writer) =>
{
// Read headers from client
while (!string.IsNullOrEmpty(await reader.ReadLineAsync())) ;
// Send back all headers and some but not all of the response
await writer.WriteAsync($"HTTP/1.1 200 OK\r\nDate: {DateTimeOffset.UtcNow:R}\r\nContent-Length: 10\r\n\r\n");
await writer.WriteAsync("abcd"); // less than contentLength
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Assert.False(contentDisposed, "Expected request content to not be disposed while request data still being sent");
}
else // [ActiveIssue(9006, PlatformID.AnyUnix)]
{
await post;
Assert.True(contentDisposed, "Current implementation will dispose of the request content once response headers arrive");
}
// Allow request content to complete
trigger.SetResult(true);
// Send remaining response content
await writer.WriteAsync("efghij");
s.Shutdown(SocketShutdown.Send);
// The task should complete and the request content should be disposed
using (HttpResponseMessage response = await post)
{
Assert.True(contentDisposed, "Expected request content to be disposed");
Assert.Equal("abcdefghij", await response.Content.ReadAsStringAsync());
}
return null;
});
});
}
}
public async Task Invoke(HttpContext context)
{
var path = context.Request.Path;
var matchedEp = this.options.ProxiedEndpoints.FirstOrDefault((ep) => path.StartsWithSegments(ep.Endpoint));
if (matchedEp == null)
{
await this.next(context);
return;
}
var requestMessage = new HttpRequestMessage();
// copy body (if any)
if (RequestMethodContainsBody(context.Request))
{
var streamContent = new StreamContent(context.Request.Body);
requestMessage.Content = streamContent;
}
// copy the headers
foreach (var header in context.Request.Headers)
{
if ((!requestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray())) && (requestMessage.Content != null))
{
requestMessage.Content?.Headers.TryAddWithoutValidation(header.Key, header.Value.ToArray());
}
}
requestMessage.Headers.Host = $"{matchedEp.Host}:{matchedEp.Port}";
string targetPath = context.Request.Path.ToString();
if (!String.IsNullOrWhiteSpace(matchedEp.TargetEndpoint))
{
targetPath = targetPath.Replace(matchedEp.Endpoint, matchedEp.TargetEndpoint);
}
string uriString = $"{matchedEp.Scheme ?? context.Request.Scheme}://{matchedEp.Host ?? context.Request.Host.Host ?? "localhost"}:{matchedEp.Port ?? Convert.ToString(context.Request.Host.Port.GetValueOrDefault(80))}{context.Request.PathBase}{targetPath}{context.Request.QueryString}";
requestMessage.RequestUri = new Uri(uriString);
requestMessage.Method = new HttpMethod(context.Request.Method);
using (var responseMessage = await client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, context.RequestAborted))
{
context.Response.StatusCode = (int)responseMessage.StatusCode;
foreach (var header in responseMessage.Headers)
{
context.Response.Headers[header.Key] = header.Value.ToArray();
}
foreach (var header in responseMessage.Content.Headers)
{
context.Response.Headers[header.Key] = header.Value.ToArray();
}
// SendAsync removes chunking from the response. This removes the header so it doesn't expect a chunked response.
context.Response.Headers.Remove("transfer-encoding");
await responseMessage.Content.CopyToAsync(context.Response.Body);
}
}
public async Task SendAsync_SendRequestUsingMethodToEchoServerWithContent_Success(
string method,
bool secureServer)
{
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(
new HttpMethod(method),
secureServer ? Configuration.Http.SecureRemoteEchoServer : Configuration.Http.RemoteEchoServer);
request.Content = new StringContent(ExpectedContent);
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
TestHelper.VerifyRequestMethod(response, method);
string responseContent = await response.Content.ReadAsStringAsync();
_output.WriteLine(responseContent);
Assert.Contains($"\"Content-Length\": \"{request.Content.Headers.ContentLength.Value}\"", responseContent);
TestHelper.VerifyResponseBody(
responseContent,
response.Content.Headers.ContentMD5,
false,
ExpectedContent);
}
}
}
private void button4_Click(object sender, RibbonControlEventArgs e)
{
if (dropDown1.SelectedItem != null)
{
objectSelected = dropDown1.SelectedItem.Label;
}
if (dropDown2.SelectedItem != null)
{
operationSelected = dropDown2.SelectedItem.Label;
}
if (operationSelected == "Select")
{
List <String> sObjFieldLst = new List <string>();
using (var client = new HttpClient())
{
string restRequest = ServiceURL + "/services/data/v43.0/sobjects/" + objectSelected + "/describe/";;
var request = new HttpRequestMessage(HttpMethod.Get, restRequest);
request.Headers.Add("Authorization", "Bearer " + authToken);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
//request.Headers.Add("X-PrettyPrint", "1");
var response = client.SendAsync(request).Result;
var requestresponse = response.Content.ReadAsStringAsync().Result;
if (((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300)
{
JObject sObjJObj = JObject.Parse(requestresponse);
JToken tokens = sObjJObj["fields"];
if (tokens.Children().Count() > 0)
{
foreach (JToken jt in tokens.Children())
{
foreach (JProperty jp in jt)
{
if (jp.Name == "name")
{
sObjFieldLst.Add(jp.Value.ToString());
}
}
}
}
String queryStr = "SELECT " + String.Join(",", sObjFieldLst) + " FROM " + objectSelected /*+ " LIMIT 10000"*/;
String restqueryRequest = ServiceURL + "/services/data/v43.0/query/?q=" + queryStr;
response = Query(restqueryRequest);
Boolean success = ((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300;
requestresponse = response.Content.ReadAsStringAsync().Result;
//var jsonLinq = JObject.Parse(requestresponse);
var trgArray = new JArray();
String nextQueryStr;
if (success)
{
requestresponse = response.Content.ReadAsStringAsync().Result;
var jsonLinq = JObject.Parse(requestresponse);
var srcArray = jsonLinq.Descendants().Where(d => d is JArray).First();
if (srcArray.Count() > 0)
{
Globals.ThisAddIn.AddingRowsToArray(trgArray, requestresponse);
while (!(Boolean)jsonLinq.SelectToken("done"))
{
nextQueryStr = jsonLinq.SelectToken("nextRecordsUrl").ToString();
restqueryRequest = ServiceURL + nextQueryStr;
response = Query(restqueryRequest);
success = ((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300;
if (success)
{
requestresponse = response.Content.ReadAsStringAsync().Result;
jsonLinq = JObject.Parse(requestresponse);
Globals.ThisAddIn.AddingRowsToArray(trgArray, requestresponse);
}
}
Globals.ThisAddIn.BindDatatoExcel(trgArray);
}
else
{
MessageBox.Show("No Records Found");
}
}
else
{
ExceptionResponse(requestresponse);
}
}
else
{
ExceptionResponse(requestresponse);
}
}
}
else if (operationSelected == "Insert")
{
var JsonData = Globals.ThisAddIn.ToInsertJSON(Globals.ThisAddIn.GetValuesRange(), objectSelected);
MessageBox.Show(JsonData);
using (var client = new HttpClient())
{
Uri restRequest = new Uri(ServiceURL + "/services/data/v45.0/composite/tree/" + objectSelected);
HttpContent content = new StringContent(JsonData, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage(HttpMethod.Post, restRequest);
request.Headers.Add("Authorization", "Bearer " + authToken);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = content;
//var response = client.PostAsync(restRequest, content).Result;
var response = client.SendAsync(request).Result;
String message = response.Content.ReadAsStringAsync().Result;
Boolean success = ((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300;
if (!success)
{
ExceptionResponse(message);
}
else
{
MessageBox.Show("Inserted Records Successfully");
}
}
}
else if (operationSelected == "Update")
{
var JsonData = Globals.ThisAddIn.ToUpdateJSON(Globals.ThisAddIn.GetValuesRange(), objectSelected);
MessageBox.Show(JsonData);
using (var client = new HttpClient())
{
Uri restRequest = new Uri(ServiceURL + "/services/data/v45.0/composite/batch/");
HttpContent content = new StringContent(JsonData, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage(HttpMethod.Post, restRequest);
request.Headers.Add("Authorization", "Bearer " + authToken);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Content = content;
//var response = client.PostAsync(restRequest, content).Result;
var response = client.SendAsync(request).Result;
String message = response.Content.ReadAsStringAsync().Result;
Boolean success = ((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300;
if (!success)
{
ExceptionResponse(message);
}
else
{
MessageBox.Show("Updated Records Successfully");
}
}
}
else if (operationSelected == "Delete")
{
var JsonData = Globals.ThisAddIn.ToDeleteJson(Globals.ThisAddIn.GetValuesRange());
MessageBox.Show(JsonData);
using (var client = new HttpClient())
{
Uri restRequest = new Uri(ServiceURL + "/services/data/v45.0/composite/sobjects?ids=" + JsonData);
HttpContent content = new StringContent(JsonData, Encoding.UTF8, "application/json");
var request = new HttpRequestMessage(HttpMethod.Delete, restRequest);
request.Headers.Add("Authorization", "Bearer " + authToken);
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.SendAsync(request).Result;
String message = response.Content.ReadAsStringAsync().Result;
Boolean success = ((int)response.StatusCode) >= 200 && ((int)response.StatusCode) < 300;
if (!success)
{
ExceptionResponse(message);
}
else
{
MessageBox.Show("Deleted Records Successfully");
}
}
}
}
public async Task SendAsync_RequestVersion20_ResponseVersion20IfHttp2Supported(Uri server)
{
// We don't currently have a good way to test whether HTTP/2 is supported without
// using the same mechanism we're trying to test, so for now we allow both 2.0 and 1.1 responses.
var request = new HttpRequestMessage(HttpMethod.Get, server);
request.Version = new Version(2, 0);
using (var handler = new HttpClientHandler())
using (var client = new HttpClient(handler, false))
{
// It is generally expected that the test hosts will be trusted, so we don't register a validation
// callback in the usual case.
//
// However, on our Debian 8 test machines, a combination of a server side TLS chain,
// the client chain processor, and the distribution's CA bundle results in an incomplete/untrusted
// certificate chain. See https://github.com/dotnet/corefx/issues/9244 for more details.
if (PlatformDetection.IsDebian8)
{
// Func<HttpRequestMessage, X509Certificate2, X509Chain, SslPolicyErrors, bool>
handler.ServerCertificateCustomValidationCallback = (msg, cert, chain, errors) =>
{
Assert.InRange(chain.ChainStatus.Length, 0, 1);
if (chain.ChainStatus.Length > 0)
{
Assert.Equal(X509ChainStatusFlags.PartialChain, chain.ChainStatus[0].Status);
}
return true;
};
}
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(
response.Version == new Version(2, 0) ||
response.Version == new Version(1, 1),
"Response version " + response.Version);
}
}
}
/// <summary>
/// K5のOAuth認証を行う
/// </summary>
/// <returns></returns>
private async Task <string> GetAccessTokenAsync()
{
string token = null;
if (this.TokenExpireUtcTime >= DateTime.UtcNow)
{
token = this.AccessToken;
return(token);
}
try
{
// プロキシ設定
var ch = new HttpClientHandler()
{
UseCookies = true
};
if (!string.IsNullOrEmpty(this.ProxyServer))
{
var proxy = new System.Net.WebProxy(this.ProxyServer);
if (!string.IsNullOrEmpty(this.ProxyId) && !string.IsNullOrEmpty(this.ProxyPassword))
{
proxy.Credentials = new System.Net.NetworkCredential(this.ProxyId, this.ProxyPassword);
}
ch.Proxy = proxy;
}
else
{
ch.Proxy = null;
}
// 認証呼び出し
using (var client = new HttpClient(ch))
{
using (var request = new HttpRequestMessage())
{
var authBodyJsonString = "";
{
using (var ms = new MemoryStream())
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(TAuthReq));
var body = new TAuthReq()
{
clientId = this.ClientID,
clientSecret = this.ClientPassword
};
using (var sr = new StreamReader(ms))
{
serializer.WriteObject(ms, body);
ms.Position = 0;
authBodyJsonString = sr.ReadToEnd();
}
}
}
request.Method = HttpMethod.Post;
request.RequestUri = new Uri(OAuthUrlString);
request.Headers.Add("Connection", "close");
client.Timeout = TimeSpan.FromSeconds(10);
request.Content = new ByteArrayContent(Encoding.UTF8.GetBytes(authBodyJsonString)); // Content-Typeを無理やりつける
request.Content.Headers.TryAddWithoutValidation(@"Content-Type", @"application/json");
request.Headers.Add("Accept", "application/json");
var response = await client.SendAsync(request);
var jsonString = await response.Content.ReadAsStringAsync();
using (var json = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonString)))
{
var ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(TAuthRes));
{
var result = ser.ReadObject(json) as TAuthRes;
token = result.accessToken;
this.TokenExpireUtcTime = DateTime.UtcNow.AddSeconds(result.expiration - 60);
}
}
}
}
this.LastAccessTokenError = "";
}
catch (Exception ex)
{
if (ex.Message != this.LastAccessTokenError)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
this.LastAccessTokenError = ex.Message;
}
this.TokenExpireUtcTime = DateTime.MinValue;
}
return(token);
}
private async Task<Version> SendRequestAndGetRequestVersionAsync(Version requestVersion)
{
Version receivedRequestVersion = null;
await LoopbackServer.CreateServerAsync(async (server, url) =>
{
var request = new HttpRequestMessage(HttpMethod.Get, url);
request.Version = requestVersion;
using (var client = new HttpClient())
{
Task<HttpResponseMessage> getResponse = client.SendAsync(request);
List<string> receivedRequest = await LoopbackServer.ReadRequestAndSendResponseAsync(server);
using (HttpResponseMessage response = await getResponse)
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
string statusLine = receivedRequest[0];
if (statusLine.Contains("/1.0"))
{
receivedRequestVersion = new Version(1, 0);
}
else if (statusLine.Contains("/1.1"))
{
receivedRequestVersion = new Version(1, 1);
}
else
{
Assert.True(false, "Invalid HTTP request version");
}
}
});
return receivedRequestVersion;
}
/// <summary>
/// テキストを翻訳する
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
internal async Task <string> GetTranslation(string message, string orignalLangCode, string langCode)
{
var translation = string.Empty;
this.AccessToken = await GetAccessTokenAsync();
try
{
// プロキシ設定
var ch = new HttpClientHandler()
{
UseCookies = true
};
if (!string.IsNullOrEmpty(this.ProxyServer))
{
var proxy = new System.Net.WebProxy(this.ProxyServer);
if (!string.IsNullOrEmpty(this.ProxyId) && !string.IsNullOrEmpty(this.ProxyPassword))
{
proxy.Credentials = new System.Net.NetworkCredential(this.ProxyId, this.ProxyPassword);
}
ch.Proxy = proxy;
}
else
{
ch.Proxy = null;
}
// Web API呼び出し
using (var client = new HttpClient(ch))
{
using (var request = new HttpRequestMessage())
{
var questionJsonString = "";
{
using (var ms = new MemoryStream())
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(TTranslatorItem));
var body = new TTranslatorItem()
{
source = message
};
using (var sr = new StreamReader(ms))
{
serializer.WriteObject(ms, body);
ms.Position = 0;
questionJsonString = sr.ReadToEnd();
}
}
}
request.Method = HttpMethod.Post;
request.RequestUri = new Uri(string.Format(UrlString + "?langFrom={0}&langTo={1}&profile=default", orignalLangCode, langCode));
request.Headers.Add("X-Access-Token", this.AccessToken);
request.Content = new StringContent(questionJsonString, Encoding.UTF8, "application/json");
request.Headers.Add("Connection", "close");
client.Timeout = TimeSpan.FromSeconds(10);
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var jsonString = await response.Content.ReadAsStringAsync();
translation = jsonString;
using (var json = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonString)))
{
var ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(TResult));
{
var result = ser.ReadObject(json) as TResult;
translation = result.response.translation;
json.Close();
}
}
}
}
}
this.LastAccessTokenError = "";
}
catch (Exception ex)
{
if (ex.Message != this.LastAccessTokenError)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
this.LastAccessTokenError = ex.Message;
}
}
return(translation);
}
public async Task SendAsync_Cancel_CancellationTokenPropagates()
{
var cts = new CancellationTokenSource();
cts.Cancel();
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Post, Configuration.Http.RemoteEchoServer);
TaskCanceledException ex = await Assert.ThrowsAsync<TaskCanceledException>(() =>
client.SendAsync(request, cts.Token));
Assert.True(cts.Token.IsCancellationRequested, "cts token IsCancellationRequested");
Assert.True(ex.CancellationToken.IsCancellationRequested, "exception token IsCancellationRequested");
}
}
/// <inheritdoc />
public async Task <HttpResponseMessage> GetAsync(HttpRequestMessage request)
{
request.Method = HttpMethod.Get;
return(await _httpClient.SendAsync(request));
}
public async System.Threading.Tasks.Task <ICustomActivityResult> Execute()
{
HttpClient client = new HttpClient();
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications);
UriBuilder UriBuilder = new UriBuilder(endPoint);
UriBuilder.Path = uriBuilderPath;
UriBuilder.Query = AyehuHelper.queryStringBuilder(queryStringArray);
HttpRequestMessage myHttpRequestMessage = new HttpRequestMessage(new HttpMethod(httpMethod), UriBuilder.ToString());
if (contentType == "application/x-www-form-urlencoded")
{
myHttpRequestMessage.Content = AyehuHelper.formUrlEncodedContent(postData);
}
else
if (string.IsNullOrEmpty(postData) == false)
{
if (omitJsonEmptyorNull)
{
myHttpRequestMessage.Content = new StringContent(AyehuHelper.omitJsonEmptyorNull(postData), Encoding.UTF8, "application/json");
}
else
{
myHttpRequestMessage.Content = new StringContent(postData, Encoding.UTF8, contentType);
}
}
foreach (KeyValuePair <string, string> headeritem in headers)
{
client.DefaultRequestHeaders.Add(headeritem.Key, headeritem.Value);
}
HttpResponseMessage response = client.SendAsync(myHttpRequestMessage).Result;
switch (response.StatusCode)
{
case HttpStatusCode.NoContent:
case HttpStatusCode.Created:
case HttpStatusCode.Accepted:
case HttpStatusCode.OK:
{
if (string.IsNullOrEmpty(response.Content.ReadAsStringAsync().Result) == false)
{
return(this.GenerateActivityResult(response.Content.ReadAsStringAsync().Result, Jsonkeypath));
}
else
{
return(this.GenerateActivityResult("Success"));
}
}
default:
{
if (string.IsNullOrEmpty(response.Content.ReadAsStringAsync().Result) == false)
{
throw new Exception(response.Content.ReadAsStringAsync().Result);
}
else if (string.IsNullOrEmpty(response.ReasonPhrase) == false)
{
throw new Exception(response.ReasonPhrase);
}
else
{
throw new Exception(response.StatusCode.ToString());
}
}
}
}
private async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request)
{
return(await _client.SendAsync(request));
}