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;
}
