internal static async Task <Template> ReadTemplate(MultipartSection section)
{
var content = new StreamContent(section.Body);
var text = await content.ReadAsStringAsync();
return(TemplateSerializer.Deserialize(new StringReader(text)) as Template);
}
private async Task <string> GetRequestBodyContentAsync()
{
var streamContent = new StreamContent(this.HttpContext.Request.Body);
var stringContent = await streamContent.ReadAsStringAsync();
return(stringContent);
}
public static async Task ParseFiles(Stream data, string contentType, Action <string, Stream> fileProcessor)
{
var streamCotent = new StreamContent(data);
streamCotent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
if (streamCotent.IsMimeMultipartContent())
{
var provider = await streamCotent.ReadAsMultipartAsync();
foreach (var httpContent in provider.Contents)
{
var filename = httpContent.Headers.ContentDisposition.FileName;
using (var fileContents = await httpContent.ReadAsStreamAsync())
{
if (string.IsNullOrWhiteSpace(filename))
{
fileProcessor(httpContent.Headers.ContentDisposition.Name.Trim('\"'), fileContents);
continue;
}
fileProcessor(filename.Trim('\"'), fileContents);
}
}
}
else
{
var formdata = await streamCotent.ReadAsFormDataAsync();
var str = await streamCotent.ReadAsStringAsync();
var stream = await streamCotent.ReadAsStreamAsync();
}
}
private void PostLoggingEvent(LoggingEvent[] loggingEvents)
{
var formatter = new LokiBatchFormatter(labels);
var httpClient = new LokiHttpClient(TrustSelfCignedCerts);
if (httpClient is LokiHttpClient c)
{
LokiCredentials credentials;
if (!string.IsNullOrEmpty(BasicAuthUserName) && !string.IsNullOrEmpty(BasicAuthPassword))
{
credentials = new BasicAuthCredentials(ServiceUrl, BasicAuthUserName, BasicAuthPassword);
}
else
{
credentials = new NoAuthCredentials(ServiceUrl);
}
c.SetAuthCredentials(credentials);
}
using (MemoryStream ms = new MemoryStream())
using (var sc = new StreamWriter(ms))
{
formatter.Format(loggingEvents, sc);
sc.Flush();
ms.Position = 0;
var content = new StreamContent(ms);
var contentStr = content.ReadAsStringAsync().Result; // TO VERIFY
httpClient.PostAsync(LokiRouteBuilder.BuildPostUri(ServiceUrl), content);
}
}
public void WriteToStreamAsync_SetsMetadataUriWithSelectClause_OnODataWriterSettings()
{
// Arrange
MemoryStream stream = new MemoryStream();
StreamContent content = new StreamContent(stream);
content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
IEdmModel model = CreateModel();
IEdmSchemaType entityType = model.FindDeclaredType("System.Net.Http.Formatting.SampleType");
IEdmStructuralProperty property =
((IEdmStructuredType)entityType).FindProperty("Number") as IEdmStructuralProperty;
HttpRequestMessage request = CreateFakeODataRequest(model);
request.RequestUri = new Uri("http://localhost/sampleTypes?$select=Number");
request.ODataProperties().SelectExpandClause =
new SelectExpandClause(
new Collection <SelectItem>
{
new PathSelectItem(new ODataSelectPath(new PropertySegment(property))),
},
allSelected: false);
ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.Resource);
// Act
formatter.WriteToStreamAsync(typeof(SampleType[]), new SampleType[0], stream, content, transportContext: null);
// Assert
stream.Seek(0, SeekOrigin.Begin);
string result = content.ReadAsStringAsync().Result;
JObject obj = JObject.Parse(result);
Assert.Equal("http://localhost/$metadata#sampleTypes(Number)", obj["@odata.context"]);
}
public static async Task <CharacterInfo> GetCharacterInfoAsync(string token, CancellationToken cancel_token)
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Hyperwave", "1.0"));
HttpResponseMessage msg;
try
{
msg = await client.GetAsync("https://login.eveonline.com/oauth/verify", cancel_token);
}
catch (Exception)
{
return(null);
}
if (!msg.IsSuccessStatusCode)
{
return(null);
}
StreamContent stream = msg.Content as StreamContent;
string text = await stream.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <CharacterInfo>(text));
}
}
public async Task <ObjectResult> JavaPlayGround()
{
var streamContent = new StreamContent(Request.Body);
var codeSnippet = await streamContent.ReadAsStringAsync();
var mainFilePath = $"{JavaFolder}src/main/java/JavaConsole/App.java";
SnippetRunner.FileSplicer(mainFilePath, codeSnippet);
var gradle = SnippetRunner.FindExecutable("gradle.exe");
string returnString;
if (string.IsNullOrEmpty(gradle))//we are in linux
{
var buildResponse = SnippetRunner.RunCommand(null, $"./gradlew build", JavaFolder);
var runResponse = SnippetRunner.RunCommand(null, "./gradlew run", JavaFolder);
returnString = buildResponse + "\r\n\r\n\r\n" + runResponse;
}
else//we are running in a windows environment
{
var buildResponse = SnippetRunner.RunCommand(gradle, "build", JavaFolder);
var runResponse = SnippetRunner.RunCommand(gradle, "run", JavaFolder);
returnString = buildResponse + "\r\n\r\n\r\n" + runResponse;
}
return(new OkObjectResult(returnString));
}
public async Task <ObjectResult> CsharpPlayGround()
{
var streamContent = new StreamContent(Request.Body);
var codeSnippet = await streamContent.ReadAsStringAsync();
var mainFilePath = $"{ProjectFolder}Program.cs";
SnippetRunner.FileSplicer(mainFilePath, codeSnippet);
var dotnet = SnippetRunner.FindExecutable("dotnet.exe");
string returnString;
if (string.IsNullOrEmpty(dotnet))//we are in linux
{
var buildResponse = SnippetRunner.RunCommand(null, $"dotnet build {ProjectFolder}ConsoleApp.csproj", null);
var runResponse = SnippetRunner.RunCommand(null, "dotnet run", ProjectFolder);
returnString = buildResponse + "\r\n\r\n\r\n" + runResponse;
}
else//we are running in a windows environment
{
var buildResponse = SnippetRunner.RunCommand("dotnet", "build", ProjectFolder);
var runResponse = SnippetRunner.RunCommand(dotnet, "run", ProjectFolder);
returnString = buildResponse + "\r\n\r\n\r\n" + runResponse;
}
return(new OkObjectResult(returnString));
}
private Boolean IsTreePage(Int32 id)
{
NetworkCredential credential = new NetworkCredential(_config.ConfluenceSettings.Login, _config.ConfluenceSettings.Password);
var handler = new HttpClientHandler {
Credentials = credential
};
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(_config.ConfluenceSettings.Url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response =
client.GetAsync(String.Format("wiki/rest/api/content/{0}/child/page?os_authType=basic", id));
if (response.Result.IsSuccessStatusCode)
{
StreamContent content = (StreamContent)response.Result.Content;
var task = content.ReadAsStringAsync();
String stringContent = task.Result;
dynamic results = JObject.Parse(stringContent);
if (results.size != null)
{
return(results.size.Value > 0);
}
}
}
return(false);
}
public void WriteToStreamAsync_SetsMetadataUriWithSelectClause_OnODataWriterSettings()
{
// Arrange
MemoryStream stream = new MemoryStream();
StreamContent content = new StreamContent(stream);
content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
IEdmModel model = CreateModel();
HttpRequestMessage request = CreateFakeODataRequest(model);
request.RequestUri = new Uri("http://localhost/Customers?$select=something");
request.SetSelectExpandClause(new SelectExpandClause(new SelectItem[0], allSelected: true));
ODataMediaTypeFormatter formatter = CreateFormatter(model, request, ODataPayloadKind.Entry);
// Act
formatter.WriteToStreamAsync(typeof(SampleType[]), new SampleType[0], stream, content, transportContext: null);
// Assert
// This is ugly, but ODataWriter doesn't expose the writer settings that it uses. So, validate that
// the $select clause shows up in the response payload.
stream.Seek(0, SeekOrigin.Begin);
string result = content.ReadAsStringAsync().Result;
Assert.Contains("$select=something", result);
}
private Task <string> StreamToString(Stream stream)
{
var content = new StreamContent(stream);
stream.Position = 0;
return(content.ReadAsStringAsync());
}
public static async Task <string> SerializeAsync <T>(this MediaTypeFormatter formatter, T value)
{
Stream stream = new MemoryStream();
var content = new StreamContent(stream);
formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait();
stream.Position = 0;
return(await content.ReadAsStringAsync());
}
public async Task <PayResult> Pay(string paytype)
{
var stream = await this.httpClient.GetStreamAsync("all.json");
using (StreamContent streamContent = new StreamContent(stream))
{
return(new PayResult($"{ paytype }---{await streamContent.ReadAsStringAsync()}"));
}
}
private static void Main(string[] args)
{
const int TotalRun = 10 * 1000;
var customerController = new CustomerController();
var orderController = new OrderController();
var customer = customerController.Get(1);
var orders = new List <Order>();
foreach (var orderId in customer.OrderIds)
{
orders.Add(orderController.Get(1, orderId));
}
var fullCustomer = new FullCustomer(customer)
{
Orders = orders
};
var s = JsonConvert.SerializeObject(fullCustomer);
var bytes = Encoding.UTF8.GetBytes(s);
var stream = new MemoryStream(bytes);
var content = new StreamContent(stream);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var stopwatch = Stopwatch.StartNew();
for (int i = 1; i < TotalRun + 1; i++)
{
var a = content.ReadAsAsync <FullCustomer>().Result;
if (i % 100 == 0)
{
Console.Write("\r" + i);
}
}
Console.WriteLine();
Console.WriteLine(stopwatch.Elapsed);
stopwatch.Restart();
for (int i = 1; i < TotalRun + 1; i++)
{
var sa = content.ReadAsStringAsync().Result;
var a = JsonConvert.DeserializeObject <FullCustomer>(sa);
if (i % 100 == 0)
{
Console.Write("\r" + i);
}
}
Console.WriteLine();
Console.WriteLine(stopwatch.Elapsed);
Console.Read();
}
private ICollection <PageModel> GetUserManualPages(Int32 id)
{
var pages = new List <PageModel>();
NetworkCredential credential = new NetworkCredential(_config.ConfluenceSettings.Login, _config.ConfluenceSettings.Password);
var handler = new HttpClientHandler {
Credentials = credential
};
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(_config.ConfluenceSettings.Url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response =
client.GetAsync(String.Format("wiki/rest/api/content/{0}/child/page?os_authType=basic", id));
if (response.Result.IsSuccessStatusCode)
{
StreamContent content = (StreamContent)response.Result.Content;
var task = content.ReadAsStringAsync();
String stringContent = task.Result;
dynamic results = JObject.Parse(stringContent);
var regex = new Regex("\\[([^)]*)\\] ");
if (results.results != null)
{
if (results.results.Type == JTokenType.Array && results.results.Count > 0)
{
foreach (var result in results.results)
{
var pageId = Int32.Parse(result.id.Value);
var pageTitle = regex.Replace((result.title.Value as String).Replace(".", "%2E"), String.Empty);
var subPages = new List <PageModel>();
var pageContent = String.Empty;
if (IsTreePage(pageId))
{
subPages = GetUserManualPages(pageId);
}
else
{
pageContent = GetUserManualPageContent(pageId);
}
pages.Add(new PageModel
{
Content = pageContent,
Id = pageId,
Title = pageTitle,
Pages = subPages
});
}
}
}
}
}
return(pages);
}
private static string Serialize <T>(MediaTypeFormatter formatter, T value)
{
var stream = new MemoryStream();
var content = new StreamContent(stream);
formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait();
stream.Position = 0;
return(content.ReadAsStringAsync().Result);
}
public static void UsingStreamContent()
{
// When you have a stream of data, StreamContent is your best bet.
var bytes = Encoding.ASCII.GetBytes(Helpers.__);
var stream = new MemoryStream(bytes);
var content = new StreamContent(stream);
var body = content.ReadAsStringAsync().Result;
Helpers.AssertEquality("Hello, stream!", body);
}
public static string Serialize <T>(T value, MessageMediaTypes mediaType = MessageMediaTypes.Json)
{
var formatter = (mediaType == MessageMediaTypes.Json) ? (MediaTypeFormatter) new JsonMediaTypeFormatter() : (MediaTypeFormatter) new XmlMediaTypeFormatter();
Stream stream = new MemoryStream();
var content = new StreamContent(stream);
formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait();
stream.Position = 0;
return(content.ReadAsStringAsync().Result);
}
private string SerializeCollection <T>(MediaTypeFormatter formatter, IEnumerable <T> value, MediaTypeHeaderValue mediaType)
{
Stream stream = new MemoryStream();
HttpContent content = new StreamContent(stream);
content.Headers.ContentType = mediaType;
formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait();
stream.Position = 0;
return(content.ReadAsStringAsync().Result);
}
protected string Serialize <T>(MediaTypeFormatter formatter, T value)
{
// Create a dummy HTTP Content.
Stream stream = new MemoryStream();
var content = new StreamContent(stream);
/// Serialize the object.
formatter.WriteToStreamAsync(typeof(T), value, stream, content, null).Wait();
// Read the serialized string.
stream.Position = 0;
return(content.ReadAsStringAsync().Result);
}
private async Task <string> AddVersion(UserConfiguration uc, CancellationToken cancelToken)
{
string versionID = "";
Dictionary <string, string> formParms = new Dictionary <string, string>();
formParms.Add("bundle_version", _appInfo.Version);
FormUrlEncodedContent paramContent = new FormUrlEncodedContent(formParms);
HttpClient client = HttpClientFactory.Create();
client.DefaultRequestHeaders.Add("X-HockeyAppToken", uc.UserToken);
HttpResponseMessage response = await client.PostAsync(uc.ApiBase + "apps/" + _appInfo.PublicID + "/app_versions/new", paramContent, cancelToken);
if (response.StatusCode == HttpStatusCode.Created)
{
StreamContent sr = response.Content as StreamContent;
string result = await sr.ReadAsStringAsync();
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic responseInfo = serializer.Deserialize <object>(result);
versionID = ((Dictionary <string, object>)responseInfo)["id"].ToString();
}
else
{
StreamContent sr = response.Content as StreamContent;
string result = await sr.ReadAsStringAsync();
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic responseInfo = serializer.Deserialize <object>(result);
Dictionary <string, object> errors = responseInfo["errors"];
StringBuilder message = new StringBuilder();
message.AppendLine(response.ReasonPhrase);
foreach (string key in errors.Keys)
{
object[] values = (object[])errors[key];
string val = "";
foreach (object obj in values)
{
val += obj.ToString() + ", ";
}
if (val.Length > -2)
{
val = val.Substring(0, val.Length - 2);
}
message.AppendLine(key + ":" + val);
}
throw new Exception(message.ToString());
}
return(versionID);
}
public void ReadAsString()
{
var ms = new MemoryStream();
ms.WriteByte(77);
ms.WriteByte(55);
ms.Seek(0, SeekOrigin.Begin);
var sc = new StreamContent(ms);
var res = sc.ReadAsStringAsync().Result;
Assert.AreEqual("M7", res, "#1");
}
public async Task ReplaceAsync(HttpRequestMessage target, HttpRequest source, ReplaceString[] replacements)
{
using (var content = new StreamContent(source.Body))
{
var result = await content.ReadAsStringAsync();
foreach (var replacement in replacements)
{
result = result.Replace(replacement.OldValue, replacement.NewValue);
}
target.Content = new StringContent(result);
}
}
public async Task <dynamic> DownloadJsonData(DataLakeFileSystemClient fileSystemClient, string directory, string filePath)
{
DataLakeDirectoryClient directoryClient =
fileSystemClient.GetDirectoryClient(directory);
DataLakeFileClient fileClient =
directoryClient.GetFileClient(filePath);
Response <FileDownloadInfo> downloadResponse = await fileClient.ReadAsync();
var streamContent = new StreamContent(downloadResponse.Value.Content);
var stringContent = await streamContent.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <dynamic>(stringContent));
}
public async Task StreamContent_can_be_used_when_content_is_in_a_stream()
{
const string thisFileName = @"..\..\HttpContentFacts.cs";
var stream = new FileStream(thisFileName, FileMode.Open, FileAccess.Read);
using (var content = new StreamContent(stream))
{
content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
// Assert
var text = await content.ReadAsStringAsync();
Assert.True(text.Contains("this string"));
}
Assert.Throws <ObjectDisposedException>(() => stream.Read(new byte[1], 0, 1));
}
/// <summary>
/// Serializa o objeto em string
/// </summary>
/// <typeparam name="T">Tipo real desse objeto</typeparam>
/// <param name="formatter">Instância de um MediaTypeFormatter</param>
/// <returns></returns>
public static async Task <string> Serialize <T>(this Object instance, MediaTypeFormatter formatter)
{
// Create a dummy HTTP Content.
using (Stream stream = new MemoryStream())
{
using (var content = new StreamContent(stream))
{
/// Serialize the object.
await formatter.WriteToStreamAsync(typeof(T), instance, stream, content, null);
// Read the serialized string.
stream.Position = 0;
return(await content.ReadAsStringAsync());
}
}
}
public void Delete(string ApiToken, string url)
{
string userpass = ApiToken + ":api_token";
string userpassB64 = Convert.ToBase64String(Encoding.Default.GetBytes(userpass.Trim()));
HttpClient httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", userpassB64);
Task <HttpResponseMessage> task = httpClient.DeleteAsync(url);
task.Wait();
HttpResponseMessage result = task.Result;
StreamContent content = result.Content as StreamContent;
var readAsStringTask = content.ReadAsStringAsync();
readAsStringTask.Wait();
string contentStringResult = readAsStringTask.Result;
}
public async Task <IActionResult> CreateComposeApp([FromRoute] string name, IFormCollection formData)
{
var composeFile = formData.Files.FirstOrDefault(f => f.FileName.EndsWith(".yml"));
if (composeFile == null)
{
return(BadRequest());
}
var streamContent = new StreamContent(composeFile.OpenReadStream());
var composeFileContent = await streamContent.ReadAsStringAsync();
var composeApplication = new ComposeApplication(name, composeFileContent);
await _clusterManager.CreateComposeApp(composeApplication);
return(Ok(new { result = $"Application {name} created" }));
}
private async Task <String> GetContentAsync(Int32 id, Func <Int32, String, String> parser)
{
if (_cache.ContainsKey(id))
{
return(parser(id, _cache[id]));
}
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(
$"{_config.ConfluenceSettings.Login}:{_config.ConfluenceSettings.Password}");
var base64Auth = System.Convert.ToBase64String(plainTextBytes);
NetworkCredential credential = new NetworkCredential(_config.ConfluenceSettings.Login, _config.ConfluenceSettings.Password);
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications);
ServicePointManager.ServerCertificateValidationCallback += new RemoteCertificateValidationCallback(AlwaysGoodCertificate);
var handler = new HttpClientHandler {
Credentials = credential
};
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(_config.ConfluenceSettings.Url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", base64Auth);
var response =
client.GetAsync($"wiki/rest/api/content/{id}?expand=body.view&os_authType=basic");
if (response.Result.IsSuccessStatusCode)
{
StreamContent content = (StreamContent)response.Result.Content;
var task = content.ReadAsStringAsync();
String result = task.Result;
String parsed = parser(id, result);
return(parsed);
}
}
throw new ContentNotFoundException(id);
}
public static async Task <TokenInfo> GetTokenInfoAsync(string authcode, string challenge_code, CancellationToken token)
{
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Hyperwave", "1.0"));
HttpContent content = new FormUrlEncodedContent(new Dictionary <string, string>()
{
{ "grant_type", "authorization_code" },
{ "code", authcode },
{ "client_id", SSOConfiguration.ClientId },
{ "code_verifier", challenge_code }
});
DateTime tm = DateTime.Now;
HttpResponseMessage msg;
try
{
msg = await client.PostAsync("https://login.eveonline.com/v2/oauth/token", content, token);
}
catch (Exception)
{
return(null);
}
if (!msg.IsSuccessStatusCode)
{
return(null);
}
StreamContent stream = msg.Content as StreamContent;
string text = await stream.ReadAsStringAsync();
var ret = JsonConvert.DeserializeObject <TokenInfo>(text);
ret.LoginDate = tm;
return(ret);
}
}
