コード例 #1
0
 public void DoesNotCreateAuthenticationHeaderWhenUsernameIsNullOrEmpty(
     [Values("", " ", null)] string username
     )
 {
     var wrapper = new HttpClientWrapper(username);
     Assert.IsNull(wrapper.AuthenticationHeaderValue);
 }
コード例 #2
0
 public void DoesNotCreateAuthenticationHeaderWhenPasswordIsNullOrEmpty(
     [Values("", " ", null)] string password
     )
 {
     var wrapper = new HttpClientWrapper(password: password);
     Assert.IsNull(wrapper.AuthenticationHeaderValue);
 }
コード例 #3
0
        public void UsesGivenHttpClient()
        {
            var client = Substitute.For<HttpClient>();
            var wrapper = new HttpClientWrapper(client);

            Assert.AreSame(wrapper.Client, client);
        }
コード例 #4
0
 public void SetsTheUsernameAndPasswordProperties()
 {
     const string username = "******";
     const string password = "******";
     var client = Substitute.For<HttpClient>();
     var wrapper = new HttpClientWrapper(username, password, client);
     Assert.AreEqual(username, wrapper.Username);
     Assert.AreEqual(password, wrapper.Password);
 }
コード例 #5
0
        public void SetsAuthenticationHeaderValueCorrectly()
        {
            const string username = "******";
            const string password = "******";
            var base64 = Base64Header(username, password);

            var wrapper = new HttpClientWrapper(username, password, Substitute.For<HttpClient>());
            Assert.AreEqual("Basic", wrapper.AuthenticationHeaderValue.Scheme);
            Assert.AreEqual(base64, wrapper.AuthenticationHeaderValue.Parameter);
        }
コード例 #6
0
        /// <summary>
        /// Login to DLAP. Call Logout to close session.
        /// </summary>
        /// <param name="prefix">
        /// Login prefix
        /// </param>
        /// <param name="username">
        /// User name
        /// </param>
        /// <param name="password">
        /// The password
        /// </param>
        /// <returns>
        /// XML results
        /// </returns>
        public Task <XElement> LoginAsync(string prefix, string username, string password)
        {
            _httpClientWrapper = new HttpClientWrapper(Timeout, new CookieContainer(), false);

            return(PostAsync(
                       null,
                       new XElement(
                           "request",
                           new XAttribute("cmd", "login"),
                           new XAttribute("username", string.Concat(prefix, "/", username)),
                           new XAttribute("password", password))));
        }
コード例 #7
0
        public async Task Send_EmptyAcceptHeader_SetsAcceptHeaderToJson()
        {
            HttpRequestMessage actualRequest = null;
            var httpClientWrapper            = new HttpClientWrapper
                                               (
                new Config(new UnitTestHandler(request => actualRequest = request))
                                               );

            await httpClientWrapper.Send(HttpMethod.Post, new Uri(BaseUrl), requestHeaders : new Dictionary <string, string>(), content : new {});

            Assert.That(actualRequest.Headers.Accept.First().MediaType, Is.EqualTo(Config.JsonMediaType));
        }
コード例 #8
0
        /// <summary>获得指定角色的门户菜单</summary>
        public async Task <PortalMenu> GetPortalMenuAsyncInternal(HttpClientWrapper client, int roleId)
        {
            var key    = CacheConst.RoleKey + roleId.ToString();
            var result = this.MemcachedCacher?.TryGet <PortalMenu>(key, CacheConst.PermissionRegion);

            if (result == null)
            {
                var url = GetActionUrl(nameof(GetPortalMenu)) + nameof(roleId).GetFirstQueryString(roleId.ToString());
                result = await client.GetAsync <PortalMenu>(url).ConfigureAwait(false);
            }
            return(result);
        }
コード例 #9
0
        /// <summary>
        /// Get a document from Storage for owner,instance and specific document id
        /// </summary>
        /// <param name="instanceOwnerId">owner id</param>
        /// <param name="instanceGuid">id of the instance</param>
        /// <param name="dataId">id of the data element/file</param>
        /// <returns></returns>
        public Stream GetData(int instanceOwnerId, Guid instanceGuid, Guid dataId)
        {
            string cmd = $@"instances/{instanceOwnerId}/{instanceGuid}/data/{dataId}";

            HttpClientWrapper httpClientWrapper = new HttpClientWrapper(_logger);

            Task <HttpResponseMessage> response = httpClientWrapper.GetCommand(BaseAddress, cmd);

            Stream stream = response.Result.Content.ReadAsStreamAsync().Result;

            return(stream);
        }
コード例 #10
0
        public void TimeoutIsCorrectlySet()
        {
            // arrange
            var timeout = TimeSpan.FromMilliseconds(1000);
            var sut     = new HttpClientWrapper();

            // act
            sut.Timeout = timeout;

            // assert
            sut.Timeout.Should().Be(timeout);
        }
コード例 #11
0
ファイル: PartialController.cs プロジェクト: pbailey3/Rooster
        public ActionResult NavMenu()
        {
            HomeSummaryDTO summary = null;

            //Get a summary of the employes currently linked to the Employee
            using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
            {
                Task <String> response = httpClient.GetStringAsync("api/SummaryAPI");
                summary = Task.Factory.StartNew(() => JsonConvert.DeserializeObject <HomeSummaryDTO>(response.Result)).Result;
            }
            return(PartialView(summary));
        }
コード例 #12
0
        public ActionResult Create(EmployeeDTO employeedto, List <string> selectedRoles, bool addedAnother = false)
        {
            ViewBag.AddedAnother = addedAnother;

            if (selectedRoles != null)
            {
                if (selectedRoles.Count() > 5)
                {
                    ModelState.AddModelError("", "Maximimum of 5 roles can be added");
                }
                else
                {
                    employeedto.Roles = new List <RoleDTO>();
                    foreach (var selectedRole in selectedRoles)
                    {
                        employeedto.Roles.Add(new RoleDTO {
                            Id = Guid.Parse(selectedRole), Name = "PLACEHOLDER"
                        });
                    }
                }
            }

            if (ModelState.IsValid)
            {
                using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
                {
                    var responseMessage = httpClient.PostAsJsonAsync("/api/EmployeeAPI", employeedto).Result;
                    if (responseMessage.IsSuccessStatusCode)
                    {
                        if (employeedto.AddAnother)
                        {
                            return(RedirectToAction("Create", new { businessLocationId = employeedto.BusinessLocationId, businessId = employeedto.BusinessId, addedAnother = true }));
                        }
                        else
                        {
                            return(RedirectToAction("Index", new { businesslocationid = employeedto.BusinessLocationId }));
                        }
                    }
                    else
                    { //If and error occurred add details to model error.
                        var error = JsonConvert.DeserializeObject <System.Web.Http.HttpError>(responseMessage.Content.ReadAsStringAsync().Result);
                        ModelState.AddModelError(String.Empty, error.Message);
                    }
                }
            }

            //Get roles for business
            BusinessController bc = new BusinessController();

            ViewBag.BusinessRoles = bc.GetBusinessRoles(employeedto.BusinessId, this.Session);

            return(PartialView(employeedto));
        }
コード例 #13
0
ファイル: App.xaml.cs プロジェクト: lulzzz/Smart-Alerts
        /// <summary>
        /// Raises the <see cref="E:System.Windows.Application.Startup" /> event.
        /// </summary>
        /// <param name="e">A <see cref="T:System.Windows.StartupEventArgs" /> that contains the event data.</param>
        protected override void OnStartup(StartupEventArgs e)
        {
            ITracer stringTracer        = new StringTracer(string.Empty);
            ITracer consoleTracer       = new ConsoleTracer(string.Empty);
            var     smartDetectorLoader = new SmartDetectorLoader(consoleTracer);

            // *Temporary*: if package file path wasn't accepted, raise file selection window to allow package file selection.
            // This option should be removed before launching version for customers (bug for tracking: 1177247)
            string smartDetectorPackagePath = e.Args.Length != 1 ?
                                              this.GetSmartDetectorPackagePath() :
                                              Diagnostics.EnsureStringNotNullOrWhiteSpace(() => e.Args[0]);

            SmartDetectorPackage smartDetectorPackage;

            using (var fileStream = new FileStream(smartDetectorPackagePath, FileMode.Open))
            {
                smartDetectorPackage = SmartDetectorPackage.CreateFromStream(fileStream, consoleTracer);
            }

            SmartDetectorManifest smartDetectorManifest = smartDetectorPackage.Manifest;
            ISmartDetector        detector = smartDetectorLoader.LoadSmartDetector(smartDetectorPackage);

            // Authenticate the user to Active Directory
            var authenticationServices = new AuthenticationServices();

            authenticationServices.AuthenticateUser();
            ICredentialsFactory credentialsFactory = new ActiveDirectoryCredentialsFactory(authenticationServices);

            IAzureResourceManagerClient azureResourceManagerClient = new AzureResourceManagerClient(credentialsFactory, consoleTracer);

            // Create analysis service factory
            var queryRunInroProvider = new QueryRunInfoProvider(azureResourceManagerClient);
            var httpClientWrapper    = new HttpClientWrapper();
            IAnalysisServicesFactory analysisServicesFactory = new AnalysisServicesFactory(consoleTracer, httpClientWrapper, credentialsFactory, azureResourceManagerClient, queryRunInroProvider);

            // Create state repository factory
            IStateRepositoryFactory stateRepositoryFactory = new InMemoryStateRepositoryFactory();

            var smartDetectorRunner = new SmartDetectorRunner(detector, analysisServicesFactory, queryRunInroProvider, smartDetectorManifest, stateRepositoryFactory, smartDetectorManifest.Id, stringTracer);

            // Create a Unity container with all the required models and view models registrations
            Container = new UnityContainer();
            Container
            .RegisterInstance(stringTracer)
            .RegisterInstance(new AlertsRepository())
            .RegisterInstance(authenticationServices)
            .RegisterInstance(azureResourceManagerClient)
            .RegisterInstance(detector)
            .RegisterInstance(smartDetectorManifest)
            .RegisterInstance(analysisServicesFactory)
            .RegisterInstance(smartDetectorRunner)
            .RegisterInstance(stateRepositoryFactory);
        }
コード例 #14
0
 private async Task PutAsync(string endpoint, object data)
 {
     try
     {
         using (HttpClientWrapper client = new HttpClientWrapper(MixItUpAPIEndpoint))
         {
             string content = SerializerHelper.SerializeToString(data);
             HttpResponseMessage response = await client.PutAsync(endpoint, new StringContent(content, Encoding.UTF8, "application/json"));
         }
     }
     catch (Exception) { }
 }
コード例 #15
0
ファイル: ManagerController.cs プロジェクト: pbailey3/Rooster
        private IEnumerable <EmployeeRequestDTO> GetEmployeeRequestList()
        {
            IEnumerable <EmployeeRequestDTO> er = new List <EmployeeRequestDTO>();

            //Get a summary of the employes currently linked to the Employee
            using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
            {
                Task <String> response = httpClient.GetStringAsync("api/EmployerAPI/GetEmployeeRequests");
                er = Task.Factory.StartNew(() => JsonConvert.DeserializeObject <IEnumerable <EmployeeRequestDTO> >(response.Result)).Result;
            }
            return(er);
        }
コード例 #16
0
 public CoinMarketTask(IRepository <User> userRepository, Notifyer notifyer, HttpClientWrapper client,
                       CurrencyService currencyService,
                       ILogger <CoinMarketTask> logger,
                       IRepository <Alert> alertRepository)
 {
     _userRepository  = userRepository;
     _notifyer        = notifyer;
     _client          = client;
     _currencyService = currencyService;
     _logger          = logger;
     _alertRepository = alertRepository;
 }
コード例 #17
0
ファイル: SpotifyService.cs プロジェクト: kerleyc98/JukeBot
        public async Task Spotify()
        {
            HttpClientWrapper hcw = new HttpClientWrapper(new HttpClient());

            //hcw.SendAsync()

            FluentSpotifyApi.Client.SpotifyHttpClient c = new FluentSpotifyApi.Client.SpotifyHttpClient(hcw);

            //c.SendAsync()

            FluentSpotifyApi.Builder.Search.QueryFields query = new FluentSpotifyApi.Builder.Search.QueryFields();
        }
コード例 #18
0
        //
        // GET: /Calendar/Edit
        public ActionResult EditSchedule(int id)
        {
            using (HttpClientWrapper httpClient = new HttpClientWrapper(this.Session))
            {
                Task <String> response    = httpClient.GetStringAsync("api/ScheduleAPI/" + id.ToString());
                var           scheduleDTO = Task.Factory.StartNew(() => JsonConvert.DeserializeObject <ScheduleDTO>(response.Result)).Result;

                LoadViewBag();

                return(PartialView(scheduleDTO));
            }
        }
コード例 #19
0
 protected async Task <T> PatchAsync <T>(string requestUri, HttpContent content)
 {
     using (HttpClientWrapper client = new HttpClientWrapper(await this.client.GetAuthorizationToken()))
     {
         HttpMethod         method  = new HttpMethod("PATCH");
         HttpRequestMessage request = new HttpRequestMessage(method, requestUri)
         {
             Content = content
         };
         return(await this.ProcessResponse <T>(await client.SendAsync(request)));
     }
 }
コード例 #20
0
        public ActionResult EditTimesheetEntry(Guid id)
        {
            TimesheetEntryDTO val = null;

            using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
            {
                Task <String> response = httpClient.GetStringAsync("api/TimesheetAPI/TimesheetEntry/" + id.ToString());
                val = Task.Factory.StartNew(() => JsonConvert.DeserializeObject <TimesheetEntryDTO>(response.Result)).Result;
            }

            return(PartialView("_TimesheetEntryEditPartial", val));
        }
コード例 #21
0
        public async void SendAsync_WhenResponseIsSuccessButContentIsEmpty_ResultShouldBeAsExpected(HttpRequestMessage message)
        {
            var sut = new HttpClientWrapper(new HttpClient(new SuccessEmptyMessageHandler()), Substitute.For <ISerialization>(), null);

            var result = await sut.SendAsync <Foo>(message);

            result.Success.Should().BeTrue();
            result.Response.Should().BeNull();
            result.StatusCode.Should().Be(HttpStatusCode.OK);
            result.OriginalBody.Should().BeNullOrEmpty();
            sut.Serializer.DidNotReceive().Deserialize(Arg.Any <string>(), typeof(Foo));
        }
コード例 #22
0
        public void MaxResponseContentBufferIsCorrectlySet()
        {
            // arrange
            const long maxResponseBufferSize = 1245;
            var        sut = new HttpClientWrapper();

            // act
            sut.MaxResponseContentBufferSize = maxResponseBufferSize;

            // assert
            sut.MaxResponseContentBufferSize.Should().Be(maxResponseBufferSize);
        }
コード例 #23
0
        /// <summary>获得指定用户的权限集合</summary>
        public async Task <Dictionary <string, bool> > GetPermissionsAsyncInternal(HttpClientWrapper client, int userId)
        {
            var key    = CacheConst.UserKey + userId.ToString();
            var result = this.MemcachedCacher?.TryGet <Dictionary <string, bool> >(key, CacheConst.PermissionRegion);

            if (result == null)
            {
                var url = GetActionUrl(nameof(GetPermissions)) + nameof(userId).GetFirstQueryString(userId.ToString());
                result = await client.GetAsync <Dictionary <string, bool> >(url).ConfigureAwait(false);
            }
            return(result);
        }
コード例 #24
0
        public async Task Send_ByDefault_SetsExpectJsonResponse()
        {
            HttpRequestMessage actualRequest = null;
            var httpClientWrapper            = new HttpClientWrapper
                                               (
                new Config(new UnitTestHandler(request => actualRequest = request))
                                               );

            await httpClientWrapper.Send(HttpMethod.Post, new Uri(BaseUrl), null, null);

            Assert.That(actualRequest.ExpectJsonResponse(), Is.True);
        }
コード例 #25
0
        public async Task Send_DoNotSetContentType_SetsContentTypeToJson()
        {
            HttpRequestMessage actualRequest = null;
            var httpClientWrapper            = new HttpClientWrapper
                                               (
                new Config(new UnitTestHandler(request => actualRequest = request))
                                               );

            await httpClientWrapper.Send(HttpMethod.Post, new Uri(BaseUrl), null, new { });

            Assert.That(actualRequest.Content.Headers.ContentType.MediaType, Is.EqualTo(Config.JsonMediaType));
        }
コード例 #26
0
        public void Timeout()
        {
            var client1 = new WebClientWrapper();

            client1.Timeout = 1;
            var client2 = new HttpClientWrapper();

            client2.Timeout = 1;
            var    url       = "http://releases.ubuntu.com/18.04.3/ubuntu-18.04.3-desktop-amd64.iso";
            string directory = Path.Combine(TestOutputPath, "Canceled");

            Directory.CreateDirectory(directory);
            string filePath = Path.Combine(directory, "canceled.iso");
            bool   expectedResponseSuccess = false;
            int    expectedStatus          = 408;
            string expectedContentType     = null;
            long?  expectedContentLength   = null;
            bool?  actualResponseSuccess   = null;
            int?   actualStatus            = null;
            string actualContentType       = null;
            long?  actualContentLength     = null;
            Uri    actualRequestUri        = null;
            var    action = new Func <IWebClient, Task <IWebResponseMessage> >(async(target) =>
            {
                IWebResponseMessage response = null;
                Exception exception          = null;
                try
                {
                    response = await target.GetAsync(url).ConfigureAwait(false);
                    Assert.Fail("Should've thrown exception");
                }
                catch (WebClientException ex)
                {
                    exception             = ex;
                    actualResponseSuccess = ex.Response?.IsSuccessStatusCode;
                    actualStatus          = ex.Response.StatusCode;
                    actualRequestUri      = ex.Response.RequestUri;
                }
                Assert.AreEqual(expectedResponseSuccess, actualResponseSuccess, $"Failed for {target.GetType().Name}: IsSuccessStatusCode");
                Assert.AreEqual(expectedStatus, actualStatus, $"Failed for {target.GetType().Name}: StatusCode");
                Assert.AreEqual(expectedContentType, actualContentType, $"Failed for {target.GetType().Name}: ContentType");
                Assert.AreEqual(expectedContentLength, actualContentLength, $"Failed for {target.GetType().Name}: ContentLength");
                Assert.AreEqual(url, actualRequestUri.ToString(), $"Failed for {target.GetType().Name}: RequestUri");
                if (exception != null)
                {
                    throw exception;
                }
                return(response);
            });

            CompareGetAsync(client1, client2, action);
        }
コード例 #27
0
        public void NotFound_ThrowOnException()
        {
            var    client1 = new WebClientWrapper();
            var    client2 = new HttpClientWrapper();
            var    url     = "https://beatsaver.com/cdn/5317/aaa14fb7dcaeda7a688db77617045a24d7baa151d.zip";
            bool   expectedResponseSuccess = false;
            int    expectedStatus          = 404;
            string expectedContentType     = null;
            long?  expectedContentLength   = null;
            bool?  actualResponseSuccess   = null;
            string actualReasonPhrase      = null;
            int?   actualStatus            = null;
            string actualContentType       = null;
            long?  actualContentLength     = null;
            Uri    actualRequestUri        = null;
            var    action = new Func <IWebClient, Task <IWebResponseMessage> >(async(target) =>
            {
                target.ErrorHandling         = ErrorHandling.ThrowOnException;
                IWebResponseMessage response = null;
                Exception exception          = null;
                try
                {
                    response = await target.GetAsync(url).ConfigureAwait(false);
                    actualResponseSuccess = response.IsSuccessStatusCode;
                    actualStatus          = response.StatusCode;
                    actualContentType     = response.Content.ContentType;
                    actualContentLength   = response.Content.ContentLength;
                    actualRequestUri      = response.RequestUri;
                    //Assert.Fail("Should've thrown exception");
                }
                catch (WebClientException ex)
                {
                    exception             = ex;
                    actualResponseSuccess = ex.Response?.IsSuccessStatusCode;
                    actualReasonPhrase    = ex.Response.ReasonPhrase;
                    actualStatus          = ex.Response.StatusCode;
                    actualRequestUri      = ex.Response.RequestUri;
                }
                Assert.AreEqual(expectedResponseSuccess, actualResponseSuccess, $"Failed for {target.GetType().Name}: IsSuccessStatusCode");
                Assert.AreEqual(expectedStatus, actualStatus, $"Failed for {target.GetType().Name}: StatusCode");
                Assert.AreEqual(expectedContentType, response?.Content?.ContentType, $"Failed for {target.GetType().Name}: ContentType");
                Assert.AreEqual(expectedContentLength, response?.Content?.ContentLength, $"Failed for {target.GetType().Name}: ContentLength");
                Assert.AreEqual(url, actualRequestUri.ToString(), $"Failed for {target.GetType().Name}: RequestUri");
                if (exception != null)
                {
                    throw exception;
                }
                return(response);
            });

            CompareGetAsync(client1, client2, action);
        }
コード例 #28
0
 public ServiceAuthenticationHelper()
 {
     lock (LockClass)
     {
         if (HttpClient != null)
         {
             return;
         }
         var handlers   = OutboundPipeFactory.CreateDelegatingHandlers();
         var httpClient = HttpClientFactory.Create(handlers);
         HttpClient = new HttpClientWrapper(httpClient);
     }
 }
コード例 #29
0
ファイル: Program.cs プロジェクト: pdev8/WeatherChecker
        static void ConfigureServices(IServiceCollection serviceCollection)
        {
            // add services
            var httpClient = new HttpClientWrapper(new HttpClientHandler {
                UseCookies = false
            });

            serviceCollection.AddSingleton <IHttpClient>(httpClient);
            serviceCollection.AddTransient <IWeatherFetcher, WeatherFetcher>();

            // add app
            serviceCollection.AddTransient <App>();
        }
コード例 #30
0
ファイル: Logger.cs プロジェクト: rspeight/mixer-mixitup
 private static async Task LogAnalyticsUsageInternal(string eventName, string eventDetails)
 {
     try
     {
         using (HttpClientWrapper client = new HttpClientWrapper())
         {
             client.BaseAddress = new Uri("https://api.mixitupapp.com/analytics/");
             HttpResponseMessage response = await client.GetAsync(string.Format("log?username={0}&eventName={1}&eventDetails={2}&appVersion={3}",
                                                                                ChannelSession.User.username, eventName, eventDetails, Assembly.GetEntryAssembly().GetName().Version.ToString()));
         }
     }
     catch (Exception ex) { Logger.Log(ex); }
 }
コード例 #31
0
        public async Task Send_PassingStringToContent_ThrowsArgumentException()
        {
            const string stringContentToTest = "This is a string";

            var httpClientWrapper = new HttpClientWrapper
                                    (
                new Config(new UnitTestHandler())
                                    );

            await httpClientWrapper.Send(HttpMethod.Post, new Uri(BaseUrl), null, new { });

            Assert.ThrowsAsync <ArgumentException>(async() => await httpClientWrapper.Send(HttpMethod.Post, new Uri(BaseUrl), null, stringContentToTest));
        }
コード例 #32
0
        private async Task DeleteAsync(string endpoint)
        {
            try
            {
                using (HttpClientWrapper client = new HttpClientWrapper(MixItUpAPIEndpoint))
                {
                    HttpResponseMessage response = await client.DeleteAsync(endpoint);

                    await this.ProcessResponseIfError(response);
                }
            }
            catch (Exception ex) { Logger.Log(ex); }
        }
コード例 #33
0
        public ActionResult RoleDeleteConfirmed(Guid businessid, Guid id)
        {
            using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
            {
                var responseMessage = httpClient.DeleteAsync("api/BusinessAPI/Business/" + businessid.ToString() + "/Role/" + id.ToString()).Result;
                responseMessage.EnsureSuccessStatusCode();
            }

            //Invalidate dependant cache item
            CacheManager.Instance.Remove(CacheManager.CACHE_KEY_BUSINESS + businessid.ToString());

            return(RedirectToAction("RoleIndex", new { businessid = businessid }));
        }
コード例 #34
0
        /// <summary>
        /// Adds a sink that sends log events using HTTP POST over the network.
        /// </summary>
        /// <param name="sinkConfiguration">The logger configuration.</param>
        /// <param name="authToken">The token for your logzio account.</param>
        /// <param name="type">Your log type - it helps classify the logs you send.</param>
        /// <param name="options">Logzio configuration options</param>
        /// <returns>Logger configuration, allowing configuration to continue.</returns>
        public static LoggerConfiguration LogzIo(this LoggerSinkConfiguration sinkConfiguration, string authToken, string type, LogzioOptions options = null)
        {
            if (sinkConfiguration == null)
            {
                throw new ArgumentNullException(nameof(sinkConfiguration));
            }

            var client = new HttpClientWrapper();
            var sink   = new LogzioSink(client, authToken, type, options ?? new LogzioOptions());
            var restrictedToMinimumLevel = options?.RestrictedToMinimumLevel ?? LogEventLevel.Verbose;

            return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel));
        }
コード例 #35
0
        public ActionResult Search(EmployerSearchDTO searchData)
        {
            if (ModelState.IsValid)
            {
                using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
                {
                    HttpResponseMessage response = httpClient.PostAsJsonAsync("api/EmployerAPI/SearchBusinesses", searchData).Result;
                    searchData = JsonConvert.DeserializeObject <EmployerSearchDTO>(response.Content.ReadAsStringAsync().Result);
                }
            }

            return(PartialView(searchData));
        }
コード例 #36
0
        public CenturyLinkCloudServiceFactory(string username, string password, Uri proxyUri)
        {
            var serializerSettings = new JsonSerializerSettings
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver(),
                Converters = new List<JsonConverter> { new StringEnumConverter{CamelCaseText = true}}
            };

            var authProviderClient = HttpClientFactory.Create(new JsonMediaTypeHandler());
            var authProviderWrapper = new HttpClientWrapper(authProviderClient, serializerSettings);
            _authenticationProvider = new AuthenticationProvider(username, password, authProviderWrapper);

            var authHandler = new AuthenticationHandler(_authenticationProvider);
            var authorizedClient = HttpClientFactory.Create(authHandler, new JsonMediaTypeHandler());

            authProviderClient.BaseAddress = authorizedClient.BaseAddress = proxyUri;

            _clientWrapper = new HttpClientWrapper(authorizedClient, serializerSettings);
        }
コード例 #37
0
 public void CreatesNewHttpClientWhenNotSupplied()
 {
     var wrapper = new HttpClientWrapper();
     Assert.IsNotNull(wrapper.Client);
 }
コード例 #38
0
        public void Setup()
        {
            _innerHandler = new Mock<HttpClientHandler>();
            _innerClient = new HttpClient(_innerHandler.Object) {BaseAddress = new Uri(BaseAddress)};
            _serializerSettings = new JsonSerializerSettings{ContractResolver = new CamelCasePropertyNamesContractResolver()};

            _testObject = new HttpClientWrapper(_innerClient, _serializerSettings);
        }