public async Task <EntryResponse> ExecuteAsync(EntryRequest interaction)
{
if (interaction == null)
{
throw Error.ArgumentNull(nameof(interaction));
}
bool compressRequestBody = Settings.CompressRequestBody;
using var requestMessage = interaction.ToHttpRequestMessage(BaseUrl, Settings);
if (Settings.PreferCompressedResponses)
{
requestMessage.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
requestMessage.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
}
byte[] outgoingBody = null;
if (requestMessage.Method == HttpMethod.Post || requestMessage.Method == HttpMethod.Put)
{
outgoingBody = await requestMessage.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
}
using var response = await Client.SendAsync(requestMessage).ConfigureAwait(false);
try
{
var body = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
LastResult = response.ToEntryResponse(body);
return(LastResult);
}
catch (AggregateException ae)
{
throw ae.GetBaseException();
}
}
public async Task <EntryResponse> ExecuteAsync(EntryRequest interaction)
{
if (interaction == null)
{
throw Error.ArgumentNull(nameof(interaction));
}
bool compressRequestBody = false;
var request = interaction.ToHttpWebRequest(BaseUrl, Settings);
#if !NETSTANDARD1_6
request.Timeout = Settings.Timeout;
#endif
if (Settings.PreferCompressedResponses)
{
request.Headers["Accept-Encoding"] = "gzip, deflate";
}
BeforeRequest?.Invoke(request, interaction.RequestBodyContent);
// Write the body to the output
if (interaction.RequestBodyContent != null)
{
request.WriteBody(compressRequestBody, interaction.RequestBodyContent);
}
// Make sure the HttpResponse gets disposed!
using (HttpWebResponse webResponse = (HttpWebResponse)await request.GetResponseAsync(TimeSpan.FromMilliseconds(Settings.Timeout)).ConfigureAwait(false))
{
try
{
//Read body before we call the hook, so the hook cannot read the body before we do
var inBody = readBody(webResponse);
AfterResponse?.Invoke(webResponse, inBody);
return(webResponse.ToEntryResponse(inBody));
}
catch (AggregateException ae)
{
throw ae.GetBaseException();
}
}
}
public static HttpRequestMessage ToHttpRequestMessage(this EntryRequest entry, Uri baseUrl, FhirClientSettings settings)
{
System.Diagnostics.Debug.WriteLine("{0}: {1}", entry.Method, entry.Url);
if (entry.RequestBodyContent != null && !(entry.Method == HTTPVerb.POST || entry.Method == HTTPVerb.PUT))
{
throw Error.InvalidOperation("Cannot have a body on an Http " + entry.Method.ToString());
}
// Create an absolute uri when the interaction.Url is relative.
var uri = new Uri(entry.Url, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
uri = HttpUtil.MakeAbsoluteToBase(uri, baseUrl);
}
var location = new RestUrl(uri);
if (settings.UseFormatParameter)
{
location.AddParam(HttpUtil.RESTPARAM_FORMAT, ContentType.BuildFormatParam(settings.PreferredFormat));
}
var request = new HttpRequestMessage(getMethod(entry.Method), location.Uri);
request.Headers.Add("User-Agent", ".NET FhirClient for FHIR " + entry.Agent);
if (!settings.UseFormatParameter)
{
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(ContentType.BuildContentType(settings.PreferredFormat, forBundle: false)));
}
if (entry.Headers.IfMatch != null)
{
request.Headers.Add("If-Match", entry.Headers.IfMatch);
}
if (entry.Headers.IfNoneMatch != null)
{
request.Headers.Add("If-None-Match", entry.Headers.IfNoneMatch);
}
if (entry.Headers.IfModifiedSince != null)
{
request.Headers.IfModifiedSince = entry.Headers.IfModifiedSince.Value.UtcDateTime;
}
if (entry.Headers.IfNoneExist != null)
{
request.Headers.Add("If-None-Exist", entry.Headers.IfNoneExist);
}
var interactionType = entry.Type;
bool canHaveReturnPreference() => entry.Type == InteractionType.Create ||
entry.Type == InteractionType.Update ||
entry.Type == InteractionType.Patch;
if (canHaveReturnPreference() && settings.PreferredReturn != null)
{
if (settings.PreferredReturn == Prefer.RespondAsync)
{
request.Headers.Add("Prefer", PrimitiveTypeConverter.ConvertTo <string>(settings.PreferredReturn));
}
else
{
request.Headers.Add("Prefer", "return=" + PrimitiveTypeConverter.ConvertTo <string>(settings.PreferredReturn));
}
}
else if (interactionType == InteractionType.Search && settings.PreferredParameterHandling != null)
{
List <string> preferHeader = new List <string>();
if (settings.PreferredParameterHandling.HasValue)
{
preferHeader.Add("handling=" + settings.PreferredParameterHandling.GetLiteral());
}
if (settings.PreferredReturn.HasValue && settings.PreferredReturn == Prefer.RespondAsync)
{
preferHeader.Add(settings.PreferredReturn.GetLiteral());
}
if (preferHeader.Count > 0)
{
request.Headers.Add("Prefer", string.Join(", ", preferHeader));
}
}
if (entry.RequestBodyContent != null)
{
setContentAndContentType(request, entry.RequestBodyContent, entry.ContentType, settings.PreferredFormat);
}
return(request);
}
public static HttpWebRequest ToHttpWebRequest(this EntryRequest entry, Uri baseUrl, FhirClientSettings settings)
{
System.Diagnostics.Debug.WriteLine("{0}: {1}", (object)entry.Method, (object)entry.Url);
if (entry.RequestBodyContent != null && !(entry.Method == HTTPVerb.POST || entry.Method == HTTPVerb.PUT))
{
throw Error.InvalidOperation((string)("Cannot have a body on an Http " + entry.Method.ToString()));
}
// Create an absolute uri when the interaction.Url is relative.
var uri = new Uri(entry.Url, UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
uri = HttpUtil.MakeAbsoluteToBase(uri, baseUrl);
}
var location = new RestUrl(uri);
if (settings.UseFormatParameter)
{
location.AddParam(HttpUtil.RESTPARAM_FORMAT, ContentType.BuildFormatParam(settings.PreferredFormat));
}
var request = (HttpWebRequest)HttpWebRequest.Create(location.Uri);
request.Method = entry.Method.ToString();
setAgent(request, ".NET FhirClient for FHIR " + entry.Agent);
if (!settings.UseFormatParameter)
{
request.Accept = ContentType.BuildContentType(settings.PreferredFormat, forBundle: false);
}
request.ContentType = entry.ContentType ?? ContentType.BuildContentType(settings.PreferredFormat, forBundle: false);
if (entry.Headers.IfMatch != null)
{
request.Headers["If-Match"] = entry.Headers.IfMatch;
}
if (entry.Headers.IfNoneMatch != null)
{
request.Headers["If-None-Match"] = entry.Headers.IfNoneMatch;
}
#if NETSTANDARD1_1
if (entry.Headers.IfModifiedSince != null)
{
request.Headers["If-Modified-Since"] = entry.Headers.IfModifiedSince.Value.UtcDateTime.ToString();
}
#else
if (entry.Headers.IfModifiedSince != null)
{
request.IfModifiedSince = entry.Headers.IfModifiedSince.Value.UtcDateTime;
}
#endif
if (entry.Headers.IfNoneExist != null)
{
request.Headers["If-None-Exist"] = entry.Headers.IfNoneExist;
}
if (canHaveReturnPreference() && settings.PreferredReturn.HasValue)
{
if (settings.PreferredReturn == Prefer.RespondAsync)
{
request.Headers["Prefer"] = PrimitiveTypeConverter.ConvertTo <string>(settings.PreferredReturn);
}
else
{
request.Headers["Prefer"] = "return=" + PrimitiveTypeConverter.ConvertTo <string>(settings.PreferredReturn);
}
}
else if (entry.Type == InteractionType.Search)
{
List <string> preferHeader = new List <string>();
if (settings.PreferredParameterHandling.HasValue)
{
preferHeader.Add("handling=" + settings.PreferredParameterHandling.GetLiteral());
}
if (settings.PreferredReturn.HasValue && settings.PreferredReturn == Prefer.RespondAsync)
{
preferHeader.Add(settings.PreferredReturn.GetLiteral());
}
if (preferHeader.Count > 0)
{
request.Headers["Prefer"] = string.Join(", ", preferHeader);
}
}
bool canHaveReturnPreference() => entry.Type == InteractionType.Create ||
entry.Type == InteractionType.Update ||
entry.Type == InteractionType.Patch;
// PCL doesn't support setting the length (and in this case will be empty anyway)
#if !NETSTANDARD1_1
if (entry.RequestBodyContent == null)
{
request.ContentLength = 0;
}
#endif
return(request);
}
public EntryResponse Execute(EntryRequest interaction)
{
return(ExecuteAsync(interaction).WaitResult());
}
