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); } }