public async Task<bool> apiPOST(string access_token, string response, string href) { mlibrary = new methodLibrary(); HttpClient httpClient = new HttpClient(); try { httpClient.DefaultRequestHeaders.Authorization = new HttpCredentialsHeaderValue("Bearer", access_token); httpClient.DefaultRequestHeaders.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("application/json")); var httpResponseMessage = await httpClient.PostAsync(new Uri(href), new HttpStringContent(response)); string resp = await httpResponseMessage.Content.ReadAsStringAsync(); await mlibrary.writeFile("POSTresponse", resp); Debug.WriteLine(resp); ApplicationData.Current.LocalSettings.Values["POSTCallMade"] = true; } catch(Exception ex) { Debug.WriteLine("Caught exception : " + ex); return false; } return true; }
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<bool> Initialize() { _client = new HttpClient(); // Define the data needed to request an authorization token. var service = "https://datamarket.accesscontrol.windows.net/v2/OAuth2-13"; var scope = "http://music.xboxlive.com"; var grantType = "client_credentials"; // Create the request data. var requestData = new Dictionary<string, string>(); requestData["client_id"] = CLIENT_ID; requestData["client_secret"] = CLIENT_SECRET; requestData["scope"] = scope; requestData["grant_type"] = grantType; // Post the request and retrieve the response. string token = null; var response = await _client.PostAsync(new Uri(service), new HttpFormUrlEncodedContent(requestData)); var responseString = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { token = Regex.Match(responseString, ".*\"access_token\":\"(.*?)\".*", RegexOptions.IgnoreCase).Groups[1].Value; } else { await new MessageDialog("Authentication failed. Please provide a valid client.").ShowAsync(); App.Current.Exit(); } Token = token; return (token != null) ? true : false; }
public async Task<JsonValue> PostAsync(string relativeUri) { HttpStringContent content = new HttpStringContent(message.Stringify(), UnicodeEncoding.Utf8, "application/json"); HttpClient httpClient = new HttpClient(); HttpResponseMessage httpResponse = null; try { httpResponse = await httpClient.PostAsync(new Uri(serverBaseUri, relativeUri), content); } catch (Exception ex) { switch (ex.HResult) { case E_WINHTTP_TIMEOUT: // The connection to the server timed out. case E_WINHTTP_NAME_NOT_RESOLVED: case E_WINHTTP_CANNOT_CONNECT: case E_WINHTTP_CONNECTION_ERROR: // Unable to connect to the server. Check that you have Internet access. default: // "Unexpected error connecting to server: ex.Message return null; } } // We assume that if the server responds at all, it responds with valid JSON. return JsonValue.Parse(await httpResponse.Content.ReadAsStringAsync()); }
private async Task<string> HttpPost(string relativeUri, string json) { var cts = new CancellationTokenSource(); cts.CancelAfter(5000); try { HttpClient client = new HttpClient(); Uri uri = new Uri($"http://{Ip}:{Port}/api/{relativeUri}"); HttpStringContent httpContent = new HttpStringContent(json); HttpResponseMessage response = await client.PostAsync(uri, httpContent).AsTask(cts.Token); if (!response.IsSuccessStatusCode) { return string.Empty; } string jsonResponse = await response.Content.ReadAsStringAsync(); System.Diagnostics.Debug.WriteLine(jsonResponse); return jsonResponse; } catch (Exception) { return string.Empty; } }
private async Task<String> Post(string path, string json) { var cts = new CancellationTokenSource(); cts.CancelAfter(5000); try { HttpClient client = new HttpClient(); HttpStringContent content = new HttpStringContent(json, Windows.Storage.Streams.UnicodeEncoding.Utf8, "application /json"); Uri uriLampState = new Uri("http://127.0.0.1:8000/api/" + path); var response = await client.PostAsync(uriLampState, content).AsTask(cts.Token); if (!response.IsSuccessStatusCode) { return string.Empty; } string jsonResponse = await response.Content.ReadAsStringAsync(); return jsonResponse; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return string.Empty; } }
private async Task Authorize(string code) { Uri uri = new Uri("https://api.weibo.com/oauth2/access_token"); List<KeyValuePair<string, string>> pairs = new List<KeyValuePair<string, string>>(); pairs.Add(new KeyValuePair<string, string>("client_id", appInfo.Key)); pairs.Add(new KeyValuePair<string, string>("client_secret", appInfo.Secret)); pairs.Add(new KeyValuePair<string, string>("grant_type", "authorization_code")); pairs.Add(new KeyValuePair<string, string>("code", code)); pairs.Add(new KeyValuePair<string, string>("redirect_uri", appInfo.RedirectUri)); HttpFormUrlEncodedContent content = new HttpFormUrlEncodedContent(pairs); using (HttpClient client = new HttpClient()) { DateTime time = DateTime.Now; HttpResponseMessage response; try { response = await client.PostAsync(uri, content); } catch (Exception ex) { throw new Exception("network error", ex); } string json = await response.Content.ReadAsStringAsync(); JObject accessToken = JsonConvert.DeserializeObject<JObject>(json); UserInfo.Token = accessToken["access_token"].ToString(); UserInfo.ExpiresAt = Untils.ToTimestamp(time) + (long)accessToken["expires_in"]; UserInfo.Uid = accessToken["uid"].ToString(); } }
private static async Task<string> PostAsync(string url, string content) { var client = new HttpClient(); var response = await client.PostAsync(new Uri(url), new HttpStringContent(content)); var result = await response.Content.ReadAsStringAsync(); return result; }
private static async Task<string> PostFormNoParse(string url, Dictionary<string, string> args) { var client = new HttpClient(); var response = await client.PostAsync(new Uri(url), new HttpFormUrlEncodedContent(args)); var responseString = await response.Content.ReadAsStringAsync(); return responseString; }
//public List<CartUnit> Units { get; set; } //public List<CartOption> Options { get; set; } public static async Task<Cart> SetCarUnit(CancellationToken token, string cartKey, int searchDateId, int unitId, int currencyId, double pricePerItem, int taxId, long crc) { var cart = new Cart(); using (var httpClient = new HttpClient()) { var apiKey = Common.StorageService.LoadSetting("ApiKey"); var apiUrl = Common.StorageService.LoadSetting("ApiUrl"); var profileToken = Common.StorageService.LoadSetting("ProfileToken"); httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "gzip"); httpClient.DefaultRequestHeaders.Add("token", apiKey); httpClient.DefaultRequestHeaders.Add("api-version", "2"); httpClient.DefaultRequestHeaders.Add("profileToken", profileToken); var criteria = new CartUnitCriteria() { CartKey = cartKey, SearchDateId = searchDateId, UnitId = unitId, CurrencyId = currencyId, PricePerItem = pricePerItem, TaxId = taxId, Crc = crc }; var url = apiUrl + "/api/cart/unit/"; var queryString = new HttpStringContent(JsonConvert.SerializeObject(criteria), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json"); using (var httpResponse = await httpClient.PostAsync(new Uri(url), queryString).AsTask(token)) { string json = await httpResponse.Content.ReadAsStringAsync().AsTask(token); json = json.Replace("<br>", Environment.NewLine); cart = JsonConvert.DeserializeObject<Cart>(json); } } return cart; }
public async Task<string> ExecuteAsync() { if (OAuthSettings.AccessToken != null) { return OAuthSettings.AccessToken; } else if (OAuthSettings.RefreshToken == null) { return null; } using (var client = new HttpClient()) { var content = new HttpFormUrlEncodedContent(new Dictionary<string, string>{ {"grant_type","refresh_token"}, {"refresh_token", OAuthSettings.RefreshToken}, {"client_id", OAuthSettings.ClientId}, {"client_secret", OAuthSettings.ClientSecret} }); var response = await client.PostAsync(new Uri(OAuthSettings.TokenEndpoint), content); response.EnsureSuccessStatusCode(); var contentString = await response.Content.ReadAsStringAsync(); var accessTokenInfo = await JsonConvert.DeserializeObjectAsync<OAuthTokenInfo>(contentString); OAuthSettings.AccessToken = accessTokenInfo.AccessToken; OAuthSettings.RefreshToken = accessTokenInfo.RefreshToken; return OAuthSettings.AccessToken; } }
public async Task<bool> SendRemoteCommandAsync(string pressedKey) { bool succeeded = false; string address = String.Empty; if (!string.IsNullOrWhiteSpace(pressedKey) && !string.IsNullOrWhiteSpace(_ipAddress)) { address = "http://" + _ipAddress + "/RemoteControl/KeyHandling/sendKey?key=" + pressedKey; var uri = new Uri(address, UriKind.Absolute); using (HttpClient client = new HttpClient()) { HttpRequestMessage request = new HttpRequestMessage(); request.RequestUri = new Uri(address); IHttpContent httpContent = new HttpStringContent(String.Empty); try { await client.PostAsync(uri, httpContent); } catch (Exception) { return succeeded = false; } return succeeded = true; } } return succeeded = false; }
/// <summary> /// 约定成功登陆返回0,不成功返回错误代码,未知返回-1 /// </summary> /// <returns></returns> public async Task<int> DoLogin() { var httpClient = new HttpClient(); var requestUrl = "https://net.zju.edu.cn/cgi-bin/srun_portal"; var formcontent = new HttpFormUrlEncodedContent(new[] { new KeyValuePair<string, string>("action","login"), new KeyValuePair<string, string>("username",_mAccount.Username), new KeyValuePair<string, string>("password",_mAccount.Password), new KeyValuePair<string, string>("ac_id","3"), new KeyValuePair<string, string>("type","1"), new KeyValuePair<string, string>("wbaredirect",@"http://www.qsc.zju.edu.cn/"), new KeyValuePair<string, string>("mac","undefined"), new KeyValuePair<string, string>("user_ip",""), new KeyValuePair<string, string>("is_ldap","1"), new KeyValuePair<string, string>("local_auth","1"), }); var response = await httpClient.PostAsync(new Uri(requestUrl), formcontent); if (response.Content != null) { string textMessage = await response.Content.ReadAsStringAsync(); Debug.WriteLine(textMessage); } httpClient.Dispose(); return -1; }
public async Task<string> PostStringAsync(string link, string param) { try { System.Diagnostics.Debug.WriteLine(param); Uri uri = new Uri(link); HttpClient httpClient = new HttpClient(); HttpStringContent httpStringContent = new HttpStringContent(param, Windows.Storage.Streams.UnicodeEncoding.Utf8,"application/x-www-form-urlencoded"); //,Windows.Storage.Streams.UnicodeEncoding.Utf8 HttpResponseMessage response = await httpClient.PostAsync(uri, httpStringContent).AsTask(cts.Token); responseHeaders = response.Headers; System.Diagnostics.Debug.WriteLine(responseHeaders); string responseBody = await response.Content.ReadAsStringAsync().AsTask(cts.Token); return responseBody; } catch(Exception e) { return "Error:" + e.Message; } }
/// <summary> /// Invoked to acquire the PlayReady license. /// </summary> /// <param name="licenseServerUri">License Server URI to retrieve the PlayReady license.</param> /// <param name="httpRequestContent">HttpContent including the Challenge transmitted to the PlayReady server.</param> public async virtual Task<IHttpContent> AcquireLicense(Uri licenseServerUri, IHttpContent httpRequestContent) { try { HttpClient httpClient = new HttpClient(); httpClient.DefaultRequestHeaders.Add("msprdrm_server_redirect_compat", "false"); httpClient.DefaultRequestHeaders.Add("msprdrm_server_exception_compat", "false"); HttpResponseMessage response = await httpClient.PostAsync(licenseServerUri, httpRequestContent); response.EnsureSuccessStatusCode(); if (response.StatusCode == HttpStatusCode.Ok) { _lastErrorMessage = string.Empty; return response.Content; } else { _lastErrorMessage = "AcquireLicense - Http Response Status Code: " + response.StatusCode.ToString(); } } catch (Exception exception) { _lastErrorMessage = exception.Message; return null; } return null; }
public static async Task<Chat> PostChatMessage(int chatId, string message) { var chat = new Chat(); //var authenticatedProfile = await Common.StorageService.RetrieveObjectAsync<Profile>("Profile"); using (var httpClient = new HttpClient()) { var apiKey = Common.StorageService.LoadSetting("ApiKey"); var apiUrl = Common.StorageService.LoadSetting("ApiUrl"); var profileToken = Common.StorageService.LoadSetting("ProfileToken"); httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "gzip"); httpClient.DefaultRequestHeaders.Add("token", apiKey); httpClient.DefaultRequestHeaders.Add("api-version", "2"); httpClient.DefaultRequestHeaders.Add("profileToken", profileToken); var criteria = new NewChatMessageCriteria { ChatId = chatId, Message = message }; var uri = new Uri(apiUrl + "/api/chat/message"); var queryString = new HttpStringContent(JsonConvert.SerializeObject(criteria), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json"); HttpResponseMessage response = await httpClient.PostAsync(uri, queryString); string json = await response.Content.ReadAsStringAsync(); json = json.Replace("<br>", Environment.NewLine); chat = JsonConvert.DeserializeObject<Chat>(json); } return chat; }
public async Task SavePaymentMethodAsync(PaymentMethod paymentMethod) { using (var client = new HttpClient()) { var response = await client.PostAsync(new Uri(_clientBaseUrl), new HttpStringContent(JsonConvert.SerializeObject(paymentMethod), Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json")); await response.EnsureSuccessWithValidationSupportAsync(); } }
public async Task<HttpResponseMessage> ExecuteSOAPRequest(string uri, string data, string soapAction) { HttpClient client = new HttpClient(); var httpStringContent = new HttpStringContent(data, UnicodeEncoding.Utf8, "text/xml"); client.DefaultRequestHeaders.Add("SOAPAction", soapAction); var message = await client.PostAsync(new Uri(uri), httpStringContent); return message; }
public async Task RemoveProductFromShoppingCartAsync(string shoppingCartId, string productIdToDecrement) { using (var shoppingCartClient = new HttpClient()) { string requestUrl = _shoppingCartBaseUrl + shoppingCartId + "?productIdToDecrement=" + productIdToDecrement; var response = await shoppingCartClient.PostAsync(new Uri(requestUrl), null); response.EnsureSuccessStatusCode(); } }
public async Task SaveAddressAsync(Address address) { using (var client = new HttpClient()) { var serializedAddress = JsonConvert.SerializeObject(address); var response = await client.PostAsync(new Uri(_clientBaseUrl), new HttpStringContent(serializedAddress, Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json")); await response.EnsureSuccessWithValidationSupportAsync(); } }
/// <summary> /// Attemps to login to the server /// </summary> /// <param name="username">The Username</param> /// <param name="password">The Password</param> /// <returns> /// true if the app was able to login /// </returns> public async Task<LoginStatus> LoginAsync(string username, string password) { UriBuilder builder; try { builder = new UriBuilder(new Uri(settings.ServerUrl)); builder.Path = "/Account/Login"; } catch(UriFormatException) { return LoginStatus.InvalidServerUrl; } HttpBaseProtocolFilter httpFilter = new HttpBaseProtocolFilter(); using (var client = new HttpClient(httpFilter)) { var content = new Windows.Web.Http.HttpFormUrlEncodedContent(new KeyValuePair<String, String>[] { new KeyValuePair<string, string>("Email", username), new KeyValuePair<string, string>("Password", password), new KeyValuePair<string, string>("RememberMe", "true") }); HttpResponseMessage result = null; try { result = await client.PostAsync(builder.Uri, content); } catch (COMException ce) { if(ce.HResult == -2147012867) { return LoginStatus.UnableToConnectToServer; } return LoginStatus.Error; } if (result.StatusCode == HttpStatusCode.Ok) { var cookies = httpFilter.CookieManager.GetCookies(new Uri($"{builder.Scheme}://{builder.Host}:{builder.Port}")); var authz = cookies.FirstOrDefault(i => String.Compare(i.Name, "Authz") == 0); if(authz != null) { this.authz = authz; return LoginStatus.Success; } else { return LoginStatus.ErrorAuthenticating; } } } return LoginStatus.Unknown; }
//primjer post zahtjeva prema servisu public async void dodajKorisnika(Uposlenik uposlenik) { HttpClient httpClient = new HttpClient(); //mora se stavity content/type da je json inace ce aplikacija da odbija zahtjev httpClient.DefaultRequestHeaders.Accept.Add(new HttpMediaTypeWithQualityHeaderValue("application/json")); //json se salje u body post zahtjeva string jsonContents = JsonConvert.SerializeObject(uposlenik); HttpResponseMessage response = await httpClient.PostAsync(new Uri(serviceHost+ uposleniciName), new HttpStringContent(jsonContents, Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json")); //dalje sa odgovorom se moze uraditi sta god zatreba JsonValue value = JsonValue.Parse(response.Content.ToString()); }
public static Task <HttpResponseMessage> PostAsJsonAsync <T>(this HttpClient httpClient, string url, T data) { var dataAsString = JsonConvert.SerializeObject(data); #pragma warning disable CA2000 // Dispose objects before losing scope var content = new StringContent(dataAsString); #pragma warning restore CA2000 // Dispose objects before losing scope content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); return(httpClient?.PostAsync(new Uri(url), content)); }
static async Task AsyncTask(Dictionary<string, string> pairs) { Uri signup_uri = new Uri(SLOT_URL); HttpClient client = new HttpClient(); HttpFormUrlEncodedContent content = new HttpFormUrlEncodedContent(pairs); HttpResponseMessage res = await client.PostAsync(signup_uri, content); if (res.IsSuccessStatusCode) { response = res.Content.ToString(); } }
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 static async Task<string> GetTextByPost(string posturi, string poststr, IEnumerable<KeyValuePair<string, string>> body) { var httpClient = new HttpClient(); //CreateHttpClient(ref httpClient); var postData = new HttpFormUrlEncodedContent(body); string responseString; using (var response = await httpClient.PostAsync(new Uri(posturi), postData)) { responseString = await response.Content.ReadAsStringAsync(); } return responseString; }
public async Task<bool> MergeShoppingCartsAsync(string anonymousShoppingCartId, string authenticatedShoppingCartId) { using (var shoppingCartClient = new HttpClient()) { string requestUrl = _shoppingCartBaseUrl + authenticatedShoppingCartId + "?anonymousShoppingCartId=" + anonymousShoppingCartId; var response = await shoppingCartClient.PostAsync(new Uri(requestUrl), null); response.EnsureSuccessStatusCode(); var responseContent = await response.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject<bool>(responseContent); return result; } }
public async Task <bool> AddItemAsync(Item item) { if (item == null || !IsConnected) { return(false); } var serializedItem = JsonConvert.SerializeObject(item); var response = await client?.PostAsync($"api/item", new StringContent(serializedItem, Encoding.UTF8, "application/json")); return(response.IsSuccessStatusCode); }
public static async Task<string> RetrieveUsername() { System.Diagnostics.Debug.WriteLine("Retrieving username"); Boolean hasGotUsername = false; string jsonResponse = ""; string usernameRetrieved = ""; while (!hasGotUsername) { try { HttpClient client = new HttpClient(); HttpStringContent content = new HttpStringContent("{\"devicetype\":\"HueApp#ComfyCrew\"}", Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json"); string ip, username; int port; SettingsService.RetrieveSettings(out ip, out port, out username); var response = await client.PostAsync(new Uri(string.Format("http://{0}:{1}/api/", ip, port)), content); if (!response.IsSuccessStatusCode) { return string.Empty; } jsonResponse = await response.Content.ReadAsStringAsync(); System.Diagnostics.Debug.WriteLine(jsonResponse); JsonArray jsonArray = JsonArray.Parse(jsonResponse); ICollection<string> keys = jsonArray.First().GetObject().Keys; if (keys.Contains("error")) { Hugh.Views_Viewmodels.MainPage.ShowErrorDialogue(); await Task.Delay(TimeSpan.FromSeconds(1)); } else { hasGotUsername = true; JsonObject succesObject = jsonArray.First().GetObject(); System.Diagnostics.Debug.WriteLine(succesObject.Values.First().GetObject().Values.First().GetString()); usernameRetrieved = succesObject.Values.First().GetObject().Values.First().GetString(); } } catch (Exception) { return string.Empty; } } return usernameRetrieved; }
/// <summary> /// Common method to request in POST, GET, PUT and DELETE form to get data in key value format. /// </summary> /// <param name="requestType"></param> /// <param name="url"></param> /// <param name="data"></param> /// <returns name="StatusAndResponseClass"></returns> public static async Task <StatusAndResponseClass> Request(RequestType requestType, string url, Dictionary <string, string> data, Dictionary <string, string> header) { StatusAndResponseClass getResponse = new StatusAndResponseClass(); HttpClient client = new HttpClient(); if (header != null && header.Count() > 0) { foreach (var item in header) { client.DefaultRequestHeaders.Add(item.Key, item.Value); } } IProgress <Windows.Web.Http.HttpProgress> progress = new Progress <Windows.Web.Http.HttpProgress>(ProgressHandler); HttpResponseMessage response = new HttpResponseMessage(); HttpContent content; System.Diagnostics.Debug.WriteLine("PostStringJsonData (URL): " + url); System.Diagnostics.Debug.WriteLine("PostStringJsonData (POSTDATA): " + data); try { switch (requestType) { case RequestType.POST: content = new FormUrlEncodedContent(data); response = await client.PostAsync(new Uri(url), content, cancellationToken.Token); break; case RequestType.GET: var message = new HttpRequestMessage(HttpMethod.Get, url); response = await client.SendAsync(message, cancellationToken.Token); //response = await client.GetAsync(new Uri(url)); break; case RequestType.PUT: content = new FormUrlEncodedContent(data); response = await client.PutAsync(new Uri(url), content, cancellationToken.Token); break; case RequestType.DELETE: content = new FormUrlEncodedContent(data); response = await client.DeleteAsync(new Uri(url + content), cancellationToken.Token); break; default: break; } client.Dispose(); HttpStatusCode statuscode = response.StatusCode; string responseBody = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { getResponse.responseString = responseBody; } else { getResponse.responseString = responseBody; } getResponse.statusCode = Convert.ToInt32(statuscode); if (getResponse.statusCode == 404) { getResponse.responseString = string.Empty; } return(getResponse); } catch (Exception ex) { return(getResponse); } }
public void Security_AuthorizeEndpointTests(HostType hostType) { using (ApplicationDeployer deployer = new ApplicationDeployer()) { var applicationUrl = deployer.Deploy(hostType, AuthServerHappyPathConfiguration); IDisposable clientEndpoint = null; try { clientEndpoint = WebApp.Start(Client_Redirect_Uri, app => app.Run(context => { return(context.Response.WriteAsync(context.Request.QueryString.Value)); })); string tokenEndpointUri = applicationUrl + "TokenEndpoint"; var basicClient = new HttpClient(); var headerValue = Convert.ToBase64String(Encoding.Default.GetBytes(string.Format("{0}:{1}", "123", "invalid"))); basicClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", headerValue); HttpClient httpClient = new HttpClient(); string requestUri = null; Uri landingUri = null; Uri applicationUri = new Uri(applicationUrl); HttpResponseMessage httpResponseMessage = null; //Happy path - response_type:code requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "validstate"); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["code"]); Assert.Equal <string>("validstate", landingUri.ParseQueryString()["state"]); //Happy path - response_type:token requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", "123", Client_Redirect_Uri, "scope1", "validstate"); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; landingUri = new Uri(landingUri.AbsoluteUri.Replace('#', '?')); Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["access_token"]); Assert.NotNull(landingUri.ParseQueryString()["expires_in"]); Assert.Equal <string>("bearer", landingUri.ParseQueryString()["token_type"]); Assert.Equal <string>("validstate", landingUri.ParseQueryString()["state"]); //Invalid redirect URI - pass error to application requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", "invalid_uri_passonerror", "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.Equal <string>("error: invalid_request\r\n", httpResponseMessage.Content.ReadAsStringAsync().Result); Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); //Invalid redirect URI - Display error by middleware requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", "invalid_uri_displayerror", "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri"); //What happens if we don't set Validated explicitly. Send an invalid clientId => We don't set Validated for this case. requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", "invalidClient", Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri"); //OnValidateAuthorizeRequest - Rejecting a request. Send an invalid state as we validate it there. Client should receive all the error code & description that we send requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "invalidstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; landingUri = httpResponseMessage.RequestMessage.RequestUri; Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.Equal <string>("state.invalid", landingUri.ParseQueryString()["error"]); Assert.Equal <string>("state.invaliddescription", landingUri.ParseQueryString()["error_description"]); Assert.Equal <string>("state.invaliduri", landingUri.ParseQueryString()["error_uri"]); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error=state.invalid&error_description=state.invaliddescription&error_uri=state.invaliduri"), "Did not receive an error when provider did not set Validated"); //Missing response_type requestUri = AuthZ.CreateAuthZUri(applicationUrl, null, "123", Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.Equal <string>(Client_Redirect_Uri, httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Path)); Assert.Equal <string>("invalid_request", httpResponseMessage.RequestMessage.RequestUri.ParseQueryString()["error"]); //Unsupported response_type requestUri = AuthZ.CreateAuthZUri(applicationUrl, "invalid_response_type", "123", Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.Equal <string>(Client_Redirect_Uri, httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Path)); Assert.Equal <string>("unsupported_response_type", httpResponseMessage.RequestMessage.RequestUri.ParseQueryString()["error"]); //Missing client_id requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", null, Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri"); //Missing state - Should succeed requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", null); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["code"]); Assert.Equal <bool>(false, landingUri.ParseQueryString().ContainsKey("state")); //Token endpoint tests //Invalid client (client_id, client_secret) - As form parameters var formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "invalid") }); var responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; var jToken = JToken.Parse(responseMessage); Assert.Equal <string>("invalid_client", jToken.SelectToken("error").Value <string>()); //Invalid client (client_id, client_secret) - As Basic auth headers responseMessage = basicClient.GetAsync(tokenEndpointUri).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.Equal <string>("invalid_client", jToken.SelectToken("error").Value <string>()); //grant_type=authorization_code - invalid code being sent formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "authorization_code"), new kvp("code", "InvalidCode"), new kvp("redirect_uri", Client_Redirect_Uri) }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.Equal <string>("invalid_grant", jToken.SelectToken("error").Value <string>()); //grant_type=authorization_code - Full scenario requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "validstate"); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; Assert.Equal <string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["code"]); Assert.Equal <string>("validstate", landingUri.ParseQueryString()["state"]); formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "authorization_code"), new kvp("code", landingUri.ParseQueryString()["code"]), new kvp("redirect_uri", Client_Redirect_Uri) }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value <string>()); Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value <string>()); Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>()); Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>()); Assert.NotNull(jToken.SelectToken("refresh_token").Value <string>()); //grant_type=password -- Resource owner credentials -- Invalid credentials formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "password"), new kvp("username", "user1"), new kvp("password", "invalid"), new kvp("scope", "scope1 scope2 scope3") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.Equal <string>("invalid_grant", jToken.SelectToken("error").Value <string>()); //grant_type=password -- Resource owner credentials formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "password"), new kvp("username", "user1"), new kvp("password", "password1"), new kvp("scope", "scope1 scope2 scope3") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value <string>()); Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value <string>()); Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>()); Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>()); Assert.NotNull(jToken.SelectToken("refresh_token").Value <string>()); //grant_type=refresh_token -- Use the refresh token issued on the previous call formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "refresh_token"), new kvp("refresh_token", jToken.SelectToken("refresh_token").Value <string>()), new kvp("scope", "scope1 scope2") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value <string>()); Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value <string>()); Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>()); Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>()); Assert.NotNull(jToken.SelectToken("refresh_token").Value <string>()); //grant_type=client_credentials - Bug# https://github.com/Katana/katana/issues/562 formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "client_credentials"), new kvp("scope", "scope1 scope2 scope3") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value <string>()); Assert.Equal <string>("bearer", jToken.SelectToken("token_type").Value <string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value <string>()); Assert.Equal <string>("value1", jToken.SelectToken("param1").Value <string>()); Assert.Equal <string>("value2", jToken.SelectToken("param2").Value <string>()); } finally { //Finally close the client endpoint if (clientEndpoint != null) { clientEndpoint.Dispose(); } } } }
///<summary>Bliver kaldt når vi skal lave en netværks update</summary> private async void OnNetworkUpdate() { if (isGameMaster == true) { ServerDataPacket oldPacket = updateIntervalPacket; updateIntervalPacket = GenerateServerPacket(oldPacket); //Konverter data packeten til json format string packetDataJson = JsonUtility.ToJson(updateIntervalPacket); //Encode json stringen til base64 string string packetDataEncoded = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(packetDataJson)); //Send vores data til serveren FormUrlEncodedContent packetValue = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("clientType", "master"), new KeyValuePair <string, string>("packetData", packetDataEncoded) }); await networkClient.PostAsync(gameserverUrl, packetValue); } else { //Send en request til serveren om data FormUrlEncodedContent packetValue = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("clientType", "client") }); HttpResponseMessage response = await networkClient.PostAsync(gameserverUrl, packetValue); string responseData = await response.Content.ReadAsStringAsync(); //Tjek om der er data og vidersend til handleren if (responseData.Trim() != string.Empty) { //base 64 stringen til json string string packetDataDecoded = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String(responseData)); //Konverter json stringen til en data packet ServerDataPacket packetData = JsonUtility.FromJson <ServerDataPacket>(packetDataDecoded); //Vi tjekker her om sessionen har ændret sig eller om der er en fullupdate, hvis ja så fjerner vi alt i scenen og instantiere alt på nyt if (packetData.fullUpdate == true || packetData.gameSession != updateIntervalSession) { updateIntervalSession = packetData.gameSession; ResetNetworkedData(); CleanupUnnetworkedData(); OnNetworkDataReceived(packetData); updateIntervalPacket = packetData; } else if (packetData.ID > updateIntervalPacket.ID) { OnNetworkDataReceived(packetData); updateIntervalPacket = packetData; } } } }
/// <summary> /// 发送一个 Post 请求 /// </summary> /// <typeparam name="TResponse"></typeparam> /// <param name="httpClient"></param> /// <param name="url">请求地址</param> /// <param name="requestContent"></param> /// <returns></returns> public static async Task <string> PostAsync(this HttpClient httpClient, string url, object requestContent) { var response = await httpClient.PostAsync(url, new StringContent(JsonConvert.SerializeObject(requestContent), Encoding.UTF8, "application/json")); return(await GetContentAsync(response)); }
private async Task WorkerAsync() { _timer.Stop(); string fromMail = ""; try { _emails = EmailService.GetAll().Where(x => !x.IsSent).OrderBy(x => x.Id).ToList(); if (_emails.Count == 0) { _timer.Start(); return; } foreach (var email in _emails) { using (var client = new HttpClient()) { client.BaseAddress = new Uri(_apiUrl); using (var stream = new MemoryStream()) using (var bson = new BsonWriter(stream)) { var jsonSerializer = new JsonSerializer(); fromMail = email.From; _emailAttachments = EmailAttachmentService.GetAllNoTracking().Where(x => x.EmailId == email.Id).ToList(); var attachments = _emailAttachments.Select(attachment => new EMailAttachmentViewModel { File = attachment.File, FileName = attachment.FileName, EmailId = attachment.EmailId }).ToList(); if (email.Retry >= _retryLimitation) { continue; } var willBeSentAgainEmail = new EMailViewModel { Id = email.Id, From = email.From, To = email.To, Subject = email.Subject, Body = email.Body, Bcc = email.Bcc, Cc = email.Cc, Exception = email.Exception, Retry = ++email.Retry, SmtpServer = email.SmtpServer, IsRead = false, IsSent = false, LastTryDate = DateTime.Now, EmailAttachments = attachments }; jsonSerializer.Serialize(bson, willBeSentAgainEmail); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/bson")); var byteArrayContent = new ByteArrayContent(stream.ToArray()); byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/bson"); await client?.PostAsync("api/mail/sendemailasync", byteArrayContent, _cancellationToken); } } } _timer.Start(); } catch (Exception ex) { _timer.Start(); #region Write Log string address = BaseAddress + ".MailController(IEmail emailService)"; var dic = LogBusiness.GetDictionary(); dic.Add(LogFieldName.FullyQualifiedFunctionName, address); var dicParams = LogBusiness.GetDictionary(); dicParams.Add(LogFieldName.Token, dicParams); dic = LogBusiness.GetDictionary(); dic.Add(LogFieldName.FullyQualifiedFunctionName, address); dic.Add(LogFieldName.ErrorMessage, ex.Message); dic.Add(LogFieldName.StackTrace, ex.StackTrace); LogBusiness.CustomLog(fromMail, LogEvent.ErrorEvent, dic, dicParams); #endregion } _timer.Start(); }
public async Task <List <string> > InvokeRequestResponseService(IBrowserFile File) { List <string> TagList = new(); var handler = new HttpClientHandler() { ClientCertificateOptions = ClientCertificateOption.Manual, ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) => { return(true); } }; using (var MS = new MemoryStream()) { await File.OpenReadStream(10485760).CopyToAsync(MS); MS.Position = 0; string base64ImageData = Convert.ToBase64String(MS.ToArray()); using (var client = new HttpClient(handler)) { var scoreRequest = new { Inputs = new Dictionary <string, List <Dictionary <string, string> > >() { { "WebServiceInput0", new List <Dictionary <string, string> >() { new Dictionary <string, string>() { { "image", "data:image/png;base64," + base64ImageData }, { "id", "0" }, { "category", "" }, } } }, }, GlobalParameters = new Dictionary <string, string>() { } }; string apiKey = Environment.GetEnvironmentVariable("MLApiKey") ?? MLApiKey; // Replace this with the API key for the web service client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey); client.BaseAddress = new Uri(Environment.GetEnvironmentVariable("MLUrl") ?? MLUrl); // WARNING: The 'await' statement below can result in a deadlock // if you are calling this code from the UI thread of an ASP.Net application. // One way to address this would be to call ConfigureAwait(false) // so that the execution does not attempt to resume on the original context. // For instance, replace code such as: // result = await DoSomeTask() // with the following: // result = await DoSomeTask().ConfigureAwait(false) var requestString = JsonConvert.SerializeObject(scoreRequest); var content = new StringContent(requestString); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); HttpResponseMessage response = await client.PostAsync("", content); if (response.IsSuccessStatusCode) { string result = await response.Content.ReadAsStringAsync(); ImageResponse resultObj = JsonConvert.DeserializeObject <ImageResponse>(result); Console.WriteLine("Normalizing score list"); resultObj.Response.SetScoreValues(); Console.WriteLine("Fetching top 5 result"); var top5Probabilities = (from entry in resultObj.Response.ScoreValues orderby entry.Value descending select entry).Take(5); TagList = top5Probabilities.ToDictionary(k => k.Key, v => v.Value).Keys.ToList(); } else { Console.WriteLine(string.Format("The request failed with status code: {0}", response.StatusCode)); // Print the headers - they include the requert ID and the timestamp, // which are useful for debugging the failure Console.WriteLine(response.Headers.ToString()); string responseContent = await response.Content.ReadAsStringAsync(); Console.WriteLine(responseContent); } } } return(TagList); }
public async Task PostAsync(string accessToken, string endpoint, object data, string args = null) { var payload = GetPayload(data); await _httpClient.PostAsync($"{endpoint}?access_token={accessToken}&{args}", payload); }
public void AddSensor(Sensor sensor) { var url = "/sensors/add"; var jsonString = JsonConvert.SerializeObject(sensor); HttpResponseMessage response = client.PostAsync(url, new StringContent(jsonString, Encoding.UTF8, "application/json")).Result; }
static void Main(string[] args) { const string serverUrl = "http://localhost:61172/"; HttpClientHandler handler = new HttpClientHandler(); handler.UseDefaultCredentials = true; using (var client = new HttpClient(handler)) { client.BaseAddress = new Uri(serverUrl); client.DefaultRequestHeaders.Clear(); client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); try { var response = client.GetAsync("api/demohotels").Result; if (response.IsSuccessStatusCode) { string res = response.Content.ReadAsStringAsync().Result; var hotels = JsonConvert.DeserializeObject <List <DemoHotel> >(res); foreach (var hotel in hotels) { Console.WriteLine(hotel); } } response = client.GetAsync("api/demohotels/5").Result; if (response.IsSuccessStatusCode) { string res = response.Content.ReadAsStringAsync().Result; var hotel = JsonConvert.DeserializeObject <DemoHotel>(res); Console.WriteLine(""); Console.WriteLine("Get single hotel:"); Console.WriteLine(hotel); Console.WriteLine("Rooms:"); foreach (DemoRoom dr in hotel.DemoRooms) { Console.WriteLine(dr); } } response = client.DeleteAsync("api/demohotels/42").Result; if (response.IsSuccessStatusCode) { var res = response.Content.ReadAsStringAsync().Result; var hotel = JsonConvert.DeserializeObject <DemoHotel>(res); Console.WriteLine(""); Console.WriteLine("Delete single hotel:"); Console.WriteLine(hotel); } DemoHotel dh = new DemoHotel() { Hotel_No = 42, Address = "Address 42", Name = "42nd hotel" }; String jsonStr = JsonConvert.SerializeObject(dh); StringContent content = new StringContent(jsonStr, Encoding.ASCII, "application/json"); response = client.PostAsync("api/demohotels", content).Result; if (response.IsSuccessStatusCode) { var res = response.Content.ReadAsStringAsync().Result; var hotel = JsonConvert.DeserializeObject <DemoHotel>(res); Console.WriteLine(""); Console.WriteLine("Create single hotel:"); Console.WriteLine(hotel); } else { Console.WriteLine("Failed to create single hotel"); } dh = new DemoHotel() { Hotel_No = 42, Address = "Address 42 (update)", Name = "42nd hotel (update)" }; jsonStr = JsonConvert.SerializeObject(dh); content = new StringContent(jsonStr, Encoding.ASCII, "application/json"); response = client.PutAsync("api/demohotels/42", content).Result; if (response.IsSuccessStatusCode) { Console.WriteLine("Updated single hotel"); } else { Console.WriteLine("Failed to update single hotel"); } } catch (Exception) { } } Console.ReadLine(); }
public async Task <bool> Notify(string title, string message, Dictionary <string, string> customData = default(Dictionary <string, string>)) { try { if (!receiver.IOSDevices.Any() && !receiver.AndroidDevices.Any()) { return(false); //No devices to send } //To make sure in Android, title and message is retain when click from notification. Else it's lost when app is in background if (customData == null) { customData = new Dictionary <string, string>(); } if (!customData.ContainsKey("Title")) { customData.Add("Title", title); } if (!customData.ContainsKey("Message")) { customData.Add("Message", message); } var push = new Push { Content = new Content { Title = title, Body = message, CustomData = customData }, Target = new Target { Type = Constants.DeviceTarget } }; HttpClient httpClient = new HttpClient(); //Set the content header to json and inject the token httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); httpClient.DefaultRequestHeaders.Add(Constants.ApiKeyName, Constants.FullAccessToken); //Needed to solve SSL/TLS issue when ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12; if (receiver.IOSDevices.Any()) { push.Target.Devices = receiver.IOSDevices; string content = JsonConvert.SerializeObject(push); HttpContent httpContent = new StringContent(content, Encoding.UTF8, "application/json"); string URL = $"{Constants.Url}/{Constants.Organization}/Constants.AppNameiOS}/{Constants.Apis.Notification}"; var result = await httpClient.PostAsync(URL, httpContent); } if (receiver.AndroidDevices.Any()) { push.Target.Devices = receiver.AndroidDevices; string content = JsonConvert.SerializeObject(push); HttpContent httpContent = new StringContent(content, Encoding.UTF8, "application/json"); string URL = $"{Constants.Url}/{Constants.Organization}/{Constants.AppNameAndroid}/{Constants.Apis.Notification}"; var result = await httpClient.PostAsync(URL, httpContent); } return(true); } catch (Exception ex) { Console.WriteLine(ex.ToString()); return(false); } }
public static async void Run([TimerTrigger("0 0 14 * * *")] TimerInfo myTimer, ILogger log) { DateTime start = DateTime.Now.AddDays(-1); string time = start.ToString("MM/dd/yyyy"); log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}"); var azureServiceTokenProvider = new AzureServiceTokenProvider(); string AuthToken = await azureServiceTokenProvider.GetAccessTokenAsync("https://management.azure.com/"); using (var client = new HttpClient()) { // Setting Authorization. client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AuthToken); // Setting Base address. client.BaseAddress = new Uri("https://management.azure.com"); // Setting content type. client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); // Initialization. HttpResponseMessage response = new HttpResponseMessage(); string myJson = @"{ 'dataset': { 'aggregation': { 'totalCost': { 'function': 'Sum', 'name': 'PreTaxCost' } }, 'granularity': 'Daily', 'grouping': [ { 'name': 'ResourceId', 'type': 'Dimension' }, { 'name': 'ResourceType', 'type': 'dimension' }, { 'name': 'SubscriptionName', 'type': 'dimension' }, { 'name': 'ResourceGroup', 'type': 'dimension' } ] }, 'timePeriod': { 'from': '" + time + @"', 'to': '" + time + @"' }, 'timeframe': 'Custom', 'type': 'Usage' }"; Console.WriteLine(myJson); AzureLogAnalytics logAnalytics = new AzureLogAnalytics( workspaceId: $"{workspaceid}", sharedKey: $"{workspacekey}", logType: $"{logName}"); foreach (string scope in scopes) { Console.WriteLine(scope); // HTTP Post response = await client.PostAsync("/" + scope + "/providers/Microsoft.CostManagement/query?api-version=2019-11-01", new StringContent(myJson, Encoding.UTF8, "application/json")); QueryResults result = Newtonsoft.Json.JsonConvert.DeserializeObject <QueryResults>(response.Content.ReadAsStringAsync().Result); jsonResult = "["; for (int i = 0; i < result.properties.rows.Length; i++) { object[] row = result.properties.rows[i]; double cost = Convert.ToDouble(row[0]); if (i == 0) { jsonResult += $"{{\"PreTaxCost\": {cost},\"Date\": \"{row[1]}\",\"ResourceId\": \"{row[2]}\",\"ResourceType\": \"{row[3]}\",\"SubscriptionName\": \"{row[4]}\",\"ResourceGroup\": \"{row[5]}\"}}"; } else { jsonResult += $",{{\"PreTaxCost\": {cost},\"Date\": \"{row[1]}\",\"ResourceId\": \"{row[2]}\",\"ResourceType\": \"{row[3]}\",\"SubscriptionName\": \"{row[4]}\",\"ResourceGroup\": \"{row[5]}\"}}"; } } jsonResult += "]"; logAnalytics.Post(jsonResult); if (result.properties.nextLink != null) { string nextLink = result.properties.nextLink.ToString(); string skipToken = nextLink.Split('&')[1]; callAPIPage(scope, skipToken, workspaceid, workspacekey, logName, log, myJson); } } } }
public async Task <HttpResponseMessage> PostAsync(string uri, StringContent content) { return(await _httpClient.PostAsync(uri, content)); }
private void SendHttp(byte[] buffer) { string data = Convert.ToBase64String(buffer); lock (_httpClient) _httpClient?.PostAsync(GetUrl("update"), new StringContent(data, Encoding.ASCII)).Wait(); }
/// <summary> /// Common method to request in POST, GET, PUT and DELETE form to get data in json format. /// </summary> /// <param name="requestType"></param> /// <param name="url"></param> /// <param name="data"></param> /// <returns name="StatusAndResponseClass"></returns> public static async Task <StatusAndResponseClass> Request(RequestType requestType, string url, string data, Dictionary <string, string> header) { StatusAndResponseClass getResponse = new StatusAndResponseClass(); HttpClient client = new HttpClient(); if (header != null && header.Count() > 0) { foreach (var item in header) { client.DefaultRequestHeaders.Add(item.Key, item.Value); } } HttpResponseMessage response = new HttpResponseMessage(); StringContent queryString; System.Diagnostics.Debug.WriteLine("PostStringJsonData (URL): " + url); System.Diagnostics.Debug.WriteLine("PostStringJsonData (POSTDATA): " + data); try { switch (requestType) { case RequestType.POST: queryString = new StringContent(data, UTF8Encoding.UTF8, "application/json"); response = await client.PostAsync(new Uri(url), queryString); break; case RequestType.GET: response = await client.GetAsync(new Uri(url)); break; case RequestType.PUT: queryString = new StringContent(data, UTF8Encoding.UTF8, "application/json"); response = await client.PutAsync(new Uri(url), queryString); break; case RequestType.DELETE: response = await client.DeleteAsync(new Uri(url + data)); break; default: break; } client.Dispose(); HttpStatusCode statuscode = response.StatusCode; string responseBody = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { getResponse.responseString = responseBody; } else { getResponse.responseString = responseBody; } getResponse.statusCode = Convert.ToInt32(statuscode); if (getResponse.statusCode == 404) { getResponse.responseString = string.Empty; } return(getResponse); } catch (Exception ex) { return(getResponse); } }
public async Task<List<ActionResult>> Execute(DeploymentTaskExecutionParams execParams) { var definition = GetDefinition(execParams.Definition); var results = await Validate(execParams); if (results.Any()) { return results; } var managedCert = ManagedCertificate.GetManagedCertificate(execParams.Subject); if (string.IsNullOrEmpty(managedCert.CertificatePath)) { results.Add(new ActionResult("No certificate to deploy.", false)); return results; } string vaultUri = execParams.Settings.Parameters.FirstOrDefault(c => c.Key == "vault_uri")?.Value; string vaultPath = execParams.Settings.Parameters.FirstOrDefault(c => c.Key == "vault_secret_path")?.Value; var httpClient = new HttpClient(); httpClient.DefaultRequestHeaders.Add("X-Vault-Token", execParams.Credentials["api_token"]); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var vaultUrl = $"{vaultUri}{vaultPath}"; byte[] pfxData = File.ReadAllBytes(managedCert.CertificatePath); var pfxPwd = ""; var secret = new { data = new { key = GetEncodedCertComponent("pemkey", pfxData, pfxPwd), cert = GetEncodedCertComponent("pemcrt", pfxData, pfxPwd), intermediates = GetEncodedCertComponent("pemchain", pfxData, pfxPwd), pfx = GetEncodedCertComponent("pfxfull", pfxData, pfxPwd) } }; /* { "data": { }, "options": { }, "version": 0 }"; */ var content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(secret), System.Text.UnicodeEncoding.UTF8, "application/json"); execParams.Log.Information($"Deploying to Vault: {vaultUrl}"); var response = await httpClient.PostAsync(vaultUrl, content); if (response.IsSuccessStatusCode) { return results; } else { var error = await response.Content.ReadAsStringAsync(); return new List<ActionResult> { new ActionResult("Vault storage failed: " + error, false) }; } }
public async Task <string> GetUserProfile(string userid) { try { using (var client = new HttpClient()) { var formContent = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("user_id", Settings.User_id), new KeyValuePair <string, string>("user_profile_id", userid), new KeyValuePair <string, string>("s", Settings.Session) }); var response = await client.PostAsync(Settings.Website + "/app_api.php?application=phone&type=get_user_data", formContent); response.EnsureSuccessStatusCode(); string json = await response.Content.ReadAsStringAsync(); var data = JsonConvert.DeserializeObject <Dictionary <string, object> >(json); string apiStatus = data["api_status"].ToString(); if (apiStatus == "200") { JObject userdata = JObject.FromObject(data["user_data"]); //Settings.UserFullName = userdata["name"].ToString(); var avatar = userdata["avatar"].ToString(); var cover = userdata["cover"].ToString(); var First_name = userdata["first_name"].ToString(); var Last_name = userdata["last_name"].ToString(); var Website = userdata["website"].ToString(); var user_id = userdata["user_id"].ToString(); var Lastseen = userdata["lastseen_time_text"].ToString(); var url = userdata["url"].ToString(); var is_following = userdata["is_following"].ToString(); var Pro_Type = userdata["pro_type"].ToString(); var Is_Pro = userdata["is_pro"].ToString(); var Is_blocked = userdata["is_blocked"].ToString(); S_About = Functions.DecodeString(userdata["about"].ToString()); S_Website = userdata["website"].ToString(); S_Name = userdata["name"].ToString(); S_Username = userdata["username"].ToString(); S_Gender = userdata["gender"].ToString(); S_Email = userdata["email"].ToString(); S_Birthday = userdata["birthday"].ToString(); S_Address = userdata["address"].ToString(); S_URL = userdata["url"].ToString(); S_School = userdata["school"].ToString(); S_Working = userdata["working"].ToString(); S_Facebook = userdata["facebook"].ToString(); S_Google = userdata["google"].ToString(); S_Twitter = userdata["twitter"].ToString(); S_Linkedin = userdata["linkedin"].ToString(); S_Youtube = userdata["youtube"].ToString(); S_VK = userdata["vk"].ToString(); S_Instagram = userdata["instagram"].ToString(); S_Can_follow = userdata["can_follow"].ToString(); if (Is_Pro == "1") { if (Pro_Type == "1") { StarIcon.IsVisible = true; } else if (Pro_Type == "2") { HotIcon.IsVisible = true; } else if (Pro_Type == "3") { UltimaIcon.IsVisible = true; } else if (Pro_Type == "4") { VIPIcon.IsVisible = true; } } if (Is_blocked == "true") { } CoverImage.Source = ImageSource.FromFile(DependencyService.Get <IPicture>().GetPictureFromDisk(cover, user_id)); if (DependencyService.Get <IPicture>().GetPictureFromDisk(cover, user_id) == "File Dont Exists") { CoverImage.Source = new UriImageSource { Uri = new Uri(cover) }; DependencyService.Get <IPicture>().SavePictureToDisk(cover, user_id); } AvatarImage.Source = ImageSource.FromFile(DependencyService.Get <IPicture>().GetPictureFromDisk(avatar, user_id)); if (DependencyService.Get <IPicture>().GetPictureFromDisk(avatar, user_id) == "File Dont Exists") { AvatarImage.Source = new UriImageSource { Uri = new Uri(avatar) }; DependencyService.Get <IPicture>().SavePictureToDisk(avatar, user_id); } if (Website == "") { Website = AppResources.Label_Unavailable; } if (S_School == "") { S_School = AppResources.Label_Askme; } if (S_Birthday == "" || S_Birthday.Contains("00")) { S_Birthday = AppResources.Label_Askme; } if (S_About == "" || S_About == " ") { S_About = Settings.PR_AboutDefault; } if (S_Address == "") { S_Address = AppResources.Label_Unavailable; } if (S_Gender == "") { S_Gender = AppResources.Label_Unavailable; } if (S_Working == "") { S_Working = AppResources.Label_Unavailable; } if (S_Website == "") { S_Website = AppResources.Label_Unavailable; } LastseenLabel.Text = Lastseen; if (Lastseen == "online" || Lastseen == "Online" || Lastseen.Contains("sec") || Lastseen.Contains("Sec")) { LastseenLabel.Text = AppResources.Label_Online; } Username.Text = S_Name; if (UserprofileListItems.Count > 0) { UserprofileListItems.Clear(); } if (UserProfilePage.S_About != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_About, Icon = "\uf040", Color = "#c5c9c8" }); } else { UserprofileListItems.Add(new Userprofiletems() { Label = AppResources.Label_About_Me, Icon = "\uf040", Color = "#c5c9c8" }); } UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Gender, Icon = "\uf224", Color = "#c5c9c8" }); if (UserProfilePage.S_Birthday != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Birthday, Icon = "\uf133", Color = "#c5c9c8" }); } UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Address, Icon = "\uf041", Color = "#c5c9c8" }); UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Website, Icon = "\uf0ac", Color = "#c5c9c8" }); UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_School, Icon = "\uf19d", Color = "#c5c9c8" }); UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Working, Icon = "\uf0b1", Color = "#c5c9c8" }); if (UserProfilePage.S_Facebook != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Facebook, Icon = "\uf09a", Color = "#00487b" }); } if (UserProfilePage.S_Google != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Google, Icon = "\uf0d5", Color = "#be2020" }); } if (UserProfilePage.S_VK != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_VK, Icon = "\uf189", Color = "#326c95" }); } if (UserProfilePage.S_Twitter != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Twitter, Icon = "\uf099", Color = "#5a89aa" }); } if (UserProfilePage.S_Youtube != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Youtube, Icon = "\uf16a", Color = "#be2020" }); } if (UserProfilePage.S_Linkedin != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Linkedin, Icon = "\uf0e1", Color = "#5a89aa" }); } if (UserProfilePage.S_Instagram != "") { UserprofileListItems.Add(new Userprofiletems() { Label = UserProfilePage.S_Instagram, Icon = "\uf16d", Color = "#5a89aa" }); } UserInfoList.ItemsSource = UserprofileListItems; this.Title = S_Name; //UserInfoList.HeightRequest = Functions.ListInfoResizer(S_About); var contact = SQL_Commander.GetContactUser(user_id); if (contact != null) { if (contact.UserID == user_id && ((contact.Cover != cover) || (contact.Avatar != avatar) || (contact.Birthday != S_Birthday) || (contact.Name != S_Name) || (contact.Username != S_Username) || (contact.First_name != First_name) || (contact.Last_name != Last_name) || (contact.lastseen != Lastseen) || (contact.About != S_About) || (contact.Website != Website) || (contact.School != S_School))) { if ((contact.Avatar != avatar)) { DependencyService.Get <IPicture>().DeletePictureFromDisk(contact.Avatar, user_id); } if ((contact.Cover != cover)) { DependencyService.Get <IPicture>().DeletePictureFromDisk(contact.Cover, user_id); } contact.UserID = user_id; contact.Name = S_Name; contact.Avatar = avatar; contact.Cover = cover; contact.Birthday = S_Birthday; contact.Address = S_Address; contact.Gender = S_Gender; contact.Email = S_Email; contact.Username = S_Username; contact.First_name = First_name; contact.Last_name = Last_name; contact.About = S_About; contact.Website = Website; contact.School = S_School; contact.Youtube = S_Youtube; contact.Facebook = S_Facebook; contact.Twitter = S_Twitter; contact.Linkedin = S_Linkedin; contact.Google = S_Google; contact.instagram = S_Instagram; SQL_Commander.UpdateContactUsers(contact); } } else { ContactsTableDB contactt = new ContactsTableDB(); contactt.UserID = user_id; contactt.Name = S_Name; contactt.Avatar = avatar; contactt.Cover = cover; contactt.Birthday = S_Birthday; contactt.Address = S_Address; contactt.Gender = S_Gender; contactt.Email = S_Email; contactt.Username = S_Username; contactt.First_name = First_name; contactt.Last_name = Last_name; contactt.About = S_About; contactt.Website = Website; contactt.School = S_School; contactt.lastseen = Lastseen; contactt.Youtube = S_Youtube; contactt.Facebook = S_Facebook; contactt.Twitter = S_Twitter; contactt.Linkedin = S_Linkedin; contactt.Google = S_Google; contactt.instagram = S_Instagram; SQL_Commander.InsertContactUsers(contactt); } } else if (apiStatus == "400") { json = AppResources.Label_Error; } return(json); } } catch (Exception) { return(AppResources.Label_Error); } }
public async Task <string?> CreateRule(string name, IEnumerable <RuleCondition> conditions, IEnumerable <InternalBridgeCommand> actions) { CheckInitialized(); if (conditions == null || !conditions.Any()) { throw new ArgumentNullException(nameof(conditions)); } if (actions == null || !actions.Any()) { throw new ArgumentNullException(nameof(actions)); } if (conditions.Count() > 8) { throw new ArgumentException("Max 8 conditions allowed", nameof(conditions)); } if (actions.Count() > 8) { throw new ArgumentException("Max 8 actions allowed", nameof(actions)); } JObject jsonObj = new JObject(); if (conditions != null && conditions.Any()) { jsonObj.Add("conditions", JToken.FromObject(conditions, new JsonSerializer { NullValueHandling = NullValueHandling.Ignore })); } if (actions != null && actions.Any()) { jsonObj.Add("actions", JToken.FromObject(actions, new JsonSerializer { NullValueHandling = NullValueHandling.Ignore })); } if (!string.IsNullOrEmpty(name)) { jsonObj.Add("name", name); } string jsonString = JsonConvert.SerializeObject(jsonObj, new JsonSerializerSettings() { NullValueHandling = NullValueHandling.Ignore }); HttpClient client = await GetHttpClient().ConfigureAwait(false); //Create group with the lights we want to target var response = await client.PostAsync(new Uri(String.Format("{0}rules", ApiBase)), new JsonContent(jsonString)).ConfigureAwait(false); var jsonResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false); HueResults rulesResult = DeserializeDefaultHueResult(jsonResult); if (rulesResult.Count > 0 && rulesResult.First().Success != null && !string.IsNullOrEmpty(rulesResult.First().Success.Id)) { return(rulesResult.First().Success.Id); } if (rulesResult.HasErrors()) { throw new HueException(rulesResult.Errors.First().Error.Description); } return(null); }
public async Task SendEventData(IEnumerable <CoffeeMachineData> coffeeMachineData) { var body = JsonConvert.SerializeObject(coffeeMachineData); var content = new StringContent(body, Encoding.UTF8, "application/json"); var response = await client.PostAsync("https://localhost:44347/event/send", content); }
/// <summary> /// 调用api方法 /// </summary> /// <param name="url"></param> /// <param name="aparmList"></param> /// <returns></returns> public static ClientResult InvokeApi(string url, List <ParmField> aparmList) { // File.AppendAllText("D:\\crm.invoke.api.txt", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff") + url +" ==>start \r\n"); if (!url.StartsWith("http")) { string tempt = System.Configuration.ConfigurationManager.AppSettings["appurl"]; if (tempt.EndsWith("/")) { tempt = tempt.Remove(tempt.Length - 1, 1); } if (!url.StartsWith("/")) { url = "/" + url; } url = tempt + url; } ClientResult result = new ClientResult(); HttpClient client = new HttpClient(); Task <HttpResponseMessage> resultTask; try { List <ParmField> curParmList = new List <ParmField>(); curParmList = aparmList; //curParmList.Add(new StringField("sign", sign)); string boundary = "------------------------------7dXiaoXiao"; byte[] bodybyte = getBody(curParmList, boundary); HttpContent content = new ByteArrayContent(bodybyte, 0, bodybyte.Length); content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("multipart/form-data;boundary=" + boundary); //string httpcode = WebLib.Sys.BytesToStr(bodybyte); resultTask = client.PostAsync(url, content); resultTask.Wait(); result.statuscode = (int)resultTask.Result.StatusCode; if (result.statuscode == 404) { result.code = -100; result.msg = "您正在查找的资源不可用!"; result.resString = "您正在查找的资源不可用!"; return(result); } try { result.responseContentType = resultTask.Result.Content.Headers.ContentType.MediaType.ToLower(); } catch { result.responseContentType = "applicaiton/octet-stream"; } if (result.responseContentType == "application/json" || result.responseContentType == "text/html") { Task <string> strTask = resultTask.Result.Content.ReadAsStringAsync(); strTask.Wait(); result.resString = strTask.Result; result.total = 0; if (result.statuscode == 200) { try { result.repObject = JObject.Parse(result.resString); result.code = result.repObject["code"].Value <int>(); result.msg = result.repObject["msg"] != null ? result.repObject["msg"].Value <string>() : ""; result.total = result.repObject["total"] != null ? result.repObject["total"].Value <long>() : 0L; } catch// (Exception ex) { result.code = -100; result.msg = "返回json解析出错,源json请查看result.resString."; } } else { result.code = -100; result.msg = "请求出错,请查看result.statuscode"; } return(result); } else { //文件流返回, //result.code = -100; //result.msg = "此外为文件下载,如需要此功能,请编写。如非文件下载,请检查 result.responseContentType "; // return result; #region result.code = 1; Task <Stream> streamTask = resultTask.Result.Content.ReadAsStreamAsync(); streamTask.Wait(); result.responseStream = streamTask.Result; result.responseContentType = resultTask.Result.Content.Headers.ContentType.MediaType; if (result.responseStream == null) { result.code = -100; result.statuscode = -1; result.msg = "下载文件时发生错误!"; return(result); } else { if (resultTask.Result.Content.Headers.ContentDisposition.FileName == null) { result.resString = resultTask.Result.Content.Headers.ContentDisposition.FileNameStar; } else { result.resString = resultTask.Result.Content.Headers.ContentDisposition.FileName; } return(result); } #endregion } } catch (Exception ex) { result.code = -100; if (ex.InnerException != null) { if (ex.InnerException is System.Net.Http.HttpRequestException) { result.msg = "连接服务器[" + url + "]时发生错误!"; } else { result.msg = ex.InnerException.Message; } } else { result.msg = ex.Message; } return(result); } finally { // File.AppendAllText("D:\\crm.invoke.api.txt", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff") + url + " ==>end\r\n"); client.Dispose(); } }
public async Task <UserModel> AddAsync(UserModel item) { try { if (App.HasNetwork) { using (HttpClient client = new HttpClient { BaseAddress = new Uri(App.ApiAddress) }) { HttpResponseMessage response; if (string.IsNullOrEmpty(item.Id)) { response = await client.PostAsync ( $"Account", new StringContent ( JsonConvert.SerializeObject ( new RegisterCommand ( item.Email, item.RegistrationNumber, item.Password, item.Name, item.PhoneCountryCode, item.PhoneNumber, true, RoleOptions.Other, false ) ), Encoding.UTF8, "application/json" ) ); } else { var oldUser = await GetAsync(item.Id); if (oldUser != null) { response = await client.PutAsync ( $"Account/{item.Id}", new StringContent ( JsonConvert.SerializeObject ( new RegisterCommand ( item.Email, item.RegistrationNumber, item.Password, item.Name, item.PhoneCountryCode, item.PhoneNumber, !oldUser.Email.Equals(item.Email, StringComparison.OrdinalIgnoreCase), oldUser.Role, oldUser.Status ) ), Encoding.UTF8, "application/json" ) ); } else { throw new HttpRequestException($"User {item.Email} not found !"); } } if (response.IsSuccessStatusCode) { var json = await response.Content.ReadAsStringAsync(); var user = JsonConvert.DeserializeObject <UserDto>(json); return(new UserModel ( user.UserId, user.Email, user.RegistrationNumber, user.PhoneCountryCode, user.PhoneNumber, user.FullName, user.CreatedAt, new ObservableCollection <InteractionModel> ( user.ProductInteractions?.Select ( x => new InteractionModel ( x.UserId, x.ProductId, x.InteractionType, x.Count, x.Content, x.CreatedAt ) ).ToList() ?? new List <InteractionModel>() ), user.Token, user.TokenExpiresIn, user.IsEmailVerified, user.Role, user.Status )); } else { throw new HttpRequestException(await response.Content.ReadAsStringAsync()); } } } else { throw new HttpRequestException("No internet connection !"); } } catch (HttpRequestException ex) { throw ex; } catch (TaskCanceledException) { throw new HttpRequestException("Cannot join the server!"); } catch (Exception ex) { throw ex; } }
public StatsService(DiscordSocketClient client, CommandHandler cmdHandler, IBotCredentials creds, EvilMortyBot evilMorty, IDataCache cache) { _log = LogManager.GetCurrentClassLogger(); _client = client; _creds = creds; _redis = cache.Redis; _started = DateTime.UtcNow; _client.MessageReceived += _ => Task.FromResult(Interlocked.Increment(ref _messageCounter)); cmdHandler.CommandExecuted += (_, e) => Task.FromResult(Interlocked.Increment(ref _commandsRan)); _client.ChannelCreated += (c) => { var _ = Task.Run(() => { if (c is ITextChannel) { Interlocked.Increment(ref _textChannels); } else if (c is IVoiceChannel) { Interlocked.Increment(ref _voiceChannels); } }); return(Task.CompletedTask); }; _client.ChannelDestroyed += (c) => { var _ = Task.Run(() => { if (c is ITextChannel) { Interlocked.Decrement(ref _textChannels); } else if (c is IVoiceChannel) { Interlocked.Decrement(ref _voiceChannels); } }); return(Task.CompletedTask); }; _client.GuildAvailable += (g) => { var _ = Task.Run(() => { var tc = g.Channels.Count(cx => cx is ITextChannel); var vc = g.Channels.Count - tc; Interlocked.Add(ref _textChannels, tc); Interlocked.Add(ref _voiceChannels, vc); }); return(Task.CompletedTask); }; _client.JoinedGuild += (g) => { var _ = Task.Run(() => { var tc = g.Channels.Count(cx => cx is ITextChannel); var vc = g.Channels.Count - tc; Interlocked.Add(ref _textChannels, tc); Interlocked.Add(ref _voiceChannels, vc); }); return(Task.CompletedTask); }; _client.GuildUnavailable += (g) => { var _ = Task.Run(() => { var tc = g.Channels.Count(cx => cx is ITextChannel); var vc = g.Channels.Count - tc; Interlocked.Add(ref _textChannels, -tc); Interlocked.Add(ref _voiceChannels, -vc); }); return(Task.CompletedTask); }; _client.LeftGuild += (g) => { var _ = Task.Run(() => { var tc = g.Channels.Count(cx => cx is ITextChannel); var vc = g.Channels.Count - tc; Interlocked.Add(ref _textChannels, -tc); Interlocked.Add(ref _voiceChannels, -vc); }); return(Task.CompletedTask); }; if (_client.ShardId == 0) { _carbonitexTimer = new Timer(async(state) => { if (string.IsNullOrWhiteSpace(_creds.CarbonKey)) { return; } try { using (var http = new HttpClient()) { using (var content = new FormUrlEncodedContent( new Dictionary <string, string> { { "servercount", evilMorty.GuildCount.ToString() }, { "key", _creds.CarbonKey } })) { content.Headers.Clear(); content.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); await http.PostAsync("https://www.carbonitex.net/discord/data/botdata.php", content).ConfigureAwait(false); } } } catch { // ignored } }, null, TimeSpan.FromHours(1), TimeSpan.FromHours(1)); } _botlistTimer = new Timer(async(state) => { if (string.IsNullOrWhiteSpace(_creds.BotListToken)) { return; } try { using (var http = new HttpClient()) { using (var content = new FormUrlEncodedContent( new Dictionary <string, string> { { "shard_count", _creds.TotalShards.ToString() }, { "shard_id", client.ShardId.ToString() }, { "server_count", client.Guilds.Count().ToString() } })) { content.Headers.Clear(); content.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); http.DefaultRequestHeaders.Add("Authorization", _creds.BotListToken); await http.PostAsync($"https://discordbots.org/api/bots/{client.CurrentUser.Id}/stats", content).ConfigureAwait(false); } } } catch (Exception ex) { _log.Error(ex); // ignored } }, null, TimeSpan.FromMinutes(5), TimeSpan.FromHours(1)); var platform = "other"; if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { platform = "linux"; } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { platform = "osx"; } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { platform = "windows"; } _dataTimer = new Timer(async(state) => { try { using (var http = new HttpClient()) { using (var content = new FormUrlEncodedContent( new Dictionary <string, string> { { "id", string.Concat(MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(_creds.ClientId.ToString())).Select(x => x.ToString("X2"))) }, { "guildCount", evilMorty.GuildCount.ToString() }, { "version", BotVersion }, { "platform", platform } })) { content.Headers.Clear(); content.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); await http.PostAsync("https://selfstats.evilMortybot.me/", content).ConfigureAwait(false); } } } catch { // ignored } }, null, TimeSpan.FromSeconds(1), TimeSpan.FromHours(1)); }
/// <summary> /// Gets the analysis of the specified image file by using /// the Computer Vision REST API. /// </summary> /// <param name="byteData">A byte array of the image file to analyze.</param> async Task <String> MakeComputerVisionRequest(byte[] byteData) { try { HttpClient client = new HttpClient(); // Request headers. client.DefaultRequestHeaders.Add( "Ocp-Apim-Subscription-Key", localSettings.Values["ComputerVisionSubKey"].ToString()); // Request parameters. A third optional parameter is "details". // The Analyze Image method returns information about the following // visual features: // Categories: categorizes image content according to a // taxonomy defined in documentation. // Description: describes the image content with a complete // sentence in supported languages. // Color: determines the accent color, dominant color, // and whether an image is black & white. string requestParameters = "visualFeatures=Categories,Description,Color"; //Get Computer Vision URI from settings string tempUri = localSettings.Values["ComputerVisionEndpointUrl"].ToString(); //remote trailing "/" if present tempUri = tempUri.EndsWith("/") ? tempUri.Substring(0, tempUri.Length - 1) : tempUri; //Add request parameters string uri = tempUri + "?" + requestParameters; HttpResponseMessage response; // Read the contents of the specified local image // into a byte array. //byte[] byteData = GetImageAsByteArray(imageFilePath); // Add the byte array as an octet stream to the request body. using (ByteArrayContent content = new ByteArrayContent(byteData)) { // This example uses the "application/octet-stream" content type. // The other content types you can use are "application/json" // and "multipart/form-data". content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); // Asynchronously call the REST API method. response = await client.PostAsync(uri, content); } // Asynchronously get the JSON response. string contentString = await response.Content.ReadAsStringAsync(); // Display the JSON response. //Debug.WriteLine("\nResponse:\n\n{0}\n", JToken.Parse(contentString).ToString()); //Now extract just the description generated by Computer Vision Service using JSON.Net try { JObject jObject = JObject.Parse(contentString); //Get the first Caption that is proviced using JPath JToken value = jObject.SelectToken("$.description.captions[0]['text']"); Debug.WriteLine(value.ToString()); return(value.ToString()); } catch (Exception e) { Debug.WriteLine(e.Message); return(""); } } catch (Exception e) { Debug.WriteLine("\n" + e.Message); return(""); } }
static void Main(string[] args) { // Populate with the appropriate values for your environment string clientId = "{your client ID here}"; string clientSecret = "{your client secret here}"; string tenantId = "{your tenant ID here}"; string subscriptionId = "{your subscription ID here}"; string resourceId = "/subscriptions/{your subscription ID here}/resourceGroups/{your resource group name here}/providers/Microsoft.Compute/virtualMachines/{your VM name here}"; string accessToken = string.Empty; // Authenticate HttpClient client = new HttpClient(); client.BaseAddress = new Uri($"https://login.microsoftonline.com"); List <KeyValuePair <string, string> > postBody = new List <KeyValuePair <string, string> >(); postBody.Add(new KeyValuePair <string, string>("grant_type", "client_credentials")); postBody.Add(new KeyValuePair <string, string>("client_id", clientId)); postBody.Add(new KeyValuePair <string, string>("client_secret", clientSecret)); postBody.Add(new KeyValuePair <string, string>("resource", "https://management.core.windows.net/")); FormUrlEncodedContent content = new FormUrlEncodedContent(postBody); HttpResponseMessage response = client.PostAsync($"/{tenantId}/oauth2/token", content).Result; if (response.IsSuccessStatusCode) { Stream responseStream = response.Content.ReadAsStreamAsync().Result; using (StreamReader streamReader = new StreamReader(responseStream)) { string responseContent = streamReader.ReadToEnd(); JObject responseObject = JObject.Parse(responseContent); accessToken = responseObject["access_token"].Value <string>(); } if (!string.IsNullOrEmpty(accessToken)) { // Query activity for the last 7 days - adjust the timeframe as needed HttpClient httpClient = new HttpClient(); httpClient.BaseAddress = new Uri("https://management.azure.com/"); DateTime endDateTime = DateTime.UtcNow; DateTime startDateTime = endDateTime.AddDays(-7); string startDateTimeString = startDateTime.ToString("yyyy-MM-ddTHH:mm:ss.sssZ"); string endDateTimeString = endDateTime.ToString("yyyy-MM-ddTHH:mm:ss.sssZ"); string filter = $"eventTimestamp ge '{startDateTimeString}' and eventTimestamp le '{endDateTimeString}' and resourceUri eq '{resourceId}'"; string requestUri = $"/subscriptions/{subscriptionId}/providers/microsoft.insights/eventtypes/management/values?api-version=2015-04-01&$filter={filter}"; httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken); HttpResponseMessage logResponse = httpClient.GetAsync(requestUri).Result; if (logResponse.IsSuccessStatusCode) { Stream logResponseStream = logResponse.Content.ReadAsStreamAsync().Result; using (StreamReader streamReader = new StreamReader(logResponseStream)) { string logContent = streamReader.ReadToEnd(); JObject logEntries = JObject.Parse(logContent); foreach (KeyValuePair <string, JToken> logEntry in logEntries) { foreach (JToken activity in logEntry.Value) { string operationName = activity["operationName"]["localizedValue"].Value <string>(); string status = activity["status"]["localizedValue"].Value <string>(); // Extract the successful start and stop virtual machine events if ((operationName.Contains("Start Virtual Machine") || operationName.Contains("Deallocate Virtual Machine")) && status == "Succeeded") { Console.WriteLine("\tEvent: " + activity["eventName"]["localizedValue"].Value <string>()); Console.WriteLine("\tOperation: " + operationName); Console.WriteLine("\tCaller: " + activity["caller"].Value <string>()); Console.WriteLine("\tCorrelationId: " + activity["correlationId"].Value <string>()); Console.WriteLine("\tSubscriptionId: " + activity["subscriptionId"].Value <string>()); Console.WriteLine("\tEventTimeStamp: " + activity["eventTimestamp"].Value <string>()); Console.WriteLine("\tStatus: " + status); Console.WriteLine(); } } } } } else { Console.WriteLine("Management API call Failed!"); } } } else { Console.WriteLine("Authentication Failed!"); } }
public async Task <string> PerformLoginActions(string username, string password) { try { bool success = false; HttpStatusCode code; string responseBody = ""; string ApiToken; using (Httpclient = new HttpClient()) { Httpclient.DefaultRequestHeaders.Clear(); Httpclient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var values = new List <KeyValuePair <string, string> > { new KeyValuePair <string, string>("grant_type", "password"), new KeyValuePair <string, string>("username", username), new KeyValuePair <string, string> ("Password", password) }; FormUrlEncodedContent postBody = new FormUrlEncodedContent(values); Task taskDownload = Httpclient.PostAsync((myserviceurl()), postBody) .ContinueWith(task => { if (task.Status == TaskStatus.RanToCompletion) { var response = task.Result; if (response.IsSuccessStatusCode) { success = true; code = response.StatusCode; responseBody = response.Content.ReadAsStringAsync().Result; ApiToken = responseBody; TokenGrant token = JsonConvert.DeserializeObject <TokenGrant> (ApiToken.ToString()); ApiToken = token.access_token; DataValues md = TokenDecode.GetInstance() .Decode(token); md.UserName = username; ApplicationsVariables.Username = username; ApplicationsVariables.Token = md.Token; ApplicationsVariables.Datavalues = md; } else { code = response.StatusCode; responseBody = response.Content.ReadAsStringAsync().Result; } } }); taskDownload.Wait(); } if (success) { responseBody = "ok"; } return(responseBody); //if (success) // return "ok"; //else if (responseBody.Contains("invalid_grant")) // return responseBody; //else if (responseBody.Contains("no_confirmed")) // return responseBody; throw new Exception(); } catch (Exception ex) { throw; } }
public async Task<TestingSystemResponse> CheckSolution(SolutionTestingRequest solutionRequest) { try { var solution = _db.Solutions.Find(solutionRequest.SolutionId); if (solution != null && solution.File != null) { var taskTests = _db.TaskTests.Where(t => t.TaskId == solution.TaskId).ToArray(); if (taskTests != null && taskTests.Length > 0) { var isAlive = await CheckIfAlive(_config.CompilerServicesOrchestrator); if (isAlive) { //var dataBytes = await file.GetBytes(); var codeStyleTask = taskTests.FirstOrDefault(t => t.TestType == "codeStyleTest"); var req = new TestRequest { SolutionId = solutionRequest.SolutionId, TestId = codeStyleTask is null ? -1 : codeStyleTask.Id, ReCheck = solutionRequest.ReCheck, }; string url = _config.CompilerServicesOrchestrator.GetFullTestLinkFrom(_config.TestingSystemWorker); using var httpClient = new HttpClient(); using var form = JsonContent.Create(req); HttpResponseMessage response = await httpClient.PostAsync(url, form); string apiResponse = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { TestResponse compResponse = JsonConvert.DeserializeObject<TestResponse>(apiResponse); if (compResponse.OK && compResponse.Result == ResultCode.OK) { var compResult = _db.CompilationResults.Find(solutionRequest.SolutionId); if (compResult != null) { if (compResult.ResultCode != ResultCode.CE && compResult.File != null) { var testTasks = new List<Task<TestResponse>>(); foreach (var test in taskTests) { if (_config.Tests.ContainsKey(test.TestType)) { testTasks.Add(StartTest(test.TestType, solutionRequest.SolutionId, test.Id, solutionRequest.ReCheck)); } else { testTasks.Add(Task.Run(() => NoTestFound(test.TestType, solutionRequest.SolutionId, test.Id))); } } await Task.WhenAll(testTasks); var responses = testTasks.Select(t => t.Result).ToArray(); var results = responses.Join(taskTests, i => i.TestId, o => o.Id, (i, o) => new { Result = i, Definition = o }).ToArray(); double totalScore = 0; ResultCode totalResult = results.Select(r => r.Result.Result).Max(); foreach (var res in results) { if (res.Definition.Block && res.Result.Score == 0) { totalScore = 0; break; } else { totalScore += res.Result.Score * res.Definition.Weight; } } return WriteToDb(solution, totalResult, totalScore, "success", true, responses); } else { return WriteToDb(solution, compResult.ResultCode, 0, "compilation error!", true); } } else { return WriteToDb(solution, compResponse.Result, 0, "can't find compilation! Inner message: " + compResponse.Message, false); } } else { return WriteToDb(solution, compResponse.Result, 0, "something went wrong during compilation! Inner message: " + compResponse.Message, false); } } else { return WriteToDb(solution, ResultCode.IE, 0, "bad response from compilation container: " + response.StatusCode, false); } } else { return WriteToDb(solution, ResultCode.IE, 0, "Compiler Service Is Dead!", false); } } else { return WriteToDb(null, ResultCode.IE, 0, "Can't find task tests!", false); } } else { return WriteToDb(null, ResultCode.IE, 0, "Can't find solution!", false); } } catch { return new TestingSystemResponse(); } }
private async void recognizeButtonCloud_Click(object sender, RoutedEventArgs e) { FileOpenPicker fileOpenPicker = new FileOpenPicker(); fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; fileOpenPicker.FileTypeFilter.Add(".jpg"); fileOpenPicker.FileTypeFilter.Add(".bmp"); fileOpenPicker.FileTypeFilter.Add(".png"); fileOpenPicker.ViewMode = PickerViewMode.Thumbnail; var inputFile = await fileOpenPicker.PickSingleFileAsync(); if (inputFile == null) { // The user cancelled the picking operation return; } TimeSpan duration; imageLabelCloud.Text = ""; imageLabelCloud.FontSize = 28; imageLabelCloud.Foreground = new SolidColorBrush(Windows.UI.Colors.Black); imageLabelCloud.Text = "Recognizing..."; DateTime startTime = DateTime.UtcNow; SoftwareBitmap softwareBitmap; using (IRandomAccessStream stream = await inputFile.OpenAsync(FileAccessMode.Read)) { // Create the decoder from the stream BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); // Get the SoftwareBitmap representation of the file softwareBitmap = await decoder.GetSoftwareBitmapAsync(); softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore); var source = new SoftwareBitmapSource(); await source.SetBitmapAsync(softwareBitmap); previewImage.Source = source; HttpClient client = new HttpClient(); HttpResponseMessage response; string result; client.DefaultRequestHeaders.Add("Prediction-key", APIInfo.predictionKey); Uri RequestUri = new Uri( string.Format("https://southcentralus.api.cognitive.microsoft.com/customvision/v2.0/Prediction/{0}/image?iterationId={1}", APIInfo.projectId, APIInfo.iterationId)); using (HttpStreamContent httpStreamContent = new HttpStreamContent(stream)) { httpStreamContent.Headers.ContentType = new Windows.Web.Http.Headers.HttpMediaTypeHeaderValue("application/octet-stream"); try { response = await client.PostAsync(RequestUri, httpStreamContent); result = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { CustomVisionResponse customVisionResponse = JsonConvert.DeserializeObject <CustomVisionResponse>(result); string topTagName = ""; float topProbability = 0; string labelText = ""; foreach (PredictionResult predictionResult in customVisionResponse.Predictions) { if (predictionResult.Probability > topProbability) { topProbability = predictionResult.Probability; topTagName = predictionResult.TagName; } } labelText += string.Format("{0}\r\n", topTagName); duration = DateTime.UtcNow - startTime; labelText += string.Format("\r\n\r\n\r\n\r\n{0:#}ms", duration.TotalMilliseconds); imageLabelCloud.Text = labelText; } else { imageLabelCloud.Text = response.StatusCode.ToString() + "\r\n" + result; } } catch (Exception ex) { imageLabelCloud.FontSize = 22; imageLabelCloud.Foreground = new SolidColorBrush(Windows.UI.Colors.Red); imageLabelCloud.Text = ex.Message; } } } }
private async void BtnGuardarPr_Clicked(object sender, EventArgs e) { if (CrossConnectivity.Current.IsConnected) { if (!string.IsNullOrWhiteSpace(pickedID_TP.ToString()) || (!string.IsNullOrEmpty(pickedID_TP.ToString()))) { if (!string.IsNullOrWhiteSpace(nombrePEntry.Text) || (!string.IsNullOrEmpty(nombrePEntry.Text))) { if (!string.IsNullOrWhiteSpace(precioventaEntry.Text) || (!string.IsNullOrEmpty(precioventaEntry.Text))) { if (!string.IsNullOrWhiteSpace(stockProductoEntry.Text) || (!string.IsNullOrEmpty(stockProductoEntry.Text))) { if (!string.IsNullOrWhiteSpace(stockValoradoProductoEntry.Text) || (!string.IsNullOrEmpty(stockValoradoProductoEntry.Text))) { if (!string.IsNullOrWhiteSpace(promedioProductoEntry.Text) || (!string.IsNullOrEmpty(promedioProductoEntry.Text))) { if (!string.IsNullOrWhiteSpace(alertaProductoEntry.Text) || (!string.IsNullOrEmpty(alertaProductoEntry.Text))) { try { Models.Producto producto = new Models.Producto() { nombre_producto = nombrePEntry.Text, id_tipo_producto = pickedID_TP, stock = Convert.ToInt32(stockProductoEntry.Text), stock_valorado = Convert.ToDecimal(stockValoradoProductoEntry.Text), promedio = Convert.ToDecimal(promedioProductoEntry.Text), precio_venta = Convert.ToDecimal(precioventaEntry.Text), producto_alerta = Convert.ToDecimal(alertaProductoEntry.Text) }; var json = JsonConvert.SerializeObject(producto); var content = new StringContent(json, Encoding.UTF8, "application/json"); HttpClient client = new HttpClient(); var result = await client.PostAsync("https://dmrbolivia.com/api_distribuidora/productos/agregarProducto.php", content); if (result.StatusCode == HttpStatusCode.OK) { await DisplayAlert("Guardado", "Se agrego correctamente", "OK"); await Shell.Current.Navigation.PopAsync(); } else { await DisplayAlert("Error", "Algo salio mal, intentelo de nuevo", "OK"); await Shell.Current.Navigation.PopAsync(); } } catch (Exception error) { await DisplayAlert("Error", "Algo salio mal, intentelo de nuevo", "OK"); } } else { await DisplayAlert("Campo vacio", "El campo de Alerta esta vacio", "Ok"); } } else { await DisplayAlert("Campo vacio", "El campo de Promedio esta vacio", "Ok"); } } else { await DisplayAlert("Campo vacio", "El campo de Stock Valorado esta vacio", "Ok"); } } else { await DisplayAlert("Campo vacio", "El campo de Stock esta vacio", "Ok"); } } else { await DisplayAlert("Campo vacio", "El campo de Precio de venta esta vacio", "Ok"); } } else { await DisplayAlert("Campo vacio", "El campo de Nombre esta vacio", "Ok"); } } else { await DisplayAlert("Campo vacio", "El campo de Tipo de producto esta vacio", "Ok"); } } else { await DisplayAlert("Error", "Necesitas estar conectado a internet", "OK"); } }
/// <summary> /// Gets the analysis of the specified image file by using /// the Computer Vision REST API. /// </summary> /// <param name="byteData">A byte array of the image file to analyze.</param> async Task <ObjectIdentifier> MakeComputerVisionObjectRequest(byte[] byteData) { try { HttpClient client = new HttpClient(); // Request headers. client.DefaultRequestHeaders.Add( "Ocp-Apim-Subscription-Key", localSettings.Values["ComputerVisionSubKey"].ToString()); // Request parameters. A third optional parameter is "details". // The Analyze Image method returns information about the following // visual features: // Categories: categorizes image content according to a // taxonomy defined in documentation. // Description: describes the image content with a complete // sentence in supported languages. // Color: determines the accent color, dominant color, // and whether an image is black & white. string requestParameters = "visualFeatures=objects"; //Get Computer Vision URI from settings string tempUri = localSettings.Values["ComputerVisionEndpointUrl"].ToString(); //remote trailing "/" if present tempUri = tempUri.EndsWith("/") ? tempUri.Substring(0, tempUri.Length - 1) : tempUri; //Add request parameters string uri = tempUri + "?" + requestParameters; HttpResponseMessage response; // Read the contents of the specified local image // into a byte array. //byte[] byteData = GetImageAsByteArray(imageFilePath); // Add the byte array as an octet stream to the request body. using (ByteArrayContent content = new ByteArrayContent(byteData)) { // This example uses the "application/octet-stream" content type. // The other content types you can use are "application/json" // and "multipart/form-data". content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); // Asynchronously call the REST API method. response = await client.PostAsync(uri, content); } // Asynchronously get the JSON response. string contentString = await response.Content.ReadAsStringAsync(); Debug.WriteLine(contentString); try { JObject jObject = JObject.Parse(contentString); //TODO: Delete these lines after testing of new solution //JToken tagName = jObject.SelectToken("$.predictions[0]['tagName']"); //JToken probability = jObject.SelectToken("$.predictions[0]['probability']"); //Sort the JSON Response by probability descending to get the most accurate prediction IEnumerable <JToken> tokenCollection = jObject.SelectToken("$.objects").OrderByDescending(c => c["confidence"].Value <double>()); if (tokenCollection.Count() > 0) { JToken token = tokenCollection.First(); //JToken boundingBox = jObject.SelectToken("$.predictions[0]['boundingBox']"); JToken tagName = token.SelectToken("$.object"); JToken boundingBox = token.SelectToken("$.rectangle"); JToken probability = token.SelectToken("$.confidence"); ObjectIdentifier objIdent = new ObjectIdentifier(); objIdent.Left = (double)boundingBox.SelectToken("x"); objIdent.Top = (double)boundingBox.SelectToken("y"); objIdent.Width = (double)boundingBox.SelectToken("w"); objIdent.Height = (double)boundingBox.SelectToken("h"); objIdent.Tag = tagName.ToString() + "; " + probability.ToString(); return(objIdent); } return(null); } catch (Exception e) { Debug.WriteLine(e.Message); return(null); } } catch (Exception e) { Debug.WriteLine("\n" + e.Message); return(null); } }
public async Task<DateTime?> DoCheckInOrOutAsync(string userName, string password) { var regexSuccessCheckIn = new Regex(@"success:\s*true"); var checkInOrOutUri = new Uri(baseUri, "SaveTimmingEvent"); var httpClient = new HttpClient(); var checkinDateTime = await RemoteDatetimeAsync(); try { var content = new Windows.Web.Http.HttpFormUrlEncodedContent(BuildHttpFormContentForCheckInOrOut(userName, password)); var response = await httpClient.PostAsync(checkInOrOutUri, content); var responseContent = await response.Content.ReadAsStringAsync(); var responseJson = FixJson(responseContent); var responseType = new { success = false, msg = new { type = 0, msg = "" } }; var responseObject = JsonConvert.DeserializeAnonymousType(responseJson, responseType); if (IsCheckSaved((int)responseObject.msg.type) && responseObject.success) { return checkinDateTime; } else { return null; } } catch { } return null; }
public async Task<long> UploadFileAsync( string fileName, Stream fileContent ) { var client = new HttpClient(); foreach ( var pair in _headers.Current ) { client.DefaultRequestHeaders.Add( pair.Key, pair.Value ); } string downloadUrl = _settings.Configuration.ServerBaseUrl + PluginName; var uri = new Uri( downloadUrl, UriKind.Absolute ); var streamContent = new HttpStreamContent( fileContent.AsInputStream() ); var content = new HttpMultipartFormDataContent { { streamContent, FileContentName }, }; // It's important to set this here and not before; // HttpMultipartFormDataContent overwrites the headers of its contents. streamContent.Headers.ContentDisposition.FileName = fileName; var response = await client.PostAsync( uri, content ); if ( response.StatusCode == HttpStatusCode.ProxyAuthenticationRequired ) { throw new AuthenticationRequiredException(); } response.EnsureSuccessStatusCode(); var responseStream = await response.Content.ReadAsInputStreamAsync(); var serializer = new DataContractJsonSerializer( typeof( CloudPrintUploadResponse ) ); var responseObj = (CloudPrintUploadResponse) serializer.ReadObject( responseStream.AsStreamForRead() ); return responseObj.DocumentId; }
public async Task<bool> SendRemoteCommandForAppAsync(string pressedApp) { bool succeeded = false; string address = String.Empty; if (!string.IsNullOrWhiteSpace(pressedApp) && !string.IsNullOrWhiteSpace(_ipAddress)) { address = "http://" + _ipAddress + "/Applications/Lifecycle/open?appId=" + pressedApp; var uri = new Uri(address, UriKind.Absolute); using (HttpClient client = new HttpClient()) { HttpRequestMessage request = new HttpRequestMessage(); request.RequestUri = new Uri(address); IHttpContent httpContent = new HttpStringContent(String.Empty); try { await client.PostAsync(uri, httpContent); } catch (Exception) { return succeeded = false; } return succeeded = true; } } return succeeded = false; }