public FhirApiResult(HttpStatusCode HttpStatusCode, Common.Enums.FhirVersion FhirVersion, string CorrelationId)
{
this.HttpStatusCode = HttpStatusCode;
this.FhirVersion = FhirVersion;
this.CorrelationId = CorrelationId;
this.Headers = new Dictionary <string, StringValues>();
}
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 void ReadQueryTest(Common.Enums.FhirVersion fhirVersion, string resourceName, string resourceId)
{
//Setup
var IOperationOutcomeSupportMock = IOperationOutcomeSupport_MockFactory.Get();
var IFhirResourceNameSupportMock = IFhirResourceNameSupport_MockFactory.Get(resourceName);
var IFhirResourceIdSupportMock = IFhirResourceIdSupport_MockFactory.Get(resourceId);
FhirUriFactory FhirUriFactory = GetFhirUriFactory(resourceName);
ValidateQueryService ValidateQueryService = new ValidateQueryService(IOperationOutcomeSupportMock.Object, IFhirResourceNameSupportMock.Object, IFhirResourceIdSupportMock.Object, FhirUriFactory);
var ReadQuery = new ReadQuery(
HttpVerb.GET,
fhirVersion,
new Uri($"{TestData.BaseUrlServer}/{resourceName}/{resourceId}"),
new Dictionary <string, Microsoft.Extensions.Primitives.StringValues>(),
new Dictionary <string, Microsoft.Extensions.Primitives.StringValues>(),
resourceName,
resourceId);
//Act
bool Result = ValidateQueryService.IsValid(ReadQuery, out Common.FhirTools.FhirResource? IsNotValidOperationOutCome);
//Assert
Assert.True(Result);
Assert.Null(IsNotValidOperationOutCome);
}
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 <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 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);
}
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));
}
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 Common.FhirTools.FhirResource GetFhirResource(Common.Enums.FhirVersion fhirMajorVersion, BundleModel bundleModel)
{
switch (fhirMajorVersion)
{
case Common.Enums.FhirVersion.Stu3:
var Stu3Tool = IFhirResourceBundleSupportFactory.GetStu3();
return(Stu3Tool.GetFhirResource(bundleModel));
case Common.Enums.FhirVersion.R4:
var R4Tool = IFhirResourceBundleSupportFactory.GetR4();
return(R4Tool.GetFhirResource(bundleModel));
default:
throw new FhirVersionFatalException(fhirMajorVersion);
}
}
protected override bool CanReadType(Type type)
{
if (typeof(Stu3Model.Resource).IsAssignableFrom(type))
{
FhirMajorVersion = Common.Enums.FhirVersion.Stu3;
return(true);
}
if (typeof(R4Model.Resource).IsAssignableFrom(type))
{
FhirMajorVersion = Common.Enums.FhirVersion.R4;
return(true);
}
return(false);
}
public FhirBaseApiQuery(HttpVerb HttpVerb, Common.Enums.FhirVersion FhirVersion, Uri RequestUri, Dictionary <string, StringValues> RequestQuery, Dictionary <string, StringValues> HeaderDictionary)
{
this.CorrelationId = Guid.NewGuid().ToString();
this.Method = HttpVerb;
this.FhirVersion = FhirVersion;
this.RequestUri = RequestUri;
FhirHeaders FhirHeaders = new FhirHeaders();
FhirHeaders.Parse(HeaderDictionary);
this.Headers = FhirHeaders;
FhirSearchQuery FhirSearchQuery = new FhirSearchQuery();
FhirSearchQuery.Parse(RequestQuery);
this.RequestQuery = FhirSearchQuery;
}
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 <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);
}
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 <IList <ResourceStore> > GetBaseHistoryListAsync(Common.Enums.FhirVersion fhirMajorVersion)
{
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).OrderBy(z => z.LastUpdated).ToListAsync());
}
public Common.FhirTools.FhirResource ParseJson(Common.Enums.FhirVersion fhirMajorVersion, string jsonResource)
{
switch (fhirMajorVersion)
{
case Common.Enums.FhirVersion.Stu3:
return(new Common.FhirTools.FhirResource(fhirMajorVersion)
{
Stu3 = IStu3ParseJson.ParseJson(jsonResource)
});
case Common.Enums.FhirVersion.R4:
return(new Common.FhirTools.FhirResource(fhirMajorVersion)
{
R4 = IR4ParseJson.ParseJson(jsonResource)
});
default:
throw new FhirVersionFatalException(fhirMajorVersion);
}
}
/// <summary>
/// Get at OperationOutcome with a issue status of Information: The issue has no relation to the degree of success of the action.
/// </summary>
/// <param name="fhirMajorVersion"></param>
/// <param name="errorMessages"></param>
/// <returns></returns>
public Common.FhirTools.FhirResource GetInformation(Common.Enums.FhirVersion fhirMajorVersion, string[] errorMessages)
{
switch (fhirMajorVersion)
{
case Common.Enums.FhirVersion.Stu3:
var Stu3Tool = IOperationOutcomeSupportFactory.GetStu3();
var Stu3FhirResource = new Common.FhirTools.FhirResource(fhirMajorVersion);
Stu3FhirResource.Stu3 = Stu3Tool.GetInformation(errorMessages);
return(Stu3FhirResource);
case Common.Enums.FhirVersion.R4:
var R4Tool = IOperationOutcomeSupportFactory.GetR4();
var R4FhirResource = new Common.FhirTools.FhirResource(fhirMajorVersion);
R4FhirResource.R4 = R4Tool.GetInformation(errorMessages);
return(R4FhirResource);
default:
throw new FhirVersionFatalException(fhirMajorVersion);
}
}
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 <DomainModel.FhirVersion?> GetAsync(Common.Enums.FhirVersion fhirMajorVersion)
{
byte[]? data = await IDistributedCache.GetAsync($"{ParameterName}{fhirMajorVersion.GetCode()}");
if (data is object)
{
return(JsonSerializer.Deserialize <DomainModel.FhirVersion>(data));
}
else
{
DomainModel.FhirVersion?FhirVersion = await IFhirVersionRepository.GetByVersionAsycn(fhirMajorVersion);
if (FhirVersion is object)
{
await this.SetAsync(FhirVersion);
return(FhirVersion);
}
return(null);
}
}
public async Task <ReferentialIntegrityOutcome> CheckOnDelete(Common.Enums.FhirVersion fhirVersion, ResourceType resourceType, string resourceId)
{
var Outcome = new ReferentialIntegrityOutcome();
if (!IEnforceResourceReferentialIntegrity.EnforceRelativeResourceReferentialIntegrity)
{
Outcome.IsError = false;
return(Outcome);
}
var PrimaryServiceBaseUrl = await IServiceBaseUrlCache.GetPrimaryAsync(fhirVersion);
if (!await IIndexReferenceRepository.AnyAsync(fhirVersion, PrimaryServiceBaseUrl.Id, resourceType, resourceId))
{
Outcome.IsError = false;
return(Outcome);
}
else
{
List <string> ErrorMessageList = new List <string>
{
$"Enforce relative resource referential integrity is turned on for this server. " +
$"The following resources have resource references to the resource you are trying to delete. " +
$"These references must be resolved before the resource can be deleted. Only the first 100 detected references are listed below. "
};
List <ReferentialIntegrityQuery> ReferentialIntegrityQueryList = await IIndexReferenceRepository.GetResourcesReferenced(fhirVersion, PrimaryServiceBaseUrl.Id, resourceType, resourceId);
foreach (var ReferentialIntegrityQuery in ReferentialIntegrityQueryList)
{
ErrorMessageList.Add($"The resource: {ReferentialIntegrityQuery.TargetResourceTypeId.GetCode()}/{ReferentialIntegrityQuery.TargetResourceId} references the resource attempting to be deleted.");
}
Outcome.IsError = true;
Outcome.FhirResource = IOperationOutcomeSupport.GetError(fhirVersion, ErrorMessageList.ToArray());
return(Outcome);
}
}
public async Task <Logic.DomainModel.FhirVersion?> GetByVersionAsycn(Common.Enums.FhirVersion fhirMajorVersion)
{
return(await DbSet.SingleOrDefaultAsync(x => x.Id == fhirMajorVersion));
}
public ExpressionStarter <ResourceStore> CurrentMainResource(Common.Enums.FhirVersion fhirVersion, Common.Enums.ResourceType resourceType)
{
return(IResourceStorePredicateFactory.CurrentMainResource(fhirVersion, resourceType));
}
public UpdateQuery(HttpVerb HttpVerb, Common.Enums.FhirVersion FhirVersion, Uri RequestUri, Dictionary <string, StringValues> RequestQuery, Dictionary <string, StringValues> HeaderDictionary, string ResourceName, string ResourceId, Common.FhirTools.FhirResource FhirResource)
: base(HttpVerb, FhirVersion, RequestUri, RequestQuery, HeaderDictionary, ResourceName, ResourceId)
{
this.FhirResource = FhirResource;
}
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 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 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 <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 <ReferentialIntegrityOutcome> CheckOnCommit(Common.Enums.FhirVersion fhirVersion, List <Bug.Common.Dto.Indexing.IndexReference> IndexReferenceList)
{
var Outcome = new ReferentialIntegrityOutcome();
List <string> ErrorMessageList = new List <string>();
var PrimaryServiceBaseUrl = await IServiceBaseUrlCache.GetPrimaryAsync(fhirVersion);
foreach (var Index in IndexReferenceList.Where(x => x.ServiceBaseUrlId == PrimaryServiceBaseUrl.Id))
{
if (!Index.ServiceBaseUrlId.HasValue)
{
throw new ArgumentNullException(nameof(Index.ServiceBaseUrlId));
}
if (!Index.ResourceTypeId.HasValue)
{
throw new ArgumentNullException(nameof(Index.ResourceTypeId));
}
if (string.IsNullOrWhiteSpace(Index.ResourceId))
{
throw new ArgumentNullException(nameof(Index.ResourceId));
}
string Ref = $"{Index.ResourceTypeId.GetCode()}/{Index.ResourceId}";
if (!string.IsNullOrWhiteSpace(Index.VersionId))
{
Ref += $"/_history/{Index.VersionId}";
}
else if (!string.IsNullOrWhiteSpace(Index.CanonicalVersionId))
{
Ref += $"|{Index.CanonicalVersionId}";
}
bool HasIntegerVersionError = false;
int? IntegerVersionId = null;
if (!string.IsNullOrWhiteSpace(Index.VersionId))
{
if (!int.TryParse(Index.VersionId, out int IntegerVersionIdTest))
{
HasIntegerVersionError = true;
ErrorMessageList.Add($"The submitted resource contained a resource reference relative to this server which has a resource version part that is not an integer. All resources in this server must have an integer version therefore this resource reference must be invalid. The reference found was: {Ref} .");
}
else
{
IntegerVersionId = IntegerVersionIdTest;
}
}
if (IEnforceResourceReferentialIntegrity.EnforceRelativeResourceReferentialIntegrity && !HasIntegerVersionError)
{
if (!await IResourceStoreRepository.ReferentialIntegrityCheckAsync(fhirVersion, Index.ResourceTypeId.Value, Index.ResourceId, IntegerVersionId))
{
ErrorMessageList.Add($"Enforce relative resource referential integrity is turned on for this server. The submitted resource contained a resource reference of: {Ref} which does not exist in the server.");
}
}
}
if (ErrorMessageList.Count > 0)
//Remove duplicates with Distinct() because the same reference can be reported twice
//or more as it can have many search parameters pointing to the same reference
{
Outcome.IsError = true;
Outcome.FhirResource = IOperationOutcomeSupport.GetError(fhirVersion, ErrorMessageList.Distinct().ToArray());
}
return(Outcome);
}
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 RemoveAsync(Common.Enums.FhirVersion fhirMajorVersion)
{
await IDistributedCache.RemoveAsync($"{ParameterName}{fhirMajorVersion.GetCode()}");
}
