private Expression ParseSearchValueExpression(SearchParameterInfo searchParameter, string modifier, string value)
{
SearchModifier parsedModifier = ParseSearchParamModifier();
return(_searchParameterExpressionParser.Parse(searchParameter, parsedModifier, value));
SearchModifier ParseSearchParamModifier()
{
if (string.IsNullOrEmpty(modifier))
{
return(null);
}
if (SearchParamModifierMapping.TryGetValue(modifier, out SearchModifierCode searchModifierCode))
{
return(new SearchModifier(searchModifierCode));
}
// Modifier on a Reference Search Parameter can be used to restrict target type
if (searchParameter.Type == SearchParamType.Reference && searchParameter.TargetResourceTypes.Contains(modifier, StringComparer.OrdinalIgnoreCase))
{
return(new SearchModifier(SearchModifierCode.Type, modifier));
}
throw new InvalidSearchOperationException(
string.Format(Core.Resources.ModifierNotSupported, modifier, searchParameter.Code));
}
}
public IList <Category> LoadRange(int startIndex, int count, SortDescriptionCollection sortDescriptions, out int overallCount)
{
var retVal = new List <Category>();
using (var repository = _repositoryFactory.GetRepositoryInstance())
{
var query = repository.Categories.Expand("Catalog").OfType <Category>();
if (!String.IsNullOrEmpty(SearchName))
{
query = query.Where(x => x.Name.Contains(SearchName));
}
if (!String.IsNullOrEmpty(SearchCode))
{
query = query.Where(x => x.Code.Contains(SearchCode));
}
if (!String.IsNullOrEmpty(SearchCatalogId))
{
query = query.Where(x => x.CatalogId == SearchCatalogId);
}
else if (SearchModifier.HasFlag(SearchCategoryModifier.RealCatalogsOnly))
{
query = query.Where(x => x.Catalog is catalogModel.Catalog);
}
overallCount = query.Count();
var results = query.OrderBy(x => x.CatalogId).Skip(startIndex).Take(count);
retVal.AddRange(results);
}
return(retVal);
}
private void Validate(
SearchParameterInfo searchParameter,
SearchModifier modifier,
string value,
Action <Expression> valueValidator)
{
Expression expression = _parser.Parse(searchParameter, modifier, value);
Assert.NotNull(expression);
ValidateSearchParameterExpression(expression, DefaultParamName, valueValidator);
}
public void InitializeForOpen()
{
CanChangeSearchCatalog = SearchModifier.HasFlag(SearchCategoryModifier.UserCanChangeSearchCatalog) ||
(!(_catalogInfo is CatalogBase) && string.IsNullOrEmpty(_catalogInfo as string));
if (_catalogInfo is CatalogBase && !CanChangeSearchCatalog)
{
AvailableCatalogs = new List <CatalogBase> {
(CatalogBase)_catalogInfo
};
SearchCatalogId = AvailableCatalogs[0].CatalogId;
}
else
{
if (_catalogInfo is CatalogBase)
{
SearchCatalogId = ((CatalogBase)_catalogInfo).CatalogId;
}
else if (!string.IsNullOrEmpty(_catalogInfo as string))
{
SearchCatalogId = (string)_catalogInfo;
}
using (var repository = _repositoryFactory.GetRepositoryInstance())
{
var query = repository.Catalogs;
if (!string.IsNullOrEmpty(SearchCatalogId) && !CanChangeSearchCatalog)
{
query = query.Where(x => x.CatalogId == SearchCatalogId);
}
else
{
if (SearchModifier.HasFlag(SearchCategoryModifier.RealCatalogsOnly))
{
query = query.OfType <catalogModel.Catalog>();
}
query = query.OrderBy(x => x.Name);
}
AvailableCatalogs = query.ToList();
}
}
SearchCommand = new DelegateCommand(DoSearch);
ClearFiltersCommand = new DelegateCommand(DoClearFilters);
SelectCommand = new DelegateCommand <Category>(RaiseSelectInteractionRequest);
ListItemsSource = new VirtualList <Category>(this, 20, SynchronizationContext.Current);
}
public Expression Build(
string searchParameterName,
SearchModifier modifier,
SearchComparator comparator,
int?componentIndex,
ISearchValue searchValue)
{
EnsureArg.IsNotNullOrWhiteSpace(searchParameterName, nameof(searchParameterName));
Debug.Assert(
Enum.IsDefined(typeof(SearchComparator), comparator),
"Invalid comparator.");
EnsureArg.IsNotNull(searchValue, nameof(searchValue));
_searchParameterName = searchParameterName;
_modifier = modifier;
_comparator = comparator;
_componentIndex = componentIndex;
searchValue.AcceptVisitor(this);
return(_outputExpression);
}
public void GivenAReferenceWithInvalidModifier_WhenBuilding_ThenInvalidSearchOperationExceptionShouldBeThrown(SearchModifier modifier)
{
_referenceSearchValueParser.Parse(Arg.Any <string>()).Returns(new ReferenceSearchValue(ReferenceKind.InternalOrExternal, null, null, "123"));
Assert.Throws <InvalidSearchOperationException>(
() => _parser.Parse(CreateSearchParameter(SearchParamType.Reference), modifier, "Patient/test"));
}
public void GivenAQuantityWithInvalidModifier_WhenBuilding_ThenInvalidSearchOperationExceptionShouldBeThrown(SearchModifier modifier)
{
Assert.Throws <InvalidSearchOperationException>(
() => _parser.Parse(CreateSearchParameter(SearchParamType.Quantity), modifier, "1"));
}
public void GivenACompositeWithInvalidModifier_WhenBuilding_ThenInvalidSearchOperationExceptionShouldBeThrown(SearchModifier modifier)
{
var quantityUri = new Uri("http://quantity");
SearchParameterComponentInfo[] components = new[] { new SearchParameterComponentInfo(quantityUri), new SearchParameterComponentInfo(quantityUri) };
var searchParameter1 = new SearchParameterInfo(
DefaultParamName,
DefaultParamName,
Microsoft.Health.Fhir.ValueSets.SearchParamType.Composite,
components: components);
SearchParameterInfo searchParameter = searchParameter1;
_searchParameterDefinitionManager.GetSearchParameter(quantityUri.OriginalString).Returns(
new SearchParameter
{
Name = "quantity",
Code = "quantity",
Type = SearchParamType.Quantity,
}.ToInfo());
Assert.Throws <InvalidSearchOperationException>(
() => _parser.Parse(CreateSearchParameter(SearchParamType.Composite), modifier, "10|s|c$10|s|c"));
}
