void ISearchValueVisitor.Visit(StringSearchValue s)
{
EnsureArg.IsNotNull(s, nameof(s));
EnsureOnlyEqualComparatorIsSupported();
if (_modifier == null)
{
// Based on spec http://hl7.org/fhir/STU3/search.html#string,
// is case-insensitive search so we will normalize into lower case for search.
_outputExpression = Expression.StartsWith(FieldName.String, _componentIndex, s.String, true);
}
else if (_modifier == SearchModifierCode.Exact)
{
_outputExpression = Expression.StringEquals(FieldName.String, _componentIndex, s.String, false);
}
else if (_modifier == SearchModifierCode.Contains)
{
// Based on spec http://hl7.org/fhir/STU3/search.html#modifiers,
// contains is case-insensitive search so we will normalize into lower case for search.
_outputExpression = Expression.Contains(FieldName.String, _componentIndex, s.String, true);
}
else
{
ThrowModifierNotSupported();
}
}
void ISearchValueVisitor.Visit(UriSearchValue uri)
{
EnsureArg.IsNotNull(uri, nameof(uri));
switch (_modifier)
{
case null:
_outputExpression = Expression.StringEquals(FieldName.Uri, _componentIndex, uri.Uri, false);
break;
case SearchModifierCode.Above:
_outputExpression = Expression.And(
Expression.EndsWith(FieldName.Uri, _componentIndex, uri.Uri, false),
Expression.NotStartsWith(FieldName.Uri, _componentIndex, KnownUriSchemes.Urn, false));
break;
case SearchModifierCode.Below:
_outputExpression = Expression.And(
Expression.StartsWith(FieldName.Uri, _componentIndex, uri.Uri, false),
Expression.NotStartsWith(FieldName.Uri, _componentIndex, KnownUriSchemes.Urn, false));
break;
default:
ThrowModifierNotSupported();
break;
}
}
private Expression CreateSearchExpression(ResourceElement coverage, ResourceElement patient)
{
var coverageValues = _searchIndexer.Extract(coverage);
var patientValues = _searchIndexer.Extract(patient);
var expressions = new List <Expression>();
var reverseChainExpressions = new List <Expression>();
expressions.Add(Expression.SearchParameter(_resourceTypeSearchParameter, Expression.StringEquals(FieldName.TokenCode, null, KnownResourceTypes.Patient, false)));
foreach (var patientValue in patientValues)
{
if (IgnoreInSearch(patientValue))
{
continue;
}
var modifier = string.Empty;
if (patientValue.SearchParameter.Type == ValueSets.SearchParamType.String)
{
modifier = ":exact";
}
expressions.Add(_expressionParser.Parse(new[] { KnownResourceTypes.Patient }, patientValue.SearchParameter.Code + modifier, patientValue.Value.ToString()));
}
foreach (var coverageValue in coverageValues)
{
if (IgnoreInSearch(coverageValue))
{
continue;
}
var modifier = string.Empty;
if (coverageValue.SearchParameter.Type == ValueSets.SearchParamType.String)
{
modifier = ":exact";
}
reverseChainExpressions.Add(_expressionParser.Parse(new[] { KnownResourceTypes.Coverage }, coverageValue.SearchParameter.Code + modifier, coverageValue.Value.ToString()));
}
if (reverseChainExpressions.Count != 0)
{
Expression reverseChainedExpression;
if (reverseChainExpressions.Count == 1)
{
reverseChainedExpression = reverseChainExpressions[0];
}
else
{
reverseChainedExpression = Expression.And(reverseChainExpressions);
}
var expression = Expression.Chained(new[] { KnownResourceTypes.Coverage }, _coverageBeneficiaryParameter, new[] { KnownResourceTypes.Patient }, true, reverseChainedExpression);
expressions.Add(expression);
}
return(Expression.And(expressions));
}
void ISearchValueVisitor.Visit(TokenSearchValue token)
{
EnsureArg.IsNotNull(token, nameof(token));
EnsureOnlyEqualComparatorIsSupported();
if (_modifier == null)
{
_outputExpression = BuildEqualityExpression();
}
else if (_modifier == SearchModifierCode.Not)
{
_outputExpression = Expression.Not(BuildEqualityExpression());
}
else if (_modifier == SearchModifierCode.Above ||
_modifier == SearchModifierCode.Below ||
_modifier == SearchModifierCode.In ||
_modifier == SearchModifierCode.NotIn)
{
// These modifiers are not supported yet but will be supported eventually.
ThrowModifierNotSupported();
}
else
{
ThrowModifierNotSupported();
}
Expression BuildEqualityExpression()
{
// Based on spec http://hl7.org/fhir/search.html#token,
// we need to make sure to test if system is missing or not based on how it is supplied.
if (token.System == null)
{
// If the system is not supplied, then the token code is matched irrespective of the value of system.
return(Expression.StringEquals(FieldName.TokenCode, _componentIndex, token.Code, false));
}
else if (token.System.Length == 0)
{
// If the system is empty, then the token is matched if there is no system property.
return(Expression.And(
Expression.Missing(FieldName.TokenSystem, _componentIndex),
Expression.StringEquals(FieldName.TokenCode, _componentIndex, token.Code, false)));
}
else if (string.IsNullOrWhiteSpace(token.Code))
{
// If the code is empty, then the token is matched if system is matched.
return(Expression.StringEquals(FieldName.TokenSystem, _componentIndex, token.System, false));
}
else
{
return(Expression.And(
Expression.StringEquals(FieldName.TokenSystem, _componentIndex, token.System, false),
Expression.StringEquals(FieldName.TokenCode, _componentIndex, token.Code, false)));
}
}
}
void ISearchValueVisitor.Visit(ReferenceSearchValue reference)
{
EnsureArg.IsNotNull(reference, nameof(reference));
if (_modifier != null)
{
ThrowModifierNotSupported();
}
EnsureOnlyEqualComparatorIsSupported();
if (reference.BaseUri != null)
{
// The reference is external.
_outputExpression = Expression.And(
Expression.StringEquals(FieldName.ReferenceBaseUri, _componentIndex, reference.BaseUri.ToString(), false),
Expression.StringEquals(FieldName.ReferenceResourceType, _componentIndex, reference.ResourceType.Value.ToString(), false),
Expression.StringEquals(FieldName.ReferenceResourceId, _componentIndex, reference.ResourceId, false));
}
else if (reference.ResourceType == null)
{
// Only resource id is specified.
_outputExpression = Expression.StringEquals(FieldName.ReferenceResourceId, _componentIndex, reference.ResourceId, false);
}
else if (reference.Kind == ReferenceKind.Internal)
{
// The reference must be internal.
_outputExpression = Expression.And(
Expression.Missing(FieldName.ReferenceBaseUri, _componentIndex),
Expression.StringEquals(FieldName.ReferenceResourceType, _componentIndex, reference.ResourceType.Value.ToString(), false),
Expression.StringEquals(FieldName.ReferenceResourceId, _componentIndex, reference.ResourceId, false));
}
else
{
// The reference can be internal or external.
_outputExpression = Expression.And(
Expression.StringEquals(FieldName.ReferenceResourceType, _componentIndex, reference.ResourceType.Value.ToString(), false),
Expression.StringEquals(FieldName.ReferenceResourceId, _componentIndex, reference.ResourceId, false));
}
}
void ISearchValueVisitor.Visit(QuantitySearchValue quantity)
{
EnsureArg.IsNotNull(quantity, nameof(quantity));
if (_modifier != null)
{
ThrowModifierNotSupported();
}
var expressions = new List <Expression>(3);
// Based on spec http://hl7.org/fhir/STU3/search.html#quantity,
// The system is handled differently in quantity than token.
if (!string.IsNullOrWhiteSpace(quantity.System))
{
expressions.Add(
Expression.StringEquals(FieldName.QuantitySystem, _componentIndex, quantity.System, false));
}
if (!string.IsNullOrWhiteSpace(quantity.Code))
{
expressions.Add(
Expression.StringEquals(FieldName.QuantityCode, _componentIndex, quantity.Code, false));
}
Debug.Assert(quantity.Low.HasValue && quantity.Low == quantity.High, "quantity low and high should be the same and not null");
expressions.Add(GenerateNumberExpression(FieldName.Quantity, quantity.Low.Value));
if (expressions.Count == 1)
{
_outputExpression = expressions[0];
}
else
{
_outputExpression = Expression.And(expressions.ToArray());
}
}
public SearchOptions Create(string compartmentType, string compartmentId, string resourceType, IReadOnlyList <Tuple <string, string> > queryParameters)
{
var searchOptions = new SearchOptions();
string continuationToken = null;
var searchParams = new SearchParams();
var unsupportedSearchParameters = new List <Tuple <string, string> >();
// Extract the continuation token, filter out the other known query parameters that's not search related.
foreach (Tuple <string, string> query in queryParameters ?? Enumerable.Empty <Tuple <string, string> >())
{
if (query.Item1 == KnownQueryParameterNames.ContinuationToken)
{
if (continuationToken != null)
{
throw new InvalidSearchOperationException(
string.Format(Core.Resources.MultipleQueryParametersNotAllowed, KnownQueryParameterNames.ContinuationToken));
}
continuationToken = query.Item2;
}
else if (query.Item1 == KnownQueryParameterNames.Format)
{
// TODO: We need to handle format parameter.
}
else if (string.IsNullOrWhiteSpace(query.Item1) || string.IsNullOrWhiteSpace(query.Item2))
{
// Query parameter with empty value is not supported.
unsupportedSearchParameters.Add(query);
}
else
{
// Parse the search parameters.
try
{
searchParams.Add(query.Item1, query.Item2);
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Failed to parse the query parameter. Skipping.");
// There was a problem parsing the parameter. Add it to list of unsupported parameters.
unsupportedSearchParameters.Add(query);
}
}
}
searchOptions.ContinuationToken = continuationToken;
// Check the item count.
if (searchParams.Count != null)
{
searchOptions.MaxItemCount = searchParams.Count.Value;
}
// Check to see if only the count should be returned
searchOptions.CountOnly = searchParams.Summary == SummaryType.Count;
// If the resource type is not specified, then the common
// search parameters should be used.
ResourceType parsedResourceType = ResourceType.DomainResource;
if (!string.IsNullOrWhiteSpace(resourceType) &&
!Enum.TryParse(resourceType, out parsedResourceType))
{
throw new ResourceNotSupportedException(resourceType);
}
var searchExpressions = new List <Expression>();
if (!string.IsNullOrWhiteSpace(resourceType))
{
searchExpressions.Add(Expression.SearchParameter(_resourceTypeSearchParameter, Expression.StringEquals(FieldName.TokenCode, null, resourceType, false)));
}
searchExpressions.AddRange(searchParams.Parameters.Select(
q =>
{
try
{
return(_expressionParser.Parse(parsedResourceType.ToString(), q.Item1, q.Item2));
}
catch (SearchParameterNotSupportedException)
{
unsupportedSearchParameters.Add(q);
return(null);
}
})
.Where(item => item != null));
if (!string.IsNullOrWhiteSpace(compartmentType))
{
if (Enum.TryParse(compartmentType, out CompartmentType parsedCompartmentType))
{
if (string.IsNullOrWhiteSpace(compartmentId))
{
throw new InvalidSearchOperationException(Core.Resources.CompartmentIdIsInvalid);
}
searchExpressions.Add(Expression.CompartmentSearch(compartmentType, compartmentId));
}
else
{
throw new InvalidSearchOperationException(string.Format(Core.Resources.CompartmentTypeIsInvalid, compartmentType));
}
}
if (searchExpressions.Count == 1)
{
searchOptions.Expression = searchExpressions[0];
}
else if (searchExpressions.Count > 1)
{
searchOptions.Expression = Expression.And(searchExpressions.ToArray());
}
if (unsupportedSearchParameters.Any())
{
// TODO: Client can specify whether exception should be raised or not when it encounters unknown search parameters.
// For now, we will ignore any unknown search parameters.
}
searchOptions.UnsupportedSearchParams = unsupportedSearchParameters;
return(searchOptions);
}
public SearchOptions Create(string compartmentType, string compartmentId, string resourceType, IReadOnlyList <Tuple <string, string> > queryParameters)
{
var searchOptions = new SearchOptions();
string continuationToken = null;
var searchParams = new SearchParams();
var unsupportedSearchParameters = new List <Tuple <string, string> >();
bool setDefaultBundleTotal = true;
// Extract the continuation token, filter out the other known query parameters that's not search related.
foreach (Tuple <string, string> query in queryParameters ?? Enumerable.Empty <Tuple <string, string> >())
{
if (query.Item1 == KnownQueryParameterNames.ContinuationToken)
{
// This is an unreachable case. The mapping of the query parameters makes it so only one continuation token can exist.
if (continuationToken != null)
{
throw new InvalidSearchOperationException(
string.Format(Core.Resources.MultipleQueryParametersNotAllowed, KnownQueryParameterNames.ContinuationToken));
}
try
{
continuationToken = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(query.Item2));
}
catch (FormatException)
{
throw new BadRequestException(Core.Resources.InvalidContinuationToken);
}
setDefaultBundleTotal = false;
}
else if (query.Item1 == KnownQueryParameterNames.Format)
{
// TODO: We need to handle format parameter.
}
else if (string.IsNullOrWhiteSpace(query.Item1) || string.IsNullOrWhiteSpace(query.Item2))
{
// Query parameter with empty value is not supported.
unsupportedSearchParameters.Add(query);
}
else if (string.Compare(query.Item1, KnownQueryParameterNames.Total, StringComparison.OrdinalIgnoreCase) == 0)
{
if (Enum.TryParse <TotalType>(query.Item2, true, out var totalType))
{
ValidateTotalType(totalType);
searchOptions.IncludeTotal = totalType;
setDefaultBundleTotal = false;
}
else
{
throw new BadRequestException(string.Format(Core.Resources.InvalidTotalParameter, query.Item2, SupportedTotalTypes));
}
}
else
{
// Parse the search parameters.
try
{
// Basic format checking (e.g. integer value for _count key etc.).
searchParams.Add(query.Item1, query.Item2);
}
catch (Exception ex)
{
throw new BadRequestException(ex.Message);
}
}
}
searchOptions.ContinuationToken = continuationToken;
if (setDefaultBundleTotal)
{
ValidateTotalType(_featureConfiguration.IncludeTotalInBundle);
searchOptions.IncludeTotal = _featureConfiguration.IncludeTotalInBundle;
}
// Check the item count.
if (searchParams.Count != null)
{
if (searchParams.Count > _featureConfiguration.MaxItemCountPerSearch)
{
searchOptions.MaxItemCount = _featureConfiguration.MaxItemCountPerSearch;
_contextAccessor.FhirRequestContext.BundleIssues.Add(
new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Information,
OperationOutcomeConstants.IssueType.Informational,
string.Format(Core.Resources.SearchParamaterCountExceedLimit, _featureConfiguration.MaxItemCountPerSearch, searchParams.Count)));
}
else
{
searchOptions.MaxItemCount = searchParams.Count.Value;
}
}
else
{
searchOptions.MaxItemCount = _featureConfiguration.DefaultItemCountPerSearch;
}
searchOptions.IncludeCount = _featureConfiguration.DefaultIncludeCountPerSearch;
// Check to see if only the count should be returned
searchOptions.CountOnly = searchParams.Summary == SummaryType.Count;
// If the resource type is not specified, then the common
// search parameters should be used.
ResourceType parsedResourceType = ResourceType.DomainResource;
if (!string.IsNullOrWhiteSpace(resourceType) &&
!Enum.TryParse(resourceType, out parsedResourceType))
{
throw new ResourceNotSupportedException(resourceType);
}
var searchExpressions = new List <Expression>();
if (!string.IsNullOrWhiteSpace(resourceType))
{
searchExpressions.Add(Expression.SearchParameter(_resourceTypeSearchParameter, Expression.StringEquals(FieldName.TokenCode, null, resourceType, false)));
}
searchExpressions.AddRange(searchParams.Parameters.Select(
q =>
{
try
{
return(_expressionParser.Parse(parsedResourceType.ToString(), q.Item1, q.Item2));
}
catch (SearchParameterNotSupportedException)
{
unsupportedSearchParameters.Add(q);
return(null);
}
})
.Where(item => item != null));
if (searchParams.Include?.Count > 0)
{
searchExpressions.AddRange(searchParams.Include.Select(
q => _expressionParser.ParseInclude(parsedResourceType.ToString(), q, false /* not reversed */, false /* no iterate */))
.Where(item => item != null));
}
if (searchParams.RevInclude?.Count > 0)
{
searchExpressions.AddRange(searchParams.RevInclude.Select(
q => _expressionParser.ParseInclude(parsedResourceType.ToString(), q, true /* reversed */, false /* no iterate */))
.Where(item => item != null));
}
// Parse _include:iterate (_include:recurse) parameters.
// :iterate (:recurse) modifiers are not supported by Hl7.Fhir.Rest, hence not added to the Include collection and exist in the Parameters list.
// See https://github.com/FirelyTeam/fhir-net-api/issues/222
// _include:iterate (_include:recurse) expression may appear without a preceding _include parameter
// when applied on a circular reference
searchExpressions.AddRange(ParseIncludeIterateExpressions(searchParams));
// remove _include:iterate and _revinclude:iterate parameters from unsupportedSearchParameters
unsupportedSearchParameters.RemoveAll(p => AllIterateModifiers.Contains(p.Item1));
if (!string.IsNullOrWhiteSpace(compartmentType))
{
if (Enum.TryParse(compartmentType, out CompartmentType parsedCompartmentType))
{
if (string.IsNullOrWhiteSpace(compartmentId))
{
throw new InvalidSearchOperationException(Core.Resources.CompartmentIdIsInvalid);
}
searchExpressions.Add(Expression.CompartmentSearch(compartmentType, compartmentId));
}
else
{
throw new InvalidSearchOperationException(string.Format(Core.Resources.CompartmentTypeIsInvalid, compartmentType));
}
}
if (searchExpressions.Count == 1)
{
searchOptions.Expression = searchExpressions[0];
}
else if (searchExpressions.Count > 1)
{
searchOptions.Expression = Expression.And(searchExpressions.ToArray());
}
if (unsupportedSearchParameters.Any())
{
// TODO: Client can specify whether exception should be raised or not when it encounters unknown search parameters.
// For now, we will ignore any unknown search parameters.
}
searchOptions.UnsupportedSearchParams = unsupportedSearchParameters;
if (searchParams.Sort?.Count > 0)
{
var sortings = new List <(SearchParameterInfo, SortOrder)>();
List <(string parameterName, string reason)> unsupportedSortings = null;
foreach (Tuple <string, Hl7.Fhir.Rest.SortOrder> sorting in searchParams.Sort)
{
try
{
SearchParameterInfo searchParameterInfo = _searchParameterDefinitionManager.GetSearchParameter(parsedResourceType.ToString(), sorting.Item1);
if (searchParameterInfo.IsSortSupported())
{
sortings.Add((searchParameterInfo, sorting.Item2.ToCoreSortOrder()));
}
else
{
throw new SearchParameterNotSupportedException(string.Format(Core.Resources.SearchSortParameterNotSupported, searchParameterInfo.Name));
}
}
catch (SearchParameterNotSupportedException)
{
(unsupportedSortings ??= new List <(string parameterName, string reason)>()).Add((sorting.Item1, string.Format(Core.Resources.SearchSortParameterNotSupported, sorting.Item1)));
}
}
searchOptions.Sort = sortings;
searchOptions.UnsupportedSortingParams = (IReadOnlyList <(string parameterName, string reason)>)unsupportedSortings ?? Array.Empty <(string parameterName, string reason)>();
}
else
{
searchOptions.Sort = Array.Empty <(SearchParameterInfo searchParameterInfo, SortOrder sortOrder)>();
searchOptions.UnsupportedSortingParams = Array.Empty <(string parameterName, string reason)>();
}
return(searchOptions);
IEnumerable <IncludeExpression> ParseIncludeIterateExpressions(SearchParams searchParams)
{
return(searchParams.Parameters
.Where(p => p != null && AllIterateModifiers.Where(m => string.Equals(p.Item1, m, StringComparison.OrdinalIgnoreCase)).Any())
.Select(p =>
{
var includeResourceType = p.Item2?.Split(':')[0];
if (!ModelInfoProvider.IsKnownResource(includeResourceType))
{
throw new ResourceNotSupportedException(includeResourceType);
}
var reversed = RevIncludeIterateModifiers.Contains(p.Item1);
var expression = _expressionParser.ParseInclude(includeResourceType, p.Item2, reversed, true);
// Reversed Iterate expressions (not wildcard) must specify target type if there is more than one possible target type
if (expression.Reversed && expression.Iterate && expression.TargetResourceType == null && expression.ReferenceSearchParameter?.TargetResourceTypes?.Count > 1)
{
throw new BadRequestException(string.Format(Core.Resources.RevIncludeIterateTargetTypeNotSpecified, p.Item2));
}
// For circular include iterate expressions, add an informational issue indicating that a single iteration is supported.
// See https://www.hl7.org/fhir/search.html#revinclude.
if (expression.Iterate && expression.CircularReference)
{
_contextAccessor.FhirRequestContext.BundleIssues.Add(
new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Information,
OperationOutcomeConstants.IssueType.Informational,
string.Format(Core.Resources.IncludeIterateCircularReferenceExecutedOnce, p.Item1, p.Item2)));
}
return expression;
}));
}
void ValidateTotalType(TotalType totalType)
{
// Estimate is not yet supported.
if (totalType == TotalType.Estimate)
{
throw new SearchOperationNotSupportedException(string.Format(Core.Resources.UnsupportedTotalParameter, totalType, SupportedTotalTypes));
}
}
}
public SearchOptions Create(string compartmentType, string compartmentId, string resourceType, IReadOnlyList <Tuple <string, string> > queryParameters)
{
var searchOptions = new SearchOptions();
string continuationToken = null;
var searchParams = new SearchParams();
var unsupportedSearchParameters = new List <Tuple <string, string> >();
bool setDefaultBundleTotal = true;
// Extract the continuation token, filter out the other known query parameters that's not search related.
foreach (Tuple <string, string> query in queryParameters ?? Enumerable.Empty <Tuple <string, string> >())
{
if (query.Item1 == KnownQueryParameterNames.ContinuationToken)
{
// This is an unreachable case. The mapping of the query parameters makes it so only one continuation token can exist.
if (continuationToken != null)
{
throw new InvalidSearchOperationException(
string.Format(Core.Resources.MultipleQueryParametersNotAllowed, KnownQueryParameterNames.ContinuationToken));
}
try
{
continuationToken = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(query.Item2));
}
catch (FormatException)
{
throw new BadRequestException(Core.Resources.InvalidContinuationToken);
}
setDefaultBundleTotal = false;
}
else if (query.Item1 == KnownQueryParameterNames.Format || query.Item1 == KnownQueryParameterNames.Pretty)
{
// _format and _pretty are not search parameters, so we can ignore them.
}
else if (string.Equals(query.Item1, KnownQueryParameterNames.Type, StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrWhiteSpace(query.Item2))
{
throw new BadRequestException(string.Format(Core.Resources.InvalidTypeParameter, query.Item2));
}
var types = query.Item2.SplitByOrSeparator();
var badTypes = types.Where(type => !ModelInfoProvider.IsKnownResource(type)).ToHashSet();
if (badTypes.Count != 0)
{
_contextAccessor.RequestContext?.BundleIssues.Add(
new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Warning,
OperationOutcomeConstants.IssueType.NotSupported,
string.Format(Core.Resources.InvalidTypeParameter, badTypes.OrderBy(x => x).Select(type => $"'{type}'").JoinByOrSeparator())));
if (badTypes.Count != types.Count)
{
// In case of we have acceptable types, we filter invalid types from search.
searchParams.Add(KnownQueryParameterNames.Type, types.Except(badTypes).JoinByOrSeparator());
}
else
{
// If all types are invalid, we add them to search params. If we remove them, we wouldn't filter by type, and return all types,
// which is incorrect behaviour. Optimally we should indicate in search options what it would yield nothing, and skip search,
// but there is no option for that right now.
searchParams.Add(KnownQueryParameterNames.Type, query.Item2);
}
}
else
{
searchParams.Add(KnownQueryParameterNames.Type, query.Item2);
}
}
else if (string.IsNullOrWhiteSpace(query.Item1) || string.IsNullOrWhiteSpace(query.Item2))
{
// Query parameter with empty value is not supported.
unsupportedSearchParameters.Add(query);
}
else if (string.Compare(query.Item1, KnownQueryParameterNames.Total, StringComparison.OrdinalIgnoreCase) == 0)
{
if (Enum.TryParse <TotalType>(query.Item2, true, out var totalType))
{
ValidateTotalType(totalType);
searchOptions.IncludeTotal = totalType;
setDefaultBundleTotal = false;
}
else
{
throw new BadRequestException(string.Format(Core.Resources.InvalidTotalParameter, query.Item2, SupportedTotalTypes));
}
}
else
{
// Parse the search parameters.
try
{
// Basic format checking (e.g. integer value for _count key etc.).
searchParams.Add(query.Item1, query.Item2);
}
catch (Exception ex)
{
throw new BadRequestException(ex.Message);
}
}
}
searchOptions.ContinuationToken = continuationToken;
if (setDefaultBundleTotal)
{
ValidateTotalType(_featureConfiguration.IncludeTotalInBundle);
searchOptions.IncludeTotal = _featureConfiguration.IncludeTotalInBundle;
}
// Check the item count.
if (searchParams.Count != null)
{
searchOptions.MaxItemCountSpecifiedByClient = true;
if (searchParams.Count > _featureConfiguration.MaxItemCountPerSearch)
{
searchOptions.MaxItemCount = _featureConfiguration.MaxItemCountPerSearch;
_contextAccessor.RequestContext?.BundleIssues.Add(
new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Information,
OperationOutcomeConstants.IssueType.Informational,
string.Format(Core.Resources.SearchParamaterCountExceedLimit, _featureConfiguration.MaxItemCountPerSearch, searchParams.Count)));
}
else
{
searchOptions.MaxItemCount = searchParams.Count.Value;
}
}
else
{
searchOptions.MaxItemCount = _featureConfiguration.DefaultItemCountPerSearch;
}
searchOptions.IncludeCount = _featureConfiguration.DefaultIncludeCountPerSearch;
if (searchParams.Elements?.Any() == true && searchParams.Summary != null && searchParams.Summary != SummaryType.False)
{
// The search parameters _elements and _summarize cannot be specified for the same request.
throw new BadRequestException(string.Format(Core.Resources.ElementsAndSummaryParametersAreIncompatible, KnownQueryParameterNames.Summary, KnownQueryParameterNames.Elements));
}
// Check to see if only the count should be returned
searchOptions.CountOnly = searchParams.Summary == SummaryType.Count;
// If the resource type is not specified, then the common
// search parameters should be used.
ResourceType[] parsedResourceTypes = new[] { ResourceType.DomainResource };
var searchExpressions = new List <Expression>();
if (string.IsNullOrWhiteSpace(resourceType))
{
// Try to parse resource types from _type Search Parameter
// This will result in empty array if _type has any modifiers
// Which is good, since :not modifier changes the meaning of the
// search parameter and we can no longer use it to deduce types
// (and should proceed with ResourceType.DomainResource in that case)
var resourceTypes = searchParams.Parameters
.Where(q => q.Item1 == KnownQueryParameterNames.Type) // <-- Equality comparison to avoid modifiers
.SelectMany(q => q.Item2.SplitByOrSeparator())
.Where(type => ModelInfoProvider.IsKnownResource(type))
.Select(x =>
{
if (!Enum.TryParse(x, out ResourceType parsedType))
{
// Should never get here
throw new ResourceNotSupportedException(x);
}
return(parsedType);
})
.Distinct();
if (resourceTypes.Any())
{
parsedResourceTypes = resourceTypes.ToArray();
}
}
else
{
if (!Enum.TryParse(resourceType, out parsedResourceTypes[0]))
{
throw new ResourceNotSupportedException(resourceType);
}
searchExpressions.Add(Expression.SearchParameter(_resourceTypeSearchParameter, Expression.StringEquals(FieldName.TokenCode, null, resourceType, false)));
}
var resourceTypesString = parsedResourceTypes.Select(x => x.ToString()).ToArray();
searchExpressions.AddRange(searchParams.Parameters.Select(
q =>
{
try
{
return(_expressionParser.Parse(resourceTypesString, q.Item1, q.Item2));
}
catch (SearchParameterNotSupportedException)
{
unsupportedSearchParameters.Add(q);
return(null);
}
})
.Where(item => item != null));
if (searchParams.Include?.Count > 0)
{
searchExpressions.AddRange(searchParams.Include.Select(
q => _expressionParser.ParseInclude(resourceTypesString, q, false /* not reversed */, false /* no iterate */))
.Where(item => item != null));
}
if (searchParams.RevInclude?.Count > 0)
{
searchExpressions.AddRange(searchParams.RevInclude.Select(
q => _expressionParser.ParseInclude(resourceTypesString, q, true /* reversed */, false /* no iterate */))
.Where(item => item != null));
}
// Parse _include:iterate (_include:recurse) parameters.
// :iterate (:recurse) modifiers are not supported by Hl7.Fhir.Rest, hence not added to the Include collection and exist in the Parameters list.
// See https://github.com/FirelyTeam/fhir-net-api/issues/222
// _include:iterate (_include:recurse) expression may appear without a preceding _include parameter
// when applied on a circular reference
searchExpressions.AddRange(ParseIncludeIterateExpressions(searchParams));
// remove _include:iterate and _revinclude:iterate parameters from unsupportedSearchParameters
unsupportedSearchParameters.RemoveAll(p => AllIterateModifiers.Contains(p.Item1));
if (!string.IsNullOrWhiteSpace(compartmentType))
{
if (Enum.TryParse(compartmentType, out CompartmentType parsedCompartmentType))
{
if (string.IsNullOrWhiteSpace(compartmentId))
{
throw new InvalidSearchOperationException(Core.Resources.CompartmentIdIsInvalid);
}
searchExpressions.Add(Expression.CompartmentSearch(compartmentType, compartmentId));
}
else
{
throw new InvalidSearchOperationException(string.Format(Core.Resources.CompartmentTypeIsInvalid, compartmentType));
}
}
if (searchExpressions.Count == 1)
{
searchOptions.Expression = searchExpressions[0];
}
else if (searchExpressions.Count > 1)
{
searchOptions.Expression = Expression.And(searchExpressions.ToArray());
}
if (unsupportedSearchParameters.Any())
{
bool throwForUnsupported = false;
if (_contextAccessor.RequestContext?.RequestHeaders != null &&
_contextAccessor.RequestContext.RequestHeaders.TryGetValue(KnownHeaders.Prefer, out var values))
{
var handlingValue = values.FirstOrDefault(x => x.StartsWith("handling=", StringComparison.OrdinalIgnoreCase));
if (handlingValue != default)
{
handlingValue = handlingValue.Substring("handling=".Length);
if (string.IsNullOrWhiteSpace(handlingValue) || !Enum.TryParse <SearchParameterHandling>(handlingValue, true, out var handling))
{
throw new BadRequestException(string.Format(
Core.Resources.InvalidHandlingValue,
handlingValue,
string.Join(",", Enum.GetNames <SearchParameterHandling>())));
}
if (handling == SearchParameterHandling.Strict)
{
throwForUnsupported = true;
}
}
}
if (throwForUnsupported)
{
throw new BadRequestException(string.Format(
Core.Resources.SearchParameterNotSupported,
string.Join(",", unsupportedSearchParameters.Select(x => x.Item1)),
string.Join(",", resourceTypesString)));
}
else
{
foreach (var unsupported in unsupportedSearchParameters)
{
_contextAccessor.RequestContext?.BundleIssues.Add(new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Warning,
OperationOutcomeConstants.IssueType.NotSupported,
string.Format(CultureInfo.InvariantCulture, Core.Resources.SearchParameterNotSupported, unsupported.Item1, string.Join(",", resourceTypesString))));
}
}
}
searchOptions.UnsupportedSearchParams = unsupportedSearchParameters;
if (searchParams.Sort?.Count > 0)
{
var sortings = new List <(SearchParameterInfo, SortOrder)>(searchParams.Sort.Count);
bool sortingsValid = true;
foreach (Tuple <string, Hl7.Fhir.Rest.SortOrder> sorting in searchParams.Sort)
{
try
{
SearchParameterInfo searchParameterInfo = resourceTypesString.Select(t => _searchParameterDefinitionManager.GetSearchParameter(t, sorting.Item1)).Distinct().First();
sortings.Add((searchParameterInfo, sorting.Item2.ToCoreSortOrder()));
}
catch (SearchParameterNotSupportedException)
{
sortingsValid = false;
_contextAccessor.RequestContext?.BundleIssues.Add(new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Warning,
OperationOutcomeConstants.IssueType.NotSupported,
string.Format(CultureInfo.InvariantCulture, Core.Resources.SearchParameterNotSupported, sorting.Item1, string.Join(", ", resourceTypesString))));
}
}
if (sortingsValid)
{
if (!_sortingValidator.ValidateSorting(sortings, out IReadOnlyList <string> errorMessages))
{
if (errorMessages == null || errorMessages.Count == 0)
{
throw new InvalidOperationException($"Expected {_sortingValidator.GetType().Name} to return error messages when {nameof(_sortingValidator.ValidateSorting)} returns false");
}
sortingsValid = false;
foreach (var errorMessage in errorMessages)
{
_contextAccessor.RequestContext?.BundleIssues.Add(new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Warning,
OperationOutcomeConstants.IssueType.NotSupported,
errorMessage));
}
}
}
if (sortingsValid)
{
searchOptions.Sort = sortings;
}
}
if (searchOptions.Sort == null)
{
searchOptions.Sort = Array.Empty <(SearchParameterInfo searchParameterInfo, SortOrder sortOrder)>();
}
return(searchOptions);
IEnumerable <IncludeExpression> ParseIncludeIterateExpressions(SearchParams searchParams)
{
return(searchParams.Parameters
.Where(p => p != null && AllIterateModifiers.Where(m => string.Equals(p.Item1, m, StringComparison.OrdinalIgnoreCase)).Any())
.Select(p =>
{
var includeResourceType = p.Item2?.Split(':')[0];
if (!ModelInfoProvider.IsKnownResource(includeResourceType))
{
throw new ResourceNotSupportedException(includeResourceType);
}
var reversed = RevIncludeIterateModifiers.Contains(p.Item1);
var expression = _expressionParser.ParseInclude(new[] { includeResourceType }, p.Item2, reversed, true);
// Reversed Iterate expressions (not wildcard) must specify target type if there is more than one possible target type
if (expression.Reversed && expression.Iterate && expression.TargetResourceType == null && expression.ReferenceSearchParameter?.TargetResourceTypes?.Count > 1)
{
throw new BadRequestException(string.Format(Core.Resources.RevIncludeIterateTargetTypeNotSpecified, p.Item2));
}
// For circular include iterate expressions, add an informational issue indicating that a single iteration is supported.
// See https://www.hl7.org/fhir/search.html#revinclude.
if (expression.Iterate && expression.CircularReference)
{
_contextAccessor.RequestContext?.BundleIssues.Add(
new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Information,
OperationOutcomeConstants.IssueType.Informational,
string.Format(Core.Resources.IncludeIterateCircularReferenceExecutedOnce, p.Item1, p.Item2)));
}
return expression;
}));
}
void ValidateTotalType(TotalType totalType)
{
// Estimate is not yet supported.
if (totalType == TotalType.Estimate)
{
throw new SearchOperationNotSupportedException(string.Format(Core.Resources.UnsupportedTotalParameter, totalType, SupportedTotalTypes));
}
}
}
public SearchOptions Create(string compartmentType, string compartmentId, string resourceType, IReadOnlyList <Tuple <string, string> > queryParameters)
{
var searchOptions = new SearchOptions();
string continuationToken = null;
var searchParams = new SearchParams();
var unsupportedSearchParameters = new List <Tuple <string, string> >();
// Extract the continuation token, filter out the other known query parameters that's not search related.
foreach (Tuple <string, string> query in queryParameters ?? Enumerable.Empty <Tuple <string, string> >())
{
if (query.Item1 == KnownQueryParameterNames.ContinuationToken)
{
// This is an unreachable case. The mapping of the query parameters makes it so only one continuation token can exist.
if (continuationToken != null)
{
throw new InvalidSearchOperationException(
string.Format(Core.Resources.MultipleQueryParametersNotAllowed, KnownQueryParameterNames.ContinuationToken));
}
// Checks if the continuation token is base 64 bit encoded. Needed for systems that have cached continuation tokens from before they were encoded.
if (Base64FormatRegex.IsMatch(query.Item2))
{
continuationToken = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(query.Item2));
}
else
{
continuationToken = query.Item2;
}
}
else if (query.Item1 == KnownQueryParameterNames.Format)
{
// TODO: We need to handle format parameter.
}
else if (string.IsNullOrWhiteSpace(query.Item1) || string.IsNullOrWhiteSpace(query.Item2))
{
// Query parameter with empty value is not supported.
unsupportedSearchParameters.Add(query);
}
else
{
// Parse the search parameters.
try
{
searchParams.Add(query.Item1, query.Item2);
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Failed to parse the query parameter. Skipping.");
// There was a problem parsing the parameter. Add it to list of unsupported parameters.
unsupportedSearchParameters.Add(query);
}
}
}
searchOptions.ContinuationToken = continuationToken;
// Check the item count.
if (searchParams.Count != null)
{
searchOptions.MaxItemCount = searchParams.Count.Value;
}
// Check to see if only the count should be returned
searchOptions.CountOnly = searchParams.Summary == SummaryType.Count;
// If the resource type is not specified, then the common
// search parameters should be used.
ResourceType parsedResourceType = ResourceType.DomainResource;
if (!string.IsNullOrWhiteSpace(resourceType) &&
!Enum.TryParse(resourceType, out parsedResourceType))
{
throw new ResourceNotSupportedException(resourceType);
}
var searchExpressions = new List <Expression>();
if (!string.IsNullOrWhiteSpace(resourceType))
{
searchExpressions.Add(Expression.SearchParameter(_resourceTypeSearchParameter, Expression.StringEquals(FieldName.TokenCode, null, resourceType, false)));
}
searchExpressions.AddRange(searchParams.Parameters.Select(
q =>
{
try
{
return(_expressionParser.Parse(parsedResourceType.ToString(), q.Item1, q.Item2));
}
catch (SearchParameterNotSupportedException)
{
unsupportedSearchParameters.Add(q);
return(null);
}
})
.Where(item => item != null));
if (!string.IsNullOrWhiteSpace(compartmentType))
{
if (Enum.TryParse(compartmentType, out CompartmentType parsedCompartmentType))
{
if (string.IsNullOrWhiteSpace(compartmentId))
{
throw new InvalidSearchOperationException(Core.Resources.CompartmentIdIsInvalid);
}
searchExpressions.Add(Expression.CompartmentSearch(compartmentType, compartmentId));
}
else
{
throw new InvalidSearchOperationException(string.Format(Core.Resources.CompartmentTypeIsInvalid, compartmentType));
}
}
if (searchExpressions.Count == 1)
{
searchOptions.Expression = searchExpressions[0];
}
else if (searchExpressions.Count > 1)
{
searchOptions.Expression = Expression.And(searchExpressions.ToArray());
}
if (unsupportedSearchParameters.Any())
{
// TODO: Client can specify whether exception should be raised or not when it encounters unknown search parameters.
// For now, we will ignore any unknown search parameters.
}
searchOptions.UnsupportedSearchParams = unsupportedSearchParameters;
if (searchParams.Sort?.Count > 0)
{
var sortings = new List <(SearchParameterInfo, SortOrder)>();
List <(string parameterName, string reason)> unsupportedSortings = null;
foreach (Tuple <string, Hl7.Fhir.Rest.SortOrder> sorting in searchParams.Sort)
{
try
{
SearchParameterInfo searchParameterInfo = _searchParameterDefinitionManager.GetSearchParameter(parsedResourceType.ToString(), sorting.Item1);
sortings.Add((searchParameterInfo, sorting.Item2.ToCoreSortOrder()));
}
catch (SearchParameterNotSupportedException)
{
(unsupportedSortings ?? (unsupportedSortings = new List <(string parameterName, string reason)>())).Add((sorting.Item1, string.Format(Core.Resources.SearchParameterNotSupported, sorting.Item1, resourceType)));
}
}
searchOptions.Sort = sortings;
searchOptions.UnsupportedSortingParams = (IReadOnlyList <(string parameterName, string reason)>)unsupportedSortings ?? Array.Empty <(string parameterName, string reason)>();
}
else
{
searchOptions.Sort = Array.Empty <(SearchParameterInfo searchParameterInfo, SortOrder sortOrder)>();
searchOptions.UnsupportedSortingParams = Array.Empty <(string parameterName, string reason)>();
}
return(searchOptions);
}
public SearchOptions Create(string compartmentType, string compartmentId, string resourceType, IReadOnlyList <Tuple <string, string> > queryParameters)
{
var searchOptions = new SearchOptions();
string continuationToken = null;
var searchParams = new SearchParams();
var unsupportedSearchParameters = new List <Tuple <string, string> >();
bool setDefaultBundleTotal = true;
// Extract the continuation token, filter out the other known query parameters that's not search related.
foreach (Tuple <string, string> query in queryParameters ?? Enumerable.Empty <Tuple <string, string> >())
{
if (query.Item1 == KnownQueryParameterNames.ContinuationToken)
{
// This is an unreachable case. The mapping of the query parameters makes it so only one continuation token can exist.
if (continuationToken != null)
{
throw new InvalidSearchOperationException(
string.Format(Core.Resources.MultipleQueryParametersNotAllowed, KnownQueryParameterNames.ContinuationToken));
}
// Checks if the continuation token is base 64 bit encoded. Needed for systems that have cached continuation tokens from before they were encoded.
if (Base64FormatRegex.IsMatch(query.Item2))
{
continuationToken = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(query.Item2));
}
else
{
continuationToken = query.Item2;
}
setDefaultBundleTotal = false;
}
else if (query.Item1 == KnownQueryParameterNames.Format)
{
// TODO: We need to handle format parameter.
}
else if (string.IsNullOrWhiteSpace(query.Item1) || string.IsNullOrWhiteSpace(query.Item2))
{
// Query parameter with empty value is not supported.
unsupportedSearchParameters.Add(query);
}
else if (string.Compare(query.Item1, KnownQueryParameterNames.Total, StringComparison.OrdinalIgnoreCase) == 0)
{
if (Enum.TryParse <TotalType>(query.Item2, true, out var totalType))
{
ValidateTotalType(totalType);
searchOptions.IncludeTotal = totalType;
setDefaultBundleTotal = false;
}
else
{
throw new BadRequestException(string.Format(Core.Resources.InvalidTotalParameter, query.Item2, SupportedTotalTypes));
}
}
else
{
// Parse the search parameters.
try
{
// Basic format checking (e.g. integer value for _count key etc.).
searchParams.Add(query.Item1, query.Item2);
}
catch (Exception ex)
{
throw new BadRequestException(ex.Message);
}
}
}
searchOptions.ContinuationToken = continuationToken;
if (setDefaultBundleTotal)
{
ValidateTotalType(_featureConfiguration.IncludeTotalInBundle);
searchOptions.IncludeTotal = _featureConfiguration.IncludeTotalInBundle;
}
// Check the item count.
if (searchParams.Count != null)
{
searchOptions.MaxItemCount = searchParams.Count.Value;
}
// Check to see if only the count should be returned
searchOptions.CountOnly = searchParams.Summary == SummaryType.Count;
// If the resource type is not specified, then the common
// search parameters should be used.
ResourceType parsedResourceType = ResourceType.DomainResource;
if (!string.IsNullOrWhiteSpace(resourceType) &&
!Enum.TryParse(resourceType, out parsedResourceType))
{
throw new ResourceNotSupportedException(resourceType);
}
var searchExpressions = new List <Expression>();
if (!string.IsNullOrWhiteSpace(resourceType))
{
searchExpressions.Add(Expression.SearchParameter(_resourceTypeSearchParameter, Expression.StringEquals(FieldName.TokenCode, null, resourceType, false)));
}
searchExpressions.AddRange(searchParams.Parameters.Select(
q =>
{
try
{
return(_expressionParser.Parse(parsedResourceType.ToString(), q.Item1, q.Item2));
}
catch (SearchParameterNotSupportedException)
{
unsupportedSearchParameters.Add(q);
return(null);
}
})
.Where(item => item != null));
if (searchParams.Include?.Count > 0)
{
searchExpressions.AddRange(searchParams.Include.Select(
q => _expressionParser.ParseInclude(parsedResourceType.ToString(), q, false /* not reversed */))
.Where(item => item != null));
}
if (searchParams.RevInclude?.Count > 0)
{
searchExpressions.AddRange(searchParams.RevInclude.Select(
q => _expressionParser.ParseInclude(parsedResourceType.ToString(), q, true /* reversed */))
.Where(item => item != null));
}
if (!string.IsNullOrWhiteSpace(compartmentType))
{
if (Enum.TryParse(compartmentType, out CompartmentType parsedCompartmentType))
{
if (string.IsNullOrWhiteSpace(compartmentId))
{
throw new InvalidSearchOperationException(Core.Resources.CompartmentIdIsInvalid);
}
searchExpressions.Add(Expression.CompartmentSearch(compartmentType, compartmentId));
}
else
{
throw new InvalidSearchOperationException(string.Format(Core.Resources.CompartmentTypeIsInvalid, compartmentType));
}
}
if (searchExpressions.Count == 1)
{
searchOptions.Expression = searchExpressions[0];
}
else if (searchExpressions.Count > 1)
{
searchOptions.Expression = Expression.And(searchExpressions.ToArray());
}
if (unsupportedSearchParameters.Any())
{
// TODO: Client can specify whether exception should be raised or not when it encounters unknown search parameters.
// For now, we will ignore any unknown search parameters.
}
searchOptions.UnsupportedSearchParams = unsupportedSearchParameters;
if (searchParams.Sort?.Count > 0)
{
var sortings = new List <(SearchParameterInfo, SortOrder)>();
List <(string parameterName, string reason)> unsupportedSortings = null;
foreach (Tuple <string, Hl7.Fhir.Rest.SortOrder> sorting in searchParams.Sort)
{
try
{
SearchParameterInfo searchParameterInfo = _searchParameterDefinitionManager.GetSearchParameter(parsedResourceType.ToString(), sorting.Item1);
if (searchParameterInfo.IsSortSupported())
{
sortings.Add((searchParameterInfo, sorting.Item2.ToCoreSortOrder()));
}
else
{
throw new SearchParameterNotSupportedException(string.Format(Core.Resources.SearchSortParameterNotSupported, searchParameterInfo.Name));
}
}
catch (SearchParameterNotSupportedException)
{
(unsupportedSortings ??= new List <(string parameterName, string reason)>()).Add((sorting.Item1, string.Format(Core.Resources.SearchSortParameterNotSupported, sorting.Item1)));
}
}
searchOptions.Sort = sortings;
searchOptions.UnsupportedSortingParams = (IReadOnlyList <(string parameterName, string reason)>)unsupportedSortings ?? Array.Empty <(string parameterName, string reason)>();
}
else
{
searchOptions.Sort = Array.Empty <(SearchParameterInfo searchParameterInfo, SortOrder sortOrder)>();
searchOptions.UnsupportedSortingParams = Array.Empty <(string parameterName, string reason)>();
}
return(searchOptions);
void ValidateTotalType(TotalType totalType)
{
// Estimate is not yet supported.
if (totalType == TotalType.Estimate)
{
throw new SearchOperationNotSupportedException(string.Format(Core.Resources.UnsupportedTotalParameter, totalType, SupportedTotalTypes));
}
}
}