public void Init()
        {
            _auth = new AuthenticationClient();
            _auth.UsernamePasswordAsync(ConsumerKey, ConsumerSecret, Username, Password, TokenRequestEndpointUrl).Wait();

            _jsonHttpClient = new JsonHttpClient(_auth.InstanceUrl, _auth.ApiVersion, _auth.AccessToken, new HttpClient());
        }
 public void BeforeTests()
 {
     httpClient = server.CreateClient();
     client     = new JsonHttpClient("https://server.example.com")
     {
         HttpClient = httpClient
     };
 }
Example #3
0
        public async Task Can_POST_to_IdWithAlias_with_JsonHttpClient_async()
        {
            var client = new JsonHttpClient(Config.AbsoluteBaseUri);

            var response = await client.PostAsync(new IdWithAlias { Id = 1 });

            Assert.That(response.Id, Is.EqualTo(1));
        }
Example #4
0
        public void StartNewSession_throws_on_invalid_json()
        {
            var jsonHttp = new JsonHttpClient(
                JsonHttpClientTest.SetupGet("} invalid json {").Object,
                "");

            Assert.That(() => Client.StartNewSession(TestData.ClientInfo, jsonHttp),
                        ExceptionsTest.ThrowsInvalidResponseWithMessage("Invalid JSON"));
        }
Example #5
0
        static void Main(string[] args)
        {
            Console.WriteLine("JsonHttpClient SampleClient");
            Console.WriteLine("");

            //Example 1
            {
                Console.WriteLine("Example 1");

                Model1 model1 = JsonHttpClient.Deserialize <Model1>("http://localhost:5000/api/values");

                Console.WriteLine(model1.Property1);
            }

            Console.WriteLine("");

            //Example 2
            {
                Console.WriteLine("Example 2");

                JsonHttpClient <Model1> jsonHttpClient = new JsonHttpClient <Model1>("http://localhost:5000/api/values");
                jsonHttpClient.DeserializeInside();

                Console.WriteLine(jsonHttpClient.Object.Property1);
            }

            Console.WriteLine("");

            //Example 3
            {
                Console.WriteLine("Example 3");

                Console.WriteLine(new JsonHttpClient <Model1>("http://localhost:5000/api/values").Deserialize().Property1);
            }

            Console.WriteLine("");

            //Example 4
            {
                Console.WriteLine("Example 4");

                JsonHttpClient <Model1> jsonHttpClient = new JsonHttpClient <Model1>()
                {
                    Url        = "http://localhost:5000/api/values",
                    HttpClient = new HttpClient(new SocketsHttpHandler()
                    {
                    })
                };
                jsonHttpClient.DeserializeInside();

                Console.WriteLine(jsonHttpClient.Object.Property1);
            }

            Console.WriteLine("");
            Console.Write("press any key to continue...");
            Console.ReadKey();
        }
Example #6
0
        public void StartNewSession_throws_on_network_error()
        {
            var jsonHttp = new JsonHttpClient(JsonHttpClientTest.SetupGetWithFailure().Object, "");

            Assert.That(() => Client.StartNewSession(TestData.ClientInfo, jsonHttp),
                        ExceptionsTest.ThrowsReasonWithMessage(
                            ClientException.FailureReason.NetworkError,
                            "request"));
        }
        public async Task Does_compress_raw_Bytes_responses_HttpClient()
        {
            var client   = new JsonHttpClient(Config.ListeningOn);
            var response = await client.PostAsync(new CompressBytes
            {
                Bytes = "foo".ToUtf8Bytes(),
            });

            Assert.That(response, Is.EquivalentTo("foo".ToUtf8Bytes()));
        }
        public async Task Does_compress_raw_String_responses_HttpClient()
        {
            var client   = new JsonHttpClient(Config.ListeningOn);
            var response = await client.PostAsync(new CompressString
            {
                String = "foo",
            });

            Assert.That(response, Is.EqualTo("foo"));
        }
        public void Can_send_GZip_client_request_HttpClient()
        {
            var client = new JsonHttpClient(Constants.ServiceStackBaseHost)
            {
                RequestCompressionType = CompressionTypes.GZip,
            };
            var response = client.Post(new HelloZip {
                Name = "GZIP"
            });

            Assert.That(response.Result, Is.EqualTo("Hello, GZIP"));
        }
Example #10
0
    public static void Main()
    {
        var a = new[] { 1, 2, 3, 4 };
        Func <int, int, int> f = (x, y) => x * y;
        var h = f(2, 3);

        if (h != 6)
        {
            Global.Alert("Error.");
        }
        var b = a.Select(z => z * z).ToArray();
        var d = Convert.ToBase64String(Enumerable.Range(0, 255).Select(i => (Byte)(i)).ToArray());

        Q("#button_alert").Click(e =>
        {
            Global.Alert("Test Alert Message");
        });

        Q("#button_template").Click(e =>
        {
            var users    = new[] { new { id = "zhang3", name = "ZHANG San" }, new { id = "li4", name = "LI Si" } };
            var template = T("#tmpl_template");
            var text     = template.render(new { users = users });
            Q("#tbody_template").Append(text);
        });

        Q("#button_ajax").Click(e =>
        {
            jQuery.GetJSON("users.json", null, (data, textStatus, jqXHR) =>
            {
                var users    = data;
                var template = T("#tmpl_template");
                var text     = template.render(new { users = users });
                Q("#tbody_ajax").Append(text);
            });
        });

        var jsca = new JsonSerializationClientAdapter();
        var jhc  = new JsonHttpClient(jsca, "/api/", "q", true, false);
        var jc   = jsca.GetApplicationClient();

        Q("#button_servertime").Click(async e =>
        {
            var r = await jc.ServerTime(new ServerTimeRequest {
            });
            if (r.OnSuccess)
            {
                var Time     = r.Success;
                var template = T("#tmpl_paragraph");
                Q("#div_servertime").Append(template.render(new { content = Time }));
            }
        });
    }
        public void Init()
        {
            string jsonConfig = File.ReadAllText("appsettings.json");
            var    config     = JsonConvert.DeserializeObject <BulkForceClientConfig>(jsonConfig);

            _config = config;

            _auth = new AuthenticationClient();
            _auth.UsernamePasswordAsync(config.ConsumerKey, config.ConsumerSecret, config.UserName, config.Password, config.TokenRequestEndpointUrl).Wait();

            _jsonHttpClient = new JsonHttpClient(_auth.InstanceUrl, _auth.ApiVersion, _auth.AccessToken, new HttpClient());
        }
        public void Can_send_Deflate_client_request_HttpClient()
        {
            var client = new JsonHttpClient(Config.ListeningOn)
            {
                RequestCompressionType = CompressionTypes.Deflate,
            };
            var response = client.Post(new HelloZip {
                Name = "Deflate"
            });

            Assert.That(response.Result, Is.EqualTo("Hello, Deflate"));
        }
        public async Task Does_compress_RequestDto_responses_HttpClient()
        {
            var client   = new JsonHttpClient(Config.ListeningOn);
            var response = await client.PostAsync(new CompressData
            {
                String = "Hello",
                Bytes  = "World".ToUtf8Bytes()
            });

            Assert.That(response.String, Is.EqualTo("Hello"));
            Assert.That(response.Bytes, Is.EqualTo("World".ToUtf8Bytes()));
        }
Example #14
0
        public async Task <ContentResult> GetEvents()
        {
            var start = DateTime.Now.AddDays(-1);
            var end   = start.AddDays(60);
            var url   = string.Format("https://vocadb.net/api/releaseEvents?sort=Date&maxResults=100&afterDate={0:u}&beforeDate={1:u}", start, end);

            var vbEvents = await JsonHttpClient.GetObject <PartialFindResult <VdbEvent> >(url);

            var events = vbEvents.Items.Where(e => e.Date.HasValue).Select(CreateCalendarEvent);

            return(CalendarResponseFactory.CreateCalendarContentResult(Response, events, "events.ics"));
        }
Example #15
0
        public async Task <ContentResult> GetAlbums()
        {
            var start = DateTime.Now.AddDays(-1);
            var end   = start.AddDays(60);
            var url   = string.Format("https://vocadb.net/api/albums?sort=ReleaseDate&maxResults=100&releaseDateAfter={0:u}&releaseDateBefore={1:u}", start, end);

            var albums = await JsonHttpClient.GetObject <PartialFindResult <Album> >(url);

            var events = albums.Items.Select(CreateCalendarEvent);

            return(CalendarResponseFactory.CreateCalendarContentResult(Response, events, "albums.ics"));
        }
        public void Does_handle_concurrent_requests()
        {
            var rand   = new Random();
            var client = new JsonHttpClient(Config.AbsoluteBaseUri);

            client.GetHttpClient().Timeout = TimeSpan.FromMinutes(5);
            long      responsesReceived    = 0;
            long      totalSecondsWaited   = 0;
            var       sw = Stopwatch.StartNew();
            const int ConcurrentRequests = 50;

            ConcurrentRequests.Times(i =>
            {
                Interlocked.Increment(ref responsesReceived);

                ThreadPool.QueueUserWorkItem(async _ =>
                {
                    var request = new SleepTest
                    {
                        Name        = $"Request {i+1}",
                        WaitingSecs = rand.Next(30, 60),
                    };
                    Interlocked.Add(ref totalSecondsWaited, request.WaitingSecs);

                    log.Info($"[{DateTime.Now.TimeOfDay}] Sending {request.Name} to sleep for {request.WaitingSecs} seconds...");

                    try
                    {
                        var response = await client.GetAsync(request);

                        log.Info($"[{DateTime.Now.TimeOfDay}] Received {request.Name}: {response.Message}");
                    }
                    catch (Exception ex)
                    {
                        log.Error($"[{DateTime.Now.TimeOfDay}] Error Response: {ex.UnwrapIfSingleException().Message}", ex);
                    }
                    finally
                    {
                        Interlocked.Decrement(ref responsesReceived);
                    }
                });
            });

            while (Interlocked.Read(ref responsesReceived) > 0)
            {
                Thread.Sleep(10);
            }

            log.Info($"Took {sw.Elapsed.TotalSeconds} to execute {ConcurrentRequests} Concurrent Requests waiting a total of {totalSecondsWaited} seconds.");
        }
Example #17
0
        public DnfClient(string?instanceUrl, string?accessToken, string?refreshToken, Action <string>?logger = null)
        {
            Logger             = logger;
            SelectListResolver = new DataMemberSelectListResolver();
            HttpClient jsonClient;
            HttpClient xmlClient;

            if (UseCompression)
            {
                var httpHandler = new HttpClientHandler
                {
                    AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
                };
                jsonClient = new HttpClient(httpHandler)
                {
                    Timeout = TimeSpan.FromSeconds(60 * 30)
                };
                //jsonClient.DefaultRequestHeaders.ConnectionClose = true;
                jsonClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
                xmlClient = new HttpClient(httpHandler)
                {
                    Timeout = TimeSpan.FromSeconds(60 * 30)
                };
            }
            else
            {
                jsonClient = new HttpClient {
                    Timeout = TimeSpan.FromSeconds(60 * 30)
                };
                xmlClient = new HttpClient {
                    Timeout = TimeSpan.FromSeconds(60 * 30)
                };
            }

            //xmlClient.DefaultRequestHeaders.ConnectionClose = true;
            xmlClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
            InstanceUrl  = instanceUrl;
            AccessToken  = accessToken;
            RefreshToken = refreshToken;
            ApiVersion   = DefaultApiVersion;

            JsonHttp = new JsonHttpClient(InstanceUrl, ApiVersion, AccessToken, jsonClient);
            XmlHttp  = new XmlHttpClient(InstanceUrl, ApiVersion, AccessToken, xmlClient);

            Chatter   = new ChatterClient(JsonHttp);
            Composite = new CompositeClient(JsonHttp, ApiVersion, Logger);
            Tooling   = new ToolingClient(JsonHttp);
            Bulk      = new BulkClient(XmlHttp, JsonHttp);
            Layout    = new LayoutClient(XmlHttp, JsonHttp);
        }
Example #18
0
    public void Does_change_BasePath_HttpClient()
    {
        var client = new JsonHttpClient("https://example.org")
        {
            UseBasePath = "/api"
        };

        Assert.That(client.SyncReplyBaseUri, Is.EqualTo("https://example.org/api/"));
        Assert.That(client.AsyncOneWayBaseUri, Is.EqualTo("https://example.org/api/"));

        client.UseBasePath = null;
        Assert.That(client.SyncReplyBaseUri, Is.EqualTo("https://example.org/json/reply/"));
        Assert.That(client.AsyncOneWayBaseUri, Is.EqualTo("https://example.org/json/oneway/"));
    }
Example #19
0
        public async Task <bool> Connect(string serviceUri)
        {
            client = JsonHttpClient.Create(serviceUri + baseApiPath, AddAuthorization);

            try
            {
                var result = await client.Send <string>(HttpMethod.Get, "/");

                return(result.Response.StatusCode == HttpStatusCode.OK);
            }
            catch
            {
                return(false);
            }
        }
        public void ResponseFilterIShouldHaveVaryFilterTest()
        {
            using (var client = new JsonHttpClient(Config.ListeningOn))
            {
                client.ResponseFilter = message =>
                {
                    var headers = message.Headers.Vary.Join(",");
                    Assert.That(headers, Is.EqualTo("accept,origin,authorization"));
                    Assert.That(message.Headers.CacheControl.ToString(), Is.EqualTo("no-cache"));
                };

                var response = client.Get(new ResponseFilterWithVaryRequest());
                Assert.That(response, Is.EqualTo("Should have vary headers."));
            }
        }
 public void CheckInterfaces()
 {
     using (IAuthenticationClient aa = new AuthenticationClient())
     {
         Assert.IsNotNull(aa);
     }
     using (IJsonHttpClient aa = new JsonHttpClient("instanceUrl", "apiVersion", "accessToken", new HttpClient()))
     {
         Assert.IsNotNull(aa);
     }
     using (IXmlHttpClient aa = new XmlHttpClient("instanceUrl", "apiVersion", "accessToken", new HttpClient()))
     {
         Assert.IsNotNull(aa);
     }
 }
Example #22
0
        public void Load_test_GetFactorialSync_HttpClient_sync()
        {
            var client = new JsonHttpClient(Config.ListeningOn);

            for (var i = 0; i < NoOfTimes; i++)
            {
                var response = client.Get(new GetFactorialSync {
                    ForNumber = 3
                });
                if (i % 100 == 0)
                {
                    "{0}: {1}".Print(i, response.Result);
                }
            }
        }
        public async Task Requests_CheckCustomRequestsHeaders()
        {
            var client = new HttpClient(new ServiceClientRouteHandler(r =>
            {
                Assert.IsNotNull(r.Headers.GetValues("headername"));
                Assert.AreEqual(r.Headers.GetValues("headername").FirstOrDefault(), "headervalue");
            }));

            client.DefaultRequestHeaders.Add("headername", "headervalue");

            using (var httpClient = new JsonHttpClient("http://localhost:1899", "v36", "accessToken", client))
            {
                await httpClient.HttpGetAsync <object>("wade");
            }
        }
Example #24
0
        public void NewServiceHttpClient_ResetsUserAgents()
        {
            var httpClientUserAgent = UserAgent + "/v36";

            var httpClient = new HttpClient();

            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(httpClientUserAgent);
            httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(httpClientUserAgent);
            Assert.AreEqual(httpClientUserAgent + " " + httpClientUserAgent, httpClient.DefaultRequestHeaders.UserAgent.ToString());

            var serviceClient = new JsonHttpClient("http://localhost:1899", "v36", "accessToken", httpClient);

            // Ensure the old user agent header is replaced.
            Assert.AreEqual(httpClientUserAgent, httpClient.DefaultRequestHeaders.UserAgent.ToString());
        }
        public void Can_send_GZip_client_request_list_HttpClient()
        {
            var client = new JsonHttpClient(Config.ListeningOn)
            {
                RequestCompressionType = CompressionTypes.GZip,
            };
            var response = client.Post(new HelloZip
            {
                Name = "GZIP",
                Test = new List <string> {
                    "Test"
                }
            });

            Assert.That(response.Result, Is.EqualTo("Hello, GZIP (1)"));
        }
        public async Task Does_not_compress_error_responses_HttpClient()
        {
            var client = new JsonHttpClient(Config.ListeningOn);

            try
            {
                await client.PostAsync(new CompressError());

                Assert.Fail("Should throw");
            }
            catch (WebServiceException ex)
            {
                Assert.That(ex.StatusCode, Is.EqualTo(404));
                Assert.That(ex.ErrorCode, Is.EqualTo("NotFound"));
                Assert.That(ex.ErrorMessage, Is.EqualTo("Always NotFound"));
            }
        }
Example #27
0
        private async Task <string> PostRequest(RpcCommand request)
        {
            try
            {
                using (var client = new JsonHttpClient(VergeConfig.GetUri()))
                {
                    client.AddHeader("Authorization", VergeConfig.GetAuthHeaderValue());
                    var response = await client.PostAsync <string>(new Payload(request));

                    return(response);
                }
            }
            catch (Exception ex)
            {
                throw new HttpError(HttpStatusCode.InternalServerError, ex);
            }
        }
        public async void Requests_CheckHttpRequestMessage_HttpGet_WithNode()
        {
            var client = new HttpClient(new ServiceClientRouteHandler(r =>
            {
                Assert.AreEqual(r.RequestUri.ToString(), "http://localhost:1899/services/data/v34/wade");

                Assert.IsNotNull(r.Headers.UserAgent);
                Assert.AreEqual(r.Headers.UserAgent.ToString(), UserAgent + "/v34");

                Assert.IsNotNull(r.Headers.Authorization);
                Assert.AreEqual(r.Headers.Authorization.ToString(), "Bearer accessToken");
            }));

            using (var httpClient = new JsonHttpClient("http://localhost:1899", "v34", "accessToken", client))
            {
                await httpClient.HttpGetAsync<object>("wade");
            }
        }
        public async Task Requests_CheckHttpRequestMessage_HttpPost()
        {
            var client = new HttpClient(new ServiceClientRouteHandler(r =>
            {
                Assert.AreEqual(r.RequestUri.ToString(), "http://localhost:1899/services/data/v36/wade");

                Assert.IsNotNull(r.Headers.UserAgent);
                Assert.AreEqual(r.Headers.UserAgent.ToString(), UserAgent + "/v36");

                Assert.IsNotNull(r.Headers.Authorization);
                Assert.AreEqual(r.Headers.Authorization.ToString(), "Bearer accessToken");
            }));

            using (var httpClient = new JsonHttpClient("http://localhost:1899", "v36", "accessToken", client))
            {
                await httpClient.HttpPostAsync <object>(null, "wade");
            }
        }
        public async Task ThrowAsync_ServiceException_only_calls_ServiceExceptionHandlers()
        {
            ServiceEx = UnHandledEx = null;
            var client = new JsonHttpClient(Config.ListeningOn);

            try
            {
                var response = await client.GetAsync(new ThrowAsync());

                Assert.Fail("Should fail");
            }
            catch (WebServiceException ex)
            {
                Assert.That(ServiceEx.Message, Is.EqualTo(nameof(ThrowAsync)));
                Assert.That(UnHandledEx, Is.Null);
                Assert.That(ex.Message, Is.EqualTo(nameof(ThrowAsync)));
            }
        }
        public void Does_serialize_request()
        {
            var client = new JsonHttpClient(Config.ListeningOn);

            var response = client.Put(new PutConfirmed
            {
                Confirmations = new List <Confirmation>
                {
                    new Confirmation
                    {
                        ChangeId  = 126552616,
                        Confirmed = true,
                    }
                }
            });

            Assert.That(response.IsSucceed);
        }
Example #32
0
        /// <summary>Inititialies a new <see cref="ClientSession"/>.</summary>
        /// <param name="authenticationSetting">The authentication settings.</param>
        /// <returns>The initialize session.</returns>
        public static ClientSession InitializeSession(AuthenticationSetting authenticationSetting)
        {
            Uri addressUri = ServiceAddressProvider.ServiceAddress(new Uri(authenticationSetting.ServiceUrl));

            ICredentials credentials = null;

            switch (authenticationSetting.AuthenticationScheme)
            {
            case AuthenticationScheme.UserNamePassword:
                credentials = new NetworkCredential(authenticationSetting.Username, authenticationSetting.Password);
                break;

            case AuthenticationScheme.AzureActiveDirectory:
                using (var client = new HttpClient())
                {
                    var result = client.PostAsync(new Uri(authenticationSetting.Authority + "/oauth2/token"), new FormUrlEncodedContent(new[]
                    {
                        new KeyValuePair <string, string>("resource", authenticationSetting.Resource),
                        new KeyValuePair <string, string>("client_id", authenticationSetting.ClientId),
                        new KeyValuePair <string, string>("grant_type", "password"),
                        new KeyValuePair <string, string>("username", authenticationSetting.Username),
                        new KeyValuePair <string, string>("password", authenticationSetting.Password),
                        new KeyValuePair <string, string>("scope", "openid"),
                        new KeyValuePair <string, string>("client_secret", authenticationSetting.ClientSecret),
                    })).Result;

                    var content    = result.Content.ReadAsStringAsync().Result;
                    var authResult = JsonConvert.DeserializeObject <OAuthResult>(content);
                    credentials = new TokenCredential(authResult.Access_Token);
                }
                break;

            case AuthenticationScheme.Windows:
                // Windows auth is supported
                break;

            default:
                throw new Exception("Unsupported Authentication Scheme");
            }

            var jsonClient = new JsonHttpClient(addressUri, credentials, authenticationSetting.AuthenticationScheme);

            return(new ClientSession(jsonClient, new NonDispatcher(), new TimerFactory <TaskTimer>()));
        }
	    public async void BadTokenHandling()
	    {
            _auth = new AuthenticationClient();
            _auth.UsernamePasswordAsync(ConsumerKey, ConsumerSecret, Username, Password, TokenRequestEndpointUrl).Wait();

	        var badToken = "badtoken";
            var serviceHttpClient = new JsonHttpClient(_auth.InstanceUrl, _auth.ApiVersion, badToken, new HttpClient());

            const string query = "SELECT count() FROM Account";

	        try
	        {
                await serviceHttpClient.HttpGetAsync<QueryResult<dynamic>>(string.Format("query?q={0}", query));
	        }
            catch (ForceException ex)
            {
                Assert.IsNotNull(ex);
                Assert.IsNotNull(ex.Message);
                Assert.That(ex.Message, Is.EqualTo("Session expired or invalid"));
                Assert.IsNotNull(ex.Error);
            }
	    }
        public async void Requests_CheckCustomRequestsHeaders()
        {
            var client = new HttpClient(new ServiceClientRouteHandler(r =>
            {
                Assert.IsNotNull(r.Headers.GetValues("headername"));
                Assert.AreEqual(r.Headers.GetValues("headername").FirstOrDefault(), "headervalue");
            }));

            client.DefaultRequestHeaders.Add("headername", "headervalue");

            using (var httpClient = new JsonHttpClient("http://localhost:1899", "v32", "accessToken", client))
            {
                await httpClient.HttpGetAsync<object>("wade");
            }
        }
        /// <summary>Inititialies a new <see cref="ClientSession"/>.</summary>
        /// <param name="serviceAddress">The service Address.</param>
        /// <param name="tenantId">The optional tenant id.</param>
        /// <param name="company">The company to open</param>
        /// <param name="authentication">The authentication.</param>
        /// <param name="username">The username.</param>
        /// <param name="password">The password.</param>
        /// <returns>The initialize session.</returns>
        public static ClientSession InitializeSession(string serviceAddress, string tenantId = null, string company = null, AuthenticationScheme? authentication = null, string username = null, string password = null)
        {
            if (string.IsNullOrWhiteSpace(serviceAddress))
            {
                throw new ArgumentNullException("serviceAddress");
            }

            if (!string.IsNullOrEmpty(tenantId))
            {
                serviceAddress += "?tenant=" + tenantId;
            }

            if (!string.IsNullOrEmpty(company))
            {
                serviceAddress += (string.IsNullOrEmpty(tenantId) ? "?" : "&") + "company=" + Uri.EscapeDataString(company);
            }

            Uri addressUri = ServiceAddressProvider.ServiceAddress(new Uri(serviceAddress));
            ICredentials credentials = null;
            if (authentication.GetValueOrDefault() == AuthenticationScheme.UserNamePassword)
            {
                credentials = new NetworkCredential(username, password);
            }

            var jsonClient = new JsonHttpClient(addressUri, credentials, authentication.GetValueOrDefault());
            return new ClientSession(jsonClient, new NonDispatcher(), new TimerFactory<TaskTimer>());
        }
Example #36
0
		private async Task<ObservableCollection<ResponseObject>> consultaServidorLicencas (object requestObj)
		{
			Console.WriteLine ("*** Consultando servidor de licenças......");
			try {
				// consultar servico de licenças
				string urlcommerce = "http://mysafety.dyndns.org:8080/WsWebGate/json/registerclient/post";

				JsonHttpClient service = new JsonHttpClient ();
				var request = (HttpWebRequest)WebRequest.Create (urlcommerce);
				request.Method = "POST";
				request.Accept = "application/json";
				var x = await service.PostAsync<ObservableCollection<ResponseObject>> (urlcommerce, requestObj);
				if (x != null)
					return x;
			} catch (Exception ex) {
				Console.WriteLine ("*** Exception Consultando servidor de licenças......" + ex);
			}
			return new ObservableCollection<ResponseObject> ();
		}
Example #37
0
		async void OpAction ()
		{
			var sheet = await DisplayActionSheet (null, "Voltar", null, "Esqueci minha senha", null, "Reenviar email de confirmação");

			if (sheet.Equals ("Esqueci minha senha"))
				Device.OpenUri (new Uri ("http://www.ineltec.com.br/index3.htm"));
			if (sheet.Equals ("Reenviar email de confirmação")) {
				PromptResult input = null;

				input = await UserDialogs.Instance.PromptAsync ("Reenviar email", "MySafety", "Ok", "Cancelar",
					"*****@*****.**", InputType.Email);
				if (input.Ok == true) {
					if (String.IsNullOrEmpty (input.Text)) {
						await DisplayAlert ("MySafety", "Email é obrigatório", "OK");
						return;
					}
					if (!CrossConnectivity.Current.IsConnected) {
						await DependencyService.Get<IToastNotificator> ().Notify (ToastNotificationType.Error,
							"MySafety", "Não há conexão com internet.\nTente mais tarde.", TimeSpan.FromSeconds (3));
						return;
					}
					string urlsite = "http://mysafety.azurewebsites.net/api/resend";

					JsonHttpClient service = new JsonHttpClient ();

					var request = (HttpWebRequest)WebRequest.Create (urlsite);
					request.Method = "POST";
					request.Accept = "application/json";

					var result = await service.PostAsync<string> (urlsite, input.Text);

					await DisplayAlert ("MySafety", result, "OK");
				}

			}
		}
Example #38
0
        public async Task Can_post_raw_response_as_raw_JSON_HttpClient()
        {
            var httpClient = new JsonHttpClient(BaseUrl);
            var request = new GetCustomer { CustomerId = 5 };
            var response = httpClient.Post(request);
            Assert.That(response.Customer.Id, Is.EqualTo(5));

            var requestPath = request.ToPostUrl();

            string json = request.ToJson();
            response = await httpClient.PostAsync<GetCustomerResponse>(requestPath, json);
            Assert.That(response.Customer.Id, Is.EqualTo(5));

            byte[] bytes = json.ToUtf8Bytes();
            response = await httpClient.PutAsync<GetCustomerResponse>(requestPath, bytes);
            Assert.That(response.Customer.Id, Is.EqualTo(5));

            Stream ms = new MemoryStream(bytes);
            response = await httpClient.PostAsync<GetCustomerResponse>(requestPath, ms);
            Assert.That(response.Customer.Id, Is.EqualTo(5));
        }