public async SystemTasks.Task <Resource> SupersedeWithoutValidation(FhirRequest request, string oldDocumentId, string oldVersionId)
{
UpdateDefinition <BsonDocument> updates = null;
FhirRequest updateRequest = null;
SetMetaValues(request);
BuildSupersede(oldDocumentId, oldVersionId, out updates, out updateRequest);
Resource created;
bool updated;
try
{
(created, updated) = await _fhirMaintain.CreateWithUpdate <DocumentReference>(request, updateRequest, updates);
}
catch
{
throw new HttpFhirException("Error Updating DocumentReference", OperationOutcomeFactory.CreateInternalError($"There has been an internal error when attempting to persist the DocumentReference. Please contact the national helpdesk quoting - {Guid.NewGuid()}"));
}
var response = created;
if (response == null)
{
response = OperationOutcomeFactory.CreateInvalidResource("Unknown");
}
if (!updated)
{
response = OperationOutcomeFactory.CreateInvalidResource("relatesTo");
}
return(response);
}
private OperationOutcome ValidateOrganisationInteraction(string asid, string orgCode, bool isProviderCheck)
{
var providerInteractions = new string[] { FhirConstants.CreateInteractionId, FhirConstants.UpdateInteractionId, FhirConstants.DeleteInteractionId };
var map = _cache.Get<ClientAsidMap>(ClientAsidMap.Key);
if (!string.IsNullOrEmpty(asid) && map != null && map.ClientAsids != null)
{
var asidMap = map.ClientAsids.FirstOrDefault(x => x.Key == asid);
if (asidMap.Value != null)
{
var valid = false;
if (!string.IsNullOrEmpty(orgCode) && !string.IsNullOrEmpty(asidMap.Value.OrgCode) && asidMap.Value.OrgCode == orgCode)
{
valid = true;
}
if(isProviderCheck && (asidMap.Value.Interactions == null || !asidMap.Value.Interactions.Any(x => providerInteractions.Contains(x))))
{
valid = false;
}
if (valid)
{
return null;
}
}
}
return OperationOutcomeFactory.CreateAccessDenied();
}
protected void ValidateResource(string resourceType)
{
if (_supportedResources.Any() && !_supportedResources.Contains(resourceType))
{
throw new HttpFhirException("Bad Request", OperationOutcomeFactory.CreateInvalidResourceType(resourceType), HttpStatusCode.BadRequest);
}
}
public async Task <Bundle> Find <T>(FhirRequest request, bool returnFirst) where T : Resource
{
ValidateResource(request.StrResourceType);
try
{
var query = _fhirSearchHelper.BuildQuery(request);
var resources = await _context.FindResource(request.StrResourceType, query).ToFhirListAsync <T>();
var bundle = _fhirSearchHelper.ToBundle <T>(request, resources);
if (returnFirst)
{
var entries = bundle.Entry;
bundle.Entry = entries.Take(1).ToList();
bundle.Total = 1;
}
return(bundle);
}
catch (Exception ex)
{
throw new HttpFhirException($"FhirSearch.Find | {ex.Message}", OperationOutcomeFactory.CreateInternalError(ex.Message), HttpStatusCode.BadRequest);
}
}
public void CreateDuplicate_Is_Valid()
{
var identifier = new Identifier("testsystem", "testvalue");
var actual = OperationOutcomeFactory.CreateDuplicateRequest(identifier);
Assert.IsType <OperationOutcome>(actual);
//Assert.NotNull(actual.Meta);
//Assert.NotNull(actual.Meta.Profile);
//Assert.NotEmpty(actual.Meta.Profile);
//Assert.Contains("https://fhir.nhs.uk/STU3/StructureDefinition/Spine-OperationOutcome-1-0", actual.Meta.Profile);
Assert.NotNull(actual.Issue);
Assert.NotEmpty(actual.Issue);
Assert.Equal("Duplicate masterIdentifier value: testvalue system: testsystem", actual.Issue.First().Diagnostics);
Assert.Equal(OperationOutcome.IssueType.Duplicate.ToString(), actual.Issue.First().Code.ToString());
Assert.Equal(OperationOutcome.IssueSeverity.Error.ToString(), actual.Issue.First().Severity.ToString());
Assert.NotNull(actual.Issue.First().Details);
Assert.NotNull(actual.Issue.First().Details.Coding);
Assert.NotEmpty(actual.Issue.First().Details.Coding);
Assert.Equal("DUPLICATE_REJECTED", actual.Issue.First().Details.Coding.First().Code);
Assert.Equal("Duplicate DocumentReference", actual.Issue.First().Details.Coding.First().Display);
}
public void CreateOrganizationNotFound_Is_Valid()
{
var actual = OperationOutcomeFactory.CreateOrganizationNotFound("testid");
//Base checks for all OperactionOutcomes
Assert.IsType <OperationOutcome>(actual);
//Assert.NotNull(actual.Meta);
//Assert.NotNull(actual.Meta.Profile);
//Assert.NotEmpty(actual.Meta.Profile);
//Assert.Contains("https://fhir.nhs.uk/STU3/StructureDefinition/Spine-OperationOutcome-1-0", actual.Meta.Profile);
Assert.NotNull(actual.Issue);
Assert.NotEmpty(actual.Issue);
Assert.NotNull(actual.Issue.First().Details);
Assert.NotNull(actual.Issue.First().Details.Coding);
Assert.NotEmpty(actual.Issue.First().Details.Coding);
//Specific OperationOutcome checks
Assert.Equal("The ODS code in the custodian and/or author element is not resolvable – testid.", actual.Issue.First().Diagnostics);
Assert.Equal(OperationOutcome.IssueType.NotFound.ToString(), actual.Issue.First().Code.ToString());
Assert.Equal(OperationOutcome.IssueSeverity.Error.ToString(), actual.Issue.First().Severity.ToString());
Assert.Equal("ORGANISATION_NOT_FOUND", actual.Issue.First().Details.Coding.First().Code);
Assert.Equal("Organisation record not found", actual.Issue.First().Details.Coding.First().Display);
Assert.Equal("https://fhir.nhs.uk/STU3/CodeSystem/Spine-ErrorOrWarningCode-1", actual.Issue.First().Details.Coding.First().System);
}
public void CreateDelete_Is_Valid()
{
var actual = OperationOutcomeFactory.CreateDelete("https://testdomain/testurl", "91370360-d667-4bc8-bebe-f223560ff90e");
Assert.IsType <OperationOutcome>(actual);
//Assert.NotNull(actual.Meta);
//Assert.NotNull(actual.Meta.Profile);
//Assert.NotEmpty(actual.Meta.Profile);
//Assert.Contains("https://fhir.nhs.uk/STU3/StructureDefinition/Spine-OperationOutcome-1-0", actual.Meta.Profile);
Assert.NotNull(actual.Issue);
Assert.NotEmpty(actual.Issue);
Assert.Equal("Successfully removed resource DocumentReference: https://testdomain/testurl", actual.Issue.First().Diagnostics);
Assert.Equal(OperationOutcome.IssueType.Informational.ToString(), actual.Issue.First().Code.ToString());
Assert.Equal(OperationOutcome.IssueSeverity.Information.ToString(), actual.Issue.First().Severity.ToString());
Assert.NotNull(actual.Issue.First().Details);
Assert.NotNull(actual.Issue.First().Details.Coding);
Assert.NotEmpty(actual.Issue.First().Details.Coding);
Assert.Equal("91370360-d667-4bc8-bebe-f223560ff90e", actual.Issue.First().Details.Text);
Assert.Equal("RESOURCE_DELETED", actual.Issue.First().Details.Coding.First().Code);
Assert.Equal("Resource removed", actual.Issue.First().Details.Coding.First().Display);
}
public void CreateInternalError_WithoutDiags_Is_Valid()
{
var actual = OperationOutcomeFactory.CreateInternalError(null);
//Base checks for all OperactionOutcomes
Assert.IsType <OperationOutcome>(actual);
//Assert.NotNull(actual.Meta);
//Assert.NotNull(actual.Meta.Profile);
//Assert.NotEmpty(actual.Meta.Profile);
//Assert.Contains("https://fhir.nhs.uk/STU3/StructureDefinition/Spine-OperationOutcome-1-0", actual.Meta.Profile);
Assert.NotNull(actual.Issue);
Assert.NotEmpty(actual.Issue);
Assert.NotNull(actual.Issue.First().Details);
Assert.NotNull(actual.Issue.First().Details.Coding);
Assert.NotEmpty(actual.Issue.First().Details.Coding);
//Specific OperationOutcome checks
Assert.Null(actual.Issue.First().Diagnostics);
Assert.Equal(OperationOutcome.IssueType.Invalid.ToString(), actual.Issue.First().Code.ToString());
Assert.Equal(OperationOutcome.IssueSeverity.Error.ToString(), actual.Issue.First().Severity.ToString());
Assert.Equal("INTERNAL_SERVER_ERROR", actual.Issue.First().Details.Coding.First().Code);
Assert.Equal("Unexpected internal server error", actual.Issue.First().Details.Coding.First().Display);
Assert.Equal("https://fhir.nhs.uk/STU3/CodeSystem/Spine-ErrorOrWarningCode-1", actual.Issue.First().Details.Coding.First().System);
}
public override SystemTask.Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context, Encoding encoding)
{
var request = context.HttpContext.Request;
using (var streamReader = context.ReaderFactory(request.Body, encoding))
using (JsonTextReader jsonReader = new JsonTextReader(streamReader))
{
var type = context.ModelType;
try
{
//TODO: parse json
//TODO: create a simple model to allow passthrough to validation because a missing element will throw wrong error here
var resource = new FhirJsonParser().Parse(jsonReader, type);
return(InputFormatterResult.SuccessAsync(resource));
}
catch (Exception ex)
{
//TODO: Remove Fhir Hack
if (ex != null)
{
//Assuming invalid json here, see above
return(InputFormatterResult.SuccessAsync(OperationOutcomeFactory.CreateInvalidRequest()));
}
return(InputFormatterResult.FailureAsync());
}
}
}
public OperationOutcome ValidateContent(List <DocumentReference.ContentComponent> contents)
{
//profile checker checks
// - has at least one content
// - has valid format
// - has valid contentStability extension
// - has 1 attachment
// - has valid creation date
// -
foreach (var content in contents)
{
//attachment.contentType
//TODO validate contenttype format
var contentType = content.Attachment.ContentType;
if (string.IsNullOrEmpty(contentType))
{
return(OperationOutcomeFactory.CreateInvalidResource("contenttype"));
}
//attachment.url
var url = content.Attachment.Url;
if (string.IsNullOrEmpty(url) || !FhirUri.IsValidValue(url))
{
return(OperationOutcomeFactory.CreateInvalidResource("url"));
}
}
return(null);
}
private OperationOutcome ValidateOrganisationInteraction(string asid, string orgCode, bool isProviderCheck)
{
var providerInteractions = new string[] { FhirConstants.CreateInteractionId, FhirConstants.UpdateInteractionId, FhirConstants.DeleteInteractionId };
var cache = _sdsService.GetFor(asid);
if (cache != null)
{
var valid = false;
if (!string.IsNullOrEmpty(orgCode) && !string.IsNullOrEmpty(cache.OdsCode) && cache.OdsCode == orgCode)
{
valid = true;
}
if (isProviderCheck && (cache.Interactions == null || !cache.Interactions.Any(x => providerInteractions.Contains(x))))
{
valid = false;
}
if (valid)
{
return(null);
}
}
return(OperationOutcomeFactory.CreateAccessDenied());
}
private async SystemTasks.Task <FhirResponse> Request(CommandRequest request)
{
var internalTraceId = Guid.NewGuid();
var fhirResponse = new FhirResponse();
var handler = _httpRequestHelper.GetClientHandler(request);
using (var client = new HttpClient(handler))
{
var httpRequest = _httpRequestHelper.GetRequestMessage(request);
//LogRequest(httpRequest, request.Resource, internalTraceId);
using (HttpResponseMessage res = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead))
using (HttpContent content = res.Content)
{
//res.EnsureSuccessStatusCode(); //will throw a HttpRequestException to catch in future
var mediaType = content.Headers.ContentType?.MediaType?.ToLowerInvariant();
if (res.Headers?.Location != null)
{
fhirResponse.ResponseLocation = res.Headers.Location;
}
//TODO: upgrade to core 2.2 and use IHttpClientFactory
// for delegate handling and retries policy
if (!string.IsNullOrEmpty(mediaType) && mediaType.Contains("fhir"))
{
fhirResponse = await ParseResource(content, request, fhirResponse);
}
else
{
fhirResponse = await ParseBinary(content, request, fhirResponse);
}
//get content from fhirResponse
//string responseMessage = null;
//LogResponse(res.Headers, (int)res.StatusCode, responseMessage, internalTraceId);
if (!res.IsSuccessStatusCode)
{
var diagnostics = $"{res.StatusCode} encountered for the URL {httpRequest.RequestUri.AbsoluteUri}";
var errorResource =
(fhirResponse.Resource.ResourceType != ResourceType.OperationOutcome) ?
OperationOutcomeFactory.CreateGenericError(diagnostics) :
fhirResponse.GetResource <OperationOutcome>();
throw new HttpFhirException("Request resulted in an error.", errorResource, res.StatusCode);
}
}
}
return(await SystemTasks.Task.Run(() => fhirResponse));
}
public OperationOutcome ValidateIdentifierParameter(string paramName, string parameterVal)
{
if (!_validationHelper.ValidTokenParameter(parameterVal, null, false))
{
return(OperationOutcomeFactory.CreateInvalidParameter("Invalid parameter", $"The given parameter {paramName} does not confirm to the expected format - [system]|[value]"));
}
return(null);
}
private void CheckRequestRequirements(HttpContext context)
{
var contentLength = context?.Request?.ContentLength;
var type = context?.Request?.Method;
if (new string[] { HttpMethods.Post, HttpMethods.Put }.Contains(type) && (!contentLength.HasValue || contentLength.Value == 0))
{
throw new HttpFhirException("Invalid Request", OperationOutcomeFactory.CreateInvalidRequest(), HttpStatusCode.BadRequest);
}
}
public OperationOutcome ValidSummaryParameter(string summary)
{
var allowedSummaries = new[] { "count" };
if (string.IsNullOrWhiteSpace(summary) || !allowedSummaries.Contains(summary.ToLowerInvariant()))
{
return(OperationOutcomeFactory.CreateInvalidParameter("Invalid parameter", $"Unsupported search parameter - _summary={summary}"));
}
return(null);
}
private OperationOutcome InvalidAsid(string orgCode, string asid)
{
var cache = _sdsService.GetFor(asid);
if (cache != null && !string.IsNullOrEmpty(orgCode) && !string.IsNullOrEmpty(cache.OdsCode) && cache.OdsCode == orgCode)
{
return(null);
}
return(OperationOutcomeFactory.CreateInvalidResource(FhirConstants.HeaderFromAsid, "The Custodian ODS code is not affiliated with the sender ASID."));
}
public async SystemTasks.Task <Resource> ValidateConditionalUpdate(FhirRequest request)
{
if (!request.Resource.ResourceType.Equals(ResourceType.DocumentReference))
{
return(OperationOutcomeFactory.CreateInvalidResource("relatesTo"));
}
var document = request.Resource as DocumentReference;
if (document.RelatesTo == null || document.RelatesTo.Count == 0)
{
return(null);
}
var relatesTo = _fhirValidation.GetValidRelatesTo(document.RelatesTo);
if (relatesTo.element == null)
{
return(OperationOutcomeFactory.CreateInvalidResource(relatesTo.issue));
}
//Subject already validated during ValidateCreate
//relatesTo Identifier already validated during ValidateCreate => validPointer
var subjectNhsNumber = _fhirValidation.GetSubjectReferenceId(document.Subject);
var pointerRequest = NrlsPointerHelper.CreateMasterIdentifierSearch(request, relatesTo.element.Target.Identifier, subjectNhsNumber);
var pointers = await _fhirSearch.Find <DocumentReference>(pointerRequest) as Bundle;
if (pointers.Entry.Count != 1)
{
//Cant find related document
return(OperationOutcomeFactory.CreateInvalidResource("relatesTo.target"));
}
//Custodian already validated against incoming ASID during ValidateCreate
var custodianOdsCode = _fhirValidation.GetOrganizationReferenceId(document.Custodian);
var oldDocument = pointers.Entry.First().Resource as DocumentReference;
if (oldDocument.Custodian == null || string.IsNullOrEmpty(oldDocument.Custodian.Reference) || oldDocument.Custodian.Reference != $"{FhirConstants.SystemODS}{custodianOdsCode}")
{
//related document does not have same custodian
return(OperationOutcomeFactory.CreateInvalidResource("relatesTo.target"));
}
if (oldDocument.Status != DocumentReferenceStatus.Current)
{
//Only allowed to transition to superseded from current
return(OperationOutcomeFactory.CreateInvalidResource("relatesTo.code"));
}
return(oldDocument);
}
public async SystemTasks.Task <Resource> CreateWithoutValidation(FhirRequest request)
{
SetMetaValues(request);
var response = await _fhirMaintain.Create <DocumentReference>(request);
if (response == null)
{
return(OperationOutcomeFactory.CreateInvalidResource("Unknown"));
}
return(response);
}
public async Task <IActionResult> Read(string id)
{
var request = FhirRequest.Create(id, ResourceType.Patient, null, Request, null);
var result = await _pdsSearch.Get(request);
if (result == null)
{
return(NotFound(OperationOutcomeFactory.CreateNotFound(id)));
}
return(Ok(result));
}
public async SystemTasks.Task Invoke(HttpContext context, IOptionsSnapshot <ApiSetting> nrlsApiSettings)
{
_nrlsApiSettings = nrlsApiSettings.Get("NrlsApiSetting");
//Order of validation is Important
var request = context.Request;
var headers = request.Headers;
var method = request.Method;
//Accept is optional but must be valid if supplied
//Check is delegated to FhirInputMiddleware
var authorization = GetHeaderValue(headers, HeaderNames.Authorization);
var scope = method == HttpMethods.Get ? JwtScopes.Read : JwtScopes.Write;
var jwtResponse = _nrlsValidation.ValidJwt(new Tuple <JwtScopes, string>(scope, "DocumentReference"), authorization);
if (string.IsNullOrEmpty(authorization) || !jwtResponse.Success)
{
SetJwtError(HeaderNames.Authorization, jwtResponse.Message);
}
var fromASID = GetHeaderValue(headers, FhirConstants.HeaderFromAsid);
var clientCache = _sdsService.GetFor(fromASID);
if (clientCache == null)
{
SetError(FhirConstants.HeaderFromAsid, null);
}
var toASID = GetHeaderValue(headers, FhirConstants.HeaderToAsid);
if (string.IsNullOrEmpty(toASID) || toASID != _spineSettings.Asid)
{
SetError(FhirConstants.HeaderToAsid, null);
}
var interactionId = GetInteractionId(method, request.Path.Value);
if (string.IsNullOrEmpty(interactionId) || !clientCache.Interactions.Contains(interactionId))
{
throw new HttpFhirException("Client interaction request invalid", OperationOutcomeFactory.CreateAccessDenied(), HttpStatusCode.Forbidden);
}
//We've Passed! Continue to App...
await _next.Invoke(context);
return;
}
public async SystemTasks.Task Invoke(HttpContext context, IOptionsSnapshot <ApiSetting> nrlsApiSettings)
{
CheckRequestRequirements(context);
_nrlsApiSettings = nrlsApiSettings.Get("NrlsApiSetting");
var formatKey = "_format";
var acceptKey = HeaderNames.Accept;
var parameters = context.Request.QueryString.Value.GetParameters();
bool hasFormatParam = parameters?.FirstOrDefault(x => x.Item1 == "_format") != null;
string formatParam = parameters != null?parameters.GetParameter(formatKey) : null;
string acceptHeader = null;
bool hasAcceptHeader = context.Request.Headers.ContainsKey(acceptKey);
if (hasAcceptHeader)
{
acceptHeader = context.Request.Headers[acceptKey];
}
var validFormatParam = !hasFormatParam || (!string.IsNullOrWhiteSpace(formatParam) && _nrlsApiSettings.SupportedContentTypes.Contains(formatParam));
var validAcceptHeader = !hasAcceptHeader || (!string.IsNullOrWhiteSpace(acceptHeader) && ValidAccept(acceptHeader));
if (!validFormatParam && (hasFormatParam || !validAcceptHeader))
{
throw new HttpFhirException("Unsupported Media Type", OperationOutcomeFactory.CreateInvalidMediaType(), HttpStatusCode.UnsupportedMediaType);
}
if (validFormatParam)
{
var accepted = ContentType.GetResourceFormatFromFormatParam(formatParam);
if (accepted != ResourceFormat.Unknown)
{
var newAcceptHeader = ContentType.XML_CONTENT_HEADER;
if (accepted == ResourceFormat.Json)
{
newAcceptHeader = ContentType.JSON_CONTENT_HEADER;
}
var header = new MediaTypeHeaderValue(newAcceptHeader);
context.Request.Headers.Remove(acceptKey);
context.Request.Headers.Add(acceptKey, new StringValues(header.ToString()));
}
}
await this._next(context);
}
public async Task <IActionResult> Create([FromBody] Resource resource)
{
//TODO: Remove temp code
if (resource.ResourceType.Equals(ResourceType.OperationOutcome))
{
throw new HttpFhirException("Invalid Fhir Request", (OperationOutcome)resource, HttpStatusCode.BadRequest);
}
Resource result = null;
var request = FhirRequest.Create(null, ResourceType.DocumentReference, resource, Request, RequestingAsid());
var createIssue = await _nrlsMaintain.ValidateCreate <DocumentReference>(request);
if (createIssue != null)
{
return(BadRequest(createIssue));
}
//If we have a valid document that needs to be Superseded, try update on that
var validUpdateDocument = await _nrlsMaintain.ValidateConditionalUpdate(request);
if (validUpdateDocument != null)
{
if (validUpdateDocument.ResourceType == ResourceType.OperationOutcome)
{
return(BadRequest(validUpdateDocument));
}
result = await _nrlsMaintain.SupersedeWithoutValidation <DocumentReference>(request, validUpdateDocument.Id, validUpdateDocument.VersionId);
}
else
{
//just try and create new document
result = await _nrlsMaintain.CreateWithoutValidation <DocumentReference>(request);
}
if (result.ResourceType == ResourceType.OperationOutcome)
{
return(BadRequest(result));
}
var response = OperationOutcomeFactory.CreateSuccess();
var newResource = $"{_nrlsApiSettings.ResourceLocation}/{ResourceType.DocumentReference}?_id={result.Id}";
//Temp required header for NRLS API tests
Request.HttpContext.Response.Headers.Add("Content-Location", newResource);
return(Created(newResource, response));
}
//[ProducesResponseType(typeof(DocumentReference), 200)]
public async Task <IActionResult> Get([FromServices] INodeServices nodeServices, string documentId, string documentType)
{
//Not supporting 410 errors
var regex = new Regex("^[A-Fa-f0-9-]{1,1024}$");
var documentTypeTemplate = GetDocumentType(documentType);
//TODO: check pointers cache
if (documentTypeTemplate == null || string.IsNullOrWhiteSpace(documentId) || !regex.IsMatch(documentId))
{
throw new HttpFhirException("Not Found", OperationOutcomeFactory.CreateNotFound(documentId), HttpStatusCode.NotFound);
//return NotFound(OperationOutcomeFactory.CreateNotFound(documentId));
}
//TODO: switch to other types
var outputType = "application/pdf";
var responseOutputType = GetOutputType();
var template = GetTemplate(documentTypeTemplate);
var model = JsonConvert.SerializeObject(new { documentId = documentId });
var data = await nodeServices.InvokeAsync <byte[]>("./Documents/Parsers/pdf", template, model);
var result = data;
if (!string.IsNullOrEmpty(responseOutputType) && responseOutputType.ToLowerInvariant().Contains("fhir"))
{
var binary = new Binary
{
ContentType = outputType,
Content = data
};
result = new FhirJsonSerializer().SerializeToBytes(binary);
if (!responseOutputType.Contains("charset"))
{
responseOutputType = $"{responseOutputType}; charset={Encoding.UTF8.WebName}";
}
}
else
{
responseOutputType = outputType;
}
return(new FileContentResult(result, responseOutputType));
}
public async SystemTasks.Task Invoke(HttpContext context, IOptionsSnapshot <ApiSetting> apiSettings)
{
CheckRequestRequirements(context);
_apiSettings = apiSettings.Value;
var parameters = context.Request.QueryString.Value.GetParameters();
bool hasFormatParam = parameters?.FirstOrDefault(x => x.Item1 == "_format") != null;
string formatParam = parameters?.GetParameter("_format");
bool hasAcceptHeader = context.Request.Headers.ContainsKey(HeaderNames.Accept);
string acceptHeader = hasAcceptHeader ? context.Request.Headers[HeaderNames.Accept] : StringValues.Empty;
var validFormatParam = !hasFormatParam || ValidContentType(formatParam);
var validAcceptHeader = !hasAcceptHeader || ValidContentType(acceptHeader);
if (!validFormatParam && (hasFormatParam || !validAcceptHeader))
{
throw new HttpFhirException("Unsupported Media Type", OperationOutcomeFactory.CreateInvalidMediaType(), HttpStatusCode.UnsupportedMediaType);
}
if (validFormatParam)
{
var accepted = ContentType.GetResourceFormatFromFormatParam(formatParam);
if (accepted != ResourceFormat.Unknown)
{
var newAcceptHeader = ContentType.XML_CONTENT_HEADER;
if (accepted == ResourceFormat.Json)
{
newAcceptHeader = ContentType.JSON_CONTENT_HEADER;
}
var header = new MediaTypeHeaderValue(newAcceptHeader);
context.Request.Headers.Remove(HeaderNames.Accept);
context.Request.Headers.Add(HeaderNames.Accept, new StringValues(header.ToString()));
}
}
//TODO: add default switch on controller
context.Request.Headers.Remove(FhirConstants.HeaderXFhirDefault);
context.Request.Headers.Add(FhirConstants.HeaderXFhirDefault, ContentType.XML_CONTENT_HEADER);
await _next(context);
}
public OperationOutcome ValidatePatientParameter(string parameterVal)
{
if (!_validationHelper.ValidReferenceParameter(parameterVal, FhirConstants.SystemPDS))
{
return(OperationOutcomeFactory.CreateInvalidParameter("Invalid parameter", $"The given resource URL does not conform to the expected format - {FhirConstants.SystemPDS}[NHS Number]"));
}
var nhsNumber = parameterVal.Replace(FhirConstants.SystemPDS, "");
if (!_validationHelper.ValidNhsNumber(nhsNumber))
{
return(OperationOutcomeFactory.CreateInvalidNhsNumber());
}
return(null);
}
public OperationOutcome ValidatePatientReference(ResourceReference reference)
{
if (!_validationHelper.ValidReference(reference, FhirConstants.SystemPDS))
{
return(OperationOutcomeFactory.CreateInvalidResource("subject"));
}
var nhsNumber = reference.Reference.Replace(FhirConstants.SystemPDS, "");
if (!_validationHelper.ValidNhsNumber(nhsNumber))
{
return(OperationOutcomeFactory.CreateInvalidNhsNumberRes(nhsNumber));
}
return(null);
}
private OperationOutcome InvalidAsid(string orgCode, string asid, bool isCreate)
{
var map = _cache.Get <ClientAsidMap>(ClientAsidMap.Key);
if (!string.IsNullOrEmpty(asid) && map != null && map.ClientAsids != null)
{
var asidMap = map.ClientAsids.FirstOrDefault(x => x.Key == asid);
if (asidMap.Value != null && !string.IsNullOrEmpty(orgCode) && !string.IsNullOrEmpty(asidMap.Value.OrgCode) && asidMap.Value.OrgCode == orgCode)
{
return(null);
}
}
return(OperationOutcomeFactory.CreateInvalidResource(FhirConstants.HeaderFromAsid, "The Custodian ODS code is not affiliated with the sender ASID."));
}
public OperationOutcome ValidateOrganisationReference(ResourceReference reference, string type)
{
if (!_validationHelper.ValidReference(reference, FhirConstants.SystemODS))
{
return(OperationOutcomeFactory.CreateInvalidParameter("Invalid parameter", $"The given resource URL does not conform to the expected format - {FhirConstants.SystemODS}/[ODS Code]"));
}
var orgCode = GetOrganizationReferenceId(reference);
if (string.IsNullOrWhiteSpace(orgCode))
{
return(OperationOutcomeFactory.CreateInvalidResource(type));
}
return(null);
}
protected Resource ParseRead <T>(T results, string id) where T : Resource
{
var notFound = results == null;
if (!notFound && results.ResourceType == ResourceType.Bundle)
{
var bundle = results as Bundle;
notFound = (!bundle.Total.HasValue || bundle.Total.Value != 1);
}
if (notFound)
{
throw new HttpFhirException("Not Found", OperationOutcomeFactory.CreateNotFound(id), HttpStatusCode.NotFound);
}
return(results);
}
protected Resource ParseRead <T>(T results, string id) where T : Resource
{
var notFound = results == null;
if (!notFound && results.ResourceType == ResourceType.Bundle)
{
var bundle = results as Bundle;
notFound = (!bundle.Total.HasValue || bundle.Total.Value != 1);
}
if (notFound)
{
return(OperationOutcomeFactory.CreateNotFound(id));
}
return(results);
}
