PatientServiceImpl (OpenMRS 2.7.0-SNAPSHOT API)

java.lang.Object
- org.openmrs.api.impl.BaseOpenmrsService
- - org.openmrs.api.impl.PatientServiceImpl

All Implemented Interfaces:

OpenmrsService, PatientService
```
@Transactional
public class PatientServiceImpl
extends BaseOpenmrsService
implements PatientService
```
Default implementation of the patient service. This class should not be used on its own. The current OpenMRS implementation should be fetched from the Context via Context.getPatientService()

See Also:

Context, PatientService, PersonService

Constructor Summary

Constructors
Constructor and Description

PatientServiceImpl()

Constructors
Constructor and Description
`PatientServiceImpl()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkIfPatientIdentifierTypesAreLocked()` Check if patient identifier types are locked, and if they are, throws an exception during manipulation of a patient identifier type
`void`	`checkPatientIdentifiers(Patient patient)` Convenience method to validate all identifiers for a given patient
`void`	`exitFromCare(Patient patient, Date dateExited, Concept reasonForExit)` This is the way to establish that a patient has left the care center.
`Allergies`	`getAllergies(Patient patient)` Gets allergies for a given patient
`Allergy`	`getAllergy(Integer allergyId)` Returns the Allergy identified by internal Ingerger Id
`Allergy`	`getAllergyByUuid(String uuid)` Returns the Allergy identified by uuid
`Collection<IdentifierValidator>`	`getAllIdentifierValidators()`
`List<PatientIdentifierType>`	`getAllPatientIdentifierTypes()` Get all patientIdentifier types Ordered same as `PatientIdentifierTypeDefaultComparator`.
`List<PatientIdentifierType>`	`getAllPatientIdentifierTypes(boolean includeRetired)` Get all patientIdentifier types.
`List<Patient>`	`getAllPatients()` Returns all non voided patients in the system
`List<Patient>`	`getAllPatients(boolean includeVoided)` Returns patients in the system
`Integer`	`getCountOfPatients(String query)` Return the number of unvoided patients with names or patient identifiers or searchable person attributes starting with or equal to the specified text
`Integer`	`getCountOfPatients(String query, boolean includeVoided)`
`IdentifierValidator`	`getDefaultIdentifierValidator()`
`List<Patient>`	`getDuplicatePatientsByAttributes(List<String> attributes)` Search the database for patients that both share the given attributes.
`IdentifierValidator`	`getIdentifierValidator(Class<IdentifierValidator> identifierValidator)` Gets an identifier validator matching the given class.
`IdentifierValidator`	`getIdentifierValidator(String pivClassName)` Should return patient identifier validator given class name Should treat empty strings like a null entry
`Map<Class<? extends IdentifierValidator>,IdentifierValidator>`	`getIdentifierValidators()`
`Patient`	`getPatient(Integer patientId)` Get patient by internal identifier
`Patient`	`getPatientByExample(Patient patientToMatch)` This default implementation simply looks at the OpenMRS internal id (patient_id).
`Patient`	`getPatientByUuid(String uuid)` Get patient by universally unique identifier.
`PatientIdentifier`	`getPatientIdentifier(Integer patientIdentifierId)` Returns a patient identifier that matches the given patientIndentifier id
`PatientIdentifier`	`getPatientIdentifierByUuid(String uuid)` Get patient identifier by universally unique identifier.
`List<PatientIdentifier>`	`getPatientIdentifiers(String identifier, List<PatientIdentifierType> patientIdentifierTypes, List<Location> locations, List<Patient> patients, Boolean isPreferred)` Get all patientIdentifiers that match all of the given criteria Voided identifiers are not returned
`List<PatientIdentifier>`	`getPatientIdentifiersByPatientProgram(PatientProgram patientProgram)` Get all patientIdentifiers that are associated to the patient program
`PatientIdentifierType`	`getPatientIdentifierType(Integer patientIdentifierTypeId)` Get patientIdentifierType by internal identifier
`PatientIdentifierType`	`getPatientIdentifierTypeByName(String name)` Get patientIdentifierType by exact name
`PatientIdentifierType`	`getPatientIdentifierTypeByUuid(String uuid)` Get patient identifierType by universally unique identifier
`List<PatientIdentifierType>`	`getPatientIdentifierTypes(String name, String format, Boolean required, Boolean hasCheckDigit)` Get all patientIdentifier types that match the given criteria Ordered same as `PatientIdentifierTypeDefaultComparator`.
`Patient`	`getPatientOrPromotePerson(Integer patientOrPersonId)` Get patient by internal identifier.
`List<Patient>`	`getPatients(String query)` Generic search on patients based on the given string.
`List<Patient>`	`getPatients(String query, boolean includeVoided, Integer start, Integer length)`
`List<Patient>`	`getPatients(String query, Integer start, Integer length)` Generic search on patients based on the given string and returns a specific number of them from the specified starting position.
`List<Patient>`	`getPatients(String name, String identifier, List<PatientIdentifierType> identifierTypes, boolean matchIdentifierExactly)` Get patients based on given criteria The identifier is matched with the regex `OpenmrsConstants.PATIENT_IDENTIFIER_REGEX` All parameters are optional and nullable.
`List<Patient>`	`getPatients(String name, String identifier, List<PatientIdentifierType> identifierTypes, boolean matchIdentifierExactly, Integer start, Integer length)` Get a limited size of patients from a given start index based on given criteria The identifier is matched with the regex `OpenmrsConstants.PATIENT_IDENTIFIER_REGEX` All parameters are optional and nullable.
`boolean`	`isIdentifierInUseByAnotherPatient(PatientIdentifier patientIdentifier)` Checks whether the given patient identifier is already assigned to a patient other than patientIdentifier.patient
`void`	`mergePatients(Patient preferred, List<Patient> notPreferred)` Convenience method to join multiple patients' information into one record.
`void`	`mergePatients(Patient preferred, Patient notPreferred)` 1) Moves object (encounters/obs) pointing to `nonPreferred` to `preferred` 2) Copies data (gender/birthdate/names/ids/etc) from `nonPreferred` to `preferred` iff the data is missing or null in `preferred` 3) `notPreferred` is marked as voided
`void`	`onShutdown()` Clean up after this class.
`void`	`processDeath(Patient patient, Date dateDied, Concept causeOfDeath, String otherReason)` This is the way to establish that a patient has died.
`void`	`purgePatient(Patient patient)` Delete patient from database.
`void`	`purgePatientIdentifier(PatientIdentifier patientIdentifier)` Purge PatientIdentifier (cannot be undone)
`void`	`purgePatientIdentifierType(PatientIdentifierType patientIdentifierType)` Purge PatientIdentifierType (cannot be undone)
`void`	`removeAllergy(Allergy allergy, String reason)` Resolving the allergy, effectively removes the Allergy from the Patient's Active List by setting the stop date to now, if null.
`PatientIdentifierType`	`retirePatientIdentifierType(PatientIdentifierType patientIdentifierType, String reason)` Retire a type of patient identifier
`void`	`saveAllergy(Allergy allergy)` Creates an AllergyListItem to the Patient's Allergy Active List.
`void`	`saveCauseOfDeathObs(Patient patient, Date deathDate, Concept cause, String otherReason)` Convenience method that saves the Obs that indicates when and why the patient died (including any "other" reason there might be)
`Patient`	`savePatient(Patient patient)` Saved the given `patient` to the database
`PatientIdentifier`	`savePatientIdentifier(PatientIdentifier patientIdentifier)` Saved the given `patientIndentifier` to the database
`PatientIdentifierType`	`savePatientIdentifierType(PatientIdentifierType patientIdentifierType)` Create or update a PatientIdentifierType
`Allergies`	`setAllergies(Patient patient, Allergies allergies)` Updates the patient's allergies
`void`	`setIdentifierValidators(Map<Class<? extends IdentifierValidator>,IdentifierValidator> identifierValidators)` ADDs identifierValidators, doesn't replace them
`void`	`setPatientDAO(PatientDAO dao)` Sets the DAO for this service.
`PatientIdentifierType`	`unretirePatientIdentifierType(PatientIdentifierType patientIdentifierType)` Unretire a type of patient identifier
`Patient`	`unvoidPatient(Patient patient)` Unvoid patient record.
`void`	`voidAllergy(Allergy allergy, String reason)` Used only in cases where the Allergy was entered by error
`Patient`	`voidPatient(Patient patient, String reason)` Void patient record (functionally delete patient from system).
`PatientIdentifier`	`voidPatientIdentifier(PatientIdentifier patientIdentifier, String reason)` Void patient identifier (functionally delete patient identifier from system)

Methods inherited from class org.openmrs.api.impl.BaseOpenmrsService
onStartup

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.openmrs.api.OpenmrsService
onStartup

- Constructor Detail
  - PatientServiceImpl
```
public PatientServiceImpl()
```
- Method Detail
  - setPatientDAO
```
public void setPatientDAO(PatientDAO dao)
```
    Description copied from interface: PatientService
    
    Sets the DAO for this service. This is done by DI and Spring. See the applicationContext-service.xml definition file.
    
    Specified by:
    
    setPatientDAO in interface PatientService
    
    Parameters:
    
    dao - DAO for this service
    
    See Also:
    
    PatientService.setPatientDAO(org.openmrs.api.db.PatientDAO)
  - onShutdown
```
public void onShutdown()
```
    Clean up after this class. Set the static var to null so that the classloader can reclaim the space.
    
    Specified by:
    
    onShutdown in interface OpenmrsService
    
    Overrides:
    
    onShutdown in class BaseOpenmrsService
    
    See Also:
    
    BaseOpenmrsService.onShutdown()
  - savePatient
```
public Patient savePatient(Patient patient)
                    throws APIException
```
    Description copied from interface: PatientService
    
    Saved the given patient to the database
    
    Specified by:
    
    savePatient in interface PatientService
    
    Parameters:
    
    patient - patient to be created or updated
    
    Returns:
    
    patient who was created or updated
    
    Throws:
    
    APIException - Should create new patient from existing person plus user object Should not throw a NonUniqueObjectException when called with a hand constructed patient regression 1375 Should fail when patient does not have any patient identifiers Should update an existing patient Should fail when patient does not have required patient identifiers Should update the date changed and changed by on update of the person address Should set the preferred name address and identifier if none is specified Should not set the preferred name address and identifier if they already exist Should not set a voided name or address or identifier as preferred
    
    See Also:
    
    PatientService.savePatient(org.openmrs.Patient)
  - getPatient
```
@Transactional(readOnly=true)
public Patient getPatient(Integer patientId)
                                                 throws APIException
```
    Description copied from interface: PatientService
    
    Get patient by internal identifier
    
    Specified by:
    
    getPatient in interface PatientService
    
    Parameters:
    
    patientId - internal patient identifier
    
    Returns:
    
    patient with given internal identifier
    
    Throws:
    
    APIException - Should return null object if patient id doesnt exist Should fetch patient with given patient id Should return null when patient with given patient id does not exist
    
    See Also:
    
    PatientService.getPatient(java.lang.Integer)
  - getPatientOrPromotePerson
```
@Transactional(readOnly=true)
public Patient getPatientOrPromotePerson(Integer patientOrPersonId)
```
    Description copied from interface: PatientService
    
    Get patient by internal identifier. If this id is for an existing person then instantiates a new patient from that person, copying over all the fields.
    
    Specified by:
    
    getPatientOrPromotePerson in interface PatientService
    
    Returns:
    
    a new unsaved patient or null if person or patient is not found
  - getAllPatients
```
@Transactional(readOnly=true)
public List<Patient> getAllPatients()
                                                           throws APIException
```
    Description copied from interface: PatientService
    
    Returns all non voided patients in the system
    
    Specified by:
    
    getAllPatients in interface PatientService
    
    Returns:
    
    non voided patients in the system
    
    Throws:
    
    APIException - Should fetch all non voided patients
    
    See Also:
    
    PatientService.getAllPatients()
  - getAllPatients
```
@Transactional(readOnly=true)
public List<Patient> getAllPatients(boolean includeVoided)
                                                           throws APIException
```
    Description copied from interface: PatientService
    
    Returns patients in the system
    
    Specified by:
    
    getAllPatients in interface PatientService
    
    Parameters:
    
    includeVoided - if false, will limit the search to non-voided patients
    
    Returns:
    
    patients in the system
    
    Throws:
    
    APIException - Should fetch voided patients when given include voided is true Should fetch non voided patients when given include voided is false
    
    See Also:
    
    PatientService.getAllPatients(boolean)
  - getPatients
```
@Transactional(readOnly=true)
public List<Patient> getPatients(String name,
                                                               String identifier,
                                                               List<PatientIdentifierType> identifierTypes,
                                                               boolean matchIdentifierExactly)
                                                        throws APIException
```
    Description copied from interface: PatientService
    
    Get patients based on given criteria The identifier is matched with the regex OpenmrsConstants.PATIENT_IDENTIFIER_REGEX All parameters are optional and nullable. If null, it is not included in the search. Will not return voided patients
    
    Specified by:
    
    getPatients in interface PatientService
    
    Parameters:
    
    name - (optional) this is a slight break from the norm, patients with a partial match on this name will be returned
    
    identifier - (optional) only patients with a matching identifier are returned. This however applies only if name argument is null. Otherwise, its ignored.
    
    identifierTypes - (optional) the PatientIdentifierTypes to restrict to
    
    matchIdentifierExactly - (required) if true, then the given identifier must equal the id in the database. if false, then the identifier is 'searched' for by using a regular expression
    
    Returns:
    
    patients that matched the given criteria (and are not voided)
    
    Throws:
    
    APIException - Should fetch all patients that partially match given name Should fetch all patients that partially match given identifier if name argument is null Should fetch all patients that partially match given identifier when match identifier exactly equals false and if name argument is null Should fetch all patients that exactly match given identifier when match identifier exactly equals true and if name argument is null Should fetch all patients that match given identifier types Should not return duplicates Should not return voided patients Should return empty list when no match is found Should search familyName2 with name Should support simple regex Should support pattern using last digit as check digit Should return empty list if name and identifier is empty
    
    See Also:
    
    PatientService.getPatients(java.lang.String, java.lang.String, java.util.List, boolean)
  - checkPatientIdentifiers
```
@Transactional(readOnly=true)
public void checkPatientIdentifiers(Patient patient)
                                                           throws PatientIdentifierException
```
    Description copied from interface: PatientService
    
    Convenience method to validate all identifiers for a given patient
    
    Specified by:
    
    checkPatientIdentifiers in interface PatientService
    
    Parameters:
    
    patient - patient for which to validate identifiers
    
    Throws:
    
    PatientIdentifierException - if one or more of the identifiers are invalid Should validate when patient has all required and no duplicate and no blank patient identifiers Should ignore voided patient identifier Should remove identifier and throw error when patient has blank patient identifier Should throw error when patient has null patient identifiers Should throw error when patient has empty patient identifiers Should throw error when patient has identical identifiers Should throw error when patient does not have one or more required identifiers Should require one non voided patient identifier
    
    See Also:
    
    PatientService.checkPatientIdentifiers(org.openmrs.Patient)
  - voidPatient
```
public Patient voidPatient(Patient patient,
                           String reason)
                    throws APIException
```
    Description copied from interface: PatientService
    
    Void patient record (functionally delete patient from system). Voids Person and retires Users.
    
    Specified by:
    
    voidPatient in interface PatientService
    
    Parameters:
    
    patient - patient to be voided
    
    reason - reason for voiding patient
    
    Returns:
    
    the voided patient Should void given patient with given reason Should void all patient identifiers associated with given patient Should return voided patient with given reason Should return null when patient is null Should void person Should retire users
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.voidPatient(org.openmrs.Patient, java.lang.String)
  - unvoidPatient
```
public Patient unvoidPatient(Patient patient)
                      throws APIException
```
    Description copied from interface: PatientService
    
    Unvoid patient record. Unvoids Person as well.
    
    Specified by:
    
    unvoidPatient in interface PatientService
    
    Parameters:
    
    patient - patient to be revived
    
    Returns:
    
    the revived Patient Should unvoid given patient Should return unvoided patient Should unvoid person Should not unretire users
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.unvoidPatient(org.openmrs.Patient)
  - purgePatient
```
public void purgePatient(Patient patient)
                  throws APIException
```
    Description copied from interface: PatientService
    
    Delete patient from database. This should not be called except for testing and administration purposes. Use the void method instead.
    
    Specified by:
    
    purgePatient in interface PatientService
    
    Parameters:
    
    patient - patient to be deleted
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.purgePatient(org.openmrs.Patient)
  - getPatientIdentifiers
```
@Transactional(readOnly=true)
public List<PatientIdentifier> getPatientIdentifiers(String identifier,
                                                                                   List<PatientIdentifierType> patientIdentifierTypes,
                                                                                   List<Location> locations,
                                                                                   List<Patient> patients,
                                                                                   Boolean isPreferred)
                                                                            throws APIException
```
    Description copied from interface: PatientService
    
    Get all patientIdentifiers that match all of the given criteria Voided identifiers are not returned
    
    Specified by:
    
    getPatientIdentifiers in interface PatientService
    
    Parameters:
    
    identifier - the full identifier to match on
    
    patientIdentifierTypes - the type of identifiers to get
    
    locations - the locations of the identifiers to match
    
    patients - the patients containing these identifiers
    
    isPreferred - if true, limits to only preferred identifiers if false, only non preferred. if null, ignores preferred status
    
    Returns:
    
    PatientIdentifiers matching these criteria Should return only non voided patients and patient identifiers
    
    Throws:
    
    APIException - Should fetch patient identifiers that exactly matches given identifier Should not fetch patient identifiers that partially matches given identifier Should fetch patient identifiers that match given patient identifier types Should fetch patient identifiers that match given locations Should fetch patient identifiers that match given patients Should fetch preferred patient identifiers when given is preferred equals true Should fetch non preferred patient identifiers when given is preferred equals false Should fetch preferred and non preferred patient identifiers when given is preferred is null
    
    See Also:
    
    PatientService.getPatientIdentifiers(java.lang.String, java.util.List, java.util.List, java.util.List, java.lang.Boolean)
  - savePatientIdentifierType
```
public PatientIdentifierType savePatientIdentifierType(PatientIdentifierType patientIdentifierType)
                                                throws APIException
```
    Description copied from interface: PatientService
    
    Create or update a PatientIdentifierType
    
    Specified by:
    
    savePatientIdentifierType in interface PatientService
    
    Parameters:
    
    patientIdentifierType - PatientIdentifierType to create or update
    
    Returns:
    
    the saved type
    
    Throws:
    
    APIException - Should create new patient identifier type Should update existing patient identifier type Should throw error when trying to save a patient identifier type while patient identifier types are locked
    
    See Also:
    
    PatientService.savePatientIdentifierType(org.openmrs.PatientIdentifierType)
  - getAllPatientIdentifierTypes
```
@Transactional(readOnly=true)
public List<PatientIdentifierType> getAllPatientIdentifierTypes()
                                                                                       throws APIException
```
    Description copied from interface: PatientService
    
    Get all patientIdentifier types
    Ordered same as PatientIdentifierTypeDefaultComparator.
    
    Specified by:
    
    getAllPatientIdentifierTypes in interface PatientService
    
    Returns:
    
    patientIdentifier types list
    
    Throws:
    
    APIException - Should fetch all non retired patient identifier types Should order as default comparator
    
    See Also:
    
    PatientService.getAllPatientIdentifierTypes()
  - getAllPatientIdentifierTypes
```
@Transactional(readOnly=true)
public List<PatientIdentifierType> getAllPatientIdentifierTypes(boolean includeRetired)
                                                                                       throws APIException
```
    Description copied from interface: PatientService
    
    Get all patientIdentifier types.
    Ordered same as PatientIdentifierTypeDefaultComparator.
    
    Specified by:
    
    getAllPatientIdentifierTypes in interface PatientService
    
    Parameters:
    
    includeRetired - true/false whether retired types should be included
    
    Returns:
    
    patientIdentifier types list
    
    Throws:
    
    APIException - Should fetch patient identifier types including retired when include retired is true Should fetch patient identifier types excluding retired when include retired is false Should order as default comparator
    
    See Also:
    
    PatientService.getAllPatientIdentifierTypes(boolean)
  - getPatientIdentifierTypes
```
@Transactional(readOnly=true)
public List<PatientIdentifierType> getPatientIdentifierTypes(String name,
                                                                                           String format,
                                                                                           Boolean required,
                                                                                           Boolean hasCheckDigit)
                                                                                    throws APIException
```
    Description copied from interface: PatientService
    
    Get all patientIdentifier types that match the given criteria
    Ordered same as PatientIdentifierTypeDefaultComparator.
    
    Specified by:
    
    getPatientIdentifierTypes in interface PatientService
    
    Parameters:
    
    name - name of the type to match on
    
    format - the string format to match on
    
    required - if true, limits to only identifiers marked as required if false, only non required. if null, ignores required bit
    
    hasCheckDigit - if true, limits to only check digit'd identifiers if false, only non checkdigit'd. if null, ignores checkDigit
    
    Returns:
    
    patientIdentifier types list
    
    Throws:
    
    APIException - Should fetch patient identifier types that match given name with given format Should fetch required patient identifier types when given required is true Should fetch non required patient identifier types when given required is false Should fetch any patient identifier types when given required is null Should fetch patient identifier types with check digit when given has check digit is true Should fetch patient identifier types without check digit when given has check digit is false Should fetch any patient identifier types when given has check digit is null Should order as default comparator
    
    See Also:
    
    PatientService.getPatientIdentifierTypes(java.lang.String, java.lang.String, java.lang.Boolean, java.lang.Boolean)
  - getPatientIdentifierType
```
@Transactional(readOnly=true)
public PatientIdentifierType getPatientIdentifierType(Integer patientIdentifierTypeId)
                                                                             throws APIException
```
    Description copied from interface: PatientService
    
    Get patientIdentifierType by internal identifier
    
    Specified by:
    
    getPatientIdentifierType in interface PatientService
    
    Returns:
    
    patientIdentifierType with specified internal identifier
    
    Throws:
    
    APIException - Should fetch patient identifier with given patient identifier type id Should return null when patient identifier identifier does not exist
    
    See Also:
    
    PatientService.getPatientIdentifierType(java.lang.Integer)
  - getPatientIdentifierTypeByName
```
@Transactional(readOnly=true)
public PatientIdentifierType getPatientIdentifierTypeByName(String name)
                                                                                   throws APIException
```
    Description copied from interface: PatientService
    
    Get patientIdentifierType by exact name
    
    Specified by:
    
    getPatientIdentifierTypeByName in interface PatientService
    
    Returns:
    
    patientIdentifierType with given name
    
    Throws:
    
    APIException - Should fetch patient identifier type that exactly matches given name Should not return patient identifier type that partially matches given name Should return null when patient identifier type with given name does not exist
    
    See Also:
    
    PatientService.getPatientIdentifierTypeByName(java.lang.String)
  - retirePatientIdentifierType
```
public PatientIdentifierType retirePatientIdentifierType(PatientIdentifierType patientIdentifierType,
                                                         String reason)
                                                  throws APIException
```
    Description copied from interface: PatientService
    
    Retire a type of patient identifier
    
    Specified by:
    
    retirePatientIdentifierType in interface PatientService
    
    Parameters:
    
    patientIdentifierType - type of patient identifier to be retired
    
    reason - the reason to retire this identifier type
    
    Returns:
    
    the retired type
    
    Throws:
    
    APIException - Should retire patient identifier type with given reason Should throw error when reason is empty Should throw error when trying to retire a patient identifier type while patient identifier types are locked
    
    See Also:
    
    PatientService.retirePatientIdentifierType(org.openmrs.PatientIdentifierType, String)
  - unretirePatientIdentifierType
```
public PatientIdentifierType unretirePatientIdentifierType(PatientIdentifierType patientIdentifierType)
                                                    throws APIException
```
    Description copied from interface: PatientService
    
    Unretire a type of patient identifier
    
    Specified by:
    
    unretirePatientIdentifierType in interface PatientService
    
    Parameters:
    
    patientIdentifierType - type of patient identifier to be unretired
    
    Returns:
    
    the unretired type
    
    Throws:
    
    APIException - Should unretire patient identifier type Should return unretired patient identifier type Should throw error when trying to unretire a patient identifier type while patient identifier types are locked
    
    See Also:
    
    PatientService.unretirePatientIdentifierType(org.openmrs.PatientIdentifierType)
  - purgePatientIdentifierType
```
public void purgePatientIdentifierType(PatientIdentifierType patientIdentifierType)
                                throws APIException
```
    Description copied from interface: PatientService
    
    Purge PatientIdentifierType (cannot be undone)
    
    Specified by:
    
    purgePatientIdentifierType in interface PatientService
    
    Parameters:
    
    patientIdentifierType - PatientIdentifierType to purge from the database
    
    Throws:
    
    APIException - Should delete type from database Should delete patient identifier type from database Should throw error when trying to delete a patient identifier type while patient identifier types are locked
    
    See Also:
    
    PatientService.purgePatientIdentifierType(org.openmrs.PatientIdentifierType)
  - getPatients
```
@Transactional(readOnly=true)
public List<Patient> getPatients(String query)
                                                        throws APIException
```
    Description copied from interface: PatientService
    
    Generic search on patients based on the given string. Implementations can use this string to search on name, identifier, etc Voided patients are not returned in search results
    
    Specified by:
    
    getPatients in interface PatientService
    
    Parameters:
    
    query - the string to search on
    
    Returns:
    
    a list of matching Patients Should force search string to be greater than minsearchcharacters global property Should allow search string to be one according to minsearchcharacters global property Should fetch patients with patient identifiers matching given query Should fetch patients with any name matching given query Should return empty list if given query length less than minimum search characters Should not fail when minimum search characters is null Should not fail when minimum search characters is invalid integer
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getPatients(java.lang.String)
  - getPatientByExample
```
@Transactional(readOnly=true)
public Patient getPatientByExample(Patient patientToMatch)
                                                          throws APIException
```
    This default implementation simply looks at the OpenMRS internal id (patient_id). If the id is null, assume this patient isn't found. If the patient_id is not null, try and find that id in the database
    
    Specified by:
    
    getPatientByExample in interface PatientService
    
    Returns:
    
    null if no match found, a fresh patient object from the db if is found Should fetch patient matching patient id of given patient Should not fetch patient matching any other patient information Should return null when no patient matches given patient to match
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getPatientByExample(org.openmrs.Patient)
  - getDuplicatePatientsByAttributes
```
@Transactional(readOnly=true)
public List<Patient> getDuplicatePatientsByAttributes(List<String> attributes)
                                                                             throws APIException
```
    Description copied from interface: PatientService
    
    Search the database for patients that both share the given attributes. Each attribute that is passed in must be identical to what is stored for at least one other patient for both patients to be returned.
    
    Specified by:
    
    getDuplicatePatientsByAttributes in interface PatientService
    
    Parameters:
    
    attributes - attributes on a Person or Patient object. similar to: [gender, givenName, middleName, familyName]
    
    Returns:
    
    list of patients that match other patients
    
    Throws:
    
    APIException - Should fetch patients that exactly match on all given attributes Should not return patients that exactly match on some but not all given attributes
    
    See Also:
    
    PatientService.getDuplicatePatientsByAttributes(java.util.List)
  - mergePatients
```
public void mergePatients(Patient preferred,
                          Patient notPreferred)
                   throws APIException,
                          SerializationException
```
    1) Moves object (encounters/obs) pointing to nonPreferred to preferred 2) Copies data (gender/birthdate/names/ids/etc) from nonPreferred to preferred iff the data is missing or null in preferred 3) notPreferred is marked as voided
    
    Specified by:
    
    mergePatients in interface PatientService
    
    Parameters:
    
    preferred -
    
    notPreferred -
    
    Throws:
    
    APIException
    
    SerializationException
    
    See Also:
    
    PatientService.mergePatients(org.openmrs.Patient, org.openmrs.Patient)
  - exitFromCare
```
public void exitFromCare(Patient patient,
                         Date dateExited,
                         Concept reasonForExit)
                  throws APIException
```
    This is the way to establish that a patient has left the care center. This API call is responsible for:
    1. Closing workflow statuses
    2. Terminating programs
    3. Discontinuing orders
    4. Flagging patient table
    5. Creating any relevant observations about the patient (if applicable)
    Parameters:
    
    patient - - the patient who has exited care
    
    dateExited - - the declared date/time of the patient's exit
    
    reasonForExit - - the concept that corresponds with why the patient has been declared as exited
    
    Throws:
    
    APIException
  - processDeath
```
public void processDeath(Patient patient,
                         Date dateDied,
                         Concept causeOfDeath,
                         String otherReason)
                  throws APIException
```
    This is the way to establish that a patient has died. In addition to exiting the patient from care (see above), this method will also set the appropriate patient characteristics to indicate that they have died, when they died, etc.
    
    Specified by:
    
    processDeath in interface PatientService
    
    Parameters:
    
    patient - - the patient who has died
    
    dateDied - - the declared date/time of the patient's death
    
    causeOfDeath - - the concept that corresponds with the reason the patient died
    
    otherReason - - in case the causeOfDeath is 'other', a place to store more info
    
    Throws:
    
    APIException
  - saveCauseOfDeathObs
```
public void saveCauseOfDeathObs(Patient patient,
                                Date deathDate,
                                Concept cause,
                                String otherReason)
                         throws APIException
```
    Description copied from interface: PatientService
    
    Convenience method that saves the Obs that indicates when and why the patient died (including any "other" reason there might be)
    
    Specified by:
    
    saveCauseOfDeathObs in interface PatientService
    
    Parameters:
    
    patient - - the patient who has died
    
    deathDate - - the declared date/time of the patient's death
    
    cause - - the concept that corresponds with the reason the patient died
    
    otherReason - - if the concept representing the reason is OTHER NON-CODED, and a string-based "other" reason is supplied
    
    Throws:
    
    APIException - Should throw error when given patient is null Should throw error when given death date is null Should throw error when given cause is null is null Should throw error when cause of death global property is not specified Should throw error when patient already has more than one cause of death observations Should modify existing cause of death observation Should set death attributes as long as patient is not already dead Should be tested more thoroughly
    
    See Also:
    
    PatientService.saveCauseOfDeathObs(org.openmrs.Patient, java.util.Date, org.openmrs.Concept, java.lang.String)
  - getPatientByUuid
```
@Transactional(readOnly=true)
public Patient getPatientByUuid(String uuid)
                                                       throws APIException
```
    Description copied from interface: PatientService
    
    Get patient by universally unique identifier.
    
    Specified by:
    
    getPatientByUuid in interface PatientService
    
    Parameters:
    
    uuid - universally unique identifier
    
    Returns:
    
    the patient that matches the uuid
    
    Throws:
    
    APIException - Should fetch patient with given uuid Should return null if patient not found with given uuid
    
    See Also:
    
    PatientService.getPatientByUuid(java.lang.String)
  - getPatientIdentifierByUuid
```
@Transactional(readOnly=true)
public PatientIdentifier getPatientIdentifierByUuid(String uuid)
                                                                           throws APIException
```
    Description copied from interface: PatientService
    
    Get patient identifier by universally unique identifier.
    
    Specified by:
    
    getPatientIdentifierByUuid in interface PatientService
    
    Parameters:
    
    uuid - universally unique identifier
    
    Returns:
    
    the patient identifier that matches the uuid
    
    Throws:
    
    APIException - Should fetch patient identifier with given uuid Should return null if patient identifier not found with given uuid
  - getPatientIdentifierTypeByUuid
```
@Transactional(readOnly=true)
public PatientIdentifierType getPatientIdentifierTypeByUuid(String uuid)
                                                                                   throws APIException
```
    Description copied from interface: PatientService
    
    Get patient identifierType by universally unique identifier
    
    Specified by:
    
    getPatientIdentifierTypeByUuid in interface PatientService
    
    Returns:
    
    patientIdentifierType with specified internal identifier
    
    Throws:
    
    APIException - Should fetch patient identifier type with given uuid Should return null when patient identifier type with given uuid does not exist
    
    See Also:
    
    PatientService.getPatientIdentifierTypeByUuid(java.lang.String)
  - getDefaultIdentifierValidator
```
@Transactional(readOnly=true)
public IdentifierValidator getDefaultIdentifierValidator()
```
    Specified by:
    
    getDefaultIdentifierValidator in interface PatientService
    
    Returns:
    
    the default IdentifierValidator Should return default patient identifier validator
    
    See Also:
    
    PatientService.getDefaultIdentifierValidator()
  - getIdentifierValidator
```
public IdentifierValidator getIdentifierValidator(Class<IdentifierValidator> identifierValidator)
```
    Description copied from interface: PatientService
    
    Gets an identifier validator matching the given class.
    
    Specified by:
    
    getIdentifierValidator in interface PatientService
    
    Parameters:
    
    identifierValidator - identifierValidator which validator to get. Should return patient identifier validator given class
    
    See Also:
    
    PatientService.getIdentifierValidator(java.lang.String)
  - getIdentifierValidators
```
public Map<Class<? extends IdentifierValidator>,IdentifierValidator> getIdentifierValidators()
```
  - setIdentifierValidators
```
public void setIdentifierValidators(Map<Class<? extends IdentifierValidator>,IdentifierValidator> identifierValidators)
```
    ADDs identifierValidators, doesn't replace them
    
    Parameters:
    
    identifierValidators -
  - getAllIdentifierValidators
```
public Collection<IdentifierValidator> getAllIdentifierValidators()
```
    Specified by:
    
    getAllIdentifierValidators in interface PatientService
    
    Returns:
    
    All registered PatientIdentifierValidators Should return all registered patient identifier validators
    
    See Also:
    
    PatientService.getAllIdentifierValidators()
  - getIdentifierValidator
```
@Transactional(readOnly=true)
public IdentifierValidator getIdentifierValidator(String pivClassName)
```
    Description copied from interface: PatientService
    
    Should return patient identifier validator given class name Should treat empty strings like a null entry
    
    Specified by:
    
    getIdentifierValidator in interface PatientService
    
    See Also:
    
    PatientService.getIdentifierValidator(java.lang.String)
  - isIdentifierInUseByAnotherPatient
```
@Transactional(readOnly=true)
public boolean isIdentifierInUseByAnotherPatient(PatientIdentifier patientIdentifier)
```
    Description copied from interface: PatientService
    
    Checks whether the given patient identifier is already assigned to a patient other than patientIdentifier.patient
    
    Specified by:
    
    isIdentifierInUseByAnotherPatient in interface PatientService
    
    Parameters:
    
    patientIdentifier - the patient identifier to look for in other patients
    
    Returns:
    
    whether or not the identifier is in use by a patient other than patientIdentifier.patient Should return true when patientIdentifier contains a patient and another patient has this id Should return false when patientIdentifier contains a patient and no other patient has this id Should return true when patientIdentifier does not contain a patient and a patient has this id Should return false when patientIdentifier does not contain a patient and no patient has this id Should ignore voided patientIdentifiers Should ignore voided patients Should return true if in use for a location and id type uniqueness is set to location Should return false if in use for another location and id uniqueness is set to location Should return true if in use and id type uniqueness is set to unique Should return true if in use and id type uniqueness is null
    
    See Also:
    
    PatientService.isIdentifierInUseByAnotherPatient(org.openmrs.PatientIdentifier)
  - getPatientIdentifier
```
@Transactional(readOnly=true)
public PatientIdentifier getPatientIdentifier(Integer patientIdentifierId)
                                                                     throws APIException
```
    Description copied from interface: PatientService
    
    Returns a patient identifier that matches the given patientIndentifier id
    
    Specified by:
    
    getPatientIdentifier in interface PatientService
    
    Parameters:
    
    patientIdentifierId - the patientIdentifier id
    
    Returns:
    
    the patientIdentifier matching the Id
    
    Throws:
    
    APIException - Should return the patientIdentifier with the given id
    
    See Also:
    
    PatientService.getPatientIdentifier(java.lang.Integer)
  - voidPatientIdentifier
```
public PatientIdentifier voidPatientIdentifier(PatientIdentifier patientIdentifier,
                                               String reason)
                                        throws APIException
```
    Description copied from interface: PatientService
    
    Void patient identifier (functionally delete patient identifier from system)
    
    Specified by:
    
    voidPatientIdentifier in interface PatientService
    
    Parameters:
    
    patientIdentifier - patientIdentifier to be voided
    
    reason - reason for voiding patient identifier
    
    Returns:
    
    the voided patient identifier
    
    Throws:
    
    APIException - Should void given patient identifier with given reaso Should throw an APIException if the reason is null Should throw an APIException if the reason is an empty string Should throw an APIException if the reason is a white space character
    
    See Also:
    
    PatientService.voidPatientIdentifier(org.openmrs.PatientIdentifier, java.lang.String)
  - mergePatients
```
public void mergePatients(Patient preferred,
                          List<Patient> notPreferred)
                   throws APIException,
                          SerializationException
```
    Description copied from interface: PatientService
    
    Convenience method to join multiple patients' information into one record.
    
    Specified by:
    
    mergePatients in interface PatientService
    
    Throws:
    
    APIException
    
    SerializationException - Should merge all non Preferred patients in the the notPreferred list to preferred patient
    
    See Also:
    
    PatientService.mergePatients(org.openmrs.Patient, java.util.List)
  - savePatientIdentifier
```
public PatientIdentifier savePatientIdentifier(PatientIdentifier patientIdentifier)
                                        throws APIException
```
    Description copied from interface: PatientService
    
    Saved the given patientIndentifier to the database
    
    Specified by:
    
    savePatientIdentifier in interface PatientService
    
    Parameters:
    
    patientIdentifier - patientIndentifier to be created or updated
    
    Returns:
    
    patientIndentifier that was created or updated
    
    Throws:
    
    APIException - Should create new patientIndentifier Should update an existing patient identifier Should throw an APIException when a null argument is passed Should throw an APIException when one of the required fields is null Should throw an APIException if the patientIdentifier string is a white space Should throw an APIException if the patientIdentifier string is an empty string
    
    See Also:
    
    PatientService.savePatientIdentifier(org.openmrs.PatientIdentifier)
  - purgePatientIdentifier
```
public void purgePatientIdentifier(PatientIdentifier patientIdentifier)
                            throws APIException
```
    Description copied from interface: PatientService
    
    Purge PatientIdentifier (cannot be undone)
    
    Specified by:
    
    purgePatientIdentifier in interface PatientService
    
    Parameters:
    
    patientIdentifier - PatientIdentifier to purge from the database
    
    Throws:
    
    APIException - Should delete patient identifier from database
    
    See Also:
    
    PatientService.purgePatientIdentifier(org.openmrs.PatientIdentifier)
  - getAllergies
```
@Transactional(readOnly=true)
public Allergies getAllergies(Patient patient)
```
    Description copied from interface: PatientService
    
    Gets allergies for a given patient
    
    Specified by:
    
    getAllergies in interface PatientService
    
    Parameters:
    
    patient - the patient
    
    Returns:
    
    the allergies object Should get the allergy list and status
    
    See Also:
    
    PatientService.getAllergies(org.openmrs.Patient)
  - setAllergies
```
public Allergies setAllergies(Patient patient,
                              Allergies allergies)
```
    Description copied from interface: PatientService
    
    Updates the patient's allergies
    
    Specified by:
    
    setAllergies in interface PatientService
    
    Parameters:
    
    patient - the patient
    
    allergies - the allergies
    
    Returns:
    
    the saved allergies Should save the allergy list and status Should void removed allergies and maintain status as see list if some allergies are removed Should void all allergies and set status to unknown if all allergies are removed Should set status to no known allergies for patient without allergies Should void all allergies and set status to no known allergies if all allergies are removed and status set as such Should void allergies with edited comment Should void allergies with edited severity Should void allergies with edited coded allergen Should void allergies with edited non coded allergen Should void allergies with edited reaction coded Should void allergies with edited reaction non coded Should void allergies with removed reactions Should void allergies with added reactions Should set the non coded concept for non coded allergen if not specified
    
    See Also:
    
    PatientService.setAllergies(org.openmrs.Patient, org.openmrs.Allergies)
  - getAllergy
```
@Transactional(readOnly=true)
public Allergy getAllergy(Integer allergyId)
                                                 throws APIException
```
    Description copied from interface: PatientService
    
    Returns the Allergy identified by internal Ingerger Id
    
    Specified by:
    
    getAllergy in interface PatientService
    
    Parameters:
    
    allergyId - identifies allergy by internal Ingerger Id
    
    Returns:
    
    the allergy
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getAllergy(java.lang.Integer)
  - getAllergyByUuid
```
@Transactional(readOnly=true)
public Allergy getAllergyByUuid(String uuid)
                                                       throws APIException
```
    Description copied from interface: PatientService
    
    Returns the Allergy identified by uuid
    
    Specified by:
    
    getAllergyByUuid in interface PatientService
    
    Parameters:
    
    uuid - identifies allergy
    
    Returns:
    
    the allergy matching the given uuid Should return allergy given valid uuid Should return null if no object found with given uuid
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getAllergyByUuid(java.lang.String)
  - saveAllergy
```
public void saveAllergy(Allergy allergy)
                 throws APIException
```
    Description copied from interface: PatientService
    
    Creates an AllergyListItem to the Patient's Allergy Active List. Sets the start date to now, if it is null.
    
    Specified by:
    
    saveAllergy in interface PatientService
    
    Parameters:
    
    allergy - the Allergy
    
    Throws:
    
    APIException - Should save the allergy
    
    See Also:
    
    PatientService.saveAllergy(org.openmrs.Allergy)
  - removeAllergy
```
public void removeAllergy(Allergy allergy,
                          String reason)
                   throws APIException
```
    Description copied from interface: PatientService
    
    Resolving the allergy, effectively removes the Allergy from the Patient's Active List by setting the stop date to now, if null.
    
    Specified by:
    
    removeAllergy in interface PatientService
    
    Parameters:
    
    allergy - the Allergy
    
    reason - the reason of remove
    
    Throws:
    
    APIException - Should set the end date for the allergy
    
    See Also:
    
    PatientService.removeAllergy(org.openmrs.Allergy, java.lang.String)
  - voidAllergy
```
public void voidAllergy(Allergy allergy,
                        String reason)
                 throws APIException
```
    Description copied from interface: PatientService
    
    Used only in cases where the Allergy was entered by error
    
    Specified by:
    
    voidAllergy in interface PatientService
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.voidAllergy(org.openmrs.Allergy, java.lang.String)
  - getCountOfPatients
```
@Transactional(readOnly=true)
public Integer getCountOfPatients(String query)
```
    Description copied from interface: PatientService
    
    Return the number of unvoided patients with names or patient identifiers or searchable person attributes starting with or equal to the specified text
    
    Specified by:
    
    getCountOfPatients in interface PatientService
    
    Parameters:
    
    query - the string to search on
    
    Returns:
    
    the number of patients matching the given search phrase
    
    See Also:
    
    PatientService.getCountOfPatients(String)
  - getCountOfPatients
```
@Transactional(readOnly=true)
public Integer getCountOfPatients(String query,
                                                                boolean includeVoided)
```
    Specified by:
    
    getCountOfPatients in interface PatientService
    
    Parameters:
    
    query - the string to search on
    
    includeVoided - true/false whether or not to included voided patients
    
    Returns:
    
    the number of patients matching the given search phrase
    
    See Also:
    
    PatientService.getCountOfPatients(String, boolean)
  - getPatients
```
@Transactional(readOnly=true)
public List<Patient> getPatients(String query,
                                                               Integer start,
                                                               Integer length)
                                                        throws APIException
```
    Description copied from interface: PatientService
    
    Generic search on patients based on the given string and returns a specific number of them from the specified starting position. Implementations can use this string to search on name, identifier, searchable person attributes etc. Voided patients are not returned in search results. If start is 0 and length is not specified, then all matches are returned
    
    Specified by:
    
    getPatients in interface PatientService
    
    Parameters:
    
    query - the string to search on
    
    start - the starting index
    
    length - the number of patients to return
    
    Returns:
    
    a list of matching Patients
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getPatients(String, Integer, Integer)
  - getPatients
```
@Transactional(readOnly=true)
public List<Patient> getPatients(String query,
                                                               boolean includeVoided,
                                                               Integer start,
                                                               Integer length)
                                                        throws APIException
```
    Specified by:
    
    getPatients in interface PatientService
    
    Parameters:
    
    query - the string to search on
    
    includeVoided - true/false whether or not to included voided patients
    
    start - the starting index
    
    length - the number of patients to return
    
    Returns:
    
    a list of matching Patients
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getPatients(String, boolean, Integer, Integer)
  - getPatients
```
@Transactional(readOnly=true)
public List<Patient> getPatients(String name,
                                                               String identifier,
                                                               List<PatientIdentifierType> identifierTypes,
                                                               boolean matchIdentifierExactly,
                                                               Integer start,
                                                               Integer length)
                                                        throws APIException
```
    Description copied from interface: PatientService
    
    Get a limited size of patients from a given start index based on given criteria The identifier is matched with the regex OpenmrsConstants.PATIENT_IDENTIFIER_REGEX All parameters are optional and nullable. If null, it is not included in the search. Will not return voided patients
    
    Specified by:
    
    getPatients in interface PatientService
    
    Parameters:
    
    name - (optional) this is a slight break from the norm, patients with a partial match on this name will be returned
    
    identifier - (optional) only patients with a matching identifier are returned
    
    identifierTypes - (optional) the PatientIdentifierTypes to restrict to
    
    matchIdentifierExactly - (required) if true, then the given identifier must equal the id in the database. if false, then the identifier is 'searched' for by using a regular expression
    
    start - the starting index
    
    length - the number of patients to return
    
    Returns:
    
    patients that matched the given criteria (and are not voided)
    
    Throws:
    
    APIException
    
    See Also:
    
    PatientService.getPatients(String, String, List, boolean, Integer, Integer)
  - checkIfPatientIdentifierTypesAreLocked
```
public void checkIfPatientIdentifierTypesAreLocked()
```
    Description copied from interface: PatientService
    
    Check if patient identifier types are locked, and if they are, throws an exception during manipulation of a patient identifier type
    
    Specified by:
    
    checkIfPatientIdentifierTypesAreLocked in interface PatientService
    
    See Also:
    
    PatientService.checkIfPatientIdentifierTypesAreLocked()
  - getPatientIdentifiersByPatientProgram
```
public List<PatientIdentifier> getPatientIdentifiersByPatientProgram(PatientProgram patientProgram)
```
    Description copied from interface: PatientService
    
    Get all patientIdentifiers that are associated to the patient program
    
    Specified by:
    
    getPatientIdentifiersByPatientProgram in interface PatientService
    
    Parameters:
    
    patientProgram - the patientProgram to be used to fetch the associated identifiers
    
    Returns:
    
    PatientIdentifiers matching the patient program
    
    See Also:
    
    PatientService.getPatientIdentifiersByPatientProgram(org.openmrs.PatientProgram)

Class PatientServiceImpl

Constructor Summary

Method Summary

Methods inherited from class org.openmrs.api.impl.BaseOpenmrsService

Methods inherited from class java.lang.Object

Methods inherited from interface org.openmrs.api.OpenmrsService

Constructor Detail

PatientServiceImpl

Method Detail

setPatientDAO

onShutdown

savePatient

getPatient

getPatientOrPromotePerson

getAllPatients

getAllPatients

getPatients

checkPatientIdentifiers

voidPatient

unvoidPatient

purgePatient

getPatientIdentifiers

savePatientIdentifierType

getAllPatientIdentifierTypes

getAllPatientIdentifierTypes

getPatientIdentifierTypes

getPatientIdentifierType

getPatientIdentifierTypeByName

retirePatientIdentifierType

unretirePatientIdentifierType

purgePatientIdentifierType

getPatients

getPatientByExample

getDuplicatePatientsByAttributes

mergePatients

exitFromCare

processDeath

saveCauseOfDeathObs

getPatientByUuid

getPatientIdentifierByUuid

getPatientIdentifierTypeByUuid

getDefaultIdentifierValidator

getIdentifierValidator

getIdentifierValidators

setIdentifierValidators

getAllIdentifierValidators

getIdentifierValidator

isIdentifierInUseByAnotherPatient

getPatientIdentifier

voidPatientIdentifier

mergePatients

savePatientIdentifier

purgePatientIdentifier

getAllergies

setAllergies

getAllergy

getAllergyByUuid

saveAllergy

removeAllergy

voidAllergy

getCountOfPatients

getCountOfPatients

getPatients

getPatients

getPatients

checkIfPatientIdentifierTypesAreLocked

getPatientIdentifiersByPatientProgram