public async Task SetForIndexingAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType, List <SearchParameter> searchParameterList)
{
byte[] jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(searchParameterList);
var RedisOptions = new DistributedCacheEntryOptions()
{
SlidingExpiration = TimeSpan.FromMinutes(IFhirServerConfig.CahceSlidingExpirationMinites)
};
await IDistributedCache.SetAsync(GetCacheKey(fhirVersion, resourceType), jsonUtf8Bytes, RedisOptions);
}
private async Task LoadCompositeSubSearchParameters(Common.Enums.ResourceType ResourceContext, SearchParameter searchParameter, string ParameterValue, string RawValue, ISearchQueryBase SearchQueryBase)
{
if (SearchQueryBase is SearchQueryComposite SearchQueryComposite)
{
List <ISearchQueryBase> SearchParameterBaseList = new List <ISearchQueryBase>();
//Note we OrderBy SequentialOrder as they must be processed in this specific order
foreach (SearchParameterComponent Component in SearchQueryComposite.ComponentList) //Should this be ordered by sentinel?
{
SearchParameter?CompositeSearchParamter = await ISearchParameterRepository.GetByCanonicalUrlAsync(SearchQueryComposite.FhirVersionId, ResourceContext, Component.Definition);
if (CompositeSearchParamter is object)
{
ISearchQueryBase CompositeSubSearchQueryBase = InitalizeSearchQueryEntity(CompositeSearchParamter, ResourceContext, false, RawValue);
SearchParameterBaseList.Add(CompositeSubSearchQueryBase);
}
else
{
//This should not ever happen, but have message in case it does. We should never have a Composite
//search parameter loaded like this as on load it is checked, but you never know!
string Message =
$"Unable to locate one of the SearchParameters referenced in a Composite SearchParametrer type. " +
$"The Composite SearchParametrer Url was: {SearchQueryComposite.Url} for the resource type '{ResourceContext.GetCode()}'. " +
$"This SearchParamter references another SearchParamter with the Canonical Url of {Component.Definition}. " +
$"This SearchParamter can not be located in the FHIR Server. This is most likely a server error that will require investigation to resolve";
SearchQueryComposite.InvalidMessage = Message;
SearchQueryComposite.IsValid = false;
break;
}
}
SearchQueryComposite.ParseCompositeValue(SearchParameterBaseList, ParameterValue);
}
else
{
throw new InvalidCastException($"Unable to cast a {nameof(SearchQueryBase)} to {typeof(SearchQueryComposite).Name} when the {nameof(SearchQueryBase)}.{nameof(SearchQueryBase.SearchParamTypeId)} = {SearchQueryBase.SearchParamTypeId.GetCode()}");
}
}
public async Task <bool> ReferentialIntegrityCheckAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceTypeId, string resourceId, int?versionId = null)
{
if (versionId.HasValue)
{
return(await DbSet.AnyAsync(x =>
x.FhirVersionId == fhirVersion&
x.ResourceTypeId == resourceTypeId&
x.ResourceId == resourceId&
x.VersionId == versionId.Value&
x.IsDeleted == false));
}
else
{
return(await DbSet.AnyAsync(x =>
x.FhirVersionId == fhirVersion&
x.ResourceTypeId == resourceTypeId&
x.ResourceId == resourceId&
x.IsCurrent == true&
x.IsDeleted == false));
}
}
public async Task <ResourceStore?> GetCurrentAsync(Common.Enums.FhirVersion fhirMajorVersion, Common.Enums.ResourceType resourceType, string resourceId)
{
return(await DbSet.SingleOrDefaultAsync(x =>
x.FhirVersionId == fhirMajorVersion&
x.ResourceTypeId == resourceType&
x.ResourceId == resourceId&
x.IsCurrent == true));
}
public async Task <IList <ResourceStore> > GetSearch(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType, IList <ISearchQueryBase> searchQueryList)
{
ExpressionStarter <ResourceStore> Predicate = IPredicateFactory.CurrentMainResource(fhirVersion, resourceType);
Predicate.Extend(await IPredicateFactory.GetResourceStoreIndexPredicate(fhirVersion, resourceType, searchQueryList), PredicateOperator.And);
foreach (var exp in await IPredicateFactory.ChainEntry(_context, resourceType, searchQueryList))
{
Predicate.Extend(exp, PredicateOperator.And);
}
try
{
IQueryable <ResourceStore> Query = DbSet;
Query = Query.AsExpandable().Where(Predicate);
return(await Query.OrderBy(z => z.LastUpdated).ToListAsync());
}
catch (Exception Exec)
{
var mesg = Exec.Message;
throw Exec;
}
//string Debug = Predicate.Expand().ToString();
//return await Predicate2.AsExpandable().Where(Predicate).OrderBy(z => z.LastUpdated).ToListAsync();
}
public async Task <ResourceStore?> GetCurrentMetaAsync(Common.Enums.FhirVersion fhirMajorVersion, Common.Enums.ResourceType resourceType, string resourceId)
{
return(await DbSet.Select(x => new ResourceStore()
{
Id = x.Id,
ResourceId = x.ResourceId,
IsCurrent = x.IsCurrent,
IsDeleted = x.IsDeleted,
LastUpdated = x.LastUpdated,
VersionId = x.VersionId,
FhirVersionId = x.FhirVersionId,
ResourceTypeId = x.ResourceTypeId,
//ResourceType = x.ResourceType
}).SingleOrDefaultAsync(y =>
y.FhirVersionId == fhirMajorVersion &
y.ResourceTypeId == resourceType &
y.ResourceId == resourceId &
y.IsCurrent == true));
}
public async Task <List <SearchParameter> > GetForIndexingAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
return(await DbSet
.Include(d => d.TargetResourceTypeList)
.Where(y => y.FhirVersionId == fhirVersion & y.ResourceTypeList.Any(z => z.ResourceTypeId == resourceType))
.Select(x => new SearchParameter()
{
Id = x.Id,
Name = x.Name,
FhirPath = x.FhirPath,
SearchParamTypeId = x.SearchParamTypeId,
TargetResourceTypeList = x.TargetResourceTypeList,
ComponentList = x.ComponentList,
FhirVersionId = x.FhirVersionId,
ResourceTypeList = x.ResourceTypeList
}).ToListAsync());
//return await DbSet
//.Include(d => d.TargetResourceTypeList)
//.Where(y => y.FhirVersionId == fhirVersion & y.ResourceTypeList.Any(z => z.ResourceTypeId == resourceType))
//.Select(x => new SearchParameter()
//{
// Id = x.Id,
// Name = x.Name,
// FhirPath = x.FhirPath,
// SearchParamTypeId = x.SearchParamTypeId,
// TargetResourceTypeList = x.TargetResourceTypeList,
//}).ToListAsync();
}
public async Task <List <SearchParameter> > GetByResourceTypeAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
return(await DbSet.Where(x => x.FhirVersionId == fhirVersion& x.ResourceTypeList.Any(y => y.ResourceTypeId == resourceType)).ToListAsync());
}
public async Task <bool> AnyAsync(Common.Enums.FhirVersion fhirVersion, int serviceBaseUrlId, Common.Enums.ResourceType resourceTypeId, string resourceId, string?versionId = null)
{
return(await DbSet.AnyAsync(x =>
x.ResourceStore.FhirVersionId == fhirVersion&
x.ServiceBaseUrlId == serviceBaseUrlId&
x.ResourceTypeId == resourceTypeId&
x.ResourceId == resourceId&
x.VersionId == versionId));
}
//Remember that dbSet<ResourceStore> is equal to IQueryable<ResourceStore>
public async Task <IQueryable <ResourceStore> > ChainEntry1(AppDbContext AppDbContext, Common.Enums.ResourceType ParentResourceTypeContext, IList <ISearchQueryBase> SearchQueryList)
{
IEnumerable <ISearchQueryBase> ChainedSearchQueryList = SearchQueryList.Where(x => x.ChainedSearchParameter is object);
IQueryable <ResourceStore> ResourceStoreQuery = AppDbContext.Set <ResourceStore>();
foreach (ISearchQueryBase ChainSearchQuery in ChainedSearchQueryList)
{
if (ChainSearchQuery.ChainedSearchParameter is null)
{
throw new NullReferenceException(nameof(ChainSearchQuery.ChainedSearchParameter));
}
ExpressionStarter <IndexReference> ExpressionStarterIndexReference = PredicateBuilder.New <IndexReference>(true);
Expression <Func <IndexReference, bool> > Query = await ChainRecursion2(AppDbContext, ExpressionStarterIndexReference, ChainSearchQuery);
//Below is not tested and probably fails!!!!
ResourceStoreQuery = ResourceStoreQuery.Where(x => x.ReferenceIndexList.Any(Query.Compile()));
}
return(ResourceStoreQuery);
}
public async Task <ExpressionStarter <ResourceStore> > GetResourceStoreIndexPredicate(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType, IList <ISearchQueryBase> SearchQueryList)
{
IEnumerable <ISearchQueryBase> ChainedSearchQueryList = SearchQueryList.Where(x => x.ChainedSearchParameter is object);
IEnumerable <ISearchQueryBase> NoChainedSearchQueryList = SearchQueryList.Where(x => x.ChainedSearchParameter is null);
//Below must be true 'PredicateBuilder.New<ResourceStore>(true)' in order to get all resource when no query string
ExpressionStarter <ResourceStore> Predicate = PredicateBuilder.New <ResourceStore>(true);
foreach (var Search in NoChainedSearchQueryList)
{
switch (Search.SearchParamTypeId)
{
case Common.Enums.SearchParamType.Number:
IResourceStorePredicateFactory.NumberIndex(Search).ForEach(x => Predicate = Predicate.Or(y => y.QuantityIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.Date:
IResourceStorePredicateFactory.DateTimeIndex(Search).ForEach(x => Predicate = Predicate.Or(y => y.DateTimeIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.String:
IResourceStorePredicateFactory.StringIndex(Search).ForEach(x => Predicate = Predicate.Or(y => y.StringIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.Token:
IResourceStorePredicateFactory.TokenIndex(Search).ForEach(x => Predicate = Predicate.Or(y => y.TokenIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.Reference:
(await IResourceStorePredicateFactory.ReferenceIndex(Search)).ForEach(x => Predicate = Predicate.Or(y => y.ReferenceIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.Composite:
Predicate = await IResourceStorePredicateFactory.CompositeIndex(this, Search);
break;
case Common.Enums.SearchParamType.Quantity:
IResourceStorePredicateFactory.QuantityIndex(Search).ForEach(x => Predicate = Predicate.Or(y => y.QuantityIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.Uri:
IResourceStorePredicateFactory.UriIndex(Search).ForEach(x => Predicate = Predicate.Or(y => y.UriIndexList.Any(x.Compile())));
break;
case Common.Enums.SearchParamType.Special:
throw new Common.Exceptions.FhirFatalException(System.Net.HttpStatusCode.InternalServerError, new string[] { $"Attempt to search with a SearchParameter of type: {Common.Enums.SearchParamType.Special.GetCode()} which is not supported by this server." });
default:
break;
}
Predicate = Predicate.Extend(Predicate, PredicateOperator.And);
}
return(Predicate);
}
public ExpressionStarter <ResourceStore> CurrentMainResource(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
return(IResourceStorePredicateFactory.CurrentMainResource(fhirVersion, resourceType));
}
public async Task <List <ExpressionStarter <ResourceStore> > > ChainEntry(AppDbContext AppDbContext, Common.Enums.ResourceType ParentResourceTypeContext, IList <ISearchQueryBase> SearchQueryList)
{
var Result = new List <ExpressionStarter <ResourceStore> >();
IEnumerable <ISearchQueryBase> ChainedSearchQueryList = SearchQueryList.Where(x => x.ChainedSearchParameter is object);
IQueryable <ResourceStore> ResourceStoreQuery = AppDbContext.Set <ResourceStore>();
foreach (ISearchQueryBase ChainSearchQuery in ChainedSearchQueryList)
{
if (ChainSearchQuery.ChainedSearchParameter is null)
{
throw new NullReferenceException(nameof(ChainSearchQuery.ChainedSearchParameter));
}
ExpressionStarter <IndexReference> ExpressionStarterIndexReference = PredicateBuilder.New <IndexReference>(false);
ExpressionStarterIndexReference = await ChainRecursion2(AppDbContext, ExpressionStarterIndexReference, ChainSearchQuery);
ExpressionStarter <ResourceStore> ExpressionStarterResourceStore = PredicateBuilder.New <ResourceStore>(false);
ExpressionStarterResourceStore = ExpressionStarterResourceStore.And(r => r.ReferenceIndexList.Any(ExpressionStarterIndexReference));
Result.Add(ExpressionStarterResourceStore);
}
return(Result);
}
private string GetCacheKey(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
return($"{ParameterName}{((int)fhirVersion).ToString()}+{((int)resourceType).ToString()}");
}
public async Task RemoveForIndexingAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
await IDistributedCache.RemoveAsync(GetCacheKey(fhirVersion, resourceType));
}
public async Task <IList <ResourceStore> > GetResourceHistoryListAsync(Common.Enums.FhirVersion fhirMajorVersion, Common.Enums.ResourceType resourceType)
{
return(await DbSet.Select(x => new ResourceStore()
{
Id = x.Id,
ResourceId = x.ResourceId,
IsCurrent = x.IsCurrent,
IsDeleted = x.IsDeleted,
LastUpdated = x.LastUpdated,
VersionId = x.VersionId,
ResourceBlob = x.ResourceBlob,
FhirVersionId = x.FhirVersionId,
ResourceTypeId = x.ResourceTypeId,
ResourceType = x.ResourceType,
MethodId = x.MethodId,
HttpStatusCodeId = x.HttpStatusCodeId,
HttpStatusCode = x.HttpStatusCode
}).Where(y =>
y.FhirVersionId == fhirMajorVersion &
y.ResourceTypeId == resourceType).OrderBy(z => z.LastUpdated).ToListAsync());
}
public async Task <SearchParameter> GetByNameAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType, string name)
{
return(await DbSet.SingleOrDefaultAsync(x => x.FhirVersionId == fhirVersion& x.Name == name& x.ResourceTypeList.Any(y => y.ResourceTypeId == resourceType)));
}
public async Task <List <ReferentialIntegrityQuery> > GetResourcesReferenced(Common.Enums.FhirVersion fhirVersion, int serviceBaseUrlId, Common.Enums.ResourceType resourceTypeId, string resourceId, string?versionId = null)
{
return(await DbSet.Select(x => new ReferentialIntegrityQuery()
{
TargetResourceId = x.ResourceStore.ResourceId,
TargetResourceTypeId = x.ResourceStore.ResourceTypeId,
FhirVersionId = x.ResourceStore.FhirVersionId,
ServiceBaseUrlId = x.ServiceBaseUrlId,
ResourceTypeId = x.ResourceTypeId,
ResourceId = x.ResourceId,
VersionId = x.VersionId
}).Distinct().Take(100).Where(x =>
x.FhirVersionId == fhirVersion &
x.ServiceBaseUrlId == serviceBaseUrlId &
x.ResourceTypeId == resourceTypeId &
x.ResourceId == resourceId &
x.VersionId == versionId).ToListAsync());
}
public async Task <SearchParameter?> GetByCanonicalUrlAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType, string CanonicalUrl)
{
return(await DbSet.SingleOrDefaultAsync(x => x.FhirVersionId == fhirVersion& x.Url == CanonicalUrl& x.ResourceTypeList.Any(y => y.ResourceTypeId == resourceType)));
}
public void TestQueryTypesPositive(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType ResourceContext, Common.Enums.SearchParamType SearchParamType, string searchParameterName, string queryValue)
{
//Prepare
Setup();
List <SearchParameter> SearchParameterListForResource = ISearchParameterCacheMock !.Object.GetForIndexingAsync(fhirVersion, ResourceContext).Result;
SearchParameter SearchParameter = SearchParameterListForResource.SingleOrDefault(x => x.Name == searchParameterName);
var Parameter = new KeyValuePair <string, StringValues>(searchParameterName, new StringValues(queryValue));
//Act
IList <ISearchQueryBase> ISearchQueryBaseList = SearchQueryFactory !.Create(ResourceContext, SearchParameter, Parameter, false).Result;
//Assert
Assert.Equal(1, ISearchQueryBaseList.Count);
ISearchQueryBase SearchQueryResult = ISearchQueryBaseList[0];
Assert.Null(SearchQueryResult.ChainedSearchParameter);
if (SearchParamType == Common.Enums.SearchParamType.Composite)
{
Assert.NotNull(SearchQueryResult.ComponentList);
//We are only assuming all Composite have only two components here, which is not always true
Assert.Equal(2, SearchQueryResult.ComponentList.Count);
}
else
{
Assert.Equal(0, SearchQueryResult.ComponentList.Count);
}
Assert.Equal(fhirVersion, SearchQueryResult.FhirVersionId);
Assert.Equal(queryValue.Contains(','), SearchQueryResult.HasLogicalOrProperties);
Assert.Equal(string.Empty, SearchQueryResult.InvalidMessage);
Assert.True(SearchQueryResult.IsValid);
Assert.Null(SearchQueryResult.Modifier);
Assert.Equal(searchParameterName, SearchQueryResult.Name);
Assert.Equal($"{searchParameterName}={queryValue}", SearchQueryResult.RawValue);
Assert.Equal(ResourceContext, SearchQueryResult.ResourceContext);
Assert.True(SearchQueryResult.ResourceTypeList.Count > 0);
Assert.Contains(SearchQueryResult.ResourceTypeList.ToArray(), x => x.ResourceTypeId == ResourceContext);
Assert.Equal(SearchParamType, SearchQueryResult.SearchParamTypeId);
if (SearchParamType == Common.Enums.SearchParamType.Reference)
{
Assert.True(SearchQueryResult.TargetResourceTypeList.Count > 0);
}
else
{
Assert.True(SearchQueryResult.TargetResourceTypeList.Count == 0);
}
Assert.False(SearchQueryResult.TypeModifierResource.HasValue);
if (SearchQueryResult is SearchQueryComposite SearchQueryComposite)
{
Assert.Equal(2, SearchQueryResult.ComponentList.Count);
Assert.True(SearchQueryComposite.ValueList.Count == 1);
Assert.True(SearchQueryComposite.ValueList[0].SearchQueryBaseList.Count == 2);
if (SearchQueryComposite.ValueList[0].SearchQueryBaseList[0] is SearchQueryToken SearchQueryToken)
{
Assert.True(SearchQueryToken.ValueList.Count == 1);
Assert.Equal(queryValue.Split('$')[0].Split('|')[0], SearchQueryToken.ValueList[0].System);
Assert.Equal(queryValue.Split('$')[0].Split('|')[1], SearchQueryToken.ValueList[0].Code);
}
}
else if (SearchQueryResult is SearchQueryString SearchQueryString)
{
if (queryValue.Contains(','))
{
Assert.Equal(StringSupport.ToLowerTrimRemoveDiacriticsTruncate(queryValue.Split(',')[0], DatabaseMetaData.FieldLength.StringMaxLength), SearchQueryString.ValueList[0].Value);
Assert.Equal(StringSupport.ToLowerTrimRemoveDiacriticsTruncate(queryValue.Split(',')[1], DatabaseMetaData.FieldLength.StringMaxLength), SearchQueryString.ValueList[1].Value);
}
else
{
Assert.Equal(StringSupport.ToLowerTrimRemoveDiacriticsTruncate(queryValue, DatabaseMetaData.FieldLength.StringMaxLength), SearchQueryString.ValueList[0].Value);
}
}
else if (SearchQueryResult is SearchQueryReference SearchQueryReference)
{
Assert.NotNull(SearchQueryReference.ValueList[0].FhirUri);
if (queryValue.StartsWith(TestData.BaseUrlServer))
{
Assert.Equal(Common.Enums.ResourceType.Patient.GetCode(), SearchQueryReference.ValueList[0].FhirUri !.ResourseName);
Assert.Equal("11", SearchQueryReference.ValueList[0].FhirUri !.ResourceId);
Assert.True(SearchQueryReference.ValueList[0].FhirUri !.IsRelativeToServer);
}
else if (queryValue.StartsWith(TestData.BaseUrlRemote))
{
Assert.Equal(Common.Enums.ResourceType.Patient.GetCode(), SearchQueryReference.ValueList[0].FhirUri !.ResourseName);
Assert.Equal("11", SearchQueryReference.ValueList[0].FhirUri !.ResourceId);
Assert.False(SearchQueryReference.ValueList[0].FhirUri !.IsRelativeToServer);
}
else if (queryValue.Contains('/'))
{
Assert.Equal(queryValue.Split('/')[0], SearchQueryReference.ValueList[0].FhirUri !.ResourseName);
Assert.Equal(queryValue.Split('/')[1], SearchQueryReference.ValueList[0].FhirUri !.ResourceId);
}
else
{
Assert.Equal(Common.Enums.ResourceType.Encounter.GetCode(), SearchQueryReference.ValueList[0].FhirUri !.ResourseName);
Assert.Equal(queryValue, SearchQueryReference.ValueList[0].FhirUri !.ResourceId);
}
}
else if (SearchQueryResult is SearchQueryToken SearchQueryToken)
{
if (queryValue.StartsWith("code"))
{
Assert.Null(SearchQueryToken.ValueList[0].System);
Assert.Equal(queryValue, SearchQueryToken.ValueList[0].Code);
}
else if (queryValue.EndsWith("|"))
{
Assert.Null(SearchQueryToken.ValueList[0].Code);
Assert.Equal(queryValue.TrimEnd('|'), SearchQueryToken.ValueList[0].System);
}
else
{
Assert.Equal(queryValue.Split('|')[0], SearchQueryToken.ValueList[0].System);
Assert.Equal(queryValue.Split('|')[1], SearchQueryToken.ValueList[0].Code);
}
}
else if (SearchQueryResult is SearchQueryQuantity SearchQueryQuantity)
{
Assert.Equal(queryValue.Split('|')[1], SearchQueryQuantity.ValueList[0].System);
Assert.Equal(queryValue.Split('|')[2], SearchQueryQuantity.ValueList[0].Code);
if (queryValue.Split('|')[0].Contains("e+10") && queryValue.Split('|')[0].StartsWith('-'))
{
Assert.Equal(-54000000000m, SearchQueryQuantity.ValueList[0].Value);
Assert.Equal(0, SearchQueryQuantity.ValueList[0].Scale);
Assert.Equal(11, SearchQueryQuantity.ValueList[0].Precision);
}
else if (queryValue.Split('|')[0].Contains("e-3"))
{
Assert.Equal(0.00540m, SearchQueryQuantity.ValueList[0].Value);
Assert.Equal(5, SearchQueryQuantity.ValueList[0].Scale);
Assert.Equal(5, SearchQueryQuantity.ValueList[0].Precision);
}
else if (queryValue.Split('|')[0].Contains("e+10"))
{
Assert.Equal(54000000000m, SearchQueryQuantity.ValueList[0].Value);
Assert.Equal(0, SearchQueryQuantity.ValueList[0].Scale);
Assert.Equal(11, SearchQueryQuantity.ValueList[0].Precision);
}
else
{
Assert.Equal(Decimal.Parse(queryValue.Split('|')[0]), SearchQueryQuantity.ValueList[0].Value);
Assert.Equal(1, SearchQueryQuantity.ValueList[0].Scale);
Assert.Equal(2, SearchQueryQuantity.ValueList[0].Precision);
}
}
else if (SearchQueryResult is SearchQueryNumber SearchQueryNumber)
{
if (queryValue.StartsWith("gt"))
{
Assert.Equal(100, SearchQueryNumber.ValueList[0].Value);
Assert.Equal(0, SearchQueryNumber.ValueList[0].Scale);
Assert.Equal(3, SearchQueryNumber.ValueList[0].Precision);
Assert.Equal(SearchComparator.Gt, SearchQueryNumber.ValueList[0].Prefix);
}
else if (queryValue.StartsWith("lt"))
{
Assert.Equal(100, SearchQueryNumber.ValueList[0].Value);
Assert.Equal(0, SearchQueryNumber.ValueList[0].Scale);
Assert.Equal(3, SearchQueryNumber.ValueList[0].Precision);
Assert.Equal(SearchComparator.Lt, SearchQueryNumber.ValueList[0].Prefix);
}
else if (queryValue == "100")
{
Assert.Equal(100, SearchQueryNumber.ValueList[0].Value);
Assert.Equal(0, SearchQueryNumber.ValueList[0].Scale);
Assert.Equal(3, SearchQueryNumber.ValueList[0].Precision);
Assert.Null(SearchQueryNumber.ValueList[0].Prefix);
}
else if (queryValue == "100.00")
{
Assert.Equal(100.00m, SearchQueryNumber.ValueList[0].Value);
Assert.Equal(2, SearchQueryNumber.ValueList[0].Scale);
Assert.Equal(5, SearchQueryNumber.ValueList[0].Precision);
Assert.Null(SearchQueryNumber.ValueList[0].Prefix);
}
}
else if (SearchQueryResult is SearchQueryDateTime SearchQueryDateTime)
{
if (queryValue.StartsWith("gt"))
{
var testDate = new DateTimeOffset(new DateTime(2020, 04, 07), TimeSpan.FromHours(10));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.Day, SearchQueryDateTime.ValueList[0].Precision);
Assert.Equal(SearchComparator.Gt, SearchQueryDateTime.ValueList[0].Prefix);
}
else if (queryValue.Length == 16)
{
var testDate = new DateTimeOffset(new DateTime(2020, 04, 07, 10, 00, 00), TimeSpan.FromHours(10));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.HourMin, SearchQueryDateTime.ValueList[0].Precision);
}
else if (queryValue.Length == 4)
{
var testDate = new DateTimeOffset(new DateTime(2020, 01, 01), TimeSpan.FromHours(10));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.Year, SearchQueryDateTime.ValueList[0].Precision);
}
else if (queryValue.Length == 7)
{
var testDate = new DateTimeOffset(new DateTime(2020, 04, 01), TimeSpan.FromHours(10));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.Month, SearchQueryDateTime.ValueList[0].Precision);
}
else if (queryValue.Length == 10)
{
var testDate = new DateTimeOffset(new DateTime(2020, 04, 07), TimeSpan.FromHours(10));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.Day, SearchQueryDateTime.ValueList[0].Precision);
}
else if (queryValue.Length == 19)
{
var testDate = new DateTimeOffset(new DateTime(2020, 04, 07, 10, 00, 10), TimeSpan.FromHours(10));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.Sec, SearchQueryDateTime.ValueList[0].Precision);
}
else if (queryValue.Length == 25)
{
var testDate = new DateTimeOffset(new DateTime(2020, 04, 07, 10, 00, 10), TimeSpan.FromHours(5));
Assert.Equal(testDate.ToUniversalTime().DateTime, SearchQueryDateTime.ValueList[0].Value);
Assert.Equal(DateTimePrecision.Sec, SearchQueryDateTime.ValueList[0].Precision);
}
}
else if (SearchQueryResult is SearchQueryUri SearchQueryUri)
{
Assert.Equal(new Uri(queryValue), SearchQueryUri.ValueList[0].Value);
}
else
{
Assert.Null(SearchQueryResult.ComponentList);
}
}
public async Task <List <SearchParameter> > GetForSearchQueryAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
return(await DbSet
.Include(d => d.TargetResourceTypeList)
.Where(y => y.FhirVersionId == fhirVersion & y.ResourceTypeList.Any(z => z.ResourceTypeId == resourceType))
.Select(x => new SearchParameter()
{
Id = x.Id,
Name = x.Name,
FhirPath = x.FhirPath,
SearchParamTypeId = x.SearchParamTypeId,
TargetResourceTypeList = x.TargetResourceTypeList,
FhirVersionId = x.FhirVersionId,
ResourceTypeList = x.ResourceTypeList
}).ToListAsync());
}
public async Task <List <SearchParameter> > GetForIndexingAsync(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
//We synchronously get both the requested ResourceType and the Resource ResourceType from Redis
Task <byte[]?> ResourceResourceTask = IDistributedCache.GetAsync(GetCacheKey(fhirVersion, Common.Enums.ResourceType.Resource));
Task <byte[]?> RequestedResourceTypeTask = IDistributedCache.GetAsync(GetCacheKey(fhirVersion, resourceType));
await Task.WhenAll(ResourceResourceTask, RequestedResourceTypeTask);
//If the requested ResourceType was not found then get from the database
List <SearchParameter> RequestedResourceTypeSearchParameterList;
if (RequestedResourceTypeTask.Result is object)
{
RequestedResourceTypeSearchParameterList = JsonSerializer.Deserialize <List <SearchParameter> >(RequestedResourceTypeTask.Result);
}
else
{
RequestedResourceTypeSearchParameterList = await ISearchParameterRepository.GetForIndexingAsync(fhirVersion, resourceType);
if (RequestedResourceTypeSearchParameterList.Count > 0)
{
await this.SetForIndexingAsync(fhirVersion, resourceType, RequestedResourceTypeSearchParameterList);
}
}
//If the Resource ResourceType was not found then get from the database
List <SearchParameter> ResourceResourceTypeSearchParameterList;
if (ResourceResourceTask.Result is object)
{
ResourceResourceTypeSearchParameterList = JsonSerializer.Deserialize <List <SearchParameter> >(ResourceResourceTask.Result);
}
else
{
ResourceResourceTypeSearchParameterList = await ISearchParameterRepository.GetForIndexingAsync(fhirVersion, Common.Enums.ResourceType.Resource);
if (ResourceResourceTypeSearchParameterList.Count > 0)
{
await this.SetForIndexingAsync(fhirVersion, Common.Enums.ResourceType.Resource, ResourceResourceTypeSearchParameterList);
}
}
//Combine the two lists into one
RequestedResourceTypeSearchParameterList.AddRange(ResourceResourceTypeSearchParameterList);
return(RequestedResourceTypeSearchParameterList);
}
