public async Task <IPostResponse> SubmitLeadAsync(IPostRequest request)
{
var urlString = $"{SemServiceEndpoint}/Post?{request.ToQuerystring()}";
var xmlString = await new HttpClient().GetStringAsync(new Uri(urlString)).ConfigureAwait(false);
var postResponse = XmlConvert.DeserializeObject <PostResponse>(StripNamespacesFromPostResponseRoot(xmlString));
if (!postResponse.IsSuccess)
{
ErrorSignal.FromCurrentContext().Raise(new Exception($"SEMProxyService:SubmitLeadAsync - {postResponse.RejectedReason} | {request.ToQuerystring()}"));
}
return(postResponse);
}
protected static async ValueTask <T> PostAsync <T>(IPostRequest request, JsonSerializerOptions options)
{
using var client = CreateClient();
using var content = request.IsJson ? request.ToJson() : request.ToForm();
using var resp = await client.PostAsync(request.Host, content);
using var stream = await resp.Content.ReadAsStreamAsync();
if (stream.Length > 0)
{
var json = await JsonSerializer.DeserializeAsync <T>(stream, options);
return(json);
}
else
{
return(default);
public Task <Either <TFailedRequest, Response <TResponseData> > > PostAsync <TFailedRequest, TResponseData>(
IPostRequest <TResponseData> request, Option <string> oAuthAccessToken,
Func <string, ICustomJsonSerialiser, HttpResponseInfo, Either <TFailedRequest, Response <TResponseData> > >
responseHandler)
{
var requestOptions = new HttpRequestOptions
{
AcceptHeader = "application/json",
Url = request.Url,
RequestContent = _jsonSerialiser.Serialise(request.Data),
RequestContentType = "application/json"
};
SetToken(requestOptions, oAuthAccessToken);
_log.Debug($"Posting: '{requestOptions.RequestContent}' to '{requestOptions.Url}'");
var response = _httpClient.Post(requestOptions);
return(response.Map(r => ApplyResponseHandler(responseHandler, r)));
}
public async Task <TResponse> Handle(IPostRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next)
{
Domain.Entities.Post post = null;
try
{
post = await _blogContext.Posts
.Find(d => d.Id == request.PostId)
.FirstOrDefaultAsync(cancellationToken);
}
catch (FormatException)
{
ThrowEntityDoesNotExistsException(request);
}
if (post == null)
{
ThrowEntityDoesNotExistsException(request);
}
var response = await next();
return(response);
}
public async Task <TraktPagedResponse <TResponseContentType> > ExecutePagedRequestAsync <TResponseContentType, TRequestBodyType>(IPostRequest <TResponseContentType, TRequestBodyType> request, CancellationToken cancellationToken = default) where TRequestBodyType : IRequestBody
{
ValidateRequest(request);
ExtendedHttpRequestMessage requestMessage = await _requestMessageBuilder.Reset(request).WithRequestBody(request.RequestBody).Build(cancellationToken).ConfigureAwait(false);
return(await QueryPagedListAsync <TResponseContentType>(requestMessage, cancellationToken).ConfigureAwait(false));
}
public Task <TResponse> PostAsync <TResponse>(IPostRequest <TResponse> request)
{
throw new NotImplementedException();
}
private async Task <TraktResponse <ITraktAuthorization> > ExecuteAuthorizationRequestAsync <TRequestBodyType>(IPostRequest <ITraktAuthorization, TRequestBodyType> request, bool isRefreshRequest, CancellationToken cancellationToken = default) where TRequestBodyType : IRequestBody
{
try
{
request.Validate();
ExtendedHttpRequestMessage requestMessage =
await _requestMessageBuilder.Reset(request)
.WithRequestBody(request.RequestBody)
.DisableAPIVersionHeader()
.DisableAPIClientIdHeader()
.Build().ConfigureAwait(false);
HttpResponseMessage responseMessage = await _client.HttpClientProvider.GetHttpClient().SendAsync(requestMessage, cancellationToken).ConfigureAwait(false);
HttpStatusCode responseCode = responseMessage.StatusCode;
Stream responseContentStream;
if (responseCode == HttpStatusCode.OK)
{
responseContentStream = await ResponseMessageHelper.GetResponseContentStreamAsync(responseMessage).ConfigureAwait(false);
IObjectJsonReader <ITraktAuthorization> objectJsonReader = JsonFactoryContainer.CreateObjectReader <ITraktAuthorization>();
ITraktAuthorization traktAuthorization = await objectJsonReader.ReadObjectAsync(responseContentStream, cancellationToken).ConfigureAwait(false);
var response = new TraktResponse <ITraktAuthorization>()
{
Value = traktAuthorization,
HasValue = traktAuthorization != null,
IsSuccess = traktAuthorization != null
};
if (responseMessage.Headers != null)
{
ResponseHeaderParser.ParseResponseHeaderValues(response, responseMessage.Headers);
}
_client.Authentication.Authorization = traktAuthorization;
return(response);
}
else if (responseCode == HttpStatusCode.Unauthorized) // Invalid code
{
responseContentStream = await ResponseMessageHelper.GetResponseContentStreamAsync(responseMessage).ConfigureAwait(false);
IObjectJsonReader <ITraktError> objectJsonReader = JsonFactoryContainer.CreateObjectReader <ITraktError>();
ITraktError traktError = await objectJsonReader.ReadObjectAsync(responseContentStream, cancellationToken).ConfigureAwait(false);
var errorMessage = traktError != null ? ($"error on {(isRefreshRequest ? "refreshing" : "retrieving")} oauth access token\nerror: {traktError.Error}\ndescription: {traktError.Description}")
: "unknown error";
throw new TraktAuthenticationOAuthException(errorMessage)
{
StatusCode = responseCode,
RequestUrl = requestMessage.Url,
RequestBody = requestMessage.RequestBodyJson,
ServerReasonPhrase = responseMessage.ReasonPhrase
};
}
await ResponseErrorHandler.HandleErrorsAsync(requestMessage, responseMessage, isAuthorizationRequest : true, cancellationToken : cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
if (_client.Configuration.ThrowResponseExceptions)
{
throw;
}
return(new TraktResponse <ITraktAuthorization> {
IsSuccess = false, Exception = ex
});
}
return(new TraktResponse <ITraktAuthorization>());
}
public Task <Either <FailedRequest, Response <TResponseData> > > PostAsync <TResponseData>(
IPostRequest <TResponseData> request, Option <string> oAuthAccessToken)
{
return(PostAsync(request, oAuthAccessToken, ParseResponse <TResponseData>));
}
public async Task <T> PostAsync <T>(IPostRequest request) where T : IResponse
{
return(await restCaller.PostAsync <T>(request.GetUri(), request.GetPostContent()));
}
public T Post <T>(IPostRequest request) where T : IResponse
{
return(restCaller.Post <T>(request.GetUri(), request.GetPostContent()));
}
private static void ThrowEntityDoesNotExistsException(IPostRequest request)
{
throw new EntityDoesNotExistsException($"The post with id {request.PostId} does not exist.");
}
public RequestAdapter(IPostRequest postRequest)
{
this.postRequest = postRequest;
}
