public ThreadTest(CodeResolverRegistryTest _enclosing, int threadId, VersionNumber version, GenericCodeResolverRegistry registry
)
{
this._enclosing = _enclosing;
this.threadId = threadId;
this.version = version;
this.registry = registry;
this.thread = new Thread(this.Run);
}
/// <returns>the registry for the version being used in the current thread. If none found, returns the default registry.</returns>
internal static GenericCodeResolverRegistry GetRegistry()
{
// if an override code resolver registry has been specified it will be returned regardless of other settings
if (threadLocalCodeResolverRegistryOverride.Value != null)
{
return(threadLocalCodeResolverRegistryOverride.Value);
}
// otherwise, returns the code resolver registry stored under the HL7v3 version being used by the current thread
// if no registries found, return the default code resolver registry
VersionNumber currentlySpecifiedVersion = threadLocalVersion.Value;
GenericCodeResolverRegistry versionRegistry = (currentlySpecifiedVersion == null ? null : GetRegistryFromMap(currentlySpecifiedVersion));
return(versionRegistry == null ? _defaultRegistry : versionRegistry);
}
/// <summary>Store a CodeResolverRegistry to be used for a specific HL7v3 release version.</summary>
/// <remarks>
/// Store a CodeResolverRegistry to be used for a specific HL7v3 release version. Passing in a null value for the registry will
/// remove any existing registry for the supplied version.
/// </remarks>
/// <param name="version">the version for which the supplied code resolver registry should be used</param>
/// <param name="registry">the code resolver registry to use for this version</param>
/// <returns>returns true if there was a code resolver registry already registered for this version</returns>
public static bool RegisterCodeResolverRegistryForVersion(VersionNumber version, GenericCodeResolverRegistry registry)
{
bool result = (version == null ? false : registryMap.ContainsKey(version));
if (registry == null)
{
if (version != null)
{
registryMap.Remove(version);
return(result);
}
}
if (version != null)
{
registryMap[version] = registry;
}
return(result);
}
// transform/validator calls *may* provide a code resolver registry override in TLS
public static void SetThreadLocalCodeResolverRegistryOverride(GenericCodeResolverRegistry registryOverride)
{
threadLocalCodeResolverRegistryOverride.Value = registryOverride;
}
public virtual CdaValidatorResult Validate(XmlDocument xmlDocument, VersionNumber version, GenericCodeResolverRegistry codeResolverRegistryOverride
)
{
XmlToCdaModelResult transformResults = this.documentTransformer.TransformFromDocument(version, xmlDocument, codeResolverRegistryOverride
);
return(new CdaValidatorResult(transformResults.GetErrors()));
}
public virtual XmlToModelResult TransformFromHl7(VersionNumber version, XmlDocument hl7Message, TimeZoneInfo dateTimeZone
, TimeZoneInfo dateTimeTimeZone, GenericCodeResolverRegistry codeResolverRegistryOverride)
{
CodeResolverRegistry.SetThreadLocalVersion(version);
CodeResolverRegistry.SetThreadLocalCodeResolverRegistryOverride(codeResolverRegistryOverride);
XmlToModelResult result = new Hl7SourceMapper().MapToTeal(new Hl7MessageSource(version, hl7Message, dateTimeZone, dateTimeTimeZone
, this.service));
if (this.performAdditionalCdaValidationWhenUnmarshalling)
{
PerformAdditionalCdaValidation(version, hl7Message, result);
}
CodeResolverRegistry.ClearThreadLocalVersion();
CodeResolverRegistry.ClearThreadLocalCodeResolverRegistryOverride();
return(result);
}
public virtual XmlToModelResult TransformFromHl7(VersionNumber version, XmlDocument hl7Message, GenericCodeResolverRegistry
codeResolverRegistryOverride)
{
return(TransformFromHl7(version, hl7Message, this.dateTimeZone, this.dateTimeTimeZone, codeResolverRegistryOverride));
}
public virtual ModelToXmlResult TransformToHl7(VersionNumber version, IInteraction messageBean, TimeZoneInfo dateTimeZone
, TimeZoneInfo dateTimeTimeZone, GenericCodeResolverRegistry codeResolverRegistryOverride)
{
CodeResolverRegistry.SetThreadLocalVersion(version);
CodeResolverRegistry.SetThreadLocalCodeResolverRegistryOverride(codeResolverRegistryOverride);
XmlRenderingVisitor visitor = new XmlRenderingVisitor(this.service.IsR2(version), this.service.IsCda(version), version);
// TODO: Since the two boolean flags are derived from the version, we chould simplify this interface
new TealBeanRenderWalker(messageBean, version, dateTimeZone, dateTimeTimeZone, this.service).Accept(visitor);
CodeResolverRegistry.ClearThreadLocalVersion();
CodeResolverRegistry.ClearThreadLocalCodeResolverRegistryOverride();
ModelToXmlResult result = visitor.ToXml();
if (this.service.IsCda(version))
{
PerformAdditionalCdaValidation(version, result.GetXmlMessage(), result);
}
if (!result.IsValid() && IsStrict())
{
throw new InvalidRenderInputException(result.GetHl7Errors());
}
return(result);
}
public virtual ModelToXmlResult TransformToHl7(VersionNumber version, IInteraction messageBean, GenericCodeResolverRegistry
codeResolverRegistryOverride)
{
return(TransformToHl7(version, messageBean, this.dateTimeZone, this.dateTimeTimeZone, codeResolverRegistryOverride));
}
/// <summary>Find all domains that have value sets for the supplied version and register their matching MB interfaces against a database code resolver.
/// </summary>
/// <remarks>Find all domains that have value sets for the supplied version and register their matching MB interfaces against a database code resolver.
/// </remarks>
/// <param name="dao">the code set DAO</param>
/// <param name="codeFactory">a code factory</param>
/// <param name="version">the value set version being used</param>
/// <param name="registry">a code resolver registry</param>
/// <param name="releaseSpecificBasePackageName">base package name for the specific API release being targeted</param>
/// <returns>the results of the registration process</returns>
public virtual DatabaseCodeResolverRegistrationUtilityResults RegisterAll(CodeSetDao
dao, TypedCodeFactory codeFactory, string version, GenericCodeResolverRegistry
registry, string releaseSpecificBasePackageName)
{
DatabaseCodeResolverRegistrationUtilityResults results = new DatabaseCodeResolverRegistrationUtilityResults
(this);
ICollection <string> domainTypes = DetermineAllDomains(dao, version);
IList <Type> domainInterfaces = FindAllMatchingDomainInterfaces(domainTypes, releaseSpecificBasePackageName, results);
RegisterDomainsAgainstDatabaseCodeResolver(dao, codeFactory, version, registry, domainInterfaces);
return(results);
}
/// <summary>Create a DB resolver from supplied parameters and register all found interfaces.</summary>
/// <remarks>Create a DB resolver from supplied parameters and register all found interfaces.</remarks>
/// <param name="dao">the code set DAO</param>
/// <param name="codeFactory">a code factory</param>
/// <param name="version">the value set version being used</param>
/// <param name="registry">a code resolver registry</param>
/// <param name="domainInterfaces">the domain interfaces to register resolvers for</param>
private void RegisterDomainsAgainstDatabaseCodeResolver(CodeSetDao dao, TypedCodeFactory
codeFactory, string version, GenericCodeResolverRegistry registry, IList <Type> domainInterfaces)
{
CodeResolver dbResolver = new DatabaseCodeResolver(dao, codeFactory, version);
foreach (Type domainInterface in domainInterfaces)
{
registry.RegisterResolver(domainInterface, dbResolver);
}
}
public virtual CdaModelToXmlResult TransformToDocument(VersionNumber version, IClinicalDocument clinicalDocumentBean, GenericCodeResolverRegistry
codeResolverRegistryOverride)
{
return(new CdaModelToXmlResult(this.delegate_.TransformToHl7(version, clinicalDocumentBean, codeResolverRegistryOverride)
));
}
public virtual XmlToCdaModelResult TransformFromDocument(VersionNumber version, XmlDocument xmlDocument, TimeZoneInfo dateTimeZone
, TimeZoneInfo dateTimeTimeZone, GenericCodeResolverRegistry codeResolverRegistryOverride)
{
return(new XmlToCdaModelResult(this.delegate_.TransformFromHl7(version, xmlDocument, dateTimeZone, dateTimeTimeZone, codeResolverRegistryOverride
)));
}
public virtual MessageValidatorResult Validate(XmlDocument message, VersionNumber version, GenericCodeResolverRegistry codeResolverRegistryOverride
)
{
XmlToModelResult transformResults = this.messageTransformer.TransformFromHl7(version, message, codeResolverRegistryOverride
);
return(new MessageValidatorResult(transformResults.GetHl7Errors()));
}
