private List <(string ResourceType, SearchParameterInfo SearchParameter)> ValidateAndGetFlattenedList()
{
var issues = new List <OperationOutcomeIssue>();
Bundle bundle = null;
if (!string.IsNullOrWhiteSpace(_unsupportedParamsEmbeddedResourceName))
{
using Stream stream = _assembly.GetManifestResourceStream(_unsupportedParamsEmbeddedResourceName);
using TextReader reader = new StreamReader(stream);
_unsupportedParams = JsonConvert.DeserializeObject <UnsupportedSearchParameters>(reader.ReadToEnd());
}
using (Stream stream = _assembly.GetManifestResourceStream(_embeddedResourceName))
{
using TextReader reader = new StreamReader(stream);
using JsonReader jsonReader = new JsonTextReader(reader);
try
{
// The parser does some basic validation such as making sure entry is not null, enum has the right value, and etc.
bundle = _fhirJsonParser.Parse <Bundle>(jsonReader);
}
catch (FormatException ex)
{
AddIssue(ex.Message);
}
}
EnsureNoIssues();
// Do the first pass to make sure all resources are SearchParameter.
for (int entryIndex = 0; entryIndex < bundle.Entry.Count; entryIndex++)
{
// Make sure resources are not null and they are SearchParameter.
EntryComponent entry = bundle.Entry[entryIndex];
var searchParameter = entry.Resource as SearchParameter;
if (searchParameter == null)
{
AddIssue(Core.Resources.SearchParameterDefinitionInvalidResource, entryIndex);
continue;
}
try
{
_uriDictionary.Add(new Uri(searchParameter.Url), CreateSearchParameterInfo(searchParameter));
}
catch (FormatException)
{
AddIssue(Core.Resources.SearchParameterDefinitionInvalidDefinitionUri, entryIndex);
continue;
}
catch (ArgumentException)
{
AddIssue(Core.Resources.SearchParameterDefinitionDuplicatedEntry, searchParameter.Url);
continue;
}
}
EnsureNoIssues();
var validatedSearchParameters = new List <(string ResourceType, SearchParameterInfo SearchParameter)>
{
// _type is currently missing from the search params definition bundle, so we inject it in here.
(ResourceType.Resource.ToString(), new SearchParameterInfo(SearchParameterNames.ResourceType, SearchParamType.Token.ToString(), SearchParameterNames.ResourceTypeUri, null, "Resource.type().name", null)),
};
// Do the second pass to make sure the definition is valid.
for (int entryIndex = 0; entryIndex < bundle.Entry.Count; entryIndex++)
{
var searchParameter = (SearchParameter)bundle.Entry[entryIndex].Resource;
// If this is a composite search parameter, then make sure components are defined.
if (searchParameter.Type == SearchParamType.Composite)
{
if (searchParameter.Component?.Count == 0)
{
AddIssue(Core.Resources.SearchParameterDefinitionInvalidComponent, searchParameter.Url);
continue;
}
for (int componentIndex = 0; componentIndex < searchParameter.Component.Count; componentIndex++)
{
ComponentComponent component = searchParameter.Component[componentIndex];
if (component.GetComponentDefinitionUri() == null ||
!_uriDictionary.TryGetValue(component.GetComponentDefinitionUri(), out SearchParameterInfo componentSearchParameter))
{
AddIssue(
Core.Resources.SearchParameterDefinitionInvalidComponentReference,
searchParameter.Url,
componentIndex);
continue;
}
if (componentSearchParameter.Type == SearchParamType.Composite.ToValueSet())
{
AddIssue(
Core.Resources.SearchParameterDefinitionComponentReferenceCannotBeComposite,
searchParameter.Url,
componentIndex);
continue;
}
if (string.IsNullOrWhiteSpace(component.Expression))
{
AddIssue(
Core.Resources.SearchParameterDefinitionInvalidComponentExpression,
searchParameter.Url,
componentIndex);
continue;
}
}
}
// Make sure the base is defined.
if (searchParameter.BaseElement?.Count == 0)
{
AddIssue(Core.Resources.SearchParameterDefinitionBaseNotDefined, searchParameter.Url);
continue;
}
for (int baseElementIndex = 0; baseElementIndex < searchParameter.BaseElement.Count; baseElementIndex++)
{
Code <ResourceType> code = searchParameter.BaseElement[baseElementIndex];
string baseResourceType = code.Value.Value.ToString();
// Make sure the expression is not empty unless they are known to have empty expression.
// These are special search parameters that searches across all properties and needs to be handled specially.
if (ShouldExcludeEntry(baseResourceType, searchParameter.Name))
{
continue;
}
else
{
if (string.IsNullOrWhiteSpace(searchParameter.Expression))
{
AddIssue(Core.Resources.SearchParameterDefinitionInvalidExpression, searchParameter.Url);
continue;
}
}
validatedSearchParameters.Add((baseResourceType, CreateSearchParameterInfo(searchParameter)));
}
}
EnsureNoIssues();
return(validatedSearchParameters);
void AddIssue(string format, params object[] args)
{
issues.Add(new OperationOutcomeIssue(
OperationOutcomeConstants.IssueSeverity.Fatal,
OperationOutcomeConstants.IssueType.Invalid,
string.Format(CultureInfo.InvariantCulture, format, args)));
}
void EnsureNoIssues()
{
if (issues.Count != 0)
{
throw new InvalidDefinitionException(
Core.Resources.SearchParameterDefinitionContainsInvalidEntry,
issues.ToArray());
}
}
}
public Expression Parse(
SearchParameter searchParameter,
SearchModifierCode?modifier,
string value)
{
EnsureArg.IsNotNull(searchParameter, nameof(searchParameter));
Debug.Assert(
modifier == null || Enum.IsDefined(typeof(SearchModifierCode), modifier.Value),
"Invalid modifier.");
EnsureArg.IsNotNullOrWhiteSpace(value, nameof(value));
Expression outputExpression;
if (modifier == SearchModifierCode.Missing)
{
// We have to handle :missing modifier specially because if :missing modifier is specified,
// then the value is a boolean string indicating whether the parameter is missing or not instead of
// the search value type associated with the search parameter.
if (!bool.TryParse(value, out bool isMissing))
{
// An invalid value was specified.
throw new InvalidSearchOperationException(Core.Resources.InvalidValueTypeForMissingModifier);
}
return(Expression.MissingSearchParameter(searchParameter.ToInfo(), isMissing));
}
if (modifier == SearchModifierCode.Text)
{
// We have to handle :text modifier specially because if :text modifier is supplied for token search param,
// then we want to search the display text using the specified text, and therefore
// we don't want to actually parse the specified text into token.
if (searchParameter.Type != SearchParamType.Token)
{
throw new InvalidSearchOperationException(
string.Format(CultureInfo.InvariantCulture, Core.Resources.ModifierNotSupported, modifier, searchParameter.Name));
}
outputExpression = Expression.Contains(FieldName.TokenText, null, value, true);
}
else
{
// Build the expression for based on the search value.
if (searchParameter.Type == SearchParamType.Composite)
{
if (modifier != null)
{
throw new InvalidSearchOperationException(
string.Format(CultureInfo.InvariantCulture, Core.Resources.ModifierNotSupported, modifier, searchParameter.Name));
}
IReadOnlyList <string> compositeValueParts = value.SplitByCompositeSeparator();
if (compositeValueParts.Count > searchParameter.Component.Count)
{
throw new InvalidSearchOperationException(
string.Format(CultureInfo.InvariantCulture, Core.Resources.NumberOfCompositeComponentsExceeded, searchParameter.Name));
}
var compositeExpressions = new Expression[compositeValueParts.Count];
for (int i = 0; i < compositeValueParts.Count; i++)
{
ComponentComponent component = searchParameter.Component[i];
// Find the corresponding search parameter info.
SearchParameter componentSearchParameter = _searchParameterDefinitionManager.GetSearchParameter(component.GetComponentDefinitionUri());
string componentValue = compositeValueParts[i];
compositeExpressions[i] = Build(
componentSearchParameter,
modifier: null,
componentIndex: i,
value: componentValue);
}
outputExpression = Expression.And(compositeExpressions);
}
else
{
outputExpression = Build(
searchParameter,
modifier,
componentIndex: null,
value: value);
}
}
return(Expression.SearchParameter(searchParameter.ToInfo(), outputExpression));
}
