/// <inheritdoc />
public Task <IGetResponse <T> > GetAsync <T>(IGetRequest getRequest) where T : class
{
return(this.DispatchAsync <IGetRequest, GetRequestParameters, GetResponse <T>, IGetResponse <T> >(
getRequest,
(p, d) => this.RawDispatch.GetDispatchAsync <GetResponse <T> >(p)
));
}
/// <inheritdoc />
public IGetResponse <T> Get <T>(IGetRequest getRequest) where T : class
{
return(this.Dispatch <IGetRequest, GetRequestParameters, GetResponse <T> >(
getRequest,
(p, d) => this.RawDispatch.GetDispatch <GetResponse <T> >(p)
));
}
/// <inheritdoc />
public Task <IGetResponse <T> > GetAsync <T>(IGetRequest request, CancellationToken cancellationToken = default(CancellationToken))
where T : class =>
Dispatcher.DispatchAsync <IGetRequest, GetRequestParameters, GetResponse <T>, IGetResponse <T> >(
request,
cancellationToken,
(p, d, c) => LowLevelDispatch.GetDispatchAsync <GetResponse <T> >(p, c)
);
protected static async ValueTask <T> GetAsync <T>(IGetRequest request, JsonSerializerOptions options)
{
using var client = CreateClient();
using var resp = await client.GetAsync(request.Host);
var json = await JsonSerializer.DeserializeAsync <T>(await resp.Content.ReadAsStreamAsync(), options);
return(json);
}
public async Task <T> Get <T>(IGetRequest <T> method)
{
HttpResponseMessage response = await _client.GetAsync(_uri + method.Path);
if (response.IsSuccessStatusCode)
{
using (var stream = await response.Content.ReadAsStreamAsync())
{
return(method.Deserialize(stream));
}
}
else
{
return(default(T));
}
}
public Task <Either <TFailedRequest, Response <TResponseData> > > GetAsync <TFailedRequest, TResponseData>(
IGetRequest <TResponseData> request, Option <string> oAuthAccessToken,
Func <string, ICustomJsonSerialiser, HttpResponseInfo, Either <TFailedRequest, Response <TResponseData> > >
responseHandler)
{
var requestOptions = new HttpRequestOptions
{
AcceptHeader = "application/json",
Url = request.Url
};
SetToken(requestOptions, oAuthAccessToken);
_log.Debug($"Getting: '{requestOptions.Url}'");
var response = _httpClient.GetResponse(requestOptions);
return(response.Map(r => ApplyResponseHandler(responseHandler, r)));
}
/// <inheritdoc />
public IGetResponse <T> Get <T>(IGetRequest request) where T : class =>
Dispatcher.Dispatch <IGetRequest, GetRequestParameters, GetResponse <T> >(
request,
(p, d) => LowLevelDispatch.GetDispatch <GetResponse <T> >(p)
);
public T Get <T>(IGetRequest request) where T : IResponse
{
return(restCaller.Get <T>(request.GetUri()));
}
public override Response <T> Get <T>(IGetRequest request)
{
return(null);
}
/// <inheritdoc cref="INetworkConnector.SendMessageAsync{TMessage}(TMessage, CancellationToken)"/>
public async Task SendMessageAsync <TMessage>(TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
try
{
if (!IsRunning)
{
throw new NetworkConnectorIsNotYetStartedException("NetworkConnector has not started yet. Call Start() first");
}
if (!(Attribute.GetCustomAttribute(message.GetType(), typeof(MessageAttribute)) is MessageAttribute messageAttribute))
{
throw new InvalidMessageException("Invalid message");
}
HttpRequestMessage httpRequestMessage = null;
string httpClientBaseAddress = _httpClient.BaseAddress + messageAttribute.Path;
httpRequestMessage = messageAttribute.OriginalMethod switch
{
"GetAll" =>
new HttpRequestMessage(messageAttribute.Method, httpClientBaseAddress),
"Get" when message is IGetRequest getRequest =>
new HttpRequestMessage(messageAttribute.Method, $"{httpClientBaseAddress}{getRequest.GetId}"),
"Get" when message is PaginationRequest paginationRequest =>
new HttpRequestMessage(messageAttribute.Method, $"{httpClientBaseAddress}{paginationRequest.PageNumber}/{paginationRequest.PageSize}"),
_ =>
new HttpRequestMessage(messageAttribute.Method, httpClientBaseAddress)
{
Content = new StringContent(_messageSerializer.SerializeToString(message), Encoding.UTF8, $"application/{_messageSerializer.SerializerType}")
}
};
httpRequestMessage.Headers.Add("Request-Id", message.Id.ToString());
HttpResponseMessage response = await _httpClient.SendAsync(httpRequestMessage, cancellationToken);
_logger.LogInformation($"REST RESPONSE: {await response.Content.ReadAsStringAsync()}");
byte[] bytes = await response.Content.ReadAsByteArrayAsync();
object msg = null;
if (messageAttribute.OriginalMethod == "GetAll" || message is IPaginationRequest)
{
msg = Activator.CreateInstance(messageAttribute.ResponseType);
PropertyInfo property = messageAttribute.ResponseType.GetProperties()
.Where(p => p.PropertyType.GenericTypeArguments.Length != 0)
.Where(p => p.PropertyType.GenericTypeArguments[0] != typeof(char))
.Single(info => info.PropertyType.GetInterfaces().Count(c => c == typeof(IEnumerable)) == 1);
object e = _messageSerializer.Deserialize(bytes, property.PropertyType);
property.SetValue(msg, e);
}
else
{
msg = _messageSerializer.Deserialize(bytes, !response.IsSuccessStatusCode ? typeof(RestErrorResponse) : messageAttribute.ResponseType);
}
switch (msg)
{
case IPaginationResponse paginationResponse:
paginationResponse.RequestId = message.Id;
paginationResponse.DateTime = DateTime.UtcNow;
paginationResponse.Success = true;
paginationResponse.PageNumber = GetIntegerHeaderValue("X-Paging-PageNumber");
paginationResponse.PageSize = GetIntegerHeaderValue("X-Paging-PageSize");
paginationResponse.PageCount = GetIntegerHeaderValue("X-Paging-PageCount");
paginationResponse.TotalRecords = GetIntegerHeaderValue("X-Paging-TotalRecordCount");
await _messageProcessor.ProcessMessageAsync(paginationResponse, this);
break;
case IResponseMessage responseMessage:
{
if (responseMessage.RequestId != message.Id)
{
responseMessage.RequestId = message.Id;
responseMessage.DateTime = DateTime.UtcNow;
responseMessage.Success = true;
}
await _messageProcessor.ProcessMessageAsync(responseMessage, this);
break;
}
default:
{
ErrorResponse errorResponse = new ErrorResponse
{
Id = Guid.NewGuid(),
RequestId = message.Id,
RequestName = message.GetType().FullName,
ResponseName = messageAttribute.ResponseType.FullName,
DateTime = DateTime.UtcNow,
Success = false,
Message = msg is RestErrorResponse restErrorResponse
? restErrorResponse.title
: "Unknown error."
};
await _messageProcessor.ProcessMessageAsync(errorResponse, this);
_logger.LogError($"REST API error: {errorResponse}");
break;
}
}
int GetIntegerHeaderValue(string headerName) => int.Parse(response.Headers.First(header => header.Key == headerName).Value.First());
}
catch (Exception e)
{
_logger.LogError(e.Message, "The HttpNetworkConnector failed to send a message.");
}
}
public void Foo(IGetRequest r)
{
}
public Task <GetResponse <TDocument> > GetAsync <TDocument>(IGetRequest request, CancellationToken ct = new CancellationToken()) where TDocument : class
{
throw new NotImplementedException();
}
public Task <TResponse> GetAsync <TResponse>(IGetRequest <TResponse> request)
{
throw new NotImplementedException();
}
// Requests
/// <summary>
/// Known issue - MusicInfo object sometimes returning as an empty array: https://what.cd/forums.php?action=viewthread&threadid=169790
/// </summary>
/// <param name="options">Object that inherits IGetRequest</param>
/// <returns>Request object</returns>
public Request GetRequest(IGetRequest options)
{
StringBuilder Query = new StringBuilder();
Query.Append("ajax.php?action=request");
Query.Append(string.Format("&id={0}", options.RequestID));
if (options.CommentPage != null && options.CommentPage > 0) Query.Append(string.Format("&page={0}", options.CommentPage));
string Json = RequestJson(this.RootWhatCDURI, Query.ToString());
return JsonConvert.DeserializeObject<Request>(Json);
}
/// <inheritdoc/>
public IGetResponse <T> Get <T>(IGetRequest request) where T : class =>
this.Dispatcher.Dispatch <IGetRequest, GetRequestParameters, GetResponse <T> >(
request,
(r, s) => DeserializeGetResponse <T>(s),
(p, d) => this.LowLevelDispatch.GetDispatch <GetResponse <T> >(p)
);
/// <inheritdoc /> public GetResponse <TDocument> Get <TDocument>(IGetRequest request) where TDocument : class => DoRequest <IGetRequest, GetResponse <TDocument> >(request, request.RequestParameters);
/// <inheritdoc />
public Task <GetResponse <TDocument> > GetAsync <TDocument>(IGetRequest request, CancellationToken ct = default)
where TDocument : class =>
DoRequestAsync <IGetRequest, GetResponse <TDocument> >(request, request.RequestParameters, ct);
protected static async ValueTask <TResult> GetAsync <TResult, TEncodedResponse>(IGetRequest request, JsonSerializerOptions options) where TEncodedResponse : IEncodedResponse
{
using var client = CreateClient();
using var resp = await client.GetAsync(request.Host);
var content = await resp.Content.ReadAsStringAsync();
var json = await JsonSerializer.DeserializeAsync <TEncodedResponse>(await resp.Content.ReadAsStreamAsync(), IEncodedResponse.Options);
var result = JsonSerializer.Deserialize <TResult>(json.Decode(), options);
return(result);
}
public async Task <T> GetAsync <T>(IGetRequest request) where T : IResponse
{
return(await restCaller.GetAsync <T>(request.GetUri()));
}
public static void Update(ElasticsearchPathInfo <GetRequestParameters> pathInfo, IGetRequest request)
{
pathInfo.HttpMethod = PathInfoHttpMethod.GET;
}
private static Monad.Reader <Environment, Task <ApiResult <TResponse> > > Get <TResponse>(IGetRequest request, string route, IOption <AccessToken> token)
{
return(env =>
{
var queryString = request.ToQueryString().ToString();
var baseUri = env.HttpClient.BaseAddress;
var uriBuilder = new UriBuilder(baseUri)
{
Query = queryString,
Path = route
};
var endpoint = uriBuilder.Uri;
token.Match(t => env.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(t.Value));
var response = env.HttpClient.GetAsync(endpoint.PathAndQuery);
return response.Bind(r =>
{
var responseContent = r.Content.ReadAsStringAsync();
return responseContent.Map(c => r.IsSuccessStatusCode
? Success(JsonConvert.DeserializeObject <TResponse>(c))
: Error <TResponse>(JsonConvert.DeserializeObject <ApiError>(c))
);
});
});
}
public void Get(IGetRequest r)
{
}
public Task <Either <FailedRequest, Response <TResponseData> > > GetAsync <TResponseData>(
IGetRequest <TResponseData> request, Option <string> oAuthAccessToken)
{
return(GetAsync(request, oAuthAccessToken, ParseResponse <TResponseData>));
}
public GetResponse <TDocument> Get <TDocument>(IGetRequest request) where TDocument : class
{
throw new NotImplementedException();
}
/// <inheritdoc/>
public Task <IGetResponse <T> > GetAsync <T>(IGetRequest request) where T : class =>
this.Dispatcher.DispatchAsync <IGetRequest, GetRequestParameters, GetResponse <T>, IGetResponse <T> >(
request,
(p, d) => this.LowLevelDispatch.GetDispatchAsync <GetResponse <T> >(p)
);
// Requests
/// <summary>
/// Gets information about a specific request.
/// </summary>
/// <param name="options">Object that inherits IGetRequest</param>
/// <returns>JSON response deserialized into Request object</returns>
public WhatCD.Model.ActionRequest.Request GetRequest(IGetRequest options)
{
var builder = new QueryBuilder("ajax.php?action=request");
builder.Append("id", options.RequestID);
builder.Append("page", options.Page);
var json = _http.RequestJson(this.RootWhatCDUri, builder.Query.ToString());
return JsonConvert.DeserializeObject<WhatCD.Model.ActionRequest.Request>(json, JsonSettings);
}
public RequestAdapter(IGetRequest getRequest)
{
this.getRequest = getRequest;
}
