public MatchSummaryRepository(IClientBuilder httpClientBuilder, IHttpClientRequest httpClientRequest, IGenericRepository <MatchSummary> genericMatchSummaryRepository, IGenericRepository <MatchPlayerStats> genericMatchPlayerStatsRepository, IGenericRepository <TeamPlayer> genericTeamPlayerRepository, IGenericRepository <LiveMatchStatus> genericLiveMatchStatusRepository, ITeamRepository teamRepository, ITeamPlayerRepository teamPlayerRepository, IPlayerKillRepository playerKillRepository, ITeamLiveStatusRepository teamLiveStatusRepository, ILogger <PlayerKillRepository> logger, ICacheService cacheService) { _httpClientBuilder = httpClientBuilder; _httpClientRequest = httpClientRequest; _genericMatchSummaryRepository = genericMatchSummaryRepository; _genericMatchPlayerStatsRepository = genericMatchPlayerStatsRepository; _genericTeamPlayerRepository = genericTeamPlayerRepository; _genericLiveMatchStatusRepository = genericLiveMatchStatusRepository; _teamRepository = teamRepository; _teamPlayerRepository = teamPlayerRepository; _playerKillRepository = playerKillRepository; _teamLiveStatusRepository = teamLiveStatusRepository; _logger = logger; _cacheService = cacheService; postMatchWaitingCount = 0; }
public MatchManagementRepository(IGenericRepository <Event> tournamentRepository, IClientBuilder httpClientBuilder, IHttpClientRequest httpClientRequest, IGenericRepository <LiveEventKill> liveEventKillRepository, IGenericRepository <MatchRanking> matchRankingRepository, IGenericRepository <Kill> killRepostiory, IGenericRepository <EventDamage> eventDamageRepository, IGenericRepository <LiveMatchStatus> liveMatchStatusRepository, IGenericRepository <MatchPlayerStats> matchPlayerStatsRepository, IGenericRepository <MatchSafeZone> matchSafeZoneRepository, IGenericRepository <CreatePlayer> createPlayerRepository, IGenericRepository <PlayerPoition> playerPositionRepository, IGenericRepository <TeamRanking> teamRankingRepository, IGenericRepository <VehicleLeave> vehicleLeaveRepository, IGenericRepository <ParachuteLanding> parachuteLandingRepository, IGenericRepository <EventLiveMatchStatus> eventMatchStatusRepository, IGenericRepository <DeskSeatingPosition> deskPositionRepository, ILogger <MatchManagementRepository> logger) { _tournamentRepository = tournamentRepository; _httpClientBuilder = httpClientBuilder; _httpClientRequest = httpClientRequest; _liveEventKillRepository = liveEventKillRepository; _matchRankingRepository = matchRankingRepository; _killRepostiory = killRepostiory; _eventDamageRepository = eventDamageRepository; _liveMatchStatusRepository = liveMatchStatusRepository; _matchPlayerStatsRepository = matchPlayerStatsRepository; _matchSafeZoneRepository = matchSafeZoneRepository; _createPlayerRepository = createPlayerRepository; _playerPositionRepository = playerPositionRepository; _teamRankingRepository = teamRankingRepository; _vehicleLeaveRepository = vehicleLeaveRepository; _parachuteLandingRepository = parachuteLandingRepository; _eventMatchStatusRepository = eventMatchStatusRepository; _deskPositionRepository = deskPositionRepository; _logger = logger; }
public virtual async Task <T> SearchWithCriteriaAsync(string index, ICriteria criteria, IResultFilter filter, CancellationToken cancellationToken = default(CancellationToken)) { IHttpClientRequest request = CreateRequest(index, "POST", criteria.RawQuery, filter); IHttpClientResponse <T> response = await _client.ExecuteAsync <T>(request, cancellationToken).ConfigureAwait(false); return(response.ResponseData); }
public Then ThenShould <TResponse>(IHttpClientRequest <TResponse> response, params Expression <Func <TResponse, bool> >[] assertions) { _assertions.Add(new AsyncAssertion <TResponse>(() => Send(response), assertions)); return(this); }
public T SearchWithCriteria(string index, ICriteria criteria, IResultFilter filter) { IHttpClientRequest request = CreateRequest(index, "POST", criteria.RawQuery, filter); IHttpClientResponse <T> response = _client.Execute <T>(request); return(response.ResponseData); }
public virtual async Task <T> SearchByIdAsync(string index, string id, CancellationToken cancellationToken = default(CancellationToken)) { IHttpClientRequest request = CreateRequest(index, "GET", null, null); request.Path = $"/v1/search/{index}/{id}"; IHttpClientResponse <T> response = await _client.ExecuteAsync <T>(request, cancellationToken); return(response.ResponseData); }
public virtual T SearchById(string index, string id) { IHttpClientRequest request = CreateRequest(index, "GET", null, null); request.Path = $"/v1/search/{index}/{id}"; IHttpClientResponse <T> response = _client.Execute <T>(request); return(response.ResponseData); }
public override IHttpClientResponse <T> Execute <T>(IHttpClientRequest request) { T deserialized = Deserialize <T>(_responseData, _contentType, request.Binder, request.Convertors); return(new HttpClientResponse <T> { ContentType = _contentType, ResponseData = deserialized }); }
/// <summary> /// Add OAuth headers to http request. /// <remarks> /// The CIL TokenProvider implementation handles aquiring/refreshing tokens from the /// token service so we can be sure that on call to this our OAuth token is valid. /// </remarks> /// </summary> /// <param name="request">Http Request</param> public void ApplyManualAuthentication(IHttpClientRequest request) { // no token provider means no need to add OAuth token if (_tokenProvider == null) { return; } request.Headers.Add( DiscoveryServiceProvider.DefaultTokenProvider.AuthRequestHeaderName, DiscoveryServiceProvider.DefaultTokenProvider.AuthRequestHeaderValue); }
public void ApplyManualAuthentication(IHttpClientRequest request) { // manually add authentication to request if (string.IsNullOrEmpty(Username) || string.IsNullOrEmpty(Password)) { return; } // add basic http auth to request headers request.Headers.Add("Authorization", $"Basic {Convert.ToBase64String(Encoding.Default.GetBytes($"{Username}:{Password}"))}"); }
public virtual async Task <IHttpClientResponse <T> > ExecuteAsync <T>(IHttpClientRequest clientRequest, CancellationToken cancellationToken = default(CancellationToken)) { HttpWebRequest request = CreateHttpWebRequest(clientRequest); try { using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false)) { HttpWebResponse httpWebResponse = (HttpWebResponse)response; using (Stream responseStream = response.GetResponseStream()) { if (responseStream != null) { byte[] data = await ReadStreamAsync(responseStream, cancellationToken).ConfigureAwait(false); LogErrorResponse(data); T deserialized = await Task.Factory.StartNew( () => Deserialize <T>(data, httpWebResponse.ContentType, clientRequest.Binder, clientRequest.Convertors), cancellationToken).ConfigureAwait(false); return(new HttpClientResponse <T> { StatusCode = (int)httpWebResponse.StatusCode, ContentType = httpWebResponse.ContentType, Headers = new HttpHeaders(httpWebResponse.Headers), ResponseData = deserialized }); } } } } catch (WebException e) { Logger.Error(e, $"Failed to get http response from '{BaseUri}' with request: '{clientRequest}'"); byte[] data = ReadStream(e.Response.GetResponseStream()); throw new HttpClientException($"Failed to get http response from '{BaseUri}' with request: {clientRequest}", e, (int)e.Status, Encoding.UTF8.GetString(data)); } catch (Exception e) { Logger.Error(e, $"Failed to get http response from '{BaseUri}' with request: '{clientRequest}'"); throw new HttpClientException($"Failed to get http response from '{BaseUri}' with request: {clientRequest}", e); } Logger.Error($"Failed to get http response from '{BaseUri}' with request: '{clientRequest}'"); throw new HttpClientException($"Failed to get http response from '{BaseUri}' with request: {clientRequest}"); }
public RestRequestAdapter(IUriBuilder uriBuilder, IHttpClientRequest httpClientRequest) { if (uriBuilder == null) { throw new ArgumentNullException("uriBuilder"); } if (httpClientRequest == null) { throw new ArgumentNullException("httpClientRequest"); } _uriBuilder = uriBuilder; _httpClientRequest = httpClientRequest; }
public TelemetryRepository(IClientBuilder httpClientBuilder, IHttpClientRequest httpClientRequest, IGenericRepository <Kill> genericRepository, IPlayerKillRepository playerKillRepository, ITakeDamageRepository takeDamageRepository, IPlayerRepository playerVehicleLeaveRepository, IMatchSummaryRepository matchSummaryRepository, ILogger <PlayerKillRepository> logger) { _httpClientBuilder = httpClientBuilder; _httpClientRequest = httpClientRequest; _genericRepository = genericRepository; _playerKillRepository = playerKillRepository; _takeDamageRepository = takeDamageRepository; _playerVehicleLeaveRepository = playerVehicleLeaveRepository; _matchSummaryRepository = matchSummaryRepository; _logger = logger; }
public virtual IHttpClientResponse <T> Execute <T>(IHttpClientRequest clientRequest) { HttpWebRequest request = CreateHttpWebRequest(clientRequest); try { using (WebResponse response = request.GetResponse()) { HttpWebResponse httpWebResponse = (HttpWebResponse)response; using (Stream responseStream = response.GetResponseStream()) { if (responseStream != null) { byte[] data = ReadStream(responseStream); LogErrorResponse(data); T deserialized = Deserialize <T>(data, httpWebResponse.ContentType, clientRequest.Binder, clientRequest.Convertors); return(new HttpClientResponse <T> { StatusCode = (int)httpWebResponse.StatusCode, ContentType = httpWebResponse.ContentType, Headers = new HttpHeaders(httpWebResponse.Headers), ResponseData = deserialized }); } } } } catch (WebException e) { if (e.Response == null) { throw new HttpClientException(e.Message, e); } byte[] data = ReadStream(e.Response.GetResponseStream()); throw new HttpClientException( $"Failed to get http response from '{BaseUri}' with request: {clientRequest}", e, (int)e.Status, Encoding.UTF8.GetString(data)); } catch (Exception e) { throw new HttpClientException($"Failed to get http response from '{BaseUri}' with request: {clientRequest}", e); } throw new HttpClientException($"Failed to get http response from '{BaseUri}' with request: {clientRequest}"); }
public RestRequestConfiguration(IHttpClientRequest httpClientRequest, Uri url, TRequest data) { if (httpClientRequest == null) { throw new ArgumentNullException("httpClientRequest"); } if (url == null) { throw new ArgumentNullException("url"); } _httpClientRequest = httpClientRequest; _data = data; _url = url; }
public HttpClientRequest(IHttpClientRequest request) { AbsoluteUri = request.AbsoluteUri; Path = request.Path; Method = request.Method; ContentType = request.ContentType; Body = request.Body; QueryParameters = new HttpQueryParams(request.QueryParameters); if (request.Headers != null) { Headers = new HttpHeaders(request.Headers); } Authenticaton = request.Authenticaton; Binder = request.Binder; Convertors = request.Convertors; }
private Task <TResponse> Send <TResponse>(IHttpClientRequest <TResponse> context) { if (context == null) { throw new ArgumentNullException("context"); } HttpClient httpClient; if (false == _httpClients.TryGetValue(context.AuthorizationId, out httpClient)) { throw new InvalidOperationException( "No Authorization for '{0}' was found. You must set it up using WithUsers."); } return(context.Sender(httpClient, _messageExecutionSettings)); }
public MatchRepository(IClientBuilder httpClientBuilder, IHttpClientRequest httpClientRequest, IGenericRepository <Event> genericRepository, IGenericRepository <MatchSafeZone> matchSafeZoneRepository, IGenericRepository <MatchSummaryData> matchSummaryRepository, IGenericRepository <RankPoints> rankPointsRepository, ICacheService cacheService, ILogger <MatchRepository> logger) { _httpClientBuilder = httpClientBuilder; _httpClientRequest = httpClientRequest; _genericRepository = genericRepository; _logger = logger; _matchSafeZoneRepository = matchSafeZoneRepository; _matchSummaryRepository = matchSummaryRepository; _rankPointsRepository = rankPointsRepository; _cacheService = cacheService; }
protected virtual HttpWebRequest CreateHttpWebRequest(IHttpClientRequest clientRequest) { IHttpClientRequest requestCopy = new HttpClientRequest(clientRequest); requestCopy.Authenticaton = requestCopy.Authenticaton ?? _auth; Uri requestUri = requestCopy.BuildRequestUri(this); HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUri); request.Method = requestCopy.Method; request.Timeout = Timeout; request.ContentType = requestCopy.ContentType; request.UserAgent = UserAgent; request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate; requestCopy.Authenticaton?.ApplyManualAuthentication(requestCopy); request.Credentials = requestCopy.Authenticaton; foreach (var x in Headers) { request.Headers[x.Key] = x.Value?.ToString(); } foreach (var x in requestCopy.Headers) { request.Headers[x.Key] = x.Value?.ToString(); } if (requestCopy.Method != "POST") { return(request); } byte[] serialized = Serialize(requestCopy.Body, requestCopy.ContentType); using (Stream requestStream = request.GetRequestStream()) requestStream.Write(serialized, 0, serialized.Length); if (!Logger.IsTracingEnabled) { return(request); } Logger.Trace($"Performing Http Request:"); Logger.Trace($"[{request.Method}] {request.RequestUri}"); Logger.Trace($"[BODY] {requestCopy.Body}"); foreach (var x in request.Headers.AllKeys) { Logger.Trace($"[HEADER] {x}={request.Headers[x]}"); } return(request); }
public PlayerKillRepository(IClientBuilder httpClientBuilder, IHttpClientRequest httpClientRequest, IGenericRepository <Kill> genericRepository, IGenericRepository <CreatePlayer> genericPlayerRepository, IGenericRepository <LiveEventKill> genericLiveEventKillRepository, IGenericRepository <EventInfo> eventInfoRepository, IGenericRepository <MatchPlayerStats> genericMatchPlayerStatsRepository, IGenericRepository <TeamPlayer> genericTeamPlayerRepository, IGenericRepository <Team> team, IGenericRepository <TeamPlayer> teamPlayers, IPlayerRepository playerRepository, ITeamPlayerRepository teamPlayerRepository, IMatchRepository matchRepository, ITeamRepository teamRepository, IEventRepository eventRepository, ILogger <PlayerKillRepository> logger, IOptions <ApplicationSettings> settings, ICacheService cacheService, IAssetsRepository assetsRepository, ILiveRepository liveRepository) { _httpClientBuilder = httpClientBuilder; _httpClientRequest = httpClientRequest; _Kill = genericRepository; _CreatePlayer = genericPlayerRepository; _LiveEventKill = genericLiveEventKillRepository; _eventInfoRepository = eventInfoRepository; _playerRepository = playerRepository; _genericMatchPlayerStatsRepository = genericMatchPlayerStatsRepository; _genericTeamPlayerRepository = genericTeamPlayerRepository; _team = team; _teamPlayers = teamPlayers; _teamPlayerRepository = teamPlayerRepository; _matchRepository = matchRepository; _logger = logger; _teamRepository = teamRepository; _eventRepository = eventRepository; _cacheService = cacheService; _assetsRepository = assetsRepository; _liveRepository = liveRepository; _liveKilledCachedData = new List <KilliPrinter>(); }
protected virtual IHttpClientRequest CreateQueryParameters(IHttpClientRequest request, IResultFilter filter, string qtName) { if (qtName != null) { request.QueryParameters.Add(new KeyValuePair <string, object>(QueryConstants.ResultModel, qtName)); } if (filter == null) { return(request); } if (filter.ExcludeFields != null && filter.ExcludeFields.Count > 0) { request.QueryParameters.Add(QueryConstants.ExcludeFields, string.Join(",", filter.ExcludeFields.Select(x => x))); } if (filter.StartOfRange.HasValue) { request.QueryParameters.Add(QueryConstants.StartRange, filter.StartOfRange.Value); } if (filter.EndOfRange.HasValue) { request.QueryParameters.Add(QueryConstants.EndRange, filter.EndOfRange.Value); } if (filter.MaxResults.HasValue) { request.QueryParameters.Add(QueryConstants.MaxResults, filter.MaxResults.Value); } request.QueryParameters.Add(QueryConstants.Highlighting, filter.IsHighlightingEnabled); request.QueryParameters.Add(QueryConstants.HighlightInAll, filter.IsHighlightInAllEnabled); return(request); }
public HttpClientRequestAdapter(IHttpClientRequest request, IServiceNameProvider serviceNameProvider, ISpanNameProvider spanNameProvider) { this.request = request; this.serviceNameProvider = serviceNameProvider; this.spanNameProvider = spanNameProvider; }
public Then When(IHttpClientRequest when) { _when = when; return(this); }
public override Task <IHttpClientResponse <T> > ExecuteAsync <T>(IHttpClientRequest request, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public ApiRequest(IHttpClientRequest httpRequest, IConfiguration configuration) { this.httpRequest = httpRequest; this.configuration = configuration; }