PatientService (OpenMRS 1.8.5-SNAPSHOT API)

All Superinterfaces:

OpenmrsService

All Known Implementing Classes:

PatientServiceImpl
```
@Transactional
public interface PatientService
extends OpenmrsService
```
Contains methods pertaining to Patients in the system Use:
```
 
 List<Patient> patients = Context.getPatientService().getAllPatients();
 
```
See Also:

Context, Patient

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`checkPatientIdentifier(PatientIdentifier patientIdentifier)` Deprecated. use `PatientIdentifierValidator.validateIdentifier(PatientIdentifier)`
`void`	`checkPatientIdentifiers(Patient patient)` Convenience method to validate all identifiers for a given patient
`Patient`	`createPatient(Patient patient)` Deprecated. replaced by #savePatient(Patient)
`void`	`deletePatient(Patient patient)` Deprecated. replaced by `purgePatient(Patient)`
`void`	`exitFromCare(Patient patient, Date dateExited, Concept reasonForExit)` Convenience method to establish that a patient has left the care center.
`List<Patient>`	`findDuplicatePatients(Set<String> attributes)` Deprecated. use `getDuplicatePatientsByAttributes(List)`
`Patient`	`findPatient(Patient patientToMatch)` Deprecated. use #getPatientByExample(Patient)
`List<Patient>`	`findPatients(String query, boolean includeVoided)` Deprecated. use #getPatients(String)
`List<Allergy>`	`getAllergies(Person p)` Returns a sorted set of Allergies, sorted on sort_weight
`Allergy`	`getAllergy(Integer allergyListId)` Returns the Allergy
`Collection<IdentifierValidator>`	`getAllIdentifierValidators()`
`List<PatientIdentifierType>`	`getAllPatientIdentifierTypes()` Get all patientIdentifier types
`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 starting with or equal to the specified text
`IdentifierValidator`	`getDefaultIdentifierValidator()`
`List<Patient>`	`getDuplicatePatientsByAttributes(List<String> attributes)` Search the database for patients that both share the given attributes.
`IdentifierValidator`	`getIdentifierValidator(Class<IdentifierValidator> clazz)` Gets an identifier validator matching the given class.
`IdentifierValidator`	`getIdentifierValidator(String pivClassName)`
`Patient`	`getPatient(Integer patientId)` Get patient by internal identifier
`Patient`	`getPatientByExample(Patient patientToMatch)` This method tries to find a patient in the database given the attributes on the given `patientToMatch` object.
`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(PatientIdentifierType patientIdentifierType)` Deprecated. replaced by `getPatientIdentifiers(String, List, List, List, Boolean)`
`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>`	`getPatientIdentifiers(String identifier, PatientIdentifierType pit)` Deprecated. replaced by `getPatientIdentifiers(String, List, List, List, Boolean)`
`PatientIdentifierType`	`getPatientIdentifierType(Integer patientIdentifierTypeId)` Get patientIdentifierType by internal identifier
`PatientIdentifierType`	`getPatientIdentifierType(String name)` Deprecated. use `getPatientIdentifierTypeByName(String)`
`PatientIdentifierType`	`getPatientIdentifierTypeByName(String name)` Get patientIdentifierType by exact name
`PatientIdentifierType`	`getPatientIdentifierTypeByUuid(String uuid)` Get patient identifierType by universally unique identifier
`List<PatientIdentifierType>`	`getPatientIdentifierTypes()` Deprecated. replaced by `getAllPatientIdentifierTypes()`
`List<PatientIdentifierType>`	`getPatientIdentifierTypes(String name, String format, Boolean required, Boolean hasCheckDigit)` Get all patientIdentifier types that match the given criteria
`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, 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)` Deprecated. replaced by a call to `getPatients(String, String, List, boolean)` with "false" as the last parameter
`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.
`List<Patient>`	`getPatientsByIdentifier(String identifier, boolean includeVoided)` Deprecated. replaced by `getPatients(String, String, List)`
`List<Patient>`	`getPatientsByIdentifierPattern(String identifier, boolean includeVoided)` Deprecated. replaced by getPatients( ... )
`List<Patient>`	`getPatientsByName(String name)` Deprecated. replaced by `getPatients(String, String, List)`
`List<Patient>`	`getPatientsByName(String name, boolean includeVoided)` Deprecated. replaced by getPatients( ... )
`Problem`	`getProblem(Integer problemListId)` Returns the Problem
`List<Problem>`	`getProblems(Person p)` Get a list of the problems for the patient, sorted on sort_weight
`Patient`	`identifierInUse(String identifier, PatientIdentifierType type, Patient ignorePatient)` Deprecated. use #getPatientByIdentifier(String) instead
`boolean`	`isIdentifierInUseByAnotherPatient(PatientIdentifier patientIdentifier)` Checks whether the given patient identifier is already assigned to a patient other than patientIdentifier.patient
`void`	`mergePatients(Patient preferred, Patient notPreferred)` Convenience method to join two patients' information into one record.
`void`	`processDeath(Patient patient, Date dateDied, Concept causeOfDeath, String otherReason)` Convenience method 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.
`void`	`removeProblem(Problem problem, String reason)` Effectively removes the Problem 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 dateDied, Concept causeOfDeath, String otherReason)` Convenience method that saves the Obs that indicates when and why the patient died (including any "other" reason there might be) TODO keep this in the PatientService?
`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
`void`	`saveProblem(Problem problem)` Creates a ProblemListItem to the Patient's Problem Active List.
`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
`Patient`	`updatePatient(Patient patient)` Deprecated. replaced by #savePatient(Patient)
`void`	`updatePatientIdentifier(PatientIdentifier patientIdentifier)` Deprecated. patient identifiers should not be updated directly; rather, after changing patient identifiers, use `savePatient(Patient)` to save changes to the database
`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)
`void`	`voidProblem(Problem problem, String reason)` Used only in cases where the Problem was entered by error

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

- Method Detail
  - setPatientDAO
```
void setPatientDAO(PatientDAO dao)
```
    Sets the DAO for this service. This is done by DI and Spring. See the applicationContext-service.xml definition file.
    
    Parameters:
    
    dao - DAO for this service
  - createPatient
```
@Deprecated
 @Authorized(value="Add Patients")
Patient createPatient(Patient patient)
                                                              throws APIException
```
    Deprecated. replaced by #savePatient(Patient)
    
    Throws:
    
    APIException
    
    See Also:
    
    savePatient(Patient)
  - savePatient
```
@Authorized(value={"Add Patients","Edit Patients"})
Patient savePatient(Patient patient)
                                                                 throws APIException
```
    Saved the given patient to the database
    
    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, not throw a NonUniqueObjectException when called with a hand constructed patient regression 1375, fail when patient does not have any patient identifiers, fail when patient does not have required patient identifiers
  - getPatient
```
@Authorized(value="View Patients")
 @Transactional(readOnly=true)
Patient getPatient(Integer patientId)
                                                                              throws APIException
```
    Get patient by internal identifier
    
    Parameters:
    
    patientId - internal patient identifier
    
    Returns:
    
    patient with given internal identifier
    
    Throws:
    
    APIException
    
    Should:
    
    return null object if patient id doesnt exist, fetch patient with given patient id, return null when patient with given patient id does not exist
  - getPatientOrPromotePerson
```
@Authorized(value="View Patients")
 @Transactional(readOnly=true)
Patient getPatientOrPromotePerson(Integer patientOrPersonId)
                                                                                             throws APIException
```
    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.
    
    Parameters:
    
    patientOrPersonId -
    
    Returns:
    
    a new unsaved patient or null if person or patient is not found
    
    Throws:
    
    APIException
  - getPatientByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
Patient getPatientByUuid(String uuid)
                                                                                    throws APIException
```
    Get patient by universally unique identifier.
    
    Parameters:
    
    uuid - universally unique identifier
    
    Returns:
    
    the patient that matches the uuid
    
    Throws:
    
    APIException
    
    Should:
    
    fetch patient with given uuid, return null if patient not found with given uuid
  - getPatientIdentifierByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Patient Identifiers")
PatientIdentifier getPatientIdentifierByUuid(String uuid)
                                                                                                                   throws APIException
```
    Get patient identifier by universally unique identifier.
    
    Parameters:
    
    uuid - universally unique identifier
    
    Returns:
    
    the patient identifier that matches the uuid
    
    Throws:
    
    APIException
    
    Should:
    
    fetch patient identifier with given uuid, return null if patient identifier not found with given uuid
  - updatePatient
```
@Deprecated
Patient updatePatient(Patient patient)
                           throws APIException
```
    Deprecated. replaced by #savePatient(Patient)
    
    Throws:
    
    APIException
    
    See Also:
    
    savePatient(Patient)
  - getAllPatients
```
@Authorized(value="View Patients")
 @Transactional(readOnly=true)
List<Patient> getAllPatients()
                                                                                        throws APIException
```
    Returns all non voided patients in the system
    
    Returns:
    
    non voided patients in the system
    
    Throws:
    
    APIException
    
    See Also:
    
    getAllPatients(boolean)
    
    Should:
    
    fetch all non voided patients
  - getAllPatients
```
@Authorized(value="View Patients")
 @Transactional(readOnly=true)
List<Patient> getAllPatients(boolean includeVoided)
                                                                                        throws APIException
```
    Returns patients in the system
    
    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, fetch non voided patients when given include voided is false
  - identifierInUse
```
@Deprecated
 @Transactional(readOnly=true)
Patient identifierInUse(String identifier,
                                                                   PatientIdentifierType type,
                                                                   Patient ignorePatient)
```
    Deprecated. use #getPatientByIdentifier(String) instead
  - getPatientsByIdentifier
```
@Deprecated
 @Transactional(readOnly=true)
List<Patient> getPatientsByIdentifier(String identifier,
                                                                                 boolean includeVoided)
                                                                          throws APIException
```
    Deprecated. replaced by getPatients(String, String, List)
    
    Throws:
    
    APIException
  - getPatients
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatients(String name,
                                                                                            String identifier,
                                                                                            List<PatientIdentifierType> identifierTypes,
                                                                                            boolean matchIdentifierExactly)
                                                                                     throws APIException
```
    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
    
    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
    
    Returns:
    
    patients that matched the given criteria (and are not voided)
    
    Throws:
    
    APIException
    
    Should:
    
    fetch all patients that partially matches given name, fetch all patients that partially matches given identifier when match identifier exactly equals false, fetch all patients that exactly matches given identifier when match identifier exactly equals true, fetch all patients that match given identifier types, not return duplicates, return empty list when no match is found, search familyName2 with name, support simple regex, support pattern using last digit as check digit
  - getPatients
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatients(String name,
                                                                                                         String identifier,
                                                                                                         List<PatientIdentifierType> identifierTypes)
                                                                                                  throws APIException
```
    Deprecated. replaced by a call to getPatients(String, String, List, boolean) with "false" as the last parameter
    
    Throws:
    
    APIException
  - getPatientsByIdentifierPattern
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatientsByIdentifierPattern(String identifier,
                                                                                                                            boolean includeVoided)
                                                                                                                     throws APIException
```
    Deprecated. replaced by getPatients( ... )
    
    Throws:
    
    APIException
  - getPatientsByName
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatientsByName(String name)
                                                                                                        throws APIException
```
    Deprecated. replaced by getPatients(String, String, List)
    
    Throws:
    
    APIException
  - getPatientsByName
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatientsByName(String name,
                                                                                                               boolean includeVoided)
                                                                                                        throws APIException
```
    Deprecated. replaced by getPatients( ... )
    
    Throws:
    
    APIException
  - voidPatient
```
@Authorized(value="Delete Patients")
Patient voidPatient(Patient patient,
                                                         String reason)
                                                  throws APIException
```
    Void patient record (functionally delete patient from system)
    
    Parameters:
    
    patient - patient to be voided
    
    reason - reason for voiding patient
    
    Returns:
    
    the voided patient
    
    Throws:
    
    APIException
    
    Should:
    
    void given patient with given reason, void all patient identifiers associated with given patient, return voided patient with given reason, return null when patient is null
  - unvoidPatient
```
@Authorized(value="Delete Patients")
Patient unvoidPatient(Patient patient)
                                                    throws APIException
```
    Unvoid patient record
    
    Parameters:
    
    patient - patient to be revived
    
    Returns:
    
    the revived Patient
    
    Throws:
    
    APIException
    
    Should:
    
    unvoid given patient, return unvoided patient
  - deletePatient
```
@Deprecated
 @Authorized(value="Purge Patients")
void deletePatient(Patient patient)
                                                             throws APIException
```
    Deprecated. replaced by purgePatient(Patient)
    
    Throws:
    
    APIException
    
    See Also:
    
    purgePatient(Patient)
  - purgePatient
```
@Authorized(value="Purge Patients")
void purgePatient(Patient patient)
                                               throws APIException
```
    Delete patient from database. This should not be called except for testing and administration purposes. Use the void method instead.
    
    Parameters:
    
    patient - patient to be deleted
    
    Throws:
    
    APIException
    
    See Also:
    
    voidPatient(org.openmrs.Patient,java.lang.String)
    
    Should:
    
    delete patient from database
  - getPatientIdentifiers
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patient Identifiers")
List<PatientIdentifier> getPatientIdentifiers(PatientIdentifierType patientIdentifierType)
                                                                                                                                 throws APIException
```
    Deprecated. replaced by getPatientIdentifiers(String, List, List, List, Boolean)
    
    Throws:
    
    APIException
  - getPatientIdentifiers
```
@Transactional(readOnly=true)
 @Authorized(value="View Patient Identifiers")
List<PatientIdentifier> getPatientIdentifiers(String identifier,
                                                                                                                           List<PatientIdentifierType> patientIdentifierTypes,
                                                                                                                           List<Location> locations,
                                                                                                                           List<Patient> patients,
                                                                                                                           Boolean isPreferred)
                                                                                                                    throws APIException
```
    Get all patientIdentifiers that match all of the given criteria Voided identifiers are not returned
    
    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
    
    Throws:
    
    APIException
    
    Should:
    
    return only non voided patients and patient identifiers, fetch patient identifiers that exactly matches given identifier, fetch patient identifiers that partially matches given identifier, fetch patient identifiers that match given patient identifier types, fetch patient identifiers that match given locations, fetch patient identifiers that match given patients, fetch preferred patient identifiers when given is preferred equals true, fetch non preferred patient identifiers when given is preferred equals false, fetch preferred and non preferred patient identifiers when given is preferred is null
  - getPatientIdentifiers
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patient Identifiers")
List<PatientIdentifier> getPatientIdentifiers(String identifier,
                                                                                                                                        PatientIdentifierType pit)
                                                                                                                                 throws APIException
```
    Deprecated. replaced by getPatientIdentifiers(String, List, List, List, Boolean)
    
    Throws:
    
    APIException
  - updatePatientIdentifier
```
@Deprecated
 @Authorized(value="Edit Patient Identifiers")
void updatePatientIdentifier(PatientIdentifier patientIdentifier)
                                                                                 throws APIException
```
    Deprecated. patient identifiers should not be updated directly; rather, after changing patient identifiers, use savePatient(Patient) to save changes to the database
    
    Update patient identifier
    
    Parameters:
    
    patientIdentifier - identifier to be updated
    
    Throws:
    
    APIException
  - savePatientIdentifierType
```
@Authorized(value="Manage Identifier Types")
PatientIdentifierType savePatientIdentifierType(PatientIdentifierType patientIdentifierType)
                                                                                      throws APIException
```
    Create or update a PatientIdentifierType
    
    Parameters:
    
    patientIdentifierType - PatientIdentifierType to create or update
    
    Returns:
    
    the saved type
    
    Throws:
    
    APIException
    
    Should:
    
    create new patient identifier type, update existing patient identifier type
  - getPatientIdentifierTypes
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
List<PatientIdentifierType> getPatientIdentifierTypes()
                                                                                                                                      throws APIException
```
    Deprecated. replaced by getAllPatientIdentifierTypes()
    
    Throws:
    
    APIException
    
    See Also:
    
    getAllPatientIdentifierTypes()
  - getAllPatientIdentifierTypes
```
@Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
List<PatientIdentifierType> getAllPatientIdentifierTypes()
                                                                                                                            throws APIException
```
    Get all patientIdentifier types
    Ordered same as PatientIdentifierTypeDefaultComparator.
    
    Returns:
    
    patientIdentifier types list
    
    Throws:
    
    APIException
    
    Should:
    
    fetch all non retired patient identifier types, order as default comparator
  - getAllPatientIdentifierTypes
```
@Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
List<PatientIdentifierType> getAllPatientIdentifierTypes(boolean includeRetired)
                                                                                                                            throws APIException
```
    Get all patientIdentifier types
    Ordered same as PatientIdentifierTypeDefaultComparator.
    
    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, fetch patient identifier types excluding retired when include retired is false, order as default comparator
  - getPatientIdentifierTypes
```
@Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
List<PatientIdentifierType> getPatientIdentifierTypes(String name,
                                                                                                                                String format,
                                                                                                                                Boolean required,
                                                                                                                                Boolean hasCheckDigit)
                                                                                                                         throws APIException
```
    Get all patientIdentifier types that match the given criteria
    Ordered same as PatientIdentifierTypeDefaultComparator.
    
    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, fetch required patient identifier types when given required is true, fetch non required patient identifier types when given required is false, fetch any patient identifier types when given required is null, fetch patient identifier types with check digit when given has check digit is true, fetch patient identifier types without check digit when given has check digit is false, fetch any patient identifier types when given has check digit is null, order as default comparator
  - getPatientIdentifierType
```
@Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
PatientIdentifierType getPatientIdentifierType(Integer patientIdentifierTypeId)
                                                                                                                  throws APIException
```
    Get patientIdentifierType by internal identifier
    
    Parameters:
    
    patientIdentifierTypeId -
    
    Returns:
    
    patientIdentifierType with specified internal identifier
    
    Throws:
    
    APIException
    
    Should:
    
    fetch patient identifier with given patient identifier type id, return null when patient identifier identifier does not exist
  - getPatientIdentifierTypeByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
PatientIdentifierType getPatientIdentifierTypeByUuid(String uuid)
                                                                                                                        throws APIException
```
    Get patient identifierType by universally unique identifier
    
    Parameters:
    
    patientIdentifierTypeId -
    
    Returns:
    
    patientIdentifierType with specified internal identifier
    
    Throws:
    
    APIException
    
    Should:
    
    fetch patient identifier type with given uuid, return null when patient identifier type with given uuid does not exist
  - getPatientIdentifierType
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
PatientIdentifierType getPatientIdentifierType(String name)
                                                                                                                               throws APIException
```
    Deprecated. use getPatientIdentifierTypeByName(String)
    
    Throws:
    
    APIException
  - getPatientIdentifierTypeByName
```
@Transactional(readOnly=true)
 @Authorized(value="View Identifier Types")
PatientIdentifierType getPatientIdentifierTypeByName(String name)
                                                                                                                        throws APIException
```
    Get patientIdentifierType by exact name
    
    Parameters:
    
    name -
    
    Returns:
    
    patientIdentifierType with given name
    
    Throws:
    
    APIException
    
    Should:
    
    fetch patient identifier type that exactly matches given name, not return patient identifier type that partially matches given name, return null when patient identifier type with given name does not exist
  - retirePatientIdentifierType
```
@Authorized(value="Manage Identifier Types")
PatientIdentifierType retirePatientIdentifierType(PatientIdentifierType patientIdentifierType,
                                                                                               String reason)
                                                                                        throws APIException
```
    Retire a type of patient identifier
    
    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, throw error when reason is empty
  - unretirePatientIdentifierType
```
@Authorized(value="Manage Identifier Types")
PatientIdentifierType unretirePatientIdentifierType(PatientIdentifierType patientIdentifierType)
                                                                                          throws APIException
```
    Unretire a type of patient identifier
    
    Parameters:
    
    patientIdentifierType - type of patient identifier to be unretired
    
    Returns:
    
    the unretired type
    
    Throws:
    
    APIException
    
    Should:
    
    untire patient identifier type, return unretired patient identifier type
  - purgePatientIdentifierType
```
@Authorized(value="Purge Identifier Types")
void purgePatientIdentifierType(PatientIdentifierType patientIdentifierType)
                                                                     throws APIException
```
    Purge PatientIdentifierType (cannot be undone)
    
    Parameters:
    
    patientIdentifierType - PatientIdentifierType to purge from the database
    
    Throws:
    
    APIException
    
    Should:
    
    delete type from database, delete patient identifier type from database
  - checkPatientIdentifier
```
@Deprecated
 @Authorized(value="View Patient Identifiers")
void checkPatientIdentifier(PatientIdentifier patientIdentifier)
                                                                                throws PatientIdentifierException
```
    Deprecated. use PatientIdentifierValidator.validateIdentifier(PatientIdentifier)
    
    Convenience method to validate a patient identifier. Checks for things like blank identifiers, invalid check digits, etc
    
    Parameters:
    
    patientIdentifier - identifier to be validated
    
    Throws:
    
    PatientIdentifierException - if the identifier is invalid
    
    See Also:
    
    checkPatientIdentifiers(Patient)
  - checkPatientIdentifiers
```
@Authorized(value="View Patient Identifiers")
void checkPatientIdentifiers(Patient patient)
                                                                    throws PatientIdentifierException
```
    Convenience method to validate all identifiers for a given patient
    
    Parameters:
    
    patient - patient for which to validate identifiers
    
    Throws:
    
    PatientIdentifierException - if one or more of the identifiers are invalid
    
    See Also:
    
    checkPatientIdentifiers(Patient)
    
    Should:
    
    validate when patient has all required and no duplicate and no blank patient identifiers, ignore voided patient identifier, remove identifier and throw error when patient has blank patient identifier, throw error when patient has null patient identifiers, throw error when patient has empty patient identifiers, throw error when patient has identical identifiers, throw error when patient does not have one or more required identifiers, require one non voided patient identifier
  - findPatients
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> findPatients(String query,
                                                                                                          boolean includeVoided)
                                                                                                   throws APIException
```
    Deprecated. use #getPatients(String)
    
    Throws:
    
    APIException
    
    See Also:
    
    getPatients(String)
  - getPatients
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatients(String query)
                                                                                     throws APIException
```
    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
    
    Parameters:
    
    query - the string to search on
    
    Returns:
    
    a list of matching Patients
    
    Throws:
    
    APIException
    
    Should:
    
    force search string to be greater than minsearchcharacters global property, allow search string to be one according to minsearchcharacters global property, fetch patients with patient identifiers matching given query, fetch patients with any name matching given query, return empty list if given query length less than minimum search characters, not fail when minimum search characters is null, not fail when minimum search characters is invalid integer
  - getPatients
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatients(String query,
                                                                                            Integer start,
                                                                                            Integer length)
                                                                                     throws APIException
```
    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, etc Voided patients are not returned in search results If start is 0 and length is not specified, then all matches are returned
    
    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
    
    Since:
    
    1.8
    
    Should:
    
    find a patients with a matching identifier with no digits
  - findPatient
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
Patient findPatient(Patient patientToMatch)
                                                                                            throws APIException
```
    Deprecated. use #getPatientByExample(Patient)
    
    Throws:
    
    APIException
    
    See Also:
    
    getPatientByExample(Patient)
  - getPatientByExample
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
Patient getPatientByExample(Patient patientToMatch)
                                                                                       throws APIException
```
    This method tries to find a patient in the database given the attributes on the given patientToMatch object. Assumes there could be a PersonAttribute on this Patient with PersonAttributeType.name = "Other Matching Information". This PersonAttribute has a "value" that is just key value pairs in the form of key:value;nextkey:nextvalue;
    
    Parameters:
    
    patientToMatch -
    
    Returns:
    
    null if no match found, a fresh patient object from the db if is found
    
    Throws:
    
    APIException
    
    Should:
    
    fetch patient matching patient id of given patient, not fetch patient matching any other patient information, return null when no patient matches given patient to match
  - findDuplicatePatients
```
@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> findDuplicatePatients(Set<String> attributes)
                                                                                                            throws APIException
```
    Deprecated. use getDuplicatePatientsByAttributes(List)
    
    Throws:
    
    APIException
    
    See Also:
    
    getDuplicatePatientsByAttributes(List)
  - getDuplicatePatientsByAttributes
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getDuplicatePatientsByAttributes(List<String> attributes)
                                                                                                          throws APIException
```
    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.
    
    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, not return patients that exactly match on some but not all given attributes
  - mergePatients
```
@Authorized(value="Edit Patients")
void mergePatients(Patient preferred,
                                                      Patient notPreferred)
                                               throws APIException
```
    Convenience method to join two patients' information into one record.
    1. Moves object (encounters/obs) pointing to nonPreferred to point at 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
    Parameters:
    
    preferred - The Patient to merge to
    
    notPreferred - The Patient to merge from (and then void)
    
    Throws:
    
    APIException
    
    Should:
    
    not merge the same patient to itself, copy nonvoided names to preferred patient, copy nonvoided identifiers to preferred patient, copy nonvoided addresses to preferred patient, not copy over relationships that are only between the preferred and notpreferred patient, not merge patient with itself, not create duplicate relationships, merge non voided encounters from non preferred to preferred patient, merge non duplicate patient identifiers from non preferred to preferred patient, merge non duplicate patient names from non preferred to preferred patient, merge non duplicate addresses from non preferred to preferred patient, merge non voided patient programs from non preferred to preferred patient, merge non voided relationships from non preferred to preferred patient, merge observations associated with encounters from non preferred to preferred patient, merge non voided person attributes from non preferred to preferred patient, merge other non voided observations from non preferred to preferred patient, merge other non voided orders from non preferred to preferred patient, merge non preferred death date when preferred death date is not null or empty, merge non preferred death cause when preferred death cause is not null or empty, void non preferred person object, change user records of non preferred person to preferred person, void non preferred patient, void all relationships for non preferred patient, not void relationships for same type and side with different relatives, not copy over duplicate patient identifiers
  - exitFromCare
```
@Authorized(value="Edit Patients")
void exitFromCare(Patient patient,
                                                     Date dateExited,
                                                     Concept reasonForExit)
                                              throws APIException
```
    Convenience method 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 (if applicable) 5) Creating any relevant observations about the patient TODO keep this in the PatientService? Or move to appropriate service?
    
    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
    
    Should:
    
    save reason for exit observation for given patient, set death date and cause when given reason for exit equals death, discontinue all orders associated with given patient, terminate all program workflows associated with given paitent, throw error when given patient is null, throw error when given date exited is null, throw error when given reason for exist is null, be tested more thoroughly
  - processDeath
```
@Authorized(value="Edit Patients")
void processDeath(Patient patient,
                                                     Date dateDied,
                                                     Concept causeOfDeath,
                                                     String otherReason)
                                              throws APIException
```
    Convenience method 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. TODO Keep this in the PatientService? Or move to appropriate service
    
    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 - - if the concept representing the reason is OTHER NON-CODED, and a string-based "other" reason is supplied
    
    Throws:
    
    APIException
    
    Should:
    
    be tested more thoroughly
  - saveCauseOfDeathObs
```
@Authorized(value={"View Patients","Edit Observations"},
            requireAll=true)
void saveCauseOfDeathObs(Patient patient,
                                                                                                               Date dateDied,
                                                                                                               Concept causeOfDeath,
                                                                                                               String otherReason)
                                                                                                        throws APIException
```
    Convenience method that saves the Obs that indicates when and why the patient died (including any "other" reason there might be) TODO keep this in the 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 - - 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, throw error when given death date is null, throw error when given cause is null is null, throw error when cause of death global property is not specified, throw error when patient already has more than one cause of death observations, modify existing cause of death observation, set death attributes as long as patient is not already dead, be tested more thoroughly
  - getIdentifierValidator
```
@Transactional(readOnly=true)
IdentifierValidator getIdentifierValidator(Class<IdentifierValidator> clazz)
```
    Gets an identifier validator matching the given class.
    
    Parameters:
    
    clazz - identifierValidator which validator to get.
    
    Should:
    
    return patient identifier validator given class
  - getIdentifierValidator
```
@Transactional(readOnly=true)
IdentifierValidator getIdentifierValidator(String pivClassName)
```
    Should:
    
    return patient identifier validator given class name, treat empty strings like a null entry
  - getDefaultIdentifierValidator
```
@Transactional(readOnly=true)
IdentifierValidator getDefaultIdentifierValidator()
```
    Returns:
    
    the default IdentifierValidator
    
    Should:
    
    return default patient identifier validator
  - getAllIdentifierValidators
```
@Transactional(readOnly=true)
Collection<IdentifierValidator> getAllIdentifierValidators()
```
    Returns:
    
    All registered PatientIdentifierValidators
    
    Should:
    
    return all registered patient identifier validators
  - isIdentifierInUseByAnotherPatient
```
@Authorized(value="View Patients")
 @Transactional(readOnly=true)
boolean isIdentifierInUseByAnotherPatient(PatientIdentifier patientIdentifier)
```
    Checks whether the given patient identifier is already assigned to a patient other than patientIdentifier.patient
    
    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, return false when patientIdentifier contains a patient and no other patient has this id, return true when patientIdentifier does not contain a patient and a patient has this id, return false when patientIdentifier does not contain a patient and no patient has this id, ignore voided patientIdentifiers, ignore voided patients
  - getPatientIdentifier
```
@Authorized(value="View Patient Identifiers")
 @Transactional(readOnly=true)
PatientIdentifier getPatientIdentifier(Integer patientIdentifierId)
                                                                                                             throws APIException
```
    Returns a patient identifier that matches the given patientIndentifier id
    
    Parameters:
    
    patientIdentifier - the patientIdentifier id
    
    Returns:
    
    the patientIdentifier matching the Id
    
    Throws:
    
    APIException
    
    Should:
    
    return the patientIdentifier with the given id
  - voidPatientIdentifier
```
@Authorized(value="Delete Patient Identifiers")
PatientIdentifier voidPatientIdentifier(PatientIdentifier patientIdentifier,
                                                                                        String reason)
                                                                                 throws APIException
```
    Void patient identifier (functionally delete patient identifier from system)
    
    Parameters:
    
    patient - 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, throw an APIException if the reason is null, throw an APIException if the reason is an empty string, throw an APIException if the reason is a white space character
  - savePatientIdentifier
```
@Authorized(value={"Add Patient Identifiers","Edit Patient Identifiers"})
PatientIdentifier savePatientIdentifier(PatientIdentifier patientIdentifier)
                                                                                                           throws APIException
```
    Saved the given patientIndentifier to the database
    
    Parameters:
    
    patientIndentifier - patientIndentifier to be created or updated
    
    Returns:
    
    patientIndentifier that was created or updated
    
    Throws:
    
    APIException
    
    Should:
    
    create new patientIndentifier, update an existing patient identifier, throw an APIException when a null argument is passed, throw an APIException when one of the required fields is null, throw an APIException if the patientIdentifier string is a white space, throw an APIException if the patientIdentifier string is an empty string
  - purgePatientIdentifier
```
@Authorized(value="Purge Patient Identifiers")
void purgePatientIdentifier(PatientIdentifier patientIdentifier)
                                                                    throws APIException
```
    Purge PatientIdentifier (cannot be undone)
    
    Parameters:
    
    patientIdentifier - PatientIdentifier to purge from the database
    
    Throws:
    
    APIException
    
    Should:
    
    delete patient identifier from database
  - getProblems
```
@Transactional(readOnly=true)
 @Authorized(value="View Problems")
List<Problem> getProblems(Person p)
                                                                                     throws APIException
```
    Get a list of the problems for the patient, sorted on sort_weight
    
    Parameters:
    
    p - the Person
    
    Returns:
    
    sorted set based on the sort weight of the list items
    
    Throws:
    
    APIException
    
    Should:
    
    return empty list if no problems exist for this Patient
  - getProblem
```
@Transactional(readOnly=true)
 @Authorized(value="View Problems")
Problem getProblem(Integer problemListId)
                                                                              throws APIException
```
    Returns the Problem
    
    Parameters:
    
    problemListId -
    
    Returns:
    
    the allergy
    
    Throws:
    
    APIException
  - saveProblem
```
@Authorized(value={"Add Problems","Edit Problems"})
void saveProblem(Problem problem)
                                                              throws APIException
```
    Creates a ProblemListItem to the Patient's Problem Active List. Sets the start date to now, if it is null. Sets the weight
    
    Parameters:
    
    problem - the Problem
    
    Throws:
    
    APIException
    
    Should:
    
    save the problem and set the weight for correct ordering
  - removeProblem
```
@Authorized(value="Edit Problems")
void removeProblem(Problem problem,
                                                      String reason)
                                               throws APIException
```
    Effectively removes the Problem from the Patient's Active List by setting the stop date to now, if null.
    
    Parameters:
    
    problem - the Problem
    
    reason - the reason of removing the problem
    
    Throws:
    
    APIException
    
    Should:
    
    set the end date for the problem
  - voidProblem
```
@Authorized(value="Remove Problems")
void voidProblem(Problem problem,
                                                      String reason)
                                               throws APIException
```
    Used only in cases where the Problem was entered by error
    
    Parameters:
    
    problem -
    
    reason -
    
    Throws:
    
    APIException
  - getAllergies
```
@Transactional(readOnly=true)
 @Authorized(value="View Allergies")
List<Allergy> getAllergies(Person p)
                                                                                       throws APIException
```
    Returns a sorted set of Allergies, sorted on sort_weight
    
    Parameters:
    
    p - the Person
    
    Returns:
    
    sorted set based on the sort weight of the list items
    
    Throws:
    
    APIException
    
    Should:
    
    return empty list if no allergies exist for the Patient
  - getAllergy
```
@Transactional(readOnly=true)
 @Authorized(value="View Allergies")
Allergy getAllergy(Integer allergyListId)
                                                                               throws APIException
```
    Returns the Allergy
    
    Parameters:
    
    allergyListId -
    
    Returns:
    
    the allergy
    
    Throws:
    
    APIException
  - saveAllergy
```
@Authorized(value={"Add Allergies","Edit Allergies"})
void saveAllergy(Allergy allergy)
                                                                throws APIException
```
    Creates an AllergyListItem to the Patient's Allergy Active List. Sets the start date to now, if it is null.
    
    Parameters:
    
    allergy - the Allergy
    
    Throws:
    
    APIException
    
    Should:
    
    save the allergy
  - removeAllergy
```
@Authorized(value="Edit Allergies")
void removeAllergy(Allergy allergy,
                                                       String reason)
                                                throws APIException
```
    Resolving the allergy, effectively removes the Allergy from the Patient's Active List by setting the stop date to now, if null.
    
    Parameters:
    
    allergy - the Allergy
    
    reason - the reason of remove
    
    Throws:
    
    APIException
    
    Should:
    
    set the end date for the allergy
  - voidAllergy
```
@Authorized(value="Remove Allergies")
void voidAllergy(Allergy allergy,
                                                       String reason)
                                                throws APIException
```
    Used only in cases where the Allergy was entered by error
    
    Parameters:
    
    allergy -
    
    reason -
    
    Throws:
    
    APIException
  - getCountOfPatients
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
Integer getCountOfPatients(String query)
```
    Return the number of unvoided patients with names or patient identifiers starting with or equal to the specified text
    
    Parameters:
    
    query - the string to search on
    
    Returns:
    
    the number of patients matching the given search phrase
    
    Since:
    
    1.8
    
    Should:
    
    return the right count when a patient has multiple matching person names, return the right count of patients with a matching identifier with no digits
  - getPatients
```
@Transactional(readOnly=true)
 @Authorized(value="View Patients")
List<Patient> getPatients(String name,
                                                                                            String identifier,
                                                                                            List<PatientIdentifierType> identifierTypes,
                                                                                            boolean matchIdentifierExactly,
                                                                                            Integer start,
                                                                                            Integer length)
                                                                                     throws APIException
```
    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
    
    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
    
    Since:
    
    1.8

Interface PatientService

Method Summary

Methods inherited from interface org.openmrs.api.OpenmrsService

Method Detail

setPatientDAO

createPatient

savePatient

getPatient

getPatientOrPromotePerson

getPatientByUuid

getPatientIdentifierByUuid

updatePatient

getAllPatients

getAllPatients

identifierInUse

getPatientsByIdentifier

getPatients

getPatients

getPatientsByIdentifierPattern

getPatientsByName

getPatientsByName

voidPatient

unvoidPatient

deletePatient

purgePatient

getPatientIdentifiers

getPatientIdentifiers

getPatientIdentifiers

updatePatientIdentifier

savePatientIdentifierType

getPatientIdentifierTypes

getAllPatientIdentifierTypes

getAllPatientIdentifierTypes

getPatientIdentifierTypes

getPatientIdentifierType

getPatientIdentifierTypeByUuid

getPatientIdentifierType

getPatientIdentifierTypeByName

retirePatientIdentifierType

unretirePatientIdentifierType

purgePatientIdentifierType

checkPatientIdentifier

checkPatientIdentifiers

findPatients

getPatients

getPatients

findPatient

getPatientByExample

findDuplicatePatients

getDuplicatePatientsByAttributes

mergePatients

exitFromCare

processDeath

saveCauseOfDeathObs

getIdentifierValidator

getIdentifierValidator

getDefaultIdentifierValidator

getAllIdentifierValidators

isIdentifierInUseByAnotherPatient

getPatientIdentifier

voidPatientIdentifier

savePatientIdentifier

purgePatientIdentifier

getProblems

getProblem

saveProblem

removeProblem

voidProblem

getAllergies

getAllergy

saveAllergy

removeAllergy

voidAllergy

getCountOfPatients

getPatients