private async Task NormalSearchProcessing(KeyValuePair <string, StringValues> Parameter)
{
List <Bug.Logic.DomainModel.SearchParameter> SearchParameterList = await ISearchParameterCache.GetForIndexingAsync(this.FhirVersion, this.ResourceContext);
//Remove modifiers
var SearchParameterName = Parameter.Key.Split(FhirSearchQuery.TermSearchModifierDelimiter)[0].Trim();
Bug.Logic.DomainModel.SearchParameter SearchParameter = SearchParameterList.SingleOrDefault(x => x.Name == SearchParameterName);
if (SearchParameter != null)
{
IList <ISearchQueryBase> SearchQueryBaseList = await ISearchQueryFactory.Create(this.ResourceContext, SearchParameter, Parameter);
foreach (ISearchQueryBase SearchQueryBase in SearchQueryBaseList)
{
if (SearchQueryBase.IsValid)
{
Outcome !.SearchQueryList.Add(SearchQueryBase);
}
else
{
Outcome !.InvalidSearchQueryList.Add(new InvalidSearchQueryParameter(SearchQueryBase.RawValue, SearchQueryBase.InvalidMessage));
}
}
}
else
{
foreach (var ParamValue in Parameter.Value)
{
string Message = $"The search query parameter: {Parameter.Key} is not supported by this server for the resource type: {ResourceContext.GetCode()}, the whole parameter was : {Parameter.Key}={ParamValue}";
Outcome !.UnsupportedSearchQueryList.Add(new InvalidSearchQueryParameter(Parameter.Key, ParamValue, Message));
}
}
}
public async Task <ChainQueryProcessingOutcome> Process(FhirVersion fhirVersion, ResourceType resourceContext, KeyValuePair <string, StringValues> Parameter)
{
this.FhirVersion = fhirVersion;
this.ResourceContext = resourceContext;
var Outcome = new ChainQueryProcessingOutcome();
this.RawParameter = $"{Parameter.Key}={Parameter.Value}";
string[] ChaimedParameterSplit = Parameter.Key.Split(FhirSearchQuery.TermChainDelimiter);
for (int i = 0; i < ChaimedParameterSplit.Length; i++)
{
//Each segment in the chain is a IsChainedReferance except the last segment in the chain which has the value.
bool IsChainedReferance = !(i == ChaimedParameterSplit.Length - 1);
Bug.Logic.DomainModel.SearchParameter?SearchParameter = null;
string ParameterNameWithModifier = Parameter.Key.Split(FhirSearchQuery.TermChainDelimiter)[i];
StringValues ParameterValue = string.Empty;
//There is no valid Value for a chained reference parameter unless it is the last in a series
//of chains, so don't set it unless this is the last parameter in the whole chain.
if (i == ChaimedParameterSplit.Count() - 1)
{
ParameterValue = Parameter.Value;
}
var SingleChainedParameter = new KeyValuePair <string, StringValues>(ParameterNameWithModifier, ParameterValue);
string ParameterName = string.Empty;
string ParameterModifierTypedResource = string.Empty;
//Check for and deal with modifiers e.g 'Patient' in the example: subject:Patient.family=millar
if (ParameterNameWithModifier.Contains(FhirSearchQuery.TermSearchModifierDelimiter))
{
string[] ParameterModifierSplit = ParameterNameWithModifier.Split(FhirSearchQuery.TermSearchModifierDelimiter);
ParameterName = ParameterModifierSplit[0].Trim();
if (ParameterModifierSplit.Length > 1)
{
ResourceType?ModifierResourceType = IResourceTypeSupport.GetTypeFromName(ParameterModifierSplit[1].Trim());
if (ModifierResourceType.HasValue && IKnownResource.IsKnownResource(this.FhirVersion, ParameterModifierSplit[1].Trim()))
{
ParameterModifierTypedResource = ParameterModifierSplit[1].Trim();
}
else
{
ErrorInSearchParameterProcessing = true;
//If the Parent is ok then we can assume that any error further down the chain is an invalid search term rather than an unsupported term
//as it is clear that this is a FHIR search term and not some other search parameter forgen to FHIR
if (ParentChainSearchParameter is object)
{
InvalidSearchQueryParameterList.Add(new InvalidSearchQueryParameter(this.RawParameter, $"The resource type modifier: {ParameterModifierSplit[1].Trim()} within the chained search query of {this.RawParameter} is not a known resource for FHIR version: {this.FhirVersion.GetCode()} within this server"));
}
else
{
//Here we are only looking up the ParameterName to check weather this should be an unsupported parameter or an invalid parameter.
//If we know the ParameterName then it is invalid whereas if we don't then it is unsupported and both are not known.
List <Bug.Logic.DomainModel.SearchParameter> TempSearchParameterList = await ISearchParameterCache.GetForIndexingAsync(this.FhirVersion, this.ResourceContext);
var TempSearchParameter = TempSearchParameterList.SingleOrDefault(x => x.Name == ParameterName);
if (TempSearchParameter is null)
{
string Message = $"Both the search parameter name: {ParameterName} for the resource type: {this.ResourceContext.GetCode()} and its resource type modifier: {ParameterModifierSplit[1].Trim()} within the chained search query of {this.RawParameter} are unsupported within this server for FHIR version: {this.FhirVersion.GetCode()}.";
UnsupportedSearchQueryParameterList.Add(new InvalidSearchQueryParameter(this.RawParameter, Message));
}
else
{
InvalidSearchQueryParameterList.Add(new InvalidSearchQueryParameter(this.RawParameter, $"The resource type modifier: {ParameterModifierSplit[1].Trim()} within the chained search query of {this.RawParameter} is not a known resource type for this server and FHIR version {this.FhirVersion.GetCode()}."));
}
}
break;
}
}
}
else
{
ParameterName = ParameterNameWithModifier;
}
SearchParameter = await GetSearchParameter(ParameterName);
//We have no resolved a SearchParameter so we parse the value if it is the end of the chain, see IsChainedReferance
//or we are only parsing as a chain segment with no end value
if (SearchParameter != null)
{
//If this is the last parameter in the chain then treat is as not a chain, otherwise treat as a chain
await SetChain(SearchParameter, SingleChainedParameter, IsChainedReferance);
}
else
{
ErrorInSearchParameterProcessing = true;
if (this.InvalidSearchQueryParameterList.Count == 0 && this.UnsupportedSearchQueryParameterList.Count == 0)
{
throw new ApplicationException("Internal Server Error: When processing a chain search query we failed to resolve a search parameter for the query string however their are " +
$"no items found in either the {nameof(InvalidSearchQueryParameterList)} or the {nameof(UnsupportedSearchQueryParameterList)}. This is an error in its self.");
}
break;
}
}
//End of Chain loop
if (!ErrorInSearchParameterProcessing)
{
if (ParentChainSearchParameter is object)
{
Outcome !.SearchQueryList.Add(ParentChainSearchParameter);
return(Outcome);
}
else
{
throw new NullReferenceException(nameof(PreviousChainSearchParameter));
}
}
else
{
InvalidSearchQueryParameterList.ForEach(x => Outcome !.InvalidSearchQueryList.Add(x));
UnsupportedSearchQueryParameterList.ForEach(x => Outcome !.UnsupportedSearchQueryList.Add(x));
return(Outcome);
}
}
