PostAsync() public method

public PostAsync ( Uri requestUri, HttpContent content ) : Task
requestUri System.Uri
content HttpContent
return Task
Example #1
0
 public async Task<Result> PostData(Uri uri, MultipartContent header, StringContent content)
 {
     var httpClient = new HttpClient();
     try
     {
         if (!string.IsNullOrEmpty(AuthenticationToken))
         {
             httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AuthenticationToken);
         }
         HttpResponseMessage response;
         if (header == null)
         {
             if(content == null) content = new StringContent(string.Empty);
             response = await httpClient.PostAsync(uri, content);
         }
         else
         {
             response = await httpClient.PostAsync(uri, header);
         }
         var responseContent = await response.Content.ReadAsStringAsync();
         return new Result(response.IsSuccessStatusCode, responseContent);
     }
     catch (Exception ex)
     {
         throw new WebException("Kinder Chat API Error: Service error", ex);
     }
 }
        private async Task RunAsync(string url)
        {
            HttpClientHandler handler = new HttpClientHandler();
            handler.CookieContainer = new CookieContainer();

            using (var httpClient = new HttpClient(handler))
            {
                var loginUrl = url + "Account/Login";

                _traceWriter.WriteLine("Sending http GET to {0}", loginUrl);
                var response = await httpClient.GetAsync(loginUrl);
                var content = await response.Content.ReadAsStringAsync();
                var requestVerificationToken = ParseRequestVerificationToken(content);
                content = requestVerificationToken + "&UserName=user&Password=password&RememberMe=false";

                _traceWriter.WriteLine("Sending http POST to {0}", loginUrl);
                response = await httpClient.PostAsync(loginUrl, new StringContent(content, Encoding.UTF8, "application/x-www-form-urlencoded"));
                content = await response.Content.ReadAsStringAsync();
                requestVerificationToken = ParseRequestVerificationToken(content);

                await RunPersistentConnection(url, httpClient, handler.CookieContainer, requestVerificationToken);
                await RunHub(url, httpClient, handler.CookieContainer, requestVerificationToken);
                
                _traceWriter.WriteLine();
                _traceWriter.WriteLine("Sending http POST to {0}", url + "Account/LogOff");
                response = await httpClient.PostAsync(url + "Account/LogOff", CreateContent(requestVerificationToken));
                
                _traceWriter.WriteLine("Sending http POST to {0}", url + "Account/Logout");
                response = await httpClient.PostAsync(url + "Account/Logout", CreateContent(requestVerificationToken));
            }
        }
        public async Task<bool> CallWebApiAddReunion(Reunion reunion, ObservableCollection<Anime> selectedAnime)
        {
            HttpClient client = new HttpClient();
            string json = JsonConvert.SerializeObject(reunion);
            HttpContent content = new StringContent(json, Encoding.UTF8, "application/json");
            HttpResponseMessage response = await client.PostAsync("http://scoutome.azurewebsites.net/api/reunions", content);
            if (response.IsSuccessStatusCode)
            {
                //    Pour ajouter les présences  
                for (int i = 0; i < selectedAnime.Count(); i++)
                {
                    Presences pre = new Presences();
                    pre.codeReunion = reunion.codeReunion;
                    pre.useless = 1;
                    pre.codeAnime = selectedAnime[i].codeAnime;

                    string jsonPresence = JsonConvert.SerializeObject(pre);
                    HttpContent contentPresence = new StringContent(jsonPresence, Encoding.UTF8, "application/json");
                    HttpResponseMessage responsefav = await client.PostAsync("http://scoutome.azurewebsites.net/api/presences", contentPresence);
                    if (responsefav.IsSuccessStatusCode)
                    {

                    }
                }

            }
            return false;
        }
        private static async Task AlbumsControllerTest(HttpClient client)
        {
            // create album
            await client.PostAsync("Albums/Create",
                new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("title", "album 009") }));
            await client.PostAsync("Albums/Create",
                new FormUrlEncodedContent(new[] { new KeyValuePair<string, string>("title", "album 010") }));

            // get all albums
            Console.WriteLine(await client.GetStringAsync("Albums/All"));

            // update album
            await client.PutAsync("Albums/Update",
                new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("id", "2"),
                    new KeyValuePair<string, string>("year", "2014"),
                    new KeyValuePair<string, string>("producer", "gosho ot pochivka")
                }));

            // delete album 
            await client.DeleteAsync("Albums/Delete/1");

            // add song to album
            await client.PutAsync("Albums/AddSong?albumId=2&songId=2", null);

            // add artist to album
            await client.PutAsync("Albums/AddArtist?albumId=2&artistId=2", null);
        }
Example #5
0
        public static async Task<string> GetAccessToken(string username, string password)
        {
            try
            {
                var handler = new HttpClientHandler
                {
                    AutomaticDecompression = DecompressionMethods.GZip,
                    AllowAutoRedirect = false
                };

                using (var tempHttpClient = new HttpClient(handler))
                {
                    //Get session cookie
                    var sessionResp = await tempHttpClient.GetAsync(Resources.PtcLoginUrl);
                    var data = await sessionResp.Content.ReadAsStringAsync();
                    var lt = JsonHelper.GetValue(data, "lt");
                    var executionId = JsonHelper.GetValue(data, "execution");

                    //Login
                    var loginResp = await tempHttpClient.PostAsync(Resources.PtcLoginUrl,
                        new FormUrlEncodedContent(
                            new[]
                            {
                                new KeyValuePair<string, string>("lt", lt),
                                new KeyValuePair<string, string>("execution", executionId),
                                new KeyValuePair<string, string>("_eventId", "submit"),
                                new KeyValuePair<string, string>("username", username),
                                new KeyValuePair<string, string>("password", password)
                            }));

                    var decoder = new WwwFormUrlDecoder(loginResp.Headers.Location.Query);
                    var ticketId = decoder.GetFirstValueByName("ticket");
                    if (string.IsNullOrEmpty(ticketId))
                        throw new PtcOfflineException();

                    //Get tokenvar 
                    var tokenResp = await tempHttpClient.PostAsync(Resources.PtcLoginOauth,
                        new FormUrlEncodedContent(
                            new[]
                            {
                                new KeyValuePair<string, string>("client_id", "mobile-app_pokemon-go"),
                                new KeyValuePair<string, string>("redirect_uri",
                                    "https://www.nianticlabs.com/pokemongo/error"),
                                new KeyValuePair<string, string>("client_secret",
                                    "w8ScCUXJQc6kXKw8FiOhd8Fixzht18Dq3PEVkUCP5ZPxtgyWsbTvWHFLm2wNY0JR"),
                                new KeyValuePair<string, string>("grant_type", "refresh_token"),
                                new KeyValuePair<string, string>("code", ticketId)
                            }));

                    var tokenData = await tokenResp.Content.ReadAsStringAsync();
                    decoder = new WwwFormUrlDecoder(tokenData);
                    return decoder.GetFirstValueByName("access_token");
                }
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }
Example #6
0
        public static async Task<string> GetAccessToken(string username, string password)
        {
            var handler = new HttpClientHandler
            {
                AutomaticDecompression = DecompressionMethods.GZip,
                AllowAutoRedirect = false
            };

            using (var tempHttpClient = new HttpClient(handler))
            {
                //Get session cookie
                var sessionResp = await tempHttpClient.GetAsync(Resources.PtcLoginUrl);
                var data = await sessionResp.Content.ReadAsStringAsync();
                if (data == null) throw new PtcOfflineException();

                if (sessionResp.StatusCode == HttpStatusCode.InternalServerError || data.Contains("<title>Maintenance"))
                    throw new PtcOfflineException();

                var lt = JsonHelper.GetValue(data, "lt");
                var executionId = JsonHelper.GetValue(data, "execution");

                //Login
                var loginResp = await tempHttpClient.PostAsync(Resources.PtcLoginUrl,
                    new FormUrlEncodedContent(
                        new[]
                        {
                            new KeyValuePair<string, string>("lt", lt),
                            new KeyValuePair<string, string>("execution", executionId),
                            new KeyValuePair<string, string>("_eventId", "submit"),
                            new KeyValuePair<string, string>("username", username),
                            new KeyValuePair<string, string>("password", password)
                        }));

                if (loginResp.Headers.Location == null)
                    throw new PtcOfflineException();

                var ticketId = HttpUtility.ParseQueryString(loginResp.Headers.Location.Query)["ticket"];
                if (ticketId == null)
                    throw new PtcOfflineException();

                //Get tokenvar 
                var tokenResp = await tempHttpClient.PostAsync(Resources.PtcLoginOauth,
                    new FormUrlEncodedContent(
                        new[]
                        {
                            new KeyValuePair<string, string>("client_id", "mobile-app_pokemon-go"),
                            new KeyValuePair<string, string>("redirect_uri",
                                "https://www.nianticlabs.com/pokemongo/error"),
                            new KeyValuePair<string, string>("client_secret",
                                "w8ScCUXJQc6kXKw8FiOhd8Fixzht18Dq3PEVkUCP5ZPxtgyWsbTvWHFLm2wNY0JR"),
                            new KeyValuePair<string, string>("grant_type", "refresh_token"),
                            new KeyValuePair<string, string>("code", ticketId)
                        }));

                var tokenData = await tokenResp.Content.ReadAsStringAsync();
                return HttpUtility.ParseQueryString(tokenData)["access_token"];
            }
        }
Example #7
0
        async public Task WebClientServerTestAsync()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            HotsApi.Configure(configuration);

            using (HttpServer server = new HttpServer(configuration))
            {
                using (HttpClient client = new HttpClient(server))
                {
                    client.BaseAddress = new Uri("http://host/api/");
                    string uri = "hero/";
                    HttpResponseMessage response = await client.GetAsync(uri);

                    Assert.IsTrue(response.IsSuccessStatusCode);
                    string responseContent = await response.Content.ReadAsStringAsync();
                    Debug.WriteLine(responseContent);

                    // Get Hero Types
                    uri = "herotype/";
                    response = await client.GetAsync(uri);
                    Assert.IsTrue(response.IsSuccessStatusCode);
                    responseContent = await response.Content.ReadAsStringAsync();
                    Dictionary<string, string> heroTypes = JsonConvert
                        .DeserializeObject<IdName[]>(responseContent)
                        .ToDictionary(kv => kv.Id, kv => kv.Name);
                    Debug.WriteLine(responseContent);

                    // Get Hero States
                    uri = "herostate/";
                    response = await client.GetAsync(uri);
                    Assert.IsTrue(response.IsSuccessStatusCode);
                    responseContent = await response.Content.ReadAsStringAsync();
                    Dictionary<string, string> heroStates = JsonConvert
                        .DeserializeObject<IdName[]>(responseContent)
                        .ToDictionary(kv => kv.Id, kv => kv.Name);
                    Debug.WriteLine(responseContent);

                    // Create a Hero
                    uri = $"hero?name=heroA&type={heroTypes.Keys.First()}&price=5";
                    StringContent requestContent = new StringContent(string.Empty, Encoding.UTF8, "application/json");
                    response = await client.PostAsync(uri, requestContent);

                    Assert.IsTrue(response.IsSuccessStatusCode);
                    responseContent = await response.Content.ReadAsStringAsync();
                    IdName hero = JsonConvert.DeserializeObject<IdName>(responseContent);
                    Debug.WriteLine(responseContent);

                    // Add A Free-To-Play period
                    uri = $"freetoplayperiod?hero={hero.Id}&begin=2016%2F10%2F10&end=2016%2F10%2F17";
                    requestContent = new StringContent(string.Empty, Encoding.UTF8, "application/json");
                    response = await client.PostAsync(uri, requestContent);

                    Assert.IsTrue(response.IsSuccessStatusCode);
                    responseContent = await response.Content.ReadAsStringAsync();
                    Debug.WriteLine(responseContent);
                }
            }
        }
 public async Task Reset()
 {
     using (var client = new HttpClient())
     {
         var response = await client.PostAsync(_shoppingCartBaseUrl + "?reset=true",null);
         response.EnsureSuccessStatusCode();
         response = await client.PostAsync(_ordersBaseUrl + "?reset=true", null);
         response.EnsureSuccessStatusCode();
     }
 }
Example #9
0
		/// <summary>
		/// 
		/// </summary>
		/// <param name="url"></param>
		/// <exception cref="UnauthorizedAccessException"></exception>
		/// <returns></returns>
		public async Task<ScannerProcess> CreateProcessAsync(string url)
		{
			if (this.Token == null)
				throw new UnauthorizedAccessException("Empty token!");
			else
				this.Token.Validate();

			using (HttpClient client = new HttpClient())
			{
				client.SetCopyleaksClient(HttpContentTypes.Json, this.Token);

				CreateCommandRequest req = new CreateCommandRequest() { URL = url };

				HttpResponseMessage msg;
				if (File.Exists(url))
				{
					FileInfo localFile = new FileInfo(url);
					// Local file. Need to upload it to the server.

					using (var content = new MultipartFormDataContent("Upload----" + DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)))
					{
						using (FileStream stream = File.OpenRead(url))
						{
							content.Add(new StreamContent(stream, (int)stream.Length), "document", Path.GetFileName(url));
							msg = client.PostAsync(Resources.ServiceVersion + "/detector/create-by-file", content).Result;
						}
					}
				}
				else
				{
					// Internet path. Just submit it to the server.
					HttpContent content = new StringContent(
						JsonConvert.SerializeObject(req),
						Encoding.UTF8,
						HttpContentTypes.Json);
					msg = client.PostAsync(Resources.ServiceVersion + "/detector/create-by-url", content).Result;
				}

				if (!msg.IsSuccessStatusCode)
				{
					var errorJson = await msg.Content.ReadAsStringAsync();
					var errorObj = JsonConvert.DeserializeObject<BadResponse>(errorJson);
					if (errorObj == null)
						throw new CommandFailedException(msg.StatusCode);
					else
						throw new CommandFailedException(errorObj.Message, msg.StatusCode);
				}

				string json = await msg.Content.ReadAsStringAsync();

				CreateResourceResponse response = JsonConvert.DeserializeObject<CreateResourceResponse>(json);
				return new ScannerProcess(this.Token, response.ProcessId);
			}
		}
Example #10
0
        static async Task chamarServio()
        {
            using (var RESTClient = new HttpClient())
            {
                //RESTClient.BaseAddress = new Uri("http://localhost:2893/");

                StringBuilder novoProposta = new StringBuilder();
                novoProposta.Append("<Proposta xmlns=\"http://sclovers.com/Proposta\">");
                novoProposta.Append("<NomeCliente>Maria</NomeCliente>");
                novoProposta.Append("<DescricaoProposta>Minha proposta é R$ 15,00</DescricaoProposta>");
                novoProposta.Append("<DataHoraEnviada>2014-10-30</DataHoraEnviada>");
                novoProposta.Append("</Proposta>");
                
                HttpResponseMessage respPOST = await RESTClient.PostAsync(
                    new Uri("http://localhost:2893/Proposta.svc/enviarProposta"),
                    new StringContent(novoProposta.ToString(), Encoding.UTF8, "application/xml"));
                Console.WriteLine(respPOST.StatusCode);

                novoProposta.Clear();
                novoProposta.Append("<Proposta xmlns=\"http://sclovers.com/Proposta\">");
                novoProposta.Append("<NomeCliente>João</NomeCliente>");
                novoProposta.Append("<DescricaoProposta>Minha proposta é R$ 15,00</DescricaoProposta>");
                novoProposta.Append("<DataHoraEnviada>2014-10-30</DataHoraEnviada>");                
                novoProposta.Append("</Proposta>");
                
                respPOST = await RESTClient.PostAsync(
                    new Uri("http://localhost:2893/Proposta.svc/enviarProposta"),
                    new StringContent(novoProposta.ToString(), Encoding.UTF8, "application/xml"));
                Console.WriteLine(respPOST.StatusCode);

                HttpResponseMessage resp = 
                    await RESTClient.GetAsync(new Uri("http://localhost:2893/Proposta.svc/listaPropostaJson"));

                if (resp.IsSuccessStatusCode)
                {
                    Stream stream;
                    stream = await resp.Content.ReadAsStreamAsync();

                    DataContractJsonSerializer dataJson = new DataContractJsonSerializer(typeof(Proposta[]));
                    Proposta[] propostas = (Proposta[])dataJson.ReadObject(stream);

                    foreach (Proposta item in propostas)
                    {
                        Console.WriteLine("Id: {0}", item.Id);
                        Console.WriteLine("Nome: {0}", item.NomeCliente);
                        Console.WriteLine("Proposta: {0}", item.DescricaoProposta);
                        Console.WriteLine("Data: {0}", item.DataHoraEnviada);
                    }
                }
                Console.WriteLine(resp.StatusCode);
            }
        }
Example #11
0
    private static async Task RunClientServerSample(Uri server)
    {
      using(var httpClient = new HttpClient())
      {
        {
          var result = await httpClient.PostAsync($"{server}CreateArticle.command", new StringContent(@"{
  ""CQRSMicroservices.Articles.CreateArticleCommand"" : {
    ""ArticleId"": ""d0174342-71b0-4deb-b5b8-d1064d07ec3c"",
    ""Description"": ""iPhone 6S 64 GB Space Gray"",
    ""Price"": 850.99,
  }
}"));
          var resultContent = await result.Content.ReadAsStringAsync();
          System.Console.WriteLine(resultContent);
        }
        {
          var result = await httpClient.PostAsync($"{server}CreateCustomer.command", new StringContent(@"{
  ""CQRSMicroservices.Customers.CreateCustomerCommand"" : {
    ""CustomerId"": ""14b2e8ec-31e2-4a19-b40a-6f77ae3cf4f0"",
    ""Name"": ""AFAS Software""
  }
}"));
          var resultContent = await result.Content.ReadAsStringAsync();
          System.Console.WriteLine(resultContent);
        }
        {
          var result = await httpClient.PostAsync($"{server}SellArticle.command", new StringContent(@"{
  ""CQRSMicroservices.Articles.SellArticleCommand"" : {
    ""ArticleId"": ""d0174342-71b0-4deb-b5b8-d1064d07ec3c"",
    ""CustomerId"": ""14b2e8ec-31e2-4a19-b40a-6f77ae3cf4f0""
  }
}"));
          var resultContent = await result.Content.ReadAsStringAsync();
          System.Console.WriteLine(resultContent);
        }

        System.Console.WriteLine("Wait a second or two to let the QueryModelBuilder catch up...");
        await Task.Delay(2000);

        {
          var result = await httpClient.GetAsync($"{server}CQRSMicroservices/Articles/GetArticleQuery.query?ArticleId=d0174342-71b0-4deb-b5b8-d1064d07ec3c");
          var document = await result.Content.ReadAsStringAsync();
          System.Console.WriteLine(document);
        }

        System.Console.ReadKey();
      }
    }
Example #12
0
        public override IEnumerable<LocalizedString> Execute(WorkflowContext workflowContext, ActivityContext activityContext) {
            var url = activityContext.GetState<string>("Url");
            var verb = (activityContext.GetState<string>("Verb") ?? "GET").ToUpper();
            var headers = activityContext.GetState<string>("Headers");
            var formValues = activityContext.GetState<string>("FormValues") ?? "";

            using (var httpClient = new HttpClient {BaseAddress = new Uri(url)}) {
                HttpResponseMessage response;

                httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

                if (!String.IsNullOrWhiteSpace(headers)) {
                    foreach (var header in ParseKeyValueString(headers)) {
                        httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
                    }
                }

                switch (verb) {
                    default:
                    case "GET":
                        response = httpClient.GetAsync("").Result;
                        break;
                    case "POST":
                        var format = activityContext.GetState<string>("FormFormat");

                        switch (format) {
                            default:
                            case "KeyValue":
                                var form = ParseKeyValueString(formValues);
                                response = httpClient.PostAsync("", new FormUrlEncodedContent(form)).Result;
                                break;
                            case "Json":
                                var json = formValues.Replace("((", "{").Replace("))", "}");
                                response = httpClient.PostAsync("", new StringContent(json, Encoding.UTF8, "application/json")).Result;
                                break;
                        }
                        
                        break;
                }
                
                workflowContext.SetState("WebRequestResponse", response.Content.ReadAsStringAsync().Result);

                if (response.IsSuccessStatusCode)
                    yield return T("Success");
                else
                    yield return T("Error");
            }
        }
Example #13
0
        public void FakeServer_CapturesAllRequests()
        {
            using (var fakeServer = new FakeServer())
            {
                fakeServer.Start();
                var baseAddress = fakeServer.BaseUri;

                Action<Action, int> repeat = (a, times) =>
                {
                    for (var i = 0; i < times; i++)
                        a();
                };

                var url1 = "/request1";
                var url2 = "/request2";
                var url3 = "/request3";
                var url4 = "/request4";

                var httpClient = new HttpClient();
                httpClient.DeleteAsync(new Uri(baseAddress + url1)).Wait();
                repeat(() => httpClient.GetAsync(new Uri(baseAddress + url2)).Wait(), 2);
                repeat(() => httpClient.PostAsync(new Uri(baseAddress + url3), new StringContent(url3)).Wait(), 3);
                repeat(() => httpClient.PutAsync(new Uri(baseAddress + url4), new StringContent(url4)).Wait(), 4);

                fakeServer.CapturedRequests.Count(x => x.Method == Http.Delete && x.Url == url1).Should().Be(1);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Get && x.Url == url2).Should().Be(2);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Post && x.Url == url3 && x.Body == url3).Should().Be(3);
                fakeServer.CapturedRequests.Count(x => x.Method == Http.Put && x.Url == url4 && x.Body == url4).Should().Be(4);
            }
        }
Example #14
0
        static void Main(string[] args)
        {
            Console.WriteLine("Username:"******"Password:"******"http://localhost:3915/Account/Login";
            var client = new HttpClient();

            var response = client.PostAsync(uri, new User() { Username = username, Password = password }, new JsonMediaTypeFormatter()).Result;
            IEnumerable<string> values;
            response.Headers.TryGetValues("Set-Cookie", out values);
            if (null == values || string.IsNullOrEmpty(values.First()))
            {
                Console.WriteLine("Invalid Username or password;");
            }
            else 
            {
                string newUri = "http://localhost:3915/customer/get/1";
                string cookie = values.First();
                client.DefaultRequestHeaders.Add("Cookie", cookie);
                var getRequestResponse = client.GetAsync(newUri).Result;

                Customer customer = getRequestResponse.Content.ReadAsAsync<Customer>().Result;

                Console.WriteLine("Customer Id: {0}; Name: {1}", customer.Id, customer.Name);
            }

            Console.ReadLine();
        }
        /// <summary>
        /// Does setup of AutoCAD IO. 
        /// This method will need to be invoked once before any other methods of this
        /// utility class can be invoked.
        /// </summary>
        /// <param name="autocadioclientid">AutoCAD IO Client ID - can be obtained from developer.autodesk.com</param>
        /// <param name="autocadioclientsecret">AutoCAD IO Client Secret - can be obtained from developer.autodesk.com</param>
        public static void SetupAutoCADIOContainer(String autocadioclientid, String autocadioclientsecret)
        {
            try
            {
                String clientId = autocadioclientid;
                String clientSecret = autocadioclientsecret;

                Uri uri = new Uri("https://developer.api.autodesk.com/autocad.io/us-east/v2/");
                container = new AIO.Operations.Container(uri);
                container.Format.UseJson();

                using (var client = new HttpClient())
                {
                    var values = new List<KeyValuePair<string, string>>();
                    values.Add(new KeyValuePair<string, string>("client_id", clientId));
                    values.Add(new KeyValuePair<string, string>("client_secret", clientSecret));
                    values.Add(new KeyValuePair<string, string>("grant_type", "client_credentials"));
                    var requestContent = new FormUrlEncodedContent(values);
                    var response = client.PostAsync("https://developer.api.autodesk.com/authentication/v1/authenticate", requestContent).Result;
                    var responseContent = response.Content.ReadAsStringAsync().Result;
                    var resValues = JsonConvert.DeserializeObject<Dictionary<string, string>>(responseContent);
                    _accessToken = resValues["token_type"] + " " + resValues["access_token"];
                    if (!string.IsNullOrEmpty(_accessToken))
                    {
                        container.SendingRequest2 += (sender, e) => e.RequestMessage.SetHeader("Authorization", _accessToken);
                    }
                }
            }
            catch (System.Exception ex)
            {
                Console.WriteLine(String.Format("Error while connecting to https://developer.api.autodesk.com/autocad.io/v2/", ex.Message));
                container = null;
                throw;
            }
        }
Example #16
0
        private async void AppBarButton_Click(object sender, RoutedEventArgs e)
        {
            HttpClient httpClient = new HttpClient();
            httpClient.BaseAddress = new Uri(ip);
            models.Autenticacao a = new models.Autenticacao
            {
                Login = login.Text,
                Senha = senha.Text
            };

            string s = "=" + JsonConvert.SerializeObject(a);

            var content = new StringContent(s, Encoding.UTF8,
            "application/x-www-form-urlencoded");

            var response =  await httpClient.PostAsync("/api/user/login", content);

            var str = response.Content.ReadAsStringAsync().Result;

            str = "OK";

            if (str == "OK")
            {
                this.Frame.Navigate(typeof(MainPage));
            }
        }
Example #17
0
        HttpAbfrage(String Ziel, HttpContent content)
        {
           
            //################################################################################################

            var httpClient = new HttpClient();      // Neue httpClient instanz

            //##################################################################################################
            // mit Cockies aber nicht zu ende Programmiert weil wir keine Cockies nutzen 

            CookieContainer cookie = new CookieContainer();             // Cockie Container Construcktor
            HttpClientHandler handler = new HttpClientHandler()         // nutze beim zugriff cockies
            {
            };
            HttpClient client = new HttpClient(handler as HttpMessageHandler) // neuer http client
            {
                BaseAddress = new Uri(GlobalData.Uri2 + Ziel + GlobalData.SessionID)     // hier wird auch gleich die Session an das ziel angehangen                                        // url aus uri 2 nutzen test2.php
            };
            handler.UseCookies = false;                                        // beim zugriff cockies nicht zulassen
            handler.UseDefaultCredentials = false;

            //#################################################################################################
            // Jetzt mit POST
            // Schritt 4 Abfrage abschicken und ergebnis entgegennehmen 
            HttpResponseMessage response = await httpClient.PostAsync(client.BaseAddress, content); // schicke die abfrage an die Url , dann warte bis antwort komplett und speicher erst mal alles
            GlobalData.HttpResponse = await response.Content.ReadAsStringAsync();
           // MessageDialog msgboxRespons = new MessageDialog(GlobalData.HttpResponse);
           // await msgboxRespons.ShowAsync();        // Zeige mir an was angekommen ist 
            return GlobalData.HttpResponse;
        }
        /// <summary>
        /// Post request
        /// </summary>
        /// <param name="uri">Enqueue endpoint URI</param>
        /// <param name="authenticationHeader">Authentication header</param>
        /// <param name="bodyStream">Body stream</param>        
        /// <param name="message">ActivityMessage context</param>
        /// <returns></returns>
        public async Task<HttpResponseMessage> SendPostRequestAsync(Uri uri, Stream bodyStream, string externalCorrelationHeaderValue = null)
        {
            using (HttpClientHandler handler = new HttpClientHandler() { UseCookies = false })
            {
                using (HttpClient httpClient = new HttpClient(handler))
                {
                    httpClient.DefaultRequestHeaders.Authorization = AuthenticationHelper.GetValidAuthenticationHeader();

                    // Add external correlation id header id specified and valid
                    if (!string.IsNullOrEmpty(externalCorrelationHeaderValue))
                    {
                        httpClient.DefaultRequestHeaders.Add(Program.ExternalCorrelationHeader, externalCorrelationHeaderValue);
                    }

                    if (bodyStream != null)
                    {
                        using (StreamContent content = new StreamContent(bodyStream))
                        {
                            return await httpClient.PostAsync(uri, content);
                        }
                    }
                }
            }

            return new HttpResponseMessage()
            {
                Content = new StringContent("Request failed at client.", Encoding.ASCII),
                StatusCode = System.Net.HttpStatusCode.PreconditionFailed
            };
        }
Example #19
0
 /// <summary>
 /// 提交被扫支付API
 /// http://pay.weixin.qq.com/wiki/doc/api/index.php?chapter=5_5
 /// 1.应用场景:收银员使用扫码设备读取微信用户刷卡授权码以后,二维码或条码信息传送至商户收银台,由商户收银台或者商户后台调用该接口发起支付。
 ///是否需要证书:不需要。
 /// <param name="appid">(必填) String(32) 微信分配的公众账号ID</param>
 /// <param name="mch_id">(必填) String(32) 微信支付分配的商户号</param>
 /// <param name="device_info"> String(32) 微信支付分配的终端设备号,商户自定义</param>
 /// <param name="nonce_str">(必填) String(32) 随机字符串,不长于32位</param>
 /// <param name="body">(必填) String(32) 商品描述 商品或支付单简要描</param>
 /// <param name="detail"> String(8192) 商品详情  商品名称明细列表</param>
 /// <param name="attach"> String(127) 附加数据,在查询API和支付通知中原样返回,该字段主要用于商户携带订单的自定义数据</param>
 /// <param name="out_trade_no">(必填) String(32) 商家订单ID,32个字符内、可包含字母, 其他说明见第4.2节商户订单号:http://pay.weixin.qq.com/wiki/doc/api/index.php?chapter=4_2 </param>
 /// <param name="fee_type">符合ISO 4217标准的三位字母代码,默认人民币:CNY,其他值列表详见第4.2节货币类型: http://pay.weixin.qq.com/wiki/doc/api/index.php?chapter=4_2 </param>
 /// <param name="total_fee">(必填) Int 订单总金额,只能为整数,详见第4.2节支付金额:http://pay.weixin.qq.com/wiki/doc/api/index.php?chapter=4_2 </param>
 /// <param name="spbill_create_ip">(必填) String(32)终端IP APP和网页支付提交用户端IP,Native支付填调用微信支付API的机器IP。</param>
 /// <param name="time_start">String(14) 订单生成时间,格式为yyyyMMddHHmmss,如2009年12月25日9点10分10秒表示为20091225091010。</param>
 /// <param name="time_expire">String(14) 订单失效时间,格式为yyyyMMddHHmmss,如2009年12月27日9点10分10秒表示为20091227091010。</param>
 /// <param name="goods_tag">String(32) 商品标记,代金券或立减优惠功能的参数,说明详见第10节代金券或立减优惠:http://pay.weixin.qq.com/wiki/doc/api/index.php?chapter=10_1 </param>
 /// <param name="auth_code">String(128) 授权码 扫码支付授权码,设备读取用户微信中的条码或者二维码信息 </param>
 /// <param name="partnerKey">API密钥</param>
 /// <returns>返回json字符串,格式参见:http://pay.weixin.qq.com/wiki/doc/api/index.php?chapter=5_5 </returns>
 public static dynamic Submit(string appid, string mch_id, string device_info,
                              string nonce_str, string body, string detail, string attach,
                              string out_trade_no, string fee_type, int total_fee, string spbill_create_ip,
                              string time_start, string time_expire, string goods_tag,
                              string auth_code,
                              string partnerKey)
 {
     var stringADict = new Dictionary<string, string>();
     stringADict.Add("appid", appid);
     stringADict.Add("mch_id", mch_id);
     stringADict.Add("device_info", device_info);
     stringADict.Add("nonce_str", nonce_str);
     stringADict.Add("body", body);
     stringADict.Add("attach", attach);
     stringADict.Add("out_trade_no", out_trade_no);
     stringADict.Add("fee_type", fee_type);
     stringADict.Add("total_fee", total_fee.ToString());
     stringADict.Add("spbill_create_ip", spbill_create_ip);
     stringADict.Add("time_start", time_start);
     stringADict.Add("time_expire", time_expire);
     stringADict.Add("goods_tag", goods_tag);
     stringADict.Add("auth_code", auth_code);
     var sign = WxPayAPI.Sign(stringADict, partnerKey);//生成签名字符串
     var postdata = PayUtil.GeneralPostdata(stringADict, sign);
     var url = "https://api.mch.weixin.qq.com/pay/micropay";
     var client = new HttpClient();
     var result = client.PostAsync(url, new StringContent(postdata)).Result;
     if (!result.IsSuccessStatusCode) return string.Empty;
     return new DynamicXml(result.Content.ReadAsStringAsync().Result);
 }
        public async Task<string> CreateScheduleAsync(object attrs)
        {
            var url = BaseUrl + "/schedules";
            var bodyJson = JsonConvert.SerializeObject(attrs);            

            try
            {
                HttpClient client = new HttpClient();
                HttpResponseMessage resp = await client.PostAsync(url, new StringContent(bodyJson));
                resp.EnsureSuccessStatusCode();

                var result = await resp.Content.ReadAsStringAsync();
                Debug.WriteLine(result);

                if (!result.Contains("success"))
                {
                    return null;
                }

                JArray resultArray = JArray.Parse(result);
                JObject idObject = (JObject)resultArray[0];
                string scheduleId = idObject["success"]["id"].ToString();

                return scheduleId;
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
                return null;
            }
        }
        public double GET(string uid)
        {
            bool t = true;
            double unique;
            do
            {
                var client = new HttpClient();
                client.BaseAddress = new Uri("http://api.text.ru");
                var content = new FormUrlEncodedContent(new[] {
            new KeyValuePair<string, string>("uid", uid),
            new KeyValuePair<string, string>("userkey", Key),
            });

                var result = client.PostAsync("/post", content).Result;
                string resultContent = result.Content.ReadAsStringAsync().Result;
                var res = JsonConvert.DeserializeObject<Plagiarism>(resultContent);
                unique = res.uniq;
                int error = res.err;
                if (error == 181)
                {
                    t = false;
                    Thread.Sleep(10000);
                }
                else
                    t = true;
            } while (!t);
            Repository.Work.Plag = unique;
            return unique;
        }
        public void Authenticate()
        {
            using (var client = new HttpClient())
            {
                client.BaseAddress = new Uri(webServiceRootPath);
                var content = new StringContent(
                    string.Format("grant_type=password&username={0}&password={1}", login.Replace("@", "%40"), password),
                    Encoding.UTF8,
                    "text/plain");
                client.Timeout = TimeSpan.FromSeconds(30);
                var response = client.PostAsync("Token", content).Result;

                if (!response.IsSuccessStatusCode)
                {
                    throw new Exception("Authentication failed " + FormatHttpError(response));
                }
                string serialized = response.Content.ReadAsStringAsync().Result;
                var model = JsonConvert.DeserializeObject<TokenResponseModel>(serialized);
                if (!"bearer".Equals(model.TokenType, StringComparison.InvariantCultureIgnoreCase))
                {
                    throw new Exception("Returned token is not of bearer type, actual: " + model.TokenType);
                }
                token = model.AccessToken;
            }
        }
 public static async Task<bool> TryHitMetricsEndPoint(JObject jObject)
 {
     try
     {
         using (var httpClient = new System.Net.Http.HttpClient())
         {
             var response = await httpClient.PostAsync(new Uri(MetricsServiceUri + MetricsDownloadEventMethod), new StringContent(jObject.ToString(), Encoding.UTF8, ContentTypeJson));
             //print the header 
             Console.WriteLine("HTTP status code : {0}", response.StatusCode);
             if (response.StatusCode == HttpStatusCode.Accepted)
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
     }
     catch (HttpRequestException hre)
     {
         Console.WriteLine("Exception : {0}", hre.Message);
         return false;
     }
 }
Example #24
0
 public async Task<String> PostStringAsync(Uri uri, IDictionary<String, String> content) {
   using (var http = new HttpClient()) {
     var formContent = new FormUrlEncodedContent(content);
     var response = await http.PostAsync(uri, formContent);
     return await response.Content.ReadAsStringAsync();
   }
 }
        public override async Task<string> GetTokenFromGrant(string grant)
        {
            string token = "";

            using (var client = new HttpClient())
            {
                Dictionary<string, string> postvalues = new Dictionary<string, string>
                {
                   { "code", grant },
                   { "client_id", AppID },
                   { "client_secret", AppSecret },
                   { "redirect_uri", RedirectURI },
                   { "grant_type", "authorization_code" }
                };

                var content = new FormUrlEncodedContent(postvalues);

                var response = await client.PostAsync("https://www.googleapis.com/oauth2/v4/token", content);

                var responseString = await response.Content.ReadAsStringAsync();
                Dictionary<string, string> responseJSON = JsonConvert.DeserializeObject<Dictionary<string, string>>(responseString);
                token = responseJSON["access_token"];
            }

            return token;
        }
Example #26
0
        private HashResponseContent InternalRequestHashes(HashRequestContent request)
        {
            using (var client = new System.Net.Http.HttpClient())
            {
                client.BaseAddress = _baseAddress;
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("X-AuthToken", this.apiKey);

                var content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
                content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

                var response = client.PostAsync(_endpoint, content).Result;

                switch (response.StatusCode)
                {
                case HttpStatusCode.OK:     //200
                    AuthTokenExpiration  = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc).AddSeconds(Convert.ToUInt32(((String[])response.Headers.GetValues("X-AuthTokenExpiration"))[0])).ToLocalTime();
                    MaxRequestCount      = Convert.ToUInt16(((string[])response.Headers.GetValues("X-MaxRequestCount"))[0]);
                    RatePeriodEnd        = new DateTime(1970, 1, 1, 0, 0, 0, 0, System.DateTimeKind.Utc).AddSeconds(Convert.ToUInt32(((String[])response.Headers.GetValues("X-RatePeriodEnd"))[0])).ToLocalTime();
                    RateRequestRemaining = Convert.ToUInt16(((string[])response.Headers.GetValues("X-RateRequestsRemaining"))[0]);
                    RateLimitSeconds     = Convert.ToUInt16(((string[])response.Headers.GetValues("X-RateLimitSeconds"))[0]);
                    var remainingSeconds = (DateTime.Now - RatePeriodEnd).TotalSeconds * -1;

                    Logger.Debug($"{RateRequestRemaining}/{MaxRequestCount} requests remaining for the next {remainingSeconds} seconds. Key expires on: {AuthTokenExpiration}");
                    if ((AuthTokenExpiration - DateTime.Now).TotalDays <= 3)
                    {
                        if (ExpirationCounter-- == 0)
                        {
                            ExpirationCounter = 1000;
                            Logger.ColoredConsoleWrite(ConsoleColor.Red, $"Attention! Your key is expiring in {(AuthTokenExpiration - DateTime.Now).Days} days and {(AuthTokenExpiration - DateTime.Now).Hours} hours! Expiration date: {AuthTokenExpiration}", LogLevel.Warning);
                        }
                    }
                    ;
                    return(JsonConvert.DeserializeObject <HashResponseContent>(response.Content.ReadAsStringAsync().Result));

                case HttpStatusCode.BadRequest:     // 400
                    var responseText = response.Content.ReadAsStringAsync().Result;
                    throw new HasherException($"[HashService] 400: Your key is probably expired! {responseText}");

                case HttpStatusCode.Unauthorized:     // 401
                    Shared.KeyCollection.removeKey(this.apiKey);
                    throw new HasherException("[HashService] 401: Your PF-Hashkey you provided is incorrect (or not valid anymore). ");

                case (HttpStatusCode)429:     // To many requests
                    responseText = response.Content.ReadAsStringAsync().Result;
                    throw new HasherException($"[HashService] 429: Your request has been limited (Message : {responseText})");

                case HttpStatusCode.ServiceUnavailable:
                    responseText = response.Content.ReadAsStringAsync().Result;
                    throw new HasherException($"[HashService] 503: It seems PokeFarmer server {_baseAddress}{_endpoint} is unavailable (Message : {responseText}) ");

                default:
                    RandomHelper.RandomSleep(10000, 11000);
                    throw new HasherException($"[HashService] Unknown: Pokefamer Hash API ({_baseAddress}{_endpoint}) might down!");
                }
            }
        }
    private async static Task <List <CitrixApplicationInfo> > GetResourcesFromStoreFront(string SFURL, CitrixAuthCredential Creds, bool UseSSL)
    {
        List <CitrixApplicationInfo> _applicationList = new List <CitrixApplicationInfo>();

        CookieContainer _cookieContainer = new CookieContainer();

        Cookie _aspnetSessionIdCookie = new Cookie("ASP.NET_SessionId", Creds.SessionID, Creds.CookiePath, Creds.CookieHost);
        Cookie _csrfTokenCookie       = new Cookie("CsrfToken", Creds.CSRFToken, Creds.CookiePath, Creds.CookieHost);
        Cookie _authIDCookie          = new Cookie("CtxsAuthId", Creds.AuthToken, Creds.CookiePath, Creds.CookieHost);

        _cookieContainer.Add(_aspnetSessionIdCookie);
        _cookieContainer.Add(_csrfTokenCookie);
        _cookieContainer.Add(_authIDCookie);

        HttpClientHandler _clientHandler = new HttpClientHandler();

        _clientHandler.CookieContainer = _cookieContainer;

        System.Net.Http.HttpClient _client = new System.Net.Http.HttpClient(_clientHandler);
        _client.BaseAddress = new Uri(SFURL);

        string _postResourceUrl = (SFURL.EndsWith("/")) ? "Resources/List" : "/Resources/List";

        string _resourcesURL = SFURL + _postResourceUrl;

        if (UseSSL)
        {
            _client.DefaultRequestHeaders.Add("X-Citrix-IsUsingHTTPS", "Yes");
        }
        else
        {
            _client.DefaultRequestHeaders.Add("X-Citrix-IsUsingHTTPS", "No");
        }

        _client.DefaultRequestHeaders.Add("Csrf-Token", Creds.CSRFToken);
        _client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

        StringContent _bodyContent = new StringContent("");

        HttpResponseMessage _listResourcesResp = await _client.PostAsync(_resourcesURL, _bodyContent);

        if (_listResourcesResp.StatusCode == HttpStatusCode.OK)
        {
            string _resourcesJSON = await _listResourcesResp.Content.ReadAsStringAsync();

            JObject _resourcesBase = JObject.Parse(_resourcesJSON);

            _applicationList = Newtonsoft.Json.JsonConvert.DeserializeObject <List <CitrixApplicationInfo> >(_resourcesBase["resources"].ToString());

            foreach (var _resource in _applicationList)
            {
                _resource.Auth = Creds;
                //_resource.StorefrontURL;
            }
        }

        return(_applicationList);
    }
Example #28
0
        private async void ButtonReg_Click(object sender, RoutedEventArgs e)
        {
            if (userBox.Text == "" || passwordBox.Password.ToString() == "")
            {
                await new MessageDialog("Username & Password are required!").ShowAsync();
                return;
            }
            var user = new User
            {
                Username = userBox.Text,
                Password = passwordBox.Password.ToString()
            };

            using (var client = new System.Net.Http.HttpClient())
            {
                var content = new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json");
                var result  = client.PostAsync($"{App.BaseUri}/register", content).Result;
                if (result.IsSuccessStatusCode == true)
                {
                    var a = result.Content.ReadAsStringAsync().Result;
                    if (a == "\"exist\"")
                    {
                        await new MessageDialog("The usename is exist, try another user name").ShowAsync();
                    }
                    else
                    {
                        await new MessageDialog("Success! :)").ShowAsync();
                        var currentUser = JsonConvert.DeserializeObject <User>(a);
                        App.CurrentUser = currentUser;

                        Dictionary <string, string> userDetails = new Dictionary <string, string>();
                        userDetails.Add("userName", App.CurrentUser.Username);
                        myApp.MyHubConnection = new Microsoft.AspNet.SignalR.Client.HubConnection(SERVER_URL, userDetails);

                        myApp.MyHubProxy = myApp.MyHubConnection.CreateHubProxy("ChatHub");
                        if (myApp.MyHubConnection.State != Microsoft.AspNet.SignalR.Client.ConnectionState.Connected)
                        {
                            try
                            {
                                await myApp.MyHubConnection.Start();
                            }
                            catch
                            {
                                await new MessageDialog($"Can't connect to server {myApp.MyHubConnection.Url}").ShowAsync();
                                return;
                            }
                        }

                        Frame.Navigate(typeof(Lobby));
                    }
                }
                else
                {
                    await new MessageDialog("Can't connect to server").ShowAsync();
                    return;
                }
            }
        }
Example #29
0
        async public Task <CookieContainer> getAccountCookie(string mail, string pass)
        {
            if (mail == null || pass == null)
            {
                return(null);
            }

            var isNew = true;

            string loginUrl;
            Dictionary <string, string> param;

            if (isNew)
            {
                loginUrl = "https://account.nicovideo.jp/login/redirector";
                param    = new Dictionary <string, string> {
                    { "mail_tel", mail }, { "password", pass }, { "auth_id", "15263781" }              //dummy
                };
            }
            else
            {
                loginUrl = "https://secure.nicovideo.jp/secure/login?site=nicolive";
                param    = new Dictionary <string, string> {
                    { "mail", mail }, { "password", pass }
                };
            }

            try {
                var handler = new System.Net.Http.HttpClientHandler();
                handler.UseCookies = true;
                var http    = new System.Net.Http.HttpClient(handler);
                var content = new System.Net.Http.FormUrlEncodedContent(param);

                var _res = await http.PostAsync(loginUrl, content);

                var res = await _res.Content.ReadAsStringAsync();

                //			var a = _res.Headers;

                //			if (res.IndexOf("login_status = 'login'") < 0) return null;

                var cc      = handler.CookieContainer;
                var c       = cc.GetCookies(TargetUrl)["user_session"];
                var secureC = cc.GetCookies(TargetUrl)["user_session_secure"];
                //cc = copyUserSession(cc, c, secureC);
                log += (c == null) ? "ユーザーセッションが見つかりませんでした。" : "ユーザーセッションが見つかりました。";
                log += (secureC == null) ? "secureユーザーセッションが見つかりませんでした。" : "secureユーザーセッションが見つかりました。";
                if (c == null && secureC == null)
                {
                    return(null);
                }

                return(cc);
            } catch (Exception e) {
                util.debugWriteLine(e.Message + e.StackTrace);
                return(null);
            }
        }
        private void BtnSubmit_Clicked(object sender, EventArgs e)
        {
            using (var client = new System.Net.Http.HttpClient())
            {
                var scoreRequest = new
                {
                    Inputs = new Dictionary <string, List <Dictionary <string, string> > >()
                    {
                        {
                            "input1",
                            new List <Dictionary <string, string> >()
                            {
                                new Dictionary <string, string>()
                                {
                                    {
                                        "Class", "1"
                                    },
                                    {
                                        "sepal-length", entSepalLength.Text
                                    },
                                    {
                                        "sepal-width", entSepalWidth.Text
                                    },
                                    {
                                        "petal-length", entPetalLength.Text
                                    },
                                    {
                                        "petal-width", entPetalWidth.Text
                                    },
                                }
                            }
                        },
                    },
                    GlobalParameters = new Dictionary <string, string>()
                    {
                    }
                };
                const string apiKey = "FYT7/RTnqbT/6i9TGNKGQQCiYNowmIK9ACpNuMMEcJzxzmo2aVcGKGQSbExJN5Ub0G416as6nNk9yUCnjb121A=="; // Replace this with the API key for the web service
                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
                client.BaseAddress = new Uri("https://ussouthcentral.services.azureml.net/workspaces/2184572330564902bdafc6ff5145c22f/services/4595c4c853c74f14bbaa69c46c928a26/execute?api-version=2.0&format=swagger");
                var json    = JsonConvert.SerializeObject(scoreRequest);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                HttpResponseMessage response = client.PostAsync("", content).Result;

                if (response.IsSuccessStatusCode)
                {
                    string result     = response.Content.ReadAsStringAsync().Result;
                    var    jsonResult = JsonConvert.DeserializeObject <MyModel>(result);

                    entScoredLabel.Text = jsonResult.Results.output1[0].ScoredLabels;
                    entScoredProb.Text  = jsonResult.Results.output1[0].ScoredProbabilities;
                }
                else
                {
                    DisplayAlert("Keterangan", "Gagal akses web services", "OK");
                }
            }
        }
Example #31
0
        public async Task <ActionResult> UploadDocument(IEnumerable <HttpPostedFileBase> files, string comments, Guid requestID, Guid?taskID, string authToken, DTO.Enums.TaskItemTypes?taskItemType)
        {
            List <Lpp.Dns.DTO.ExtendedDocumentDTO> documents = new List <Lpp.Dns.DTO.ExtendedDocumentDTO>();

            using (var web = new System.Net.Http.HttpClient())
            {
                web.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", authToken);
                web.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("multipart/form-data"));

                HttpResponseMessage response = new HttpResponseMessage();
                foreach (var f in files)
                {
                    var file = f;
                    using (MultipartFormDataContent container = new MultipartFormDataContent())
                    {
                        string filename = System.IO.Path.GetFileName(file.FileName);
                        container.Add(new StreamContent(file.InputStream), "files", filename);
                        container.Add(new StringContent(System.IO.Path.GetFileNameWithoutExtension(filename)), "documentName");
                        container.Add(new StringContent(requestID.ToString()), "requestID");
                        if (taskID.HasValue)
                        {
                            container.Add(new StringContent(taskID.Value.ToString()), "taskID");

                            if (taskItemType.HasValue)
                            {
                                container.Add(new StringContent(taskItemType.Value.ToString("D")), "taskItemType");
                            }
                        }

                        if (!string.IsNullOrWhiteSpace(comments))
                        {
                            container.Add(new StringContent(comments), "comments");
                        }

                        response = await web.PostAsync(WebConfigurationManager.AppSettings["ServiceUrl"] + "/documents/upload", container);

                        string body = await response.Content.ReadAsStringAsync();

                        if (response.IsSuccessStatusCode)
                        {
                            Lpp.Utilities.BaseResponse <DTO.ExtendedDocumentDTO> savedDocument = Newtonsoft.Json.JsonConvert.DeserializeObject <Lpp.Utilities.BaseResponse <DTO.ExtendedDocumentDTO> >(body);

                            if (savedDocument.results != null && savedDocument.results.Length > 0)
                            {
                                documents.AddRange(savedDocument.results);
                            }
                        }
                        else
                        {
                            Response.StatusCode = (int)response.StatusCode;
                            return(Json(new { success = false, content = body }, "text/plain"));
                        }
                    }
                }
            }

            return(Json(new { success = true, content = Newtonsoft.Json.JsonConvert.SerializeObject(documents) }, "text/plain"));
        }
Example #32
0
        public static async Task <T> PostAsync <T>(this System.Net.Http.HttpClient httpClient, string url, object data)
        {
            var responseMessage = await httpClient.PostAsync(url, data);

            responseMessage.EnsureSuccessStatusCode();
            var result = await responseMessage.Content.ReadAsync <T>();

            return(result);
        }
Example #33
0
        public static async Task <HttpResponseMessage> PostButtonData(string json)
        {
            using (var client = new System.Net.Http.HttpClient())
            {
                var content = new StringContent(json, Encoding.UTF8, "application/json");

                return(await client.PostAsync(App.MainUrl, content));
            }
        }
Example #34
0
        public async Task <T> PostAsync <T>(Uri url, object body)
        {
            var response = await _htppClient.PostAsync(url, new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json"));

            response.EnsureSuccessStatusCode();
            var strRes = await response.Content.ReadAsStringAsync();

            return(JsonSerializer.Deserialize <T>(strRes));
        }
Example #35
0
        /// <summary>
        /// Test Method and not to be used.
        /// </summary>
        /// <param name="item"></param>
        public static async void SetKegSettings(this KegConfig item)
        {
            var           client   = new System.Net.Http.HttpClient();
            string        url      = $"{UrlCombine(Constants.COSMOSAzureFunctionsURL, "kegconfig")}?code={Constants.AF_KEGKEY}";
            StringContent content  = new StringContent(JsonConvert.SerializeObject(item));
            var           response = await client.PostAsync(url, content);

            var body = await response.Content.ReadAsStringAsync();
        }
        /// <summary>
        /// Adds a day of trip to the database when button clicked.
        /// </summary>
        public async void AddDay_Click()
        {
            if (SelectedTrip == null)
            {
                var dialog = new MessageDialog("You must choose a trip from the dropdown");
                dialog.Commands.Add(new UICommand("Ok")
                {
                    Id = 0
                });

                dialog.CancelCommandIndex = 0;

                var result = await dialog.ShowAsync();

                return;
            }
            TripId = await GetId();

            if (Day == 0 || City == null || Hotel == null || Dinner == null || Info == null || City == "" || Hotel == "" || Dinner == "" || Info == "")
            {
                var dialog = new MessageDialog("You must fill all fields");
                dialog.Commands.Add(new UICommand("Ok")
                {
                    Id = 0
                });

                dialog.CancelCommandIndex = 0;

                var result = await dialog.ShowAsync();

                return;
            }
            var day = new DayOfTrip
            {
                Day            = Day,
                City           = City,
                Hotel          = Hotel,
                Dinner         = Dinner,
                MoneySpent     = Money,
                AdditionalInfo = Info,
                TripId         = TripId
            };

            using (var client = new System.Net.Http.HttpClient())
            {
                client.BaseAddress = new Uri(@"http://localhost:10051/api/");

                var content = JsonConvert.SerializeObject(day);

                var httpContent = new StringContent(content, Encoding.UTF8, "application/json");

                var json = await client.PostAsync("dayoftrips", httpContent);

                var nav = WindowWrapper.Current().NavigationServices.FirstOrDefault();
                nav.Navigate(typeof(Views.GetTripPage));
            }
        }
Example #37
0
        public async Task <string> SendRaw(string uri, byte[] json)
        {
            System.Net.Http.HttpClient http = new System.Net.Http.HttpClient();

            var content  = new ByteArrayContent(json);
            var response = await http.PostAsync(Host + uri, content);

            return(await response.Content.ReadAsStringAsync());
        }
Example #38
0
        public static Task <HttpResponseMessage> PostAsJsonAsync <T>(
            this System.Net.Http.HttpClient httpClient, string url, T data)
        {
            var dataAsString = JsonConvert.SerializeObject(data);
            var content      = new StringContent(dataAsString);

            content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            return(httpClient.PostAsync(url, content));
        }
Example #39
0
        public async Task <JsonDefaultResponse <T> > Post <T>(string endpoint, object content)
        {
            StringContent       stringContent = new StringContent(JsonTransformer.Serialize(content), Encoding.UTF8, "application/json");
            HttpResponseMessage request       = await client.PostAsync(endpoint, stringContent);

            string response = request.Content.ReadAsStringAsync().Result;

            return(JsonTransformer.Deserialize <JsonDefaultResponse <T> >(response));
        }
Example #40
0
        public async Task <HttpResponseMessage> PostDataAsync(object data, string endPoint)
        {
            var jsonString  = JsonConvert.SerializeObject(data);
            var postContent = new StringContent(jsonString, _defaultEncoding, _postContentType);

            var response = await _client.PostAsync(endPoint, postContent);

            return(response);
        }
Example #41
0
        /// <summary>
        /// read method post request
        /// </summary>
        /// <param name="url"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public static async Task <string> ReadPostRequestAsync(string url, string data = null)
        {
            using (var client = new System.Net.Http.HttpClient())
            {
                var response = await client.PostAsync(url, new StringContent(data, Encoding.UTF8, "application/json"));

                return(await response.Content.ReadAsStringAsync());
            }
        }
Example #42
0
        internal async void GetPatientInfo(string value)
        {
            PatientName = value;
            var temp = new List <string>();

            if (CrossConnectivity.Current.IsConnected == true)
            {
                try
                {
                    HttpClient httpClient = new System.Net.Http.HttpClient();

                    dynamic p = new JObject();
                    p.Patient_Name = value;
                    p.Site_Code    = Library.KEY_USER_SiteCode;

                    string stringPayload = JsonConvert.SerializeObject(p);

                    var httpContent = new StringContent(stringPayload, Encoding.UTF8, "application/json");

                    HttpResponseMessage response = await httpClient.PostAsync(Library.URL + "/Searchpatient", httpContent);

                    // HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, Library.URL + "/Searchpatient/" + value + "/" + Library.KEY_USER_SiteCode);
                    // HttpResponseMessage response = await httpClient.SendAsync(request);

                    var data = await response.Content.ReadAsStringAsync();

                    var namelist = JsonConvert.DeserializeObject <ObservableCollection <dynamic> >(data);

                    foreach (var item in namelist)
                    {
                        string name = item.Patient_Name;
                        temp.Add(name);
                    }
                    PatientDatas = new List <string>(temp);

                    if (!PatientDatas.Any())
                    {
                        PatientDatas = new List <string> {
                            "No Results"
                        }
                    }
                    ;
                }
                catch (Exception)
                {
                }
            }
            else
            {
                var data = _patientRepo.QueryTable().Where(x => x.Patientname.ToLower().Contains(value.ToLower()));
                foreach (var item in data)
                {
                    PatientDatas.Add(item.Patientname);
                }
            }
        }
        private async Task <bool> PostProductsForPackageAsync(List <Products> products, int packageID)
        {
            HttpClient client = new System.Net.Http.HttpClient();

            // Get All ProductsSuppliers into List
            List <ProductsSuppliers> prodsSuppsListFull;
            HttpResponseMessage      response = await client.GetAsync("https://localhost:44327/api/ProductsSuppliersAPI");

            prodsSuppsListFull = JsonConvert.DeserializeObject <List <ProductsSuppliers> >(await response.Content.ReadAsStringAsync());

            // Get all ProductsSuppliers Id's for products in the list
            List <int> inputProductIds = new List <int>();

            foreach (var item in products)
            {
                inputProductIds.Add(item.ProductId);
            }

            // Filter ProductsSuppliers List for only products that are in input products
            var PerProductSupplier = new List <ProductsSuppliers>();
            List <ProductsSuppliers> prodsSuppsListFiltered = new List <ProductsSuppliers>();

            // Assign the first ProductSupplierId to the Product which package uses
            foreach (int productid in inputProductIds)
            {
                prodsSuppsListFiltered.Add(prodsSuppsListFull.Find(ps => ps.ProductId == productid));
            }


            // Got filtered list of productSupplierIds, now post this list 1 by 1 to Packages_Products_Suppliers
            List <HttpStatusCode> codes = new List <HttpStatusCode>();

            foreach (var productSupplier in prodsSuppsListFiltered)
            {
                var newPackageProductSupplier = new PackagesProductsSuppliers {
                    PackageId = packageID, ProductSupplierId = productSupplier.ProductSupplierId
                };
                var content     = JsonConvert.SerializeObject(newPackageProductSupplier);
                var httpContent = new StringContent(content, Encoding.UTF8, "application/json");
                HttpResponseMessage responseFromPost = await client.PostAsync("https://localhost:44327/api/PackagesProductsSuppliersAPI", httpContent);

                codes.Add(responseFromPost.StatusCode);
            }

            // return true if all status codes are OK otherwise return false
            bool IsGoodRequest = true;

            foreach (HttpStatusCode code in codes)
            {
                if (code != HttpStatusCode.Created)
                {
                    IsGoodRequest = false;
                }
            }
            return(IsGoodRequest);
        }
Example #44
0
        public static async Task <JsonValue> POSTreq(ServiceTypes services, T saleEntity)
        {
            Uri    requestUri          = new Uri(SaleItemGlobal.serviceURL + services);
            string json                = Newtonsoft.Json.JsonConvert.SerializeObject(saleEntity);
            var    objClint            = new System.Net.Http.HttpClient();
            HttpResponseMessage respon = objClint.PostAsync(requestUri, new StringContent(json, System.Text.Encoding.UTF8, "application/json")).Result;
            string responJsonText      = await respon.Content.ReadAsStringAsync();

            return(await Task.Run(() => JsonObject.Parse(responJsonText)));
        }
Example #45
0
        private async void button1_Click(object sender, RoutedEventArgs e)
        {
            Uri requestUri = new Uri("http://10.0.0.50:8080/api/stop"); //replace your Url
            var objClint   = new System.Net.Http.HttpClient();

            objClint.DefaultRequestHeaders.Add("key", "89034h8973hg83hg387g3hg0837h0g3hg08w34ashga34");
            System.Net.Http.HttpResponseMessage respon = await objClint.PostAsync(requestUri, new StringContent("Test"));

            string responJsonText = await respon.Content.ReadAsStringAsync();
        }
Example #46
0
        async Task serviceHilfe(IDialogContext context)
        {
            System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
            HttpContent content = new StringContent("Ticket 0038052: Netzwerkdrucker liefert Fehlercode.");
            await client.PostAsync("https://prod-13.northeurope.logic.azure.com:443/workflows/a0323b2e06fe49ce96d66677c53f1402/triggers/manual/paths/invoke?api-version=2016-06-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=nWmc56Qfr7C8jx2_3mrRNm_sk_3K8ww2srrsoFVrNE4", content);

            await context.PostAsync("Das Problem wird an einen unserer freundlichen Support-Mitarbeiter weitergeleitet :)");

            context.Wait(MessageReceived);
        }
    public static string SendHttpRequest(string url, List <KeyValuePair <String, String> > paramList, string contentType = "application/x-www-form-urlencoded")
    {
        System.Net.Http.HttpClient            httpClient = new System.Net.Http.HttpClient();
        System.Net.Http.FormUrlEncodedContent content    = new System.Net.Http.FormUrlEncodedContent(paramList);
        content.Headers.ContentType.MediaType = contentType;
        System.Net.Http.HttpResponseMessage response = httpClient.PostAsync(new Uri(url), content).Result;
        string res = response.Content.ReadAsStringAsync().Result;

        return(res);
    }
Example #48
0
        /// <summary>
        /// Retrieves a string by using a http post to a remote url.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task <HttpResult> LoadFromUrlByPost(HttpDataRequest request)
        {
            var uri      = BuildRequestUrl(request);
            var content  = CreateHttpContentFromRequest(request);
            var response = await client.PostAsync(uri, content);

            var result = await ConvertHttpResponseToHttpResult(response, request.ResultIsList);

            return(result);
        }
Example #49
0
        public async Task <bool> AddItemAsync(Review item)
        {
            var client = new System.Net.Http.HttpClient();

            StringContent jsonData = new StringContent(ReviewToJSON(item, Preferences.Get("username", "")), Encoding.UTF8, "application/json");

            var response = await client.PostAsync("https://iab330.rbvea.co/api/reviews/create", jsonData);

            return(true);
        }
Example #50
0
 private void logoutBtn_Click(object sender, RoutedEventArgs e)
 {
     using (var client = new System.Net.Http.HttpClient())
     {
         var content = new StringContent(JsonConvert.SerializeObject(App.CurrentUser), Encoding.UTF8, "application/json");
         var result  = client.PostAsync($"{App.BaseUri}/offlineUser", content).Result;
     }
     myApp.MyHubConnection.Dispose();
     Frame.Navigate(typeof(MainPage));
 }
Example #51
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="api"></param>
        /// <param name="paramList"></param>
        /// <param name="PostORGet">默认为post请求</param>
        /// <param name="fulluri"></param>
        /// <returns></returns>
        public static async Task <string> getHttpWebRequest(string api, List <KeyValuePair <String, String> > paramList = null, int PostORGet = 0, bool fulluri = false)
        {
            string content = "";

            return(await Task.Run(() =>
            {
                if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
                {
                    try
                    {
                        System.Net.Http.HttpClient httpClient = new System.Net.Http.HttpClient();
                        string uri;
                        if (!fulluri)
                        {
                            uri = "http://hongyan.cqupt.edu.cn/" + api;
                        }
                        else
                        {
                            uri = api;
                        }
                        httpClient.DefaultRequestHeaders.Add("API_APP", "winphone");
                        httpClient.DefaultRequestHeaders.Add("API_TOKEN", "0zLUZA0j+OL77OsjXC0ulOz50KaI6yANZtkOk2vQIDg=");
                        System.Net.Http.HttpRequestMessage requst;
                        System.Net.Http.HttpResponseMessage response;
                        if (PostORGet == 0)
                        {
                            requst = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, new Uri(uri));
                            response = httpClient.PostAsync(new Uri(uri), new System.Net.Http.FormUrlEncodedContent(paramList)).Result;
                        }
                        else
                        {
                            requst = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, new Uri(uri));
                            response = httpClient.GetAsync(new Uri(uri)).Result;
                        }
                        if (response.StatusCode == HttpStatusCode.OK)
                        {
                            content = response.Content.ReadAsStringAsync().Result;
                        }
                        //else if (response.StatusCode == HttpStatusCode.NotFound)
                        //    Utils.Message("Oh...服务器又跪了,给我们点时间修好它");
                    }
                    catch (Exception e)
                    {
                        Debug.WriteLine(e.Message + "网络请求异常");
                    }
                }
                else
                {
                }
                //if (content.IndexOf("{") != 0)
                //    return "";
                //else
                return content;
            }));
        }
        /// <summary>
        ///  for parameterless requests
        /// </summary>
        /// <typeparam name="TRes"></typeparam>
        /// <param name="actionUrl">action url except base api url</param>
        /// <param name="methodType">request method type</param>
        /// <returns></returns>
        public async Task <HttpClientResponse <TRes> > InvokeApi <TRes>(string actionUrl, WebMethodType methodType = WebMethodType.Post)
        {
            Uri url = new Uri(new Uri(_apiBaseUrl), actionUrl);

            using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
            {
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));


                switch (methodType)
                {
                case WebMethodType.Get:
                    using (var response = await client.GetAsync(url))
                    {
                        if (response.StatusCode != HttpStatusCode.OK)
                        {
                            return(new HttpClientResponse <TRes> {
                                HttpStatusCode = response.StatusCode
                            });
                        }

                        var data = await response.Content.ReadAsStringAsync();

                        var json = GetParsedData <TRes>(data);    //JObject.Parse(data);

                        return(new HttpClientResponse <TRes> {
                            HttpStatusCode = response.StatusCode, ResponseData = json
                        });
                    }

                case WebMethodType.Post:
                    using (var response = await client.PostAsync(url, null))
                    {
                        if (response.StatusCode != HttpStatusCode.OK)
                        {
                            return(new HttpClientResponse <TRes> {
                                HttpStatusCode = response.StatusCode
                            });
                        }

                        var data = await response.Content.ReadAsStringAsync();

                        var json = GetParsedData <TRes>(data);    //JObject.Parse(data);

                        return(new HttpClientResponse <TRes> {
                            HttpStatusCode = response.StatusCode, ResponseData = json
                        });
                    }

                default:
                    throw new ArgumentOutOfRangeException(nameof(methodType), methodType, null);
                }
            }
        }
Example #53
0
        /// <summary>
        /// Post请求Json数据
        /// </summary>
        /// <typeparam name="U">请求POCO类型</typeparam>
        /// <typeparam name="V">响应POCO类型</typeparam>
        /// <param name="relatedUrl">相对url,可含参数</param>
        /// <param name="reqObj">请求POCO实例</param>
        /// <param name="paraMode">参数模式</param>
        /// <returns>响应POCO实例</returns>
        public async Task <V> PostJson <U, V>(string relatedUrl, U reqObj, ParaMode paraMode = ParaMode.UrlPara)
        {
            this.Headers.Accept.TryParseAdd("application/json");
            var         paras = ObjToStrParas(reqObj);
            HttpContent content;

            switch (paraMode)
            {
            case ParaMode.UrlPara:
                var paraStr = relatedUrl.Contains('?') ? "&" : "?" +
                              string.Join("&", paras.Select(para => para.Key + "=" + WebUtility.UrlEncode(para.Value)));
                relatedUrl += paraStr;
                content     = new FormUrlEncodedContent(new List <KeyValuePair <string, string> >());
                break;

            case ParaMode.FormPara:
                content = new FormUrlEncodedContent(paras);
                break;

            default:
                content = new StringContent(JsonConvert.SerializeObject(reqObj), Encoding.UTF8, "application/json");
                break;
            }
            try
            {
                var response = await client.PostAsync(relatedUrl, content).ConfigureAwait(false);

                var data = response.Content.ReadAsStringAsync().Result;
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    Console.WriteLine(response.StatusCode);
                    Console.WriteLine(data);
                    return(default(V));
                }
                return(JsonConvert.DeserializeObject <V>(response.Content.ReadAsStringAsync().Result));
            }
            catch
            {
                openFlag[0] = false;
                throw;
            }
        }
Example #54
0
 /// <summary>
 /// todo:字典不允许重复的键,要改
 /// </summary>
 /// <param name="url"></param>
 /// <param name="formData"></param>
 /// <param name="userAgent"></param>
 /// <returns></returns>
 public static async Task <string> PostFormResponTextAsync(this string url, Dictionary <string, string> formData, string userAgent = null)
 {
     using (var client = new System.Net.Http.HttpClient())
     {
         if (!string.IsNullOrWhiteSpace(userAgent))
         {
             client.DefaultRequestHeaders.Add("User-Agent", userAgent);
         }
         return(await(await client.PostAsync(url, new FormUrlEncodedContent(formData))).Content.ReadAsStringAsync());
     }
 }
Example #55
0
 /// <summary>
 /// 异步获取post实体
 /// </summary>
 /// <param name="url">url</param>
 /// <param name="content">post内容,这里直接用基类</param>
 /// <param name="userAgent">UA</param>
 /// <returns></returns>
 public static async Task <string> PostResponTextAsync(this string url, HttpContent content, string userAgent = null)
 {
     using (var client = new System.Net.Http.HttpClient())
     {
         if (!string.IsNullOrWhiteSpace(userAgent))
         {
             client.DefaultRequestHeaders.Add("User-Agent", userAgent);
         }
         return(await(await client.PostAsync(url, content)).Content.ReadAsStringAsync());
     }
 }
Example #56
-1
        private static async Task SongsControllerTest(HttpClient client)
        {
            // create songs
            await client.PostAsync("Songs/Create",
                new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("title", "qka pesen 007"),
                    new KeyValuePair<string, string>("artistid", "2") 
                }));
            await client.PostAsync("Songs/Create",
                new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("title", "qka pesen 008"),
                    new KeyValuePair<string, string>("artistid", "2") 
                }));

            // get all songs
            Console.WriteLine(await client.GetStringAsync("Songs/All"));

            // update song
            await client.PutAsync("Songs/Update",
                new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("id", "2"),
                    new KeyValuePair<string, string>("year", "2010"),
                    new KeyValuePair<string, string>("genre", "narodna pesen")
                }));

            // delete song 
            await client.DeleteAsync("api/Songs/Delete/1");
        }
Example #57
-1
        private static async Task RunTestsAsync(HttpClient client, CancellationToken cancellationToken)
        {
            try
            {
                // SMS                
                await client.PostAsync("/sms/api/sms/unicorn", new StringContent($"\"hello world! ({DateTimeOffset.UtcNow.ToString("u")})\"", Encoding.UTF8, "application/json"), cancellationToken);

                await client.GetAsync("/sms/api/sms/unicorn", cancellationToken);

                // Counter
                await client.PostAsync("/counter/api/counter", new StringContent(string.Empty), cancellationToken);

                await client.GetAsync("/counter/api/counter", cancellationToken);

                await client.GetAsync("/Hosting/CounterService/api/counter", cancellationToken);

                var request = new HttpRequestMessage(HttpMethod.Get, "/api/counter");
                request.Headers.Add("SF-ServiceUri", "fabric:/Hosting/CounterService");
                await client.SendAsync(request, cancellationToken);

                // WebApp
                await client.GetAsync("/webapp", cancellationToken);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
        public void Register(string username)
        {
            try
            {
                client = new HttpClient();
                var postData = new List<KeyValuePair<string, string>>();
                postData.Add(new KeyValuePair<string, string>("email", username));

                HttpContent content = new FormUrlEncodedContent(postData);
                content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

                client.PostAsync("http://localhost:3000/User", content)
                    .ContinueWith(postTask =>
                    {
                        postTask.Result.EnsureSuccessStatusCode();
                        client.Dispose();
                    });

            }
            catch (Exception ex)
            {
                
 
            }


        }
        public async Task MashapeFacebookLogin()
        {
            //NOTE: Check App.xaml.cs for the variables that you need to fill in

            var targeturi = "https://ismaelc-facebooktest.p.mashape.com/oauth_url";

            var client = new System.Net.Http.HttpClient();

            HttpContent content = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("consumerKey", App.ConsumerKey),
                new KeyValuePair<string, string>("consumerSecret", App.ConsumerSecret),
                new KeyValuePair<string, string>("callbackUrl", App.CallbackUrl)
            });

            content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
            content.Headers.Add("X-Mashape-Authorization", App.MashapeHeader);

            progressRing.IsActive = true;
            btnLogin.IsEnabled = false;
            var response = await client.PostAsync(targeturi, content);
            progressRing.IsActive = false;
            btnLogin.IsEnabled = true;

            if (response.IsSuccessStatusCode)
            {
                string respContent = await response.Content.ReadAsStringAsync();
                string loginUrl = await Task.Run(() => JsonObject.Parse(respContent).GetNamedString("url"));

                WebAuthenticationResult WebAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(
                                                        WebAuthenticationOptions.None,
                                                        new Uri(loginUrl),
                                                        new Uri(App.CallbackUrl));

                
                if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
                {
                    btnLogin.Visibility = Windows.UI.Xaml.Visibility.Collapsed;

                    var callBackUrl = WebAuthenticationResult.ResponseData.ToString();
                    //Where's ParseQueryString when you need it...
                    App.AccessToken = GetParameter(callBackUrl, "accessToken");
                    //App.AccessSecret = GetParameter(callBackUrl, "accessSecret");

                }
                else if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp)
                {
                    throw new InvalidOperationException("HTTP Error returned by AuthenticateAsync() : " + WebAuthenticationResult.ResponseErrorDetail.ToString());
                }
                else
                {
                    // The user canceled the authentication
                }
            }
            else
            {
                //The POST failed, so update the UI accordingly
                //txtBlockResult.Text = "Error";
            }
        }
Example #60
-7
        public void sendPost()
        {
            // Définition des variables qui seront envoyés
            HttpContent stringContent1 = new StringContent(param1String); // Le contenu du paramètre P1
            HttpContent stringContent2 = new StringContent(param2String); // Le contenu du paramètre P2
            HttpContent fileStreamContent = new StreamContent(paramFileStream);
            //HttpContent bytesContent = new ByteArrayContent(paramFileBytes);

            using (var client = new HttpClient())
            using (var formData = new MultipartFormDataContent())
            {
                formData.Add(stringContent1, "P1"); // Le paramètre P1 aura la valeur contenue dans param1String
                formData.Add(stringContent2, "P2"); // Le parmaètre P2 aura la valeur contenue dans param2String
                formData.Add(fileStreamContent, "FICHIER", "RETURN.xml");
                //  formData.Add(bytesContent, "file2", "file2");
                try
                {
                    var response = client.PostAsync(actionUrl, formData).Result;
                    MessageBox.Show(response.ToString());
                    if (!response.IsSuccessStatusCode)
                    {
                        MessageBox.Show("Erreur de réponse");
                    }
                }
                catch (Exception Error)
                {
                    MessageBox.Show(Error.Message);
                }
                finally
                {
                    client.CancelPendingRequests();
                }
            }
        }