public async Task<bool> TelemetryIngest(Telemetry telemetry)
{
string serviceBusNamespace = "iotmc-ns";
string serviceBusUri = string.Format("{0}.servicebus.windows.net", serviceBusNamespace);
string eventHubName = "IoTMC";
string eventHubSASKeyName = "Device01";
string eventHubSASKey = "<< Your SAS Key here >>";
using (HttpClient httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(String.Format("https://{0}", serviceBusUri));
httpClient.DefaultRequestHeaders.Accept.Clear();
string sBToken = CreateServiceBusSASToken(eventHubSASKeyName, eventHubSASKey, serviceBusUri);
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("SharedAccessSignature", sBToken);
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(telemetry), Encoding.UTF8);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
string ingestPath = String.Format("/{0}/publishers/device01/messages", eventHubName);
var response = await httpClient.PostAsync(ingestPath, httpContent);
if (response.IsSuccessStatusCode)
{
return true;
}
return false;
}
}
public async Task Ctor_EmptyString_Accept()
{
// Consider empty strings like null strings (null and empty strings should be treated equally).
var content = new StringContent(string.Empty);
Stream result = await content.ReadAsStreamAsync();
Assert.Equal(0, result.Length);
}
public void ReadDeeplyNestedObjectThrows()
{
FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter() { MaxDepth = 100 };
StringContent content = new StringContent(GetDeeplyNestedObject(125));
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
Assert.ThrowsArgument(
() => formatter.ReadFromStreamAsync(typeof(JToken), content.ReadAsStreamAsync().Result, content.Headers, null).Result,
null);
}
public static async Task<string> PostCallAsync(string url, string parameters)
{
var content = new StringContent(parameters);
string output = string.Empty;
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PostAsync(url, content);
output = await response.Content.ReadAsStringAsync();
}
return output;
}
public void GivenSomeContentWithNoBadPhrases_PhrasesThatExist_ReturnsANullList()
{
// Arrange.
const string content =
"foo 1 12l3j1kl;j434;5 3klkrj 987*&^897^DF hsfd l;ajf;o2u3r8fjdasf jdsajf ;aljsfj asf jas;df 8asuf 80sdf 9d (& 8H ";
var stringContent = new StringContent(PhraseList);
// Act.
var results = stringContent.PhrasesThatExist(content);
// Assert.
Assert.Null(results);
}
/// <summary>
/// Initializes a new instance of the <see cref="PapRequestMessage"/>
/// class with both control and content parts.
/// </summary>
/// <param name="control">The control.</param>
/// <param name="content">The content.</param>
public PapRequestMessage(PushMessageControl control, StringContent content)
{
_control = control;
_content = content;
BoundaryGenerator bg = new BoundaryGenerator();
Boundary = bg.MakeBoundary();
if (content != null && control != null)
{
content.PushId = control.PushId;
}
}
public void Dispose_DisposesInnerContent()
{
// Arrange
StringContent innerContent = new StringContent("HelloWorld!");
HttpRequestMessage request = new HttpRequestMessage();
ProgressMessageHandler progressHandler = new ProgressMessageHandler();
ProgressContent progressContent = new ProgressContent(innerContent, progressHandler, request);
// Act
progressContent.Dispose();
// Assert
Assert.ThrowsObjectDisposed(() => innerContent.LoadIntoBufferAsync(), typeof(StringContent).FullName);
}
public async Task<CompositeType> GetDataUsingDataContract(CompositeType composite)
{
var soapString = this.CreateGetDataUsingDataContractRequest(composite);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("SOAPAction", "http://tempuri.org/IService1/GetDataUsingDataContract");
var content = new StringContent(soapString, Encoding.UTF8, "text/xml");
using (var response = await client.PostAsync(this.uri, content))
{
string soapResponse = await response.Content.ReadAsStringAsync();
CompositeType result = this.ParseGetDataUsingDataContractResponse(soapResponse);
return result;
}
}
}
public void GivenSomeContentWithBadPhrases_PhrasesThatExist_ReturnsAListOfBadPhrasesFound()
{
// Arrange.
const string content =
"This is a bad review. I noticed that there were a lot of white people living in Ivanhoe. This doesn't mean this is a racist suburb, though.";
var stringContent = new StringContent(PhraseList);
// Act.
var results = stringContent.PhrasesThatExist(content);
// Assert.
Assert.NotNull(results);
Assert.NotEmpty(results);
Assert.Equal(2, results.Count);
}
public void Constructor_CopyHeadersFromInnerContent()
{
// Arrange
StringContent innerContent = new StringContent("HelloWorld!");
innerContent.Headers.Add(TestHeader, TestValue);
HttpRequestMessage request = new HttpRequestMessage();
ProgressMessageHandler progressHandler = new ProgressMessageHandler();
// Act
ProgressContent progressContent = new ProgressContent(innerContent, progressHandler, request);
// Assert
ValidateContentHeader(progressContent);
Assert.Equal(innerContent.Headers.ContentType, progressContent.Headers.ContentType);
Assert.Equal(innerContent.Headers.ContentLength, progressContent.Headers.ContentLength);
}
public async Task Ctor_UseCustomEncodingAndMediaType_EncodingUsedAndContentTypeHeaderUpdated()
{
// Use UTF-8 encoding to serialize a chinese string.
string sourceString = "\u4f1a\u5458\u670d\u52a1";
var content = new StringContent(sourceString, Encoding.UTF8, "application/custom");
Assert.Equal("application/custom", content.Headers.ContentType.MediaType);
Assert.Equal("utf-8", content.Headers.ContentType.CharSet);
var destination = new MemoryStream(12);
await content.CopyToAsync(destination);
string destinationString = Encoding.UTF8.GetString(destination.ToArray(), 0, (int)destination.Length);
Assert.Equal(sourceString, destinationString);
}
public void GivenSomeContentWithBadPhrasesSuppliedSeparately_PhrasesThatExist_ReturnsAListOfBadPhrasesFound()
{
// Arrange.
const string content =
"This is a bad review. &^*(sd79ad hskah sad (*&(&97s a9 I noticed adult living that there were a lot of white people living in Ivanhoe. This doesn't mean this is a racist suburb, though.";
var stringContent = new StringContent();
// Act.
var results = stringContent.PhrasesThatExist(content, PhraseList);
// Assert.
Assert.NotNull(results);
Assert.NotEmpty(results);
Assert.Equal(3, results.Count);
Assert.Equal("adult living", results.First().Phrase);
Assert.Equal(65, results.First().IndexOn);
}
public async Task Ctor_DefineNoEncoding_DefaultEncodingUsed()
{
string sourceString = "\u00C4\u00E4\u00FC\u00DC";
var content = new StringContent(sourceString);
Encoding defaultStringEncoding = Encoding.GetEncoding("utf-8");
// If no encoding is defined, the default encoding is used: utf-8
Assert.Equal("text/plain", content.Headers.ContentType.MediaType);
Assert.Equal(defaultStringEncoding.WebName, content.Headers.ContentType.CharSet);
// Make sure the default encoding is also used when serializing the content.
var destination = new MemoryStream();
await content.CopyToAsync(destination);
Assert.Equal(8, destination.Length);
destination.Seek(0, SeekOrigin.Begin);
string roundTrip = new StreamReader(destination, defaultStringEncoding).ReadToEnd();
Assert.Equal(sourceString, roundTrip);
}
public Task SendAsync_DoesNotInsertSendProgressWithoutEntityOrHandlerPresent(bool insertRequestEntity, bool addSendProgressHandler)
{
// Arrange
HttpMessageInvoker invoker = CreateMessageInvoker(includeResponseEntity: false, addReceiveProgressHandler: false, addSendProgressHandler: addSendProgressHandler);
HttpRequestMessage request = new HttpRequestMessage();
HttpContent content = null;
if (insertRequestEntity)
{
content = new StringContent("Request Entity!");
content.Headers.Add(TestHeader, TestValue);
request.Content = content;
}
// Act
return invoker.SendAsync(request, CancellationToken.None).ContinueWith(
task =>
{
// Assert
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
if (insertRequestEntity && addSendProgressHandler)
{
ValidateContentHeader(request.Content);
Assert.NotSame(content, request.Content);
Assert.IsType<ProgressContent>(request.Content);
}
else
{
if (insertRequestEntity)
{
Assert.IsType<StringContent>(request.Content);
}
else
{
Assert.Null(request.Content);
}
}
});
}
internal static async Task <string> ExecutePost(this Web web, string endpoint, string payload)
{
string returnObject = null;
var accessToken = web.Context.GetAccessToken();
using (var handler = new HttpClientHandler())
{
web.EnsureProperty(w => w.Url);
// we're not in app-only or user + app context, so let's fall back to cookie based auth
if (String.IsNullOrEmpty(accessToken))
{
handler.SetAuthenticationCookies(web.Context as ClientContext);
}
using (var httpClient = new PnPHttpProvider(handler))
{
var requestUrl = $"{web.Url}{endpoint}";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, requestUrl);
request.Headers.Add("accept", "application/json;odata=nometadata");
if (!string.IsNullOrEmpty(accessToken))
{
request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
}
else
{
if (web.Context.Credentials is NetworkCredential networkCredential)
{
handler.Credentials = networkCredential;
}
}
request.Headers.Add("X-RequestDigest", await(web.Context as ClientContext).GetRequestDigest());
if (!string.IsNullOrEmpty(payload))
{
////var jsonBody = JsonConvert.SerializeObject(postObject);
var requestBody = new StringContent(payload);
MediaTypeHeaderValue sharePointJsonMediaType;
MediaTypeHeaderValue.TryParse("application/json;odata=nometadata;charset=utf-8", out sharePointJsonMediaType);
requestBody.Headers.ContentType = sharePointJsonMediaType;
request.Content = requestBody;
}
// Perform actual post operation
HttpResponseMessage response = await httpClient.SendAsync(request, new System.Threading.CancellationToken());
if (response.IsSuccessStatusCode)
{
// If value empty, URL is taken
var responseString = await response.Content.ReadAsStringAsync();
if (responseString != null)
{
try
{
returnObject = responseString;
}
catch { }
}
}
else
{
// Something went wrong...
throw new Exception(await response.Content.ReadAsStringAsync());
}
}
}
return(await Task.Run(() => returnObject));
}
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <exception cref="SwaggerException">A server side error occurred.</exception>
public async Task <Person> ThrowAsync(Guid id, CancellationToken cancellationToken)
{
var url_ = string.Format("{0}/{1}?", BaseUrl, "api/Persons/Throw");
if (id == null)
{
throw new ArgumentNullException("id");
}
else
{
url_ += string.Format("id={0}&", Uri.EscapeDataString(id.ToString()));
}
var client_ = new HttpClient();
var request_ = new HttpRequestMessage();
PrepareRequest(client_, ref url_);
var content_ = new StringContent(string.Empty);
request_.Content = content_;
request_.Method = new HttpMethod("POST");
request_.RequestUri = new Uri(url_, UriKind.RelativeOrAbsolute);
var response_ = await client_.SendAsync(request_, HttpCompletionOption.ResponseContentRead, cancellationToken).ConfigureAwait(false);
ProcessResponse(client_, response_);
var responseData_ = await response_.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
var status_ = ((int)response_.StatusCode).ToString();
if (status_ == "200")
{
var result_ = default(Person);
try
{
if (responseData_.Length > 0)
{
result_ = JsonConvert.DeserializeObject <Person>(Encoding.UTF8.GetString(responseData_, 0, responseData_.Length), new JsonConverter[] { new Newtonsoft.Json.Converters.StringEnumConverter(), new JsonExceptionConverter() });
}
return(result_);
}
catch (Exception exception)
{
throw new SwaggerException("Could not deserialize the response body.", status_, responseData_, exception);
}
}
else
if (status_ == "500")
{
var result_ = default(PersonNotFoundException);
try
{
if (responseData_.Length > 0)
{
result_ = JsonConvert.DeserializeObject <PersonNotFoundException>(Encoding.UTF8.GetString(responseData_, 0, responseData_.Length), new JsonConverter[] { new Newtonsoft.Json.Converters.StringEnumConverter(), new JsonExceptionConverter() });
}
}
catch (Exception exception)
{
throw new SwaggerException("Could not deserialize the response body.", status_, responseData_, exception);
}
if (result_ == null)
{
result_ = new PersonNotFoundException();
}
result_.Data.Add("HttpStatus", status_);
result_.Data.Add("ResponseData", Encoding.UTF8.GetString(responseData_, 0, responseData_.Length));
throw new SwaggerException <PersonNotFoundException>("A server side error occurred.", status_, responseData_, result_, result_);
}
else
{
}
throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", status_, responseData_, null);
}
public async Task <HttpResponseMessage> Request(HttpMethod httpMethod, string endpoint,
object content = null, object queryParams = null, RestRequestConfig restRequestConfig = null)
{
HttpContent httpContent = null;
if (content is HttpContent)
{
httpContent = (HttpContent)content;
}
else if (content is string s)
{
httpContent = new StringContent(s);
}
else if (content != null)
{
httpContent = new StringContent(
JsonConvert.SerializeObject(content, Formatting.None, jsonSerializerSettings), Encoding.UTF8,
"application/json"
);
}
UriBuilder uriBuilder = null;
if (endpoint.StartsWith("https://"))
{
uriBuilder = new UriBuilder(endpoint);
}
else
{
uriBuilder = new UriBuilder(server)
{
Path = endpoint
};
}
if (queryParams != null)
{
var fields = Utils.GetPairs(queryParams).Select(t =>
{
if (t.value.GetType().IsArray)
{
return(string.Join("&",
(t.value as object[]).Select(o => $"{t.name}={Uri.EscapeUriString(o.ToString())}")
.ToArray()));
}
else
{
return($"{t.name}={Uri.EscapeUriString(t.value.ToString())}");
}
});
uriBuilder.Query = string.Join("&", fields);
}
var httpRequestMessage = new HttpRequestMessage
{
Method = httpMethod,
RequestUri = uriBuilder.Uri,
Content = httpContent
};
return(await extensibleRequest(httpRequestMessage, restRequestConfig ?? RestRequestConfig.DefaultInstance));
}
public async Task UpdateAsync(T item)
{
var tmpj = JsonConvert.SerializeObject(item);
var content = new StringContent(tmpj.ToString(), Encoding.UTF8, "application/json");
await client.PutAsync(UrlAPI, content);
}
public abstract Content/*!*/ ConcatTo(StringContent/*!*/ content);
public void ReadDeeplyNestedObjectWithBigDepthQuotaWorks()
{
FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter() { MaxDepth = 150 };
StringContent content = new StringContent(GetDeeplyNestedObject(125));
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
JToken result = (JToken)formatter.ReadFromStreamAsync(typeof(JToken), content.ReadAsStreamAsync().Result, content, null).Result;
Assert.NotNull(result);
}
public async Task <JObject> PostWebApiAndProcessResultASync(string webApiUrl, string accessToken, Action <JObject> processResult, StringContent data)
{
JObject jsonObject = null;
if (!string.IsNullOrEmpty(accessToken))
{
var defaultRequestHeaders = HttpClient.DefaultRequestHeaders;
if (defaultRequestHeaders.Accept == null || !defaultRequestHeaders.Accept.Any(m => m.MediaType == "application/json"))
{
HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
defaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);
HttpResponseMessage response = await HttpClient.PostAsync(webApiUrl, data);
string json = await response.Content.ReadAsStringAsync();
jsonObject = JsonConvert.DeserializeObject(json) as JObject;
}
return(jsonObject);
}
public static async Task Update(object data, Uri uri)
{
var json = JsonConvert.SerializeObject(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");
await client.PutAsync(uri, content);
}
public Task StartAsync(CancellationToken cancellationToken)
{
string apiUrl = "http://dockerapi:80/api";
//string apiUrl = "http://xplatform.net/api";
//string apiUrl = "http://localhost:5000/api";
var apiClient = new CommonLib.WebApiClient();
apiClient.addHeader("Authorization", "Bearer t.FwRjwQy5LHo3uXE0iQ6D4VGVFRvccr1_PItEHgLIOt4sc7QkQkBzd_eDACB0TTfnBBOWi_mtg84cPbvKwD4gpQ");
CommonLib.Tinkoff.TinkoffClient _tinkoffClient = new CommonLib.Tinkoff.TinkoffClient(apiClient);
MicexISSClient micexClient = new MicexISSClient(new CommonLib.WebApiClient());
var xClient = new CommonLib.WebApiClient();
Func <string, Quote> GetQuoteFromCandles = new Func <string, Quote>(data =>
{
JObject obj = JObject.Parse(data);
JToken[] candles = null;
if (obj["payload"]["candles"].Count() < 2)
{
return(null);
}
candles = obj["payload"]["candles"]
.OrderByDescending(t => (DateTime)t["time"])
.Take(2).ToArray();
return(new Quote()
{
figi = (string)candles[0]["figi"],
open = decimal.Parse((string)candles[0]["o"], CultureInfo.InvariantCulture),
price = decimal.Parse((string)candles[0]["c"], CultureInfo.InvariantCulture),
previousClose = decimal.Parse((string)candles[1]["c"], CultureInfo.InvariantCulture)
});
});
Action <string> activate = new Action <string>((arg) =>
{
_logger.Information($"Activation: {arg}");
if (arg == "usaPriceUpdater")
{
usaSubscription = usaQuoteSeq.Subscribe(q =>
{
Log.Information($"update price {q.symbol}");
},
ex =>
{
_logger.Error(ex, "usaPriceUpdater error");
restartStream.OnNext("usaPriceUpdater");
});
}
if (arg == "moscowPriceUpdater")
{
moscowSubscription = moscowQuoteSeq.Subscribe(q =>
{
Log.Information($"update price {q.symbol}");
},
ex =>
{
_logger.Error(ex, "moscowPriceUpdater error");
restartStream.OnNext("moscowPriceUpdater");
});
}
});
usaQuoteSeq = Observable.Create <Quote>(async observer =>
{
string securities = await xClient.GetData($"{apiUrl}/security");
string currentQuotes = await xClient.GetData($"{apiUrl}/Quote");
var securityCodes = JsonConvert.DeserializeObject <List <Security> >(securities).Where(s => s.Market == "shares" && s.Region == "United States").Select(s => s.Code);
var quoteList = JsonConvert.DeserializeObject <List <Quote> >(currentQuotes)
.Where(q => securityCodes.Contains(q.symbol))
.OrderBy(q => q.symbol);
//.OrderBy(q => q.lastUpdate);
foreach (Quote quote in quoteList)
{
observer.OnNext(quote);
}
observer.OnCompleted();
return(Disposable.Empty);
})
.Select(q => Observable.FromAsync(async() =>
{
//throw new Exception();
string candles = await _tinkoffClient.GetCandles(q.figi, "day", DateTime.UtcNow.AddDays(-20), DateTime.UtcNow);
Quote result = GetQuoteFromCandles(candles);
if (result != null)
{
result.Id = q.Id;
result.symbol = q.symbol;
result.Board = q.Board;
//post quote to server
string content = JObject.FromObject(result).ToString();
HttpContent stringContent = new StringContent(content, Encoding.UTF8, "application/json");
await xClient.PostDataAsync($"{apiUrl}/Quote", stringContent);
}
if (result == null)
{
result = new Quote()
{
symbol = q.symbol
};
}
return(result);
}).Delay(TimeSpan.FromSeconds(5)))
.Concat()
.Repeat();
moscowQuoteSeq = Observable.Create <MarketData>(async observer =>
{
string securities = await xClient.GetData($"{apiUrl}/security");
string currentQuotes = await xClient.GetData($"{apiUrl}/Quote");
var securityObj = JsonConvert.DeserializeObject <List <Security> >(securities).Where(s => s.Region == "Moscow");
var securityCodes = securityObj.Select(s => s.Code);
var quoteList = JsonConvert.DeserializeObject <List <Quote> >(currentQuotes)
.Where(q => securityCodes.Contains(q.symbol))
.OrderBy(q => q.symbol);
foreach (Quote quote in quoteList)
{
MarketData md = null;
md = new MarketData()
{
quote = quote,
board = quote.Board,
market = securityObj.First(s => s.Code == quote.symbol).Market,
ticker = quote.symbol
};
observer.OnNext(md);
}
observer.OnCompleted();
return(Disposable.Empty);
}).Select(md => Observable.FromAsync(async() =>
{
ISSResponse issResp = await micexClient.GetSecurityInfo(md.market, md.board, md.ticker);
var result = new Quote()
{
Id = md.quote.Id,
symbol = md.quote.symbol,
figi = md.quote.figi,
open = issResp.MarketData.First().OPEN,
price = issResp.MarketData.First().LAST,
NKD = issResp.SecurityInfo.First().NKD,
previousClose = issResp.SecurityInfo.First().PREVPRICE,
Board = md.quote.Board
};
//post quote to server
string content = JObject.FromObject(result).ToString();
HttpContent stringContent = new StringContent(content, Encoding.UTF8, "application/json");
await xClient.PostDataAsync($"{apiUrl}/Quote", stringContent);
return(result);
}).Delay(TimeSpan.FromSeconds(10)))
.Concat()
.Repeat();
restartStream
.Delay(TimeSpan.FromMinutes(10))
.Subscribe(proc =>
{
if (proc == "usaPriceUpdater")
{
usaSubscription.Dispose();
usaSubscription = null;
}
if (proc == "moscowPriceUpdater")
{
moscowSubscription.Dispose();
moscowSubscription = null;
}
activate(proc);
});
activate("usaPriceUpdater");
activate("moscowPriceUpdater");
return(Task.CompletedTask);
}
public HttpRequestMessage Build()
{
var httpMessage = new HttpRequestMessage(HttpMethod, UriBuilder.Uri);
httpMessage.Version = HttpVersion;
if (this.PathParams.Any())
{
var path = HttpUtility.UrlDecode(UriBuilder.Path);
foreach (var p in this.PathParams)
{
path = path.Replace("{" + p.Key + "}", p.Value, StringComparison.OrdinalIgnoreCase);
}
UriBuilder.Path = HttpUtility.UrlPathEncode(path);
}
if (this.QueryStrings.Any())
{
UriBuilder.Query = string.Join("&", this.QueryStrings.Select(q => q.Key + "=" + HttpUtility.UrlEncode(q.Value)));
}
if (this.HttpMethod == HttpMethod.Post || this.HttpMethod.Method == "PATCH" ||
this.HttpMethod == HttpMethod.Put)
{
if (this.MultiPartAttribute != null)
{
var multipleContent = new MultipartContent(this.MultiPartAttribute.MultiPartType, Guid.NewGuid().ToString());
if (FormBodys.Any())
{
var content = new FormUrlEncodedContent(this.FormBodys);
multipleContent.Add(content);
}
if (JsonBody != null)
{
var stringWriter = new StringWriter();
this.JsonSerializer.Serialize(stringWriter, JsonBody);
var content = new StringContent(stringWriter.ToString(), Utf8Encoding, "application/json");
multipleContent.Add(content);
}
if (RawContents.Any())
{
foreach (var c in RawContents)
{
multipleContent.Add(c);
}
}
httpMessage.Content = multipleContent;
}
else
{
if (new[] {
FormBodys.Any(),
JsonBody != null,
RawContents.Any()
}.Count(i => i == true) > 1)
{
throw new NotSupportedException("Not support multiple kinds of http content in a message!");
}
if (FormBodys.Any())
{
httpMessage.Content = new FormUrlEncodedContent(this.FormBodys);
if (httpMessage.Content.Headers != null && httpMessage.Content.Headers.ContentType != null)
{
httpMessage.Content.Headers.ContentType.CharSet = Utf8Encoding.HeaderName;
}
}
else if (JsonBody != null)
{
var stringWriter = new StringWriter();
this.JsonSerializer.Serialize(stringWriter, JsonBody);
httpMessage.Content = new StringContent(stringWriter.ToString(), Utf8Encoding, "application/json");
if (httpMessage.Content.Headers != null && httpMessage.Content.Headers.ContentType != null)
{
httpMessage.Content.Headers.ContentType.CharSet = Utf8Encoding.HeaderName;
}
}
if (RawContents.Any())
{
httpMessage.Content = RawContents.FirstOrDefault();
}
}
}
httpMessage.RequestUri = this.UriBuilder.Uri;
foreach (var h in this.Headers.GroupBy(h => h.Key))
{
httpMessage.Headers.TryAddWithoutValidation(h.Key, h.Select(i => i.Value));
}
foreach (var c in this.Cookies)
{
httpMessage.Headers.GetCookies().Add(c);
}
return(httpMessage);
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string toTranslate = req.Query["text"];
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
dynamic data = JsonConvert.DeserializeObject(requestBody);
toTranslate = toTranslate ?? data?.text;
if (toTranslate == null)
{
var err = JsonConvert.SerializeObject(new { error = "field 'text' must be provided!" });
return(new BadRequestObjectResult(err)
{
ContentTypes = { "application/json" }
});
}
try
{
// Call API
HttpClient newClient = new HttpClient();
var json = JsonConvert.SerializeObject(new { text = toTranslate });
var content = new StringContent(
json,
System.Text.Encoding.UTF8,
"application/json"
);
using (HttpClient httpClient = new HttpClient())
{
HttpResponseMessage result =
httpClient.PostAsync("https://api.funtranslations.com/translate/pirate.json",
content).Result;
if (result.IsSuccessStatusCode)
{
JObject msg = JObject.Parse(result.Content.ReadAsStringAsync().Result);
string translated = (string)msg["contents"]["translated"];
//Return response
return(new OkObjectResult(translated));
}
else
{
JObject error = JObject.Parse(result.Content.ReadAsStringAsync().Result);
return(new BadRequestObjectResult(error));
}
}
}
catch (Exception ex)
{
return(new BadRequestObjectResult(ex));
}
}
public override Task <HttpResponseMessage> Execute(string url, StringContent stringContent)
{
return(Client.PostAsync(url, stringContent));
}
private static async Task MapAggregateContent(DownstreamContext originalContext, List <DownstreamContext> downstreamContexts)
{
var contentBuilder = new StringBuilder();
contentBuilder.Append("{");
var responseKeys = downstreamContexts.Select(s => s.DownstreamReRoute.Key).Distinct().ToList();
for (var k = 0; k < responseKeys.Count; k++)
{
var contexts = downstreamContexts.Where(w => w.DownstreamReRoute.Key == responseKeys[k]).ToList();
if (contexts.Count == 1)
{
if (contexts[0].IsError)
{
MapAggregateError(originalContext, contexts[0]);
return;
}
var content = await contexts[0].DownstreamResponse.Content.ReadAsStringAsync();
contentBuilder.Append($"\"{responseKeys[k]}\":{content}");
}
else
{
contentBuilder.Append($"\"{responseKeys[k]}\":");
contentBuilder.Append("[");
for (var i = 0; i < contexts.Count; i++)
{
if (contexts[i].IsError)
{
MapAggregateError(originalContext, contexts[i]);
return;
}
var content = await contexts[i].DownstreamResponse.Content.ReadAsStringAsync();
if (string.IsNullOrWhiteSpace(content))
{
continue;
}
contentBuilder.Append($"{content}");
if (i + 1 < contexts.Count)
{
contentBuilder.Append(",");
}
}
contentBuilder.Append("]");
}
if (k + 1 < responseKeys.Count)
{
contentBuilder.Append(",");
}
}
contentBuilder.Append("}");
var stringContent = new StringContent(contentBuilder.ToString())
{
Headers = { ContentType = new MediaTypeHeaderValue("application/json") }
};
originalContext.DownstreamResponse = new DownstreamResponse(stringContent, HttpStatusCode.OK, new List <KeyValuePair <string, IEnumerable <string> > >(), "cannot return from aggregate..which reason phrase would you use?");
}
public async Task PostAsync_CallMethod_UnicodeStringContent(Uri remoteServer)
{
using (var client = new HttpClient())
{
string data = "\ub4f1\uffc7\u4e82\u67ab4\uc6d4\ud1a0\uc694\uc77c\uffda3\u3155\uc218\uffdb";
var content = new StringContent(data, Encoding.UTF8);
content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
using (HttpResponseMessage response = await client.PostAsync(remoteServer, content))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
}
// string + chars(self) -> chars
public override Content/*!*/ ConcatTo(StringContent/*!*/ content) {
int count = content.Data.Length;
var result = new char[count + _count];
content.Data.CopyTo(0, result, 0, count);
Array.Copy(_data, 0, result, count, _count);
return new CharArrayContent(result, null);
}
async void performCodeExchangeAsync(string code, string code_verifier)
{
Ring.IsActive = true;
string tokenRequestBody = string.Format(
"code={0}&redirect_uri={1}&client_id={2}&code_verifier={3}&scope=&grant_type=authorization_code",
code,
System.Uri.EscapeDataString(redirectURI),
clientID,
code_verifier
);
StringContent content =
new StringContent(tokenRequestBody, Encoding.UTF8, "application/x-www-form-urlencoded");
HttpClientHandler handler = new HttpClientHandler();
handler.AllowAutoRedirect = true;
HttpClient client = new HttpClient(handler);
//output(Environment.NewLine + "Exchanging code for tokens...");
HttpResponseMessage response = await client.PostAsync(tokenEndpoint, content);
string responseString = await response.Content.ReadAsStringAsync();
//output(responseString);
if (!response.IsSuccessStatusCode)
{
output("Authorization code exchange failed.");
return;
}
JsonObject tokens = JsonObject.Parse(responseString);
string accessToken = tokens.GetNamedString("access_token");
client.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
//output("Making API Call to Userinfo...");
HttpResponseMessage userinfoResponse = client.GetAsync(userInfoEndpoint).Result;
//var info = await userinfoResponse.Content.ReadAsStringAsync();
//JsonObject obj = JsonObject.Parse(info);
string userinfoResponseContent = await userinfoResponse.Content.ReadAsStringAsync();
output(userinfoResponseContent);
UserInfo userInfo = Str2UserInfo(userinfoResponseContent);
FileUtil.PostUser(userInfo);
if (userinfoResponseContent != null)
{
App.sub = userInfo.sub;
App.name = userInfo.name;
App.given_name = userInfo.given_name;
App.family_name = userInfo.family_name;
App.profile = userInfo.profile;
App.picture = userInfo.picture;
App.gender = userInfo.gender;
App.locale = userInfo.locale;
this.Frame.Navigate(typeof(MainScreen));
}
}
// string + string -> string
public override Content/*!*/ ConcatTo(StringContent/*!*/ content) {
return new StringContent(content.Data + _data, null);
}
protected async void CreateItems <U>(U reportObject) where U : class
{
try
{
ToggleBusy(true);
var client = await GetHTTPClient();
var data = reportObject;
var body = JsonConvert.SerializeObject(data, Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var contents = new StringContent(body);
contents.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;odata=verbose");
if (CheckConnection())
{
Device.BeginInvokeOnMainThread(async() =>
{
string url = SPUtility.GetListURL(ReportType.FlighCrewVoyage);
var postResult = await client.PostAsync(url, contents);
if (postResult.IsSuccessStatusCode)
{
App.DAUtil.Delete(_flightcrew);
lblLoading.Text = "Item created successfully." + Environment.NewLine;
var spData = JsonConvert.DeserializeObject <SPData>(postResult.Content.ReadAsStringAsync().Result,
new JsonSerializerSettings {
DateParseHandling = DateParseHandling.None
});
int itemId = spData.d.Id;
await Task.Delay(500);
await SendAttachments(itemId);
MessagingCenter.Send(this, "home");
}
else
{
var ex = await postResult.Content.ReadAsStringAsync();
await DisplayAlert("Error", ex, "Ok");
}
ToggleBusy(false);
});
}
else
{
SaveOfflineItem(body, ReportType.FlighCrewVoyage, _attachementView.GetAttachmentInfoAsString());
await DisplayAlert("", "Item stored in local storage", "Ok");
ToggleBusy(false);
MessagingCenter.Send(this, "home");
}
}
catch (HttpRequestException ex)
{
DependencyService.Get <IMessage>().ShortAlert("Upload Error");
}
catch (Exception ex)
{
DependencyService.Get <IMessage>().ShortAlert("Upload Error" + ex.Message);
}
}
public abstract int ReverseOrdinalCompareTo(StringContent/*!*/ content);
/// <summary>
/// Analyze text.
///
/// Analyzes text, HTML, or a public webpage for the following features:
/// - Categories
/// - Concepts
/// - Emotion
/// - Entities
/// - Keywords
/// - Metadata
/// - Relations
/// - Semantic roles
/// - Sentiment
/// - Syntax
/// - Summarization (Experimental)
///
/// If a language for the input text is not specified with the `language` parameter, the service [automatically
/// detects the
/// language](https://cloud.ibm.com/docs/natural-language-understanding?topic=natural-language-understanding-detectable-languages).
/// </summary>
/// <param name="features">Specific features to analyze the document for.</param>
/// <param name="text">The plain text to analyze. One of the `text`, `html`, or `url` parameters is required.
/// (optional)</param>
/// <param name="html">The HTML file to analyze. One of the `text`, `html`, or `url` parameters is required.
/// (optional)</param>
/// <param name="url">The webpage to analyze. One of the `text`, `html`, or `url` parameters is required.
/// (optional)</param>
/// <param name="clean">Set this to `false` to disable webpage cleaning. For more information about webpage
/// cleaning, see [Analyzing
/// webpages](https://cloud.ibm.com/docs/natural-language-understanding?topic=natural-language-understanding-analyzing-webpages).
/// (optional, default to true)</param>
/// <param name="xpath">An [XPath
/// query](https://cloud.ibm.com/docs/natural-language-understanding?topic=natural-language-understanding-analyzing-webpages#xpath)
/// to perform on `html` or `url` input. Results of the query will be appended to the cleaned webpage text
/// before it is analyzed. To analyze only the results of the XPath query, set the `clean` parameter to `false`.
/// (optional)</param>
/// <param name="fallbackToRaw">Whether to use raw HTML content if text cleaning fails. (optional, default to
/// true)</param>
/// <param name="returnAnalyzedText">Whether or not to return the analyzed text. (optional, default to
/// false)</param>
/// <param name="language">ISO 639-1 code that specifies the language of your text. This overrides automatic
/// language detection. Language support differs depending on the features you include in your analysis. For
/// more information, see [Language
/// support](https://cloud.ibm.com/docs/natural-language-understanding?topic=natural-language-understanding-language-support).
/// (optional)</param>
/// <param name="limitTextCharacters">Sets the maximum number of characters that are processed by the service.
/// (optional)</param>
/// <returns><see cref="AnalysisResults" />AnalysisResults</returns>
public DetailedResponse<AnalysisResults> Analyze(Features features, string text = null, string html = null, string url = null, bool? clean = null, string xpath = null, bool? fallbackToRaw = null, bool? returnAnalyzedText = null, string language = null, long? limitTextCharacters = null)
{
if (string.IsNullOrEmpty(Version))
{
throw new ArgumentNullException("`Version` is required");
}
if (features == null)
{
throw new ArgumentNullException("`features` is required for `Analyze`");
}
DetailedResponse<AnalysisResults> result = null;
try
{
IClient client = this.Client;
SetAuthentication();
var restRequest = client.PostAsync($"{this.Endpoint}/v1/analyze");
restRequest.WithHeader("Accept", "application/json");
if (!string.IsNullOrEmpty(Version))
{
restRequest.WithArgument("version", Version);
}
restRequest.WithHeader("Content-Type", "application/json");
JObject bodyObject = new JObject();
if (features != null)
{
bodyObject["features"] = JToken.FromObject(features);
}
if (!string.IsNullOrEmpty(text))
{
bodyObject["text"] = text;
}
if (!string.IsNullOrEmpty(html))
{
bodyObject["html"] = html;
}
if (!string.IsNullOrEmpty(url))
{
bodyObject["url"] = url;
}
if (clean != null)
{
bodyObject["clean"] = JToken.FromObject(clean);
}
if (!string.IsNullOrEmpty(xpath))
{
bodyObject["xpath"] = xpath;
}
if (fallbackToRaw != null)
{
bodyObject["fallback_to_raw"] = JToken.FromObject(fallbackToRaw);
}
if (returnAnalyzedText != null)
{
bodyObject["return_analyzed_text"] = JToken.FromObject(returnAnalyzedText);
}
if (!string.IsNullOrEmpty(language))
{
bodyObject["language"] = language;
}
if (limitTextCharacters != null)
{
bodyObject["limit_text_characters"] = JToken.FromObject(limitTextCharacters);
}
var httpContent = new StringContent(JsonConvert.SerializeObject(bodyObject), Encoding.UTF8, HttpMediaType.APPLICATION_JSON);
restRequest.WithBodyContent(httpContent);
restRequest.WithHeaders(Common.GetSdkHeaders("natural-language-understanding", "v1", "Analyze"));
restRequest.WithHeaders(customRequestHeaders);
ClearCustomRequestHeaders();
result = restRequest.As<AnalysisResults>().Result;
if (result == null)
{
result = new DetailedResponse<AnalysisResults>();
}
}
catch (AggregateException ae)
{
throw ae.Flatten();
}
return result;
}
protected override async Task<Response> GetResponseFromHttp (
TestContext ctx, HttpWebResponse response, WebException error, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested ();
HttpContent content = null;
ctx.LogDebug (4, $"{ME} GET RESPONSE FROM HTTP");
switch (TestRunner.EffectiveType) {
case HttpRequestTestType.ReadTimeout:
return await ReadWithTimeout (5000, WebExceptionStatus.Timeout).ConfigureAwait (false);
}
using (var stream = response.GetResponseStream ()) {
switch (TestRunner.EffectiveType) {
case HttpRequestTestType.TestResponseStream:
content = await TestResponseStream (stream).ConfigureAwait (false);
break;
case HttpRequestTestType.LargeChunkRead:
content = await LargeChunkRead (stream).ConfigureAwait (false);
break;
case HttpRequestTestType.LargeGZipRead:
content = await ReadAsString (stream).ConfigureAwait (false);
break;
case HttpRequestTestType.GZipWithLength:
content = await GZipWithLength (stream).ConfigureAwait (false);
break;
case HttpRequestTestType.ResponseStreamCheckLength2:
content = await ResponseStreamCheckLength (stream, true).ConfigureAwait (false);
break;
case HttpRequestTestType.ResponseStreamCheckLength:
content = await ResponseStreamCheckLength (stream, false).ConfigureAwait (false);
break;
case HttpRequestTestType.GetNoLength:
content = await GetNoLength (stream).ConfigureAwait (false);
break;
default:
content = await ReadAsString (stream).ConfigureAwait (false);
break;
}
}
var status = response.StatusCode;
response.Dispose ();
finishedTcs.TrySetResult (true);
return new SimpleResponse (this, status, content, error);
async Task<Response> ReadWithTimeout (int timeout, WebExceptionStatus expectedStatus)
{
StreamReader reader = null;
try {
reader = new StreamReader (response.GetResponseStream ());
var readTask = reader.ReadToEndAsync ();
if (timeout > 0) {
var timeoutTask = Task.Delay (timeout);
var task = await Task.WhenAny (timeoutTask, readTask).ConfigureAwait (false);
if (task == timeoutTask)
throw ctx.AssertFail ("Timeout expired.");
}
var ret = await readTask.ConfigureAwait (false);
ctx.LogMessage ($"EXPECTED ERROR: {ret}");
throw ctx.AssertFail ("Expected exception.");
} catch (WebException wexc) {
ctx.Assert ((WebExceptionStatus)wexc.Status, Is.EqualTo (expectedStatus));
return new SimpleResponse (this, HttpStatusCode.InternalServerError, null, wexc);
} finally {
finishedTcs.TrySetResult (true);
}
}
async Task<HttpContent> ReadAsString (Stream stream)
{
using (var reader = new StreamReader (stream)) {
string text = null;
if (!reader.EndOfStream)
text = await reader.ReadToEndAsync ().ConfigureAwait (false);
return StringContent.CreateMaybeNull (text);
}
}
async Task<HttpContent> TestResponseStream (Stream stream)
{
var buffer = new byte[5];
var ret = await stream.ReadAsync (buffer, 4, 1).ConfigureAwait (false);
ctx.Assert (ret, Is.EqualTo (1), "#A1");
ctx.Assert (buffer[4], Is.EqualTo ((byte)65), "#A2");
ret = await stream.ReadAsync (buffer, 0, 2);
ctx.Assert (ret, Is.EqualTo (2), "#B1");
return Handler.Content;
}
async Task<HttpContent> LargeChunkRead (Stream stream)
{
var buffer = new byte[43];
var ret = await stream.ReadAsync (buffer, 0, buffer.Length).ConfigureAwait (false);
ctx.Assert (ret, Is.EqualTo (ConnectionHandler.TheQuickBrownFox.Length), "#A1");
var text = Encoding.UTF8.GetString (buffer, 0, ret);
return new StringContent (text);
}
async Task<HttpContent> GZipWithLength (Stream stream)
{
using (var ms = new MemoryStream ()) {
await stream.CopyToAsync (ms, 16384).ConfigureAwait (false);
var bytes = ms.ToArray ();
var text = Encoding.UTF8.GetString (bytes, 0, bytes.Length);
return new StringContent (text);
}
}
async Task<HttpContent> ResponseStreamCheckLength (Stream stream, bool chunked)
{
await ctx.AssertException<NotSupportedException> (() => Task.FromResult (stream.Length), "Length should throw");
if (chunked) {
ctx.Assert (response.ContentLength, Is.EqualTo (-1L), "ContentLength");
ctx.Assert (response.Headers["Transfer-Encoding"], Is.EqualTo ("chunked"), "chunked encoding");
} else {
ctx.Assert (response.ContentLength, Is.EqualTo ((long)Handler.Content.Length), "ContentLength");
ctx.Assert (response.Headers["Content-Length"], Is.EqualTo (Handler.Content.Length.ToString ()), "Content-Length header");
}
return await GZipWithLength (stream).ConfigureAwait (false);
}
async Task<HttpContent> GetNoLength (Stream stream)
{
ctx.Assert (response.ContentLength, Is.EqualTo (-1L), "ContentLength");
ctx.Assert (response.Headers["Content-Length"], Is.Null, "No Content-Length: header");
return await ReadAsString (stream);
}
}
public TestHttpMessageHandler(string content = "test")
{
Content = new StringContent(content);
ContentFactory = () => Content;
}
/// <summary>
/// Create Folder
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public async Task <Object> CreateDocumentLibrary(string listTitle, string documentTemplateUrlTitle = null)
{
// return early if SharePoint is disabled.
if (!IsValid())
{
return(null);
}
HttpRequestMessage endpointRequest =
new HttpRequestMessage(HttpMethod.Post, ApiEndpoint + "web/Lists");
if (documentTemplateUrlTitle == null)
{
documentTemplateUrlTitle = listTitle;
}
var library = CreateNewDocumentLibraryRequest(documentTemplateUrlTitle);
string jsonString = JsonConvert.SerializeObject(library);
StringContent strContent = new StringContent(jsonString, Encoding.UTF8);
strContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;odata=verbose");
endpointRequest.Content = strContent;
// make the request.
var response = await _Client.SendAsync(endpointRequest);
HttpStatusCode _statusCode = response.StatusCode;
if (_statusCode != HttpStatusCode.Created)
{
string _responseContent = null;
var ex = new SharePointRestException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
_responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
ex.Request = new HttpRequestMessageWrapper(endpointRequest, null);
ex.Response = new HttpResponseMessageWrapper(response, _responseContent);
endpointRequest.Dispose();
if (response != null)
{
response.Dispose();
}
throw ex;
}
else
{
jsonString = await response.Content.ReadAsStringAsync();
var ob = Newtonsoft.Json.JsonConvert.DeserializeObject <DocumentLibraryResponse>(jsonString);
if (listTitle != documentTemplateUrlTitle)
{
// update list title
endpointRequest = new HttpRequestMessage(HttpMethod.Post, $"{ApiEndpoint}web/lists(guid'{ob.d.Id}')");
var type = new { type = "SP.List" };
var request = new
{
__metadata = type,
Title = listTitle
};
jsonString = JsonConvert.SerializeObject(request);
strContent = new StringContent(jsonString, Encoding.UTF8);
strContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json;odata=verbose");
endpointRequest.Headers.Add("IF-MATCH", "*");
endpointRequest.Headers.Add("X-HTTP-Method", "MERGE");
endpointRequest.Content = strContent;
response = await _Client.SendAsync(endpointRequest);
jsonString = await response.Content.ReadAsStringAsync();
response.EnsureSuccessStatusCode();
}
}
return(library);
}
public async Task <XmlElement> SubmitRequestAsync(GalWebMethod _methodName, string _token, XmlElement _request, string _filter)
{
string svcCredentials = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(UserName + ":" + Password));
XDocument soapEnvelopeXml = GetSoapEnvelope(_methodName, _token, _request.GetXElement(), _filter);
HttpClient httpClient = new HttpClient();
HttpContent httpContent = new StringContent(soapEnvelopeXml.ToString());
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, Url);
req.Headers.Add("SOAPAction", "\"" + WebServiceNS + _methodName.ToString() + "\"");
req.Headers.Add("Authorization", "Basic " + svcCredentials);
req.Method = HttpMethod.Post;
req.Content = httpContent;
req.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("text/xml; charset=utf-8");
HttpResponseMessage response;
response = await httpClient.SendAsync(req);
var responseBodyAsText = await response.Content.ReadAsStringAsync();
#region C O M M E N T E D C O D E U S I N G HttpWebRequest
/*
* HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(Url);
* webRequest.Headers["SOAPAction"] = "http://webservices.galileo.com/" + _methodName.ToString();
* webRequest.Headers["Authorization"] = "Basic " + svcCredentials;
* webRequest.ContentType = "text/xml;charset=\"utf-8\"";
* webRequest.Accept = "text/xml";
* webRequest.Method = "POST";
*
*
*
* using (var stream = await Task.Factory.FromAsync<Stream>(webRequest.BeginGetRequestStream, webRequest.EndGetRequestStream, null))
* {
* soapEnvelopeXml.Save(stream);
* }
*
*
*
* // begin async call to web request.
* IAsyncResult asyncResult = webRequest.BeginGetResponse(null, null);
*
* // suspend this thread until call is complete. You might want to
* // do something usefull here like update your UI.
* asyncResult.AsyncWaitHandle.WaitOne();
*
* // get the response from the completed web request.
* string soapResult;
* using (WebResponse webResponse = webRequest.EndGetResponse(asyncResult))
* {
* using (StreamReader rd = new StreamReader(webResponse.GetResponseStream()))
* {
* soapResult = rd.ReadToEnd();
* }
* }
*/
#endregion
return(GetResponseBody(_methodName, responseBodyAsText));
}
public void GivenContentWithBlacklistedWordsWhereWordIsInBlackListTwice_PhrasesThatExist_PhraseOnlyReturnedOnce()
{
// Arrange.
const string content = "This is zebra content with an aardvark ass in it.";
IList<string> fakeBlacklist = new List<string>();
fakeBlacklist.Add("aardvark");
fakeBlacklist.Add("ass");
fakeBlacklist.Add("Ass");
fakeBlacklist.Add("zebra");
var stringContent = new StringContent(fakeBlacklist);
// Act.
var result = stringContent.PhrasesThatExist(content);
// Assert.
Assert.NotNull(result);
Assert.NotEmpty(result);
Assert.NotEqual(fakeBlacklist.Count, result.Count);
}
public async Task PostAsync_Redirect_ResultingGetFormattedCorrectly(bool secure)
{
const string ContentString = "This is the content string.";
var content = new StringContent(ContentString);
Uri redirectUri = Configuration.Http.RedirectUriForDestinationUri(
secure,
302,
secure ? Configuration.Http.SecureRemoteEchoServer : Configuration.Http.RemoteEchoServer,
1);
using (var client = new HttpClient())
using (HttpResponseMessage response = await client.PostAsync(redirectUri, content))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
string responseContent = await response.Content.ReadAsStringAsync();
Assert.DoesNotContain(ContentString, responseContent);
Assert.DoesNotContain("Content-Length", responseContent);
}
}
private static async Task <HttpResponseMessage> GetResponse(HttpClient client, StringContent content, string endPoint)
{
HttpResponseMessage response = null;
try
{
var url = $"https://identitytoolkit.googleapis.com/v1/accounts:{endPoint}?key={_apiKey}";
response = await client.PostAsync(url, content);
}
catch (System.Net.Http.HttpRequestException)
{
MessageBox.Show("Please check your Internet connection!", "Failed Request", MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception)
{
throw;
}
return(response);
}
public HttpRequestHandler (HttpRequestTestRunner parent)
: base (parent.EffectiveType.ToString ())
{
TestRunner = parent;
ME = $"{GetType ().Name}({parent.EffectiveType})";
readyTcs = new TaskCompletionSource<bool> ();
Flags = RequestFlags.KeepAlive;
switch (parent.EffectiveType) {
case HttpRequestTestType.LargeHeader:
case HttpRequestTestType.LargeHeader2:
case HttpRequestTestType.SendResponseAsBlob:
Content = ConnectionHandler.TheQuickBrownFoxContent;
CloseConnection = true;
break;
case HttpRequestTestType.CloseRequestStream:
OperationFlags = HttpOperationFlags.AbortAfterClientExits;
CloseConnection = false;
break;
case HttpRequestTestType.ReadTimeout:
CloseConnection = false;
break;
case HttpRequestTestType.RedirectNoLength:
Target = new HelloWorldHandler (ME);
OperationFlags |= HttpOperationFlags.RedirectOnNewConnection;
CloseConnection = false;
break;
case HttpRequestTestType.PutChunked:
case HttpRequestTestType.PutChunkDontCloseRequest:
CloseConnection = true;
break;
case HttpRequestTestType.ServerAbortsRedirect:
OperationFlags = HttpOperationFlags.ServerAbortsRedirection;
CloseConnection = false;
break;
case HttpRequestTestType.ServerAbortsPost:
OperationFlags = HttpOperationFlags.ServerAbortsRedirection;
CloseConnection = true;
break;
case HttpRequestTestType.PostChunked:
OperationFlags = HttpOperationFlags.DontReadRequestBody;
CloseConnection = false;
break;
case HttpRequestTestType.EntityTooBig:
case HttpRequestTestType.ClientAbortsPost:
OperationFlags = HttpOperationFlags.AbortAfterClientExits | HttpOperationFlags.DontReadRequestBody;
CloseConnection = false;
break;
case HttpRequestTestType.PostContentLength:
OperationFlags = HttpOperationFlags.DontReadRequestBody;
break;
case HttpRequestTestType.SimpleGZip:
Content = HttpContent.TheQuickBrownFox;
CloseConnection = true;
break;
case HttpRequestTestType.TestResponseStream:
Content = new StringContent ("AAAA");
CloseConnection = true;
break;
case HttpRequestTestType.LargeChunkRead:
Content = HttpContent.TheQuickBrownFoxChunked;
ExpectedContent = Content.RemoveTransferEncoding ();
CloseConnection = false;
break;
case HttpRequestTestType.LargeGZipRead:
Content = ConnectionHandler.GetLargeChunkedContent (16384);
ExpectedContent = Content.RemoveTransferEncoding ();
CloseConnection = false;
break;
case HttpRequestTestType.GZipWithLength:
Content = ConnectionHandler.GetLargeStringContent (16384);
ExpectedContent = Content;
CloseConnection = false;
break;
case HttpRequestTestType.ResponseStreamCheckLength2:
Content = HttpContent.HelloChunked;
ExpectedContent = Content.RemoveTransferEncoding ();
CloseConnection = false;
break;
case HttpRequestTestType.ResponseStreamCheckLength:
Content = HttpContent.HelloWorld;
ExpectedContent = Content;
CloseConnection = false;
break;
case HttpRequestTestType.GetNoLength:
ExpectedContent = ConnectionHandler.TheQuickBrownFoxContent;
CloseConnection = false;
break;
case HttpRequestTestType.ImplicitHost:
case HttpRequestTestType.CustomHost:
case HttpRequestTestType.CustomHostWithPort:
case HttpRequestTestType.CustomHostDefaultPort:
CloseConnection = false;
break;
default:
throw new NotSupportedException (parent.EffectiveType.ToString ());
}
if (CloseConnection)
Flags |= RequestFlags.CloseConnection;
if (ExpectedContent == null)
ExpectedContent = Content ?? new StringContent (ME);
}
public void GivenSomeContentWithNoBadWordsAndBadPhrasesSuppliedSeparately_PhrasesThatExist_ReturnsAListOfBadPhrasesFound()
{
// Arrange.
const string content =
"sdhfasjdfh sadfo8as 68sa6t &%7tsTSOtafdsf dsakf haspdf y78 6* ";
var stringContent = new StringContent();
// Act.
var results = stringContent.PhrasesThatExist(content, PhraseList);
// Assert.
Assert.Null(results);
}
public async Task Run([BlobTrigger("vision/{name}", Connection = "StorageConnectionString")] Stream myBlob, string name,
[CosmosDB(
databaseName: "%CosmosDB%",
collectionName: "%CosmosCollection%",
ConnectionStringSetting = "CosmosDBConnection")] IAsyncCollector <Entry> document,
[TwilioSms(
AccountSidSetting = "TwilioAccountSid",
AuthTokenSetting = "TwilioAuthToken",
From = "%FromNumber%")] IAsyncCollector <CreateMessageOptions> smsOptions,
ILogger log)
{
//We need to obtain linux timestamp from image name
//(8 chars "capture_" prefix, 12 = prefix + ."jpg" suffix)
var timeStampString = name.Substring(8, name.Length - 12);
var dto = DateTimeOffset.FromUnixTimeMilliseconds(Convert.ToInt64(timeStampString));
var timestamp = dto.DateTime;
List <string> entrants = new List <string>();
try
{
//Make sure you specify Recognition Model, which was used when creating person in person group
var detectedFaces = await _faceClient.Face.DetectWithStreamAsync(myBlob, recognitionModel : RecognitionModel.Recognition02);
var group = (await _faceClient.PersonGroup.ListAsync())
.Where(g => g.Name == Environment.GetEnvironmentVariable("PersonGroupName")).FirstOrDefault();
var dfIds = detectedFaces.Select(f => f.FaceId.ToGuid()).ToList();
if (dfIds.Count != 0 && group != null)
{
var identifiedFaces = await _faceClient.Face.IdentifyAsync(dfIds, group.PersonGroupId);
log.LogInformation(identifiedFaces.Count().ToString());
if (identifiedFaces.Count > 0)
{
foreach (var f in identifiedFaces)
{
if (f.Candidates.Count > 0 && f.Candidates.First().Confidence > 0.7)
{
var pInfo = await _faceClient.PersonGroupPerson.GetAsync(group.PersonGroupId, f.Candidates.First().PersonId);
//We put it to lower, as LUIS entities are always returned in "ToLower" form
entrants.Add(pInfo.Name.ToLower());
}
}
}
}
var entry = new Entry(Guid.NewGuid().ToString(), timestamp, entrants, name.ToLower());
await document.AddAsync(entry);
if (!entrants.Any())
{
//If no known entrant identified, we send sms notification
await smsOptions.AddAsync(new CreateMessageOptions(Environment.GetEnvironmentVariable("ToNumber"))
{
Body = "Warning, unidentified entrant!"
});
}
//Invoking Bot Proactive message by sending request to notify endpoint
var content = new StringContent($"{{\"imageName\":\"{name}\",\"text\":\"{String.Join(", ", entrants.ToArray())}\"}}", Encoding.UTF8, "application/json");
await _httpClient.PostAsync(Environment.GetEnvironmentVariable("ProactiveBotEndpoint"), content);
}
catch (Exception e)
{
log.LogInformation(e.Message);
}
log.LogInformation("Succesfully processed blob: " + name);
}
public async Task PostAsync_CallMethod_EmptyContent(Uri remoteServer)
{
using (var client = new HttpClient())
{
var content = new StringContent(string.Empty);
using (HttpResponseMessage response = await client.PostAsync(remoteServer, content))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
string responseContent = await response.Content.ReadAsStringAsync();
_output.WriteLine(responseContent);
TestHelper.VerifyResponseBody(
responseContent,
response.Content.Headers.ContentMD5,
false,
string.Empty);
}
}
}
private async void btnSave_Clicked(object sender, EventArgs e)
{
if (Result.Equals("AddPlace"))//AddPlace
{
if (tblErrPlaceName.IsVisible == false && tblErrIpAddress.IsVisible == false && tblErrAddress.IsVisible == false && tblErrPassWordAPI.IsVisible == false && tblErrPassWordDB.IsVisible == false && tblErrPortAPI.IsVisible == false && tblErrPortDB.IsVisible == false && tblErrUsernameAPI.IsVisible == false && tblErrUsernameDB.IsVisible == false && pkrTypePlace.SelectedItem != null)
{
placeModel = new PlaceModel();
placeModel.Name = Name;
placeModel.PassWordAPI = PassWordAPI;
placeModel.PassWordDB = PassWordDB;
placeModel.PortAPI = Int32.Parse(PortAPI);
placeModel.PortDB = Int32.Parse(PortDB);
placeModel.TypePlace = pkrTypePlace.SelectedIndex;
placeModel.UserNameAPI = UserNameAPI;
placeModel.UserNameDB = UserNameDB;
placeModel.Address = Address;
placeModel.IpAddress = IpAddress;
string url = "http://" + Global.Intance.SerIpAdress + ":" + Global.Intance.SerPortAPI + "/api/AddNewPlace";
try
{
var documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var fileName = Path.Combine(documents, "cookie.txt");
var cookie = File.ReadAllText(fileName);
HttpClient client = new HttpClient();
string jsonData = JsonConvert.SerializeObject(placeModel);
StringContent content = new StringContent(jsonData, Encoding.UTF8, "application/json");
content.Headers.Add("cookie", cookie);
HttpResponseMessage response = await client.PostAsync(url, content);
string result = await response.Content.ReadAsStringAsync();
//int responseData = Int32.Parse(result);
var responseData = JsonConvert.DeserializeObject <RespondPlaceModel>(result);
if (responseData != null && responseData.Result == true)
{
//DependencyService.Get<IMessage>().ShortTime(message);
////MessagingCenter.Send(this, "Update");//Gửi thông điệp update listview về PlacePage
//await Navigation.PushAsync(new PlacePage(User));
//await Navigation.PopAsync();
MessagingCenter.Send(this, "Update");//Gửi thông điệp update listview về PlacePage
await Navigation.PopAsync();
var message = "Thành công!";
DependencyService.Get <IMessage>().ShortTime(message.ToString());
}
else if (responseData != null && responseData.Result == false)
{
var message = responseData.Content.ToString();
DependencyService.Get <IMessage>().LongTime(message);
}
else
{
var message = "Thêm không thành công!";
DependencyService.Get <IMessage>().LongTime(message);
}
}
catch (Exception ex)
{
var Err = "Không nết nối được máy chủ";
DependencyService.Get <IMessage>().LongTime(Err);
}
}
else
{
if (pkrTypePlace.SelectedItem == null)
{
await DisplayAlert("Thông báo", "Vui lòng chọn loại cơ sở!", "OK");
}
else
{
await DisplayAlert("Thông báo", "Vui lòng nhập đúng thông tin!", "OK");
}
}
}
else //EditPlace
{
if (tblErrPlaceName.IsVisible == false && tblErrIpAddress.IsVisible == false && tblErrAddress.IsVisible == false && tblErrPassWordAPI.IsVisible == false && tblErrPassWordDB.IsVisible == false && tblErrPortAPI.IsVisible == false && tblErrPortDB.IsVisible == false && tblErrUsernameAPI.IsVisible == false && tblErrUsernameDB.IsVisible == false && pkrTypePlace.SelectedItem != null && !string.IsNullOrEmpty(Name) && !string.IsNullOrEmpty(Address) && !string.IsNullOrEmpty(PortDB) && !string.IsNullOrEmpty(UserNameDB) && !string.IsNullOrEmpty(PassWordDB) && !string.IsNullOrEmpty(PortAPI) && !string.IsNullOrEmpty(UserNameAPI) && !string.IsNullOrEmpty(PassWordAPI) && pkrTypePlace.SelectedIndex != -1)
{
placeModel.Name = Name;
placeModel.PassWordAPI = PassWordAPI;
placeModel.PassWordDB = PassWordDB;
placeModel.PortAPI = Int32.Parse(PortAPI);
placeModel.PortDB = Int32.Parse(PortDB);
placeModel.TypePlace = pkrTypePlace.SelectedIndex;
placeModel.UserNameAPI = UserNameAPI;
placeModel.UserNameDB = UserNameDB;
placeModel.Address = Address;
string url = "http://" + Global.Intance.SerIpAdress + ":" + Global.Intance.SerPortAPI + "/api/EditPlace";
try
{
var documents = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var fileName = Path.Combine(documents, "cookie.txt");
var cookie = File.ReadAllText(fileName);
HttpClient client = new HttpClient();
string jsonData = JsonConvert.SerializeObject(placeModel);
StringContent content = new StringContent(jsonData, Encoding.UTF8, "application/json");
content.Headers.Add("cookie", cookie);
HttpResponseMessage response = await client.PostAsync(url, content);
string result = await response.Content.ReadAsStringAsync();
var responseData = JsonConvert.DeserializeObject <RespondPlaceModel>(result);
if (responseData != null && responseData.Result == true)
{
MessagingCenter.Send(this, "Update");//Gửi thông điệp update listview về PlacePage
await Navigation.PopAsync();
var message = responseData.Content;
DependencyService.Get <IMessage>().ShortTime(message[0].ToString());
}
else
{
var message = "Không thành công!";
DependencyService.Get <IMessage>().LongTime(message);
}
}
catch (Exception ex)
{
var Err = "Không nết nối được máy chủ";
DependencyService.Get <IMessage>().LongTime(Err);
}
}
else
{
if (pkrTypePlace.SelectedItem == null)
{
await DisplayAlert("Thông báo", "Vui lòng chọn loại cơ sở!", "OK");
}
else
{
await DisplayAlert("Thông báo", "Vui lòng nhập đúng thông tin!", "OK");
}
}
}
}
public async Task PostAsync_CallMethodTwice_StringContent(Uri remoteServer)
{
using (var client = new HttpClient())
{
string data = "Test String";
var content = new StringContent(data, Encoding.UTF8);
content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
HttpResponseMessage response;
using (response = await client.PostAsync(remoteServer, content))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
// Repeat call.
content = new StringContent(data, Encoding.UTF8);
content.Headers.ContentMD5 = TestHelper.ComputeMD5Hash(data);
using (response = await client.PostAsync(remoteServer, content))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
}
private async void login_Tapped(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(email.Text) && !string.IsNullOrEmpty(password.Text))
{
if (NetworkCheck.IsInternet())
{
using (var client = new HttpClient())
{
var postData = new UserRegister
{
email = email.Text,
userPWD = password.Text
};
// create the request content and define Json
var json = JsonConvert.SerializeObject(postData);
var content = new StringContent(json, Encoding.UTF8, "application/json");
// send a POST request
var uri = app.url + "/AR_admin/userlogin";
var result = await client.PostAsync(uri, content);
if (result.IsSuccessStatusCode)
{
var resultString = await result.Content.ReadAsStringAsync();
var post = JsonConvert.DeserializeObject <Result>(resultString);
if (post != null && post.result != null && post.result != "" && post.result == "0")
{
if (Xamarin.Forms.Application.Current.Properties.ContainsKey("email") != false)
{
Xamarin.Forms.Application.Current.Properties["email"] = email.Text;
}
else
{
Xamarin.Forms.Application.Current.Properties.Add("email", email.Text);
}
await Xamarin.Forms.Application.Current.SavePropertiesAsync();
//write user login log
var postLogData = new UserLog
{
email = email.Text
};
var jsonLog = JsonConvert.SerializeObject(postLogData);
var contentLog = new StringContent(jsonLog, Encoding.UTF8, "application/json");
// send a POST request
var uriLog = app.url + "/AR_admin/UserLoginLog";
var resultLog = await client.PostAsync(uriLog, contentLog);
//導到選擇模式畫面
await Navigation.PushAsync(new MyProfile(), true);
Navigation.RemovePage(this);
}
else
{
await DisplayAlert("訊息", "登入失敗!", "OK");
}
}
else
{
await DisplayAlert("訊息", app.errorMessage, "OK");
}
}
}
else
{
await DisplayAlert("訊息", app.networkMessage, "OK");
}
}
else
{
await DisplayAlert("訊息", "請輸入Email和密碼!", "OK");
}
}
internal CharArrayContent/*!*/ Concatenate(StringContent/*!*/ content) {
int count = content.Data.Length;
var result = new char[_count + count];
Array.Copy(_data, 0, result, 0, _count);
content.Data.CopyTo(0, result, _count, count);
return new CharArrayContent(result, null);
}
public async void MPostAsync()
{
string url = "http://blumonpay.biz/BancaMifel/Pruebas/login_test";
string myJson = "{'Usuario':'asd','Contrasena':'123'}";
var obj = new Login {
User = "******", Pass = "******"
};
string json = JsonConvert.SerializeObject(obj, Formatting.Indented);
string json2 = await Task.Run(() => JsonConvert.SerializeObject(obj, Formatting.Indented));
var httpContent = new StringContent(myJson, Encoding.UTF8, "application/json");
using (var httpClient = new HttpClient())
{
var httpResponse = await httpClient.PostAsync(url, httpContent);
if (httpResponse.Content != null)
{
var responseContent = await httpResponse.Content.ReadAsStringAsync();
lblMensaje.Text = responseContent;
}
}
//HttpClient client = new HttpClient();
//client.BaseAddress = new Uri("http://example.com/");
//client.DefaultRequestHeaders
// .Accept
// .Add(new MediaTypeWithQualityHeaderValue("application/json"));
//HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "relativeAddress");
//request.Content = new StringContent("{\"name\":\"John Doe\",\"age\":33}",
// Encoding.UTF8,
// "application/json");
//var request = (HttpWebRequest)WebRequest.Create(url);
//request.ContentType = "application/json";
//request.Method = "POST";
//using (var client = new HttpClient())
//{
// var response = await client.PostAsync(
// url,
// new StringContent("{\"Usuario\":\"Doe\",\"Contrasena\":33}", Encoding.UTF8, "application/json"));
// lblMensaje.Text = await response.Content.ReadAsStringAsync();
//}
//HttpResponseMessage response = null;
//try
//{
// using (var client = new HttpClient())
// {
// response = client.PostAsync(
// url,
// new StringContent(json, Encoding.UTF8, "application/json")).Result;
// if (response.IsSuccessStatusCode)
// {
// lblMensaje.Text = response.StatusCode.ToString();
// }
// else
// {
// lblMensaje.Text = "NO OK";
// }
// }
//}
//catch (Exception ex)
//{
// lblMensaje.Text = "Error";
//}
//var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
//httpWebRequest.ContentType = "application/json";
//httpWebRequest.Method = "POST";
//using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
//{
// string json2 = "{\"Usuario\":\"test\"," +
// "\"Contrasena\":\"bla\"}";
// streamWriter.Write(json2);
// streamWriter.Flush();
// streamWriter.Close();
//}
//var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
//using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
//{
// var result = streamReader.ReadToEnd();
// lblMensaje.Text = result;
//}
//var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
//httpWebRequest.ContentType = "application/json";
//httpWebRequest.Method = "POST";
//using (var streamWriter = new
//StreamWriter(httpWebRequest.GetRequestStream()))
//{
// streamWriter.Write(new StringContent(myJson, Encoding.UTF8, "application/json"));
//}
//var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
//using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
//{
// var result = streamReader.ReadToEnd();
// lblMensaje.Text = result.ToString();
//}
//var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
//httpWebRequest.ContentType = "application/json";
//httpWebRequest.Method = "POST";
//using (var streamWriter = new
//StreamWriter(httpWebRequest.GetRequestStream()))
//{
// streamWriter.Write(json);
//}
//var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
//using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
//{
// var result = streamReader.ReadToEnd();
// lblMensaje.Text = result;
//}
//using (HttpClient client = new HttpClient())
//{
// using (HttpResponseMessage response = await client.PostAsync(url, new StringContent(myJson, Encoding.UTF8, "application/json")))
// {
// using (HttpContent content = response.Content)
// {
// string = await content.ReadAsStringAsync();
// lblMensaje.Text = MyContent;
// }
// }
//}
}
// content.chars + this.chars[start, count]
public override void AppendTo(StringContent/*!*/ content, int start, int count) {
if (start > _count - count) {
throw new ArgumentOutOfRangeException("start");
}
content.Append(_data, start, count);
}
// uploads public key to server under the 'email' passed in, updates private key on this machine with 'email'
void sendKey(string email)
{
var oldJson = "";
try
{
oldJson = File.ReadAllText(Directory.GetCurrentDirectory() + "\\public.key");
}
catch (FileNotFoundException)
{
Console.WriteLine("You are trying to send a key that does not exist!");
Environment.Exit(1);
}
var pk = JsonSerializer.Deserialize <Key>(oldJson);
pk.email = email;
var newJson = JsonSerializer.Serialize(pk);
using (var client = new HttpClient())
{
var uriFull = uri + "/Key/" + email;
var content = new StringContent(newJson, Encoding.UTF8, "application/json");
var response = client.PutAsync(uriFull, content).Result;
// if query executed successfully, process the response data
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Key Saved");
}
else
{
Console.WriteLine("Query failed: " + response.ReasonPhrase);
Environment.Exit(1);
}
}
// key was placed correctly, so update private.key with associated email
var oldPrivate = File.ReadAllText(Directory.GetCurrentDirectory() + "\\private.key");
var keyObj = JsonSerializer.Deserialize <PrivateKey>(oldPrivate);
var addresses = new List <string>();
foreach (var addr in keyObj.email)
{
addresses.Add(addr);
}
addresses.Add(email);
keyObj.email = addresses.ToArray();
var newPk = JsonSerializer.Serialize(keyObj);
using (var fileStream = new StreamWriter(Directory.GetCurrentDirectory() + "\\private.key"))
{
try
{
fileStream.WriteLine(newPk);
}
catch (IOException)
{
Console.WriteLine("Could not edit private.key!");
Environment.Exit(1);
}
}
}
// content.chars <=> this.chars
public override int ReverseOrdinalCompareTo(StringContent/*!*/ content) {
return content.OrdinalCompareTo(_data);
}
// finds key on local machine that corresponds to the 'email' param, then encrypts using that public key.
// finally we base64 encode the message and pass it on to the server
void sendMsg(string email, string msg)
{
// look for key
var keyPath = Directory.GetCurrentDirectory() + "\\" + email + ".key";
// get key and deserialize
var keyJson = "";
try
{
keyJson = File.ReadAllText(keyPath);
}
catch (FileNotFoundException)
{
Console.WriteLine("Key does not exist for " + email);
Environment.Exit(1);
}
catch (IOException)
{
Console.WriteLine("Could not access key for " + email + "!");
Environment.Exit(1);
}
var keyObj = JsonSerializer.Deserialize <Key>(keyJson);
// decode key
var key = keyObj.key;
var bytes = Convert.FromBase64String(key);
// get # of bytes for 1st value 'e'
var first4 = new byte[4];
for (var i = 0; i < 4; i++)
{
first4[i] = bytes[i];
}
// reverse if necessary due to endianness
if (BitConverter.IsLittleEndian)
{
Array.Reverse(first4);
}
var eLen = new BigInteger(first4);
// read bytes for 'e', and convert to BigInt
var eBytes = new byte[(int)eLen];
for (var i = 0; i < eLen; i++)
{
eBytes[i] = bytes[i + 4];
}
var eVal = new BigInteger(eBytes);
// get # of bytes for 2nd value 'n'
var second4 = new byte[4];
for (var i = 0; i < 4; i++)
{
second4[i] = bytes[i + 4 + (int)eLen];
}
if (BitConverter.IsLittleEndian)
{
Array.Reverse(second4);
}
var rLen = new BigInteger(second4);
// read bytes for 'n' and convert to BigInt
var rBytes = new byte[(int)rLen];
for (var i = 0; i < rLen; i++)
{
rBytes[i] = bytes[8 + (int)eLen + i];
}
var rVal = new BigInteger(rBytes);
// encode message
var msgBigInt = new BigInteger(Encoding.ASCII.GetBytes(msg));
var msgModPow = BigInteger.ModPow(msgBigInt, eVal, rVal);
var msgBase64 = Convert.ToBase64String(msgModPow.ToByteArray());
var msgObj = new Message();
msgObj.email = email;
msgObj.content = msgBase64;
var jsonMsg = JsonSerializer.Serialize(msgObj);
// send message
using (var client = new HttpClient())
{
var uriFull = uri + "/Message/" + email;
var content = new StringContent(jsonMsg, Encoding.UTF8, "application/json");
var response = client.PutAsync(uriFull, content).Result;
// if query executed successfully, process the response data
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Message Written");
}
else
{
Console.WriteLine("Query failed: " + response.ReasonPhrase);
Environment.Exit(1);
}
}
}
// content.chars + this.chars[start, count]
public override void AppendTo(StringContent/*!*/ content, int start, int count) {
content.Append(_data, start, count);
}
// Helper function to greet user with information in GreetingState.
private async Task <DialogTurnResult> GetPolicyRenewalDate(WaterfallStepContext stepContext)
{
var context = stepContext.Context;
var greetingState = await UserProfileAccessor.GetAsync(context);
// Display their profile information and end dialog.
await context.SendActivityAsync($"Getting policy renewal date for {greetingState.Mobile} - {greetingState.BirthYear} from CRM.. Please wait...");
var authBodyValues = new Dictionary <string, string>
{
{ "tenancyName", "sathish-paripoorna" }, { "usernameOrEmailAddress", "*****@*****.**" }, { "password", "Psss@2018" },
};
var authResult = string.Empty;
var startJobResult = string.Empty;
var renewalResultValue = string.Empty;
var jobCreatedID = string.Empty;
int[] robitIDs = new int[1];
robitIDs[0] = 74213;
int timeoutSec = 90;
string contentType = "application/json";
var authKeyValue = string.Empty;
dynamic startJobResultValues = null;
string polRenewalDate = string.Empty;
using (var authHttpClient = new HttpClient())
{
authHttpClient.BaseAddress = new Uri("https://platform.uipath.com");
authHttpClient.Timeout = new TimeSpan(0, 0, timeoutSec);
authHttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
var authJson = JsonConvert.SerializeObject(authBodyValues);
using (var stringContent = new StringContent(authJson, Encoding.UTF8, "application/json"))
{
var authResponse = authHttpClient.PostAsync("api/account/authenticate", stringContent).Result;
if (authResponse.IsSuccessStatusCode)
{
authResult = authResponse.Content.ReadAsStringAsync().Result;
dynamic authResultValues = JsonConvert.DeserializeObject(authResult);
authKeyValue = authResultValues.result;
if (authKeyValue != string.Empty)
{
object startJobArguments = new
{
in_cust_id = greetingState.Mobile,
};
object startJobBody = new
{
ReleaseKey = "30a75006-fd84-42e0-87ad-0ce347018683",
RobotIds = robitIDs,
JobsCount = 0,
Strategy = "Specific",
InputArguments = "{in_cust_id:" + greetingState.Mobile + "}",
};
object startJobWrapper = new
{
startInfo = startJobBody,
};
using (var startJobHttpClient = new HttpClient())
{
startJobHttpClient.BaseAddress = new Uri("https://platform.uipath.com");
startJobHttpClient.Timeout = new TimeSpan(0, 0, timeoutSec);
startJobHttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
startJobHttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authKeyValue);
var startJobJson = JsonConvert.SerializeObject(startJobWrapper);
using (var startJobContent = new StringContent(startJobJson, Encoding.UTF8, "application/json"))
{
var startJobResponse = startJobHttpClient.PostAsync("/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs", startJobContent).Result;
Thread.Sleep(20000);
if (startJobResponse.IsSuccessStatusCode)
{
startJobResult = startJobResponse.Content.ReadAsStringAsync().Result;
startJobResultValues = JsonConvert.DeserializeObject(startJobResult);
jobCreatedID = startJobResultValues.value[0].Id;
if (jobCreatedID != null)
{
using (var getJobHttpClient = new HttpClient())
{
polRenewalDate = await GetRenewalJobStatusResult(getJobHttpClient, greetingState.Mobile, authKeyValue).ConfigureAwait(false);
Thread.Sleep(3000);
}
}
}
}
}
}
}
}
}
await context.SendActivityAsync($"You renewal date for policy no `{polRenewalDate}`");
return(await stepContext.EndDialogAsync());
}
public abstract void AppendTo(StringContent/*!*/ content, int start, int count);
public static dynamic GetActivityLevelLogsCore(Logging logging)
{
string AppInsightsWorkspaceId = System.Environment.GetEnvironmentVariable("AppInsightsWorkspaceId");
using var client = new HttpClient();
string token = Shared.Azure.AzureSDK.GetAzureRestApiToken("https://api.applicationinsights.io");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
TaskMetaDataDatabase TMD = new TaskMetaDataDatabase();
using SqlConnection _conRead = TMD.GetSqlConnection();
//Get Last Request Date
var MaxTimesGen = _conRead.QueryWithRetry(@"
select max([timestamp]) maxtimestamp from ActivityLevelLogs");
DateTimeOffset MaxLogTimeGenerated = DateTimeOffset.UtcNow.AddDays(-30);
foreach (var datafactory in MaxTimesGen)
{
if (datafactory.maxtimestamp != null)
{
MaxLogTimeGenerated = ((DateTimeOffset)datafactory.maxtimestamp).AddMinutes(-5);
}
//string workspaceId = datafactory.LogAnalyticsWorkspaceId.ToString();
Dictionary <string, object> KqlParams = new Dictionary <string, object>
{
{ "MaxLogTimeGenerated", MaxLogTimeGenerated.ToString("yyyy-MM-dd HH:mm:ss.ff K") }
//{"SubscriptionId", ((string)datafactory.SubscriptionUid.ToString()).ToUpper()},
//{"ResourceGroupName", ((string)datafactory.ResourceGroup.ToString()).ToUpper() },
//{"DataFactoryName", ((string)datafactory.Name.ToString()).ToUpper() },
//{"DatafactoryId", datafactory.Id.ToString() }
};
string KQL = System.IO.File.ReadAllText(Shared.GlobalConfigs.GetStringConfig("KQLTemplateLocation") + "GetActivityLevelLogs.kql");
KQL = KQL.FormatWith(KqlParams, FormatWith.MissingKeyBehaviour.ThrowException, null, '{', '}');
JObject JsonContent = new JObject();
JsonContent["query"] = KQL;
var postContent = new StringContent(JsonContent.ToString(), System.Text.Encoding.UTF8, "application/json");
var response = client.PostAsync($"https://api.applicationinsights.io/v1/apps/{AppInsightsWorkspaceId}/query", postContent).Result;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
//Start to parse the response content
HttpContent responseContent = response.Content;
var content = response.Content.ReadAsStringAsync().Result;
var tables = ((JArray)(JObject.Parse(content)["tables"]));
if (tables.Count > 0)
{
DataTable dt = new DataTable();
var rows = (JArray)(tables[0]["rows"]);
var columns = (JArray)(tables[0]["columns"]);
foreach (JObject c in columns)
{
DataColumn dc = new DataColumn();
dc.ColumnName = c["name"].ToString();
dc.DataType = KustoDataTypeMapper[c["type"].ToString()];
dt.Columns.Add(dc);
}
foreach (JArray r in rows)
{
DataRow dr = dt.NewRow();
for (int i = 0; i < columns.Count; i++)
{
if (((Newtonsoft.Json.Linq.JValue)r[i]).Value != null)
{
dr[i] = ((Newtonsoft.Json.Linq.JValue)r[i]).Value;
}
else
{
dr[i] = DBNull.Value;
}
}
dt.Rows.Add(dr);
}
Table t = new Table();
t.Schema = "dbo";
string TableGuid = Guid.NewGuid().ToString();
t.Name = "#ActivityLevelLogs{TableGuid}";
using (SqlConnection _conWrite = TMD.GetSqlConnection())
{
TMD.BulkInsert(dt, t, true, _conWrite);
Dictionary <string, string> SqlParams = new Dictionary <string, string>
{
{ "TempTable", t.QuotedSchemaAndName() },
{ "DatafactoryId", "1" }
};
string MergeSQL = GenerateSQLStatementTemplates.GetSQL(Shared.GlobalConfigs.GetStringConfig("SQLTemplateLocation"), "MergeIntoActivityLevelLogs", SqlParams);
logging.LogInformation(MergeSQL.ToString());
_conWrite.ExecuteWithRetry(MergeSQL);
_conWrite.Close();
_conWrite.Dispose();
}
}
else
{
logging.LogErrors(new Exception("Kusto query failed getting ADFPipeline Stats."));
}
}
}
return(new { });
}
public static async Task SyncLogicAppJson(string requestId, TraceListener tracer)
{
_tracer = tracer;
var logicAppUrl = LogicAppUrl;
if (string.IsNullOrEmpty(logicAppUrl))
{
return;
}
var fileInfo = new FileInfo(LogicAppJsonFilePath);
if (!fileInfo.Exists)
{
Trace(TraceEventType.Verbose, "File {0} does not exists", fileInfo.FullName);
return;
}
var displayUrl = logicAppUrl;
var queryIndex = logicAppUrl.IndexOf('?');
if (queryIndex > 0)
{
// for display/logging, strip out querystring secret
displayUrl = logicAppUrl.Substring(0, queryIndex);
}
var content = File.ReadAllText(fileInfo.FullName);
var statusCode = default(HttpStatusCode);
Exception exception = null;
try
{
Trace(TraceEventType.Verbose, "Begin HttpPut {0}, x-ms-client-request-id: {1}", displayUrl, requestId);
using (var client = HttpClientFactory())
{
client.DefaultRequestHeaders.UserAgent.Add(_userAgent.Value);
client.DefaultRequestHeaders.Add(Constants.ClientRequestIdHeader, requestId);
var payload = new StringContent(content ?? string.Empty, Encoding.UTF8, "application/json");
using (var response = await client.PutAsync(logicAppUrl, payload))
{
statusCode = response.StatusCode;
response.EnsureSuccessStatusCode();
}
}
}
catch (Exception ex)
{
exception = ex;
throw;
}
finally
{
Trace(TraceEventType.Verbose, "End HttpPut, status: {0}", statusCode);
Trace(TraceEventType.Information,
"Syncing logicapp {0} with payload size {1} bytes {2}",
displayUrl,
content.Length,
exception == null ? "successful." : ("failed with " + exception));
}
}
public async Task <IActionResult> Qiang(MoKaiQiang qiang)
{
#region 基础验证
if (qiang == null || qiang.ShopId <= 0)
{
return(RedirectToAction("Error", new { msg = "操作太快，请稍后重试。" }));
}
if (!Request.Cookies.TryGetValue(EnumHelper.EmDataKey.SessionKey.ToString(), out string token))
{
return(RedirectToAction("Error", new { msg = "请先去登录。" }));
}
var sessionData = await _redis.Get <MoUserInfo>(token);
if (sessionData == null || sessionData.UserId <= 0)
{
return(RedirectToAction("Error", new { msg = "请先去登录！" }));
}
var shop = await _redis.GetHashField <MoShopping>(EnumHelper.EmDataKey.ShoppingHash.ToString(), qiang.ShopId.ToString());
if (shop == null)
{
return(NotFound());
}
else if (shop.MaxNum <= 0)
{
return(RedirectToAction("Error", new { msg = $"你太慢了，商品：{shop.Name}，已经被抢完了！" }));
}
else if (shop.MaxNum < qiang.Num)
{
return(RedirectToAction("Error", new { msg = $"库存不足，商品：{shop.Name}，只剩{shop.MaxNum}了！" }));
}
else if (shop.MaxGouNum < qiang.Num)
{
return(RedirectToAction("Error", new { msg = $"一个账号每次最多只能抢购【{shop.Name}】{shop.MaxGouNum}件。" }));
}
#endregion
#region 请求抢购商品的分布式接口
var rq = new MoQiangGouRq();
rq.Num = qiang.Num;
rq.ShoppingId = qiang.ShopId;
rq.MemberRq = new MoMemberRq
{
Ip = HttpContext.Connection.RemoteIpAddress.ToString(), //用户Ip
RqSource = (int)EnumHelper.EmRqSource.Web,
Token = token
};
var strRq = JsonConvert.SerializeObject(rq);
var content = new StringContent(strRq, System.Text.Encoding.UTF8, "application/json");
//基础接口地址
string apiBaseUrl = ConfigData.ApiUrl; //$"http://{HttpContext.Connection.LocalIpAddress}:4545";
var qiangApiUrl = $"{apiBaseUrl}/api/order/SubmitQiangGouOrder";
var strRp = await HttpTool.HttpPostAsync(qiangApiUrl, content, 30);
if (string.IsNullOrWhiteSpace(strRp))
{
return(RedirectToAction("Error", new { msg = $"抢单超时，请查看你的订单列表是否抢单成功。" }));
}
var rp = JsonConvert.DeserializeObject <MoQiangGouRp>(strRp);
if (rp == null)
{
return(RedirectToAction("Error", new { msg = $"抢单超时，请查看你的订单列表是否抢单成功。" }));
}
else if (rp.RpStatus != 1)
{
return(Error(rp.RpMsg));
}
#endregion
return(RedirectToAction("QiangResult", new { id = rp.OrderId }));
}
