Package ca.uhn.fhir.jpa.dao.index

Class IdHelperService

java.lang.Object

ca.uhn.fhir.jpa.dao.index.IdHelperService

All Implemented Interfaces:

IIdHelperService<JpaPid>

@Service
public class IdHelperService
extends Object
implements IIdHelperService<JpaPid>

This class is used to convert between PIDs (the internal primary key for a particular resource as stored in the HFJ_RESOURCE table), and the public ID that a resource has.

These IDs are sometimes one and the same (by default, a resource that the server assigns the ID of Patient/1 will simply use a PID of 1 and and ID of 1. However, they may also be different in cases where a forced ID is used (an arbitrary client-assigned ID).

This service is highly optimized in order to minimize the number of DB calls as much as possible, since ID resolution is fundamental to many basic operations. This service returns either IResourceLookup or BaseResourcePersistentId depending on the method being called. The former involves an extra database join that the latter does not require, so selecting the right method here is important.

Field Summary

Fields

Modifier and Type	Field	Description
static final jakarta.persistence.criteria.Predicate[]	EMPTY_PREDICATE_ARRAY
protected IResourceTableDao	myResourceTableDao
static final String	RESOURCE_PID

Constructor Summary

Constructors

Constructor	Description
IdHelperService()

Method Summary

Modifier and Type	Method	Description
void	addResolvedPidToFhirIdAfterCommit(JpaPid theJpaPid, RequestPartitionId theRequestPartitionId, String theResourceType, String theFhirId, Date theDeletedAt)	This method can be called to pre-emptively add entries to the ID cache.
JpaPid	getPidOrNull(RequestPartitionId theRequestPartitionId, org.hl7.fhir.instance.model.api.IBaseResource theResource)
JpaPid	getPidOrThrowException(org.hl7.fhir.instance.model.api.IAnyResource theResource)
boolean	idRequiresForcedId(String theId)	Returns true if the given resource ID should be stored in a forced ID.
static boolean	isValidPid(String theIdPart)
JpaPid	newPid(Object thePid)
JpaPid	newPidFromStringIdAndResourceName(String thePid, String theResourceName)
RequestPartitionId	replaceDefault(RequestPartitionId theRequestPartitionId)
Map<org.hl7.fhir.instance.model.api.IIdType,IResourceLookup<JpaPid>>	resolveResourceIdentities(RequestPartitionId theRequestPartitionId, Collection<org.hl7.fhir.instance.model.api.IIdType> theIds, ResolveIdentityMode theMode)
IResourceLookup<JpaPid>	resolveResourceIdentity(RequestPartitionId theRequestPartitionId, String theResourceType, String theResourceId, ResolveIdentityMode theMode)	Given a forced ID, convert it to its Long value.
org.hl7.fhir.instance.model.api.IIdType	resourceIdFromPidOrThrowException(JpaPid thePid, String theResourceType)
protected void	setDontCheckActiveTransactionForUnitTest(boolean theDontCheckActiveTransactionForUnitTest)
void	setPartitionSettingsForUnitTest(PartitionSettings thePartitionSettings)
org.hl7.fhir.instance.model.api.IIdType	translatePidIdToForcedId(ca.uhn.fhir.context.FhirContext theCtx, String theResourceType, JpaPid theId)	Given a persistent ID, returns the associated resource ID
Optional<String>	translatePidIdToForcedIdWithCache(JpaPid theId)
Set<String>	translatePidsToFhirResourceIds(Set<JpaPid> thePids)	Given a set of PIDs, return a set of public FHIR Resource IDs.
PersistentIdToForcedIdMap<JpaPid>	translatePidsToForcedIds(Set<JpaPid> theResourceIds)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface ca.uhn.fhir.jpa.api.svc.IIdHelperService

getPidOrThrowException, resolveResourceIdentityPid, resolveResourcePids

Field Details

EMPTY_PREDICATE_ARRAY

public static final jakarta.persistence.criteria.Predicate[] EMPTY_PREDICATE_ARRAY

RESOURCE_PID

public static final String RESOURCE_PID

See Also:

• Constant Field Values

myResourceTableDao

@Autowired
protected IResourceTableDao myResourceTableDao

Constructor Details

IdHelperService

public IdHelperService()

Method Details

setDontCheckActiveTransactionForUnitTest

protected void setDontCheckActiveTransactionForUnitTest(boolean theDontCheckActiveTransactionForUnitTest)

resolveResourceIdentity

@Nonnull
public IResourceLookup<JpaPid> resolveResourceIdentity(@Nonnull
 RequestPartitionId theRequestPartitionId,
 @Nullable
 String theResourceType,
 @Nonnull
 String theResourceId,
 @Nonnull
 ResolveIdentityMode theMode)
                                                throws ca.uhn.fhir.rest.server.exceptions.ResourceNotFoundException

Given a forced ID, convert it to its Long value. Since you are allowed to use string IDs for resources, we need to convert those to the underlying Long values that are stored, for lookup and comparison purposes. Optionally filters out deleted resources.

Specified by:

resolveResourceIdentity in interface IIdHelperService<JpaPid>

Throws:

ca.uhn.fhir.rest.server.exceptions.ResourceNotFoundException - If the ID can not be found

resolveResourceIdentities

@Nonnull
public Map<org.hl7.fhir.instance.model.api.IIdType,IResourceLookup<JpaPid>> resolveResourceIdentities(@Nonnull
 RequestPartitionId theRequestPartitionId,
 Collection<org.hl7.fhir.instance.model.api.IIdType> theIds,
 ResolveIdentityMode theMode)

Specified by:

resolveResourceIdentities in interface IIdHelperService<JpaPid>

idRequiresForcedId

public boolean idRequiresForcedId(String theId)

Returns true if the given resource ID should be stored in a forced ID. Under default config (meaning client ID strategy is JpaStorageSettings.ClientIdStrategyEnum.ALPHANUMERIC) this will return true if the ID has any non-digit characters.

In JpaStorageSettings.ClientIdStrategyEnum.ANY mode it will always return true.

Specified by:

idRequiresForcedId in interface IIdHelperService<JpaPid>

translatePidIdToForcedId

@Nonnull
public org.hl7.fhir.instance.model.api.IIdType translatePidIdToForcedId(ca.uhn.fhir.context.FhirContext theCtx,
 String theResourceType,
 JpaPid theId)

Given a persistent ID, returns the associated resource ID

Specified by:

translatePidIdToForcedId in interface IIdHelperService<JpaPid>

translatePidIdToForcedIdWithCache

public Optional<String> translatePidIdToForcedIdWithCache(JpaPid theId)

Specified by:

translatePidIdToForcedIdWithCache in interface IIdHelperService<JpaPid>

replaceDefault

public RequestPartitionId replaceDefault(RequestPartitionId theRequestPartitionId)

translatePidsToForcedIds

public PersistentIdToForcedIdMap<JpaPid> translatePidsToForcedIds(Set<JpaPid> theResourceIds)

Specified by:

translatePidsToForcedIds in interface IIdHelperService<JpaPid>

addResolvedPidToFhirIdAfterCommit

public void addResolvedPidToFhirIdAfterCommit(@Nonnull
 JpaPid theJpaPid,
 @Nonnull
 RequestPartitionId theRequestPartitionId,
 @Nonnull
 String theResourceType,
 @Nonnull
 String theFhirId,
 @Nullable
 Date theDeletedAt)

This method can be called to pre-emptively add entries to the ID cache. It should be called by DAO methods if they are creating or changing the deleted status of a resource. This method returns immediately, but the data is not added to the internal caches until the current DB transaction is successfully committed, and nothing is added if the transaction rolls back.

Specified by:

addResolvedPidToFhirIdAfterCommit in interface IIdHelperService<JpaPid>

setPartitionSettingsForUnitTest

public void setPartitionSettingsForUnitTest(PartitionSettings thePartitionSettings)

getPidOrNull

@Nullable
public JpaPid getPidOrNull(@Nonnull
 RequestPartitionId theRequestPartitionId,
 org.hl7.fhir.instance.model.api.IBaseResource theResource)

Specified by:

getPidOrNull in interface IIdHelperService<JpaPid>

getPidOrThrowException

@Nonnull
public JpaPid getPidOrThrowException(@Nonnull
 org.hl7.fhir.instance.model.api.IAnyResource theResource)

Specified by:

getPidOrThrowException in interface IIdHelperService<JpaPid>

resourceIdFromPidOrThrowException

public org.hl7.fhir.instance.model.api.IIdType resourceIdFromPidOrThrowException(JpaPid thePid,
 String theResourceType)

Specified by:

resourceIdFromPidOrThrowException in interface IIdHelperService<JpaPid>

translatePidsToFhirResourceIds

public Set<String> translatePidsToFhirResourceIds(Set<JpaPid> thePids)

Given a set of PIDs, return a set of public FHIR Resource IDs. This function will resolve a forced ID if it resolves, and if it fails to resolve to a forced it, will just return the pid Example: Let's say we have Patient/1(pid == 1), Patient/pat1 (pid == 2), Patient/3 (pid == 3), their pids would resolve as follows:

[1,2,3] -> ["1","pat1","3"]

Specified by:

translatePidsToFhirResourceIds in interface IIdHelperService<JpaPid>

Parameters:

thePids - The Set of pids you would like to resolve to external FHIR Resource IDs.

Returns:

A Set of strings representing the FHIR IDs of the pids.

newPid

public JpaPid newPid(Object thePid)

Specified by:

newPid in interface IIdHelperService<JpaPid>

newPidFromStringIdAndResourceName

public JpaPid newPidFromStringIdAndResourceName(String thePid,
 String theResourceName)

Specified by:

newPidFromStringIdAndResourceName in interface IIdHelperService<JpaPid>

isValidPid

public static boolean isValidPid(String theIdPart)