EncounterService (OpenMRS 2.7.0-SNAPSHOT API)

All Superinterfaces:

OpenmrsService

All Known Implementing Classes:

EncounterServiceImpl
```
public interface EncounterService
extends OpenmrsService
```
Services for Encounters and Encounter Types

Version:

1.0

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`canEditAllEncounterTypes(User subject)` Determines whether given user is granted to edit all encounter types or not
`boolean`	`canEditEncounter(Encounter encounter, User subject)` Checks if passed in user can edit given encounter.
`boolean`	`canViewAllEncounterTypes(User subject)` Determines whether given user is granted to view all encounter types or not
`boolean`	`canViewEncounter(Encounter encounter, User subject)` Checks if passed in user can view given encounter.
`void`	`checkIfEncounterTypesAreLocked()` Check if the encounter types are locked, and if so, throw exception during manipulation of encounter type
`List<Encounter>`	`filterEncountersByViewPermissions(List<Encounter> encounters, User user)` Filters out all encounters to which given user does not have access.
`List<EncounterType>`	`findEncounterTypes(String name)` Find Encounter Types with name matching the beginning of the search string.
`EncounterVisitHandler`	`getActiveEncounterVisitHandler()` Gets the active handler for assigning visits to encounters.
`List<EncounterRole>`	`getAllEncounterRoles(boolean includeRetired)` Get all encounter roles based on includeRetired flag
`Map<Integer,List<Encounter>>`	`getAllEncounters(Cohort patients)` Get all encounters for a cohort of patients
`List<EncounterType>`	`getAllEncounterTypes()` Get all encounter types (including retired)
`List<EncounterType>`	`getAllEncounterTypes(boolean includeRetired)` Get all encounter types.
`Integer`	`getCountOfEncounters(String query, boolean includeVoided)` Return the number of encounters matching a patient name or patient identifier
`Encounter`	`getEncounter(Integer encounterId)` Get encounter by internal identifier
`Encounter`	`getEncounterByUuid(String uuid)` Get Encounter by its UUID
`EncounterRole`	`getEncounterRole(Integer encounterRoleId)` Gets an encounter role when and internal encounter role id is provided.
`EncounterRole`	`getEncounterRoleByName(String name)` Get EncounterRole by name
`EncounterRole`	`getEncounterRoleByUuid(String uuid)` Get EncounterRole by its UUID
`List<EncounterRole>`	`getEncounterRolesByName(String name)` Get EncounterRoles by name
`List<Encounter>`	`getEncounters(EncounterSearchCriteria encounterSearchCriteria)` Get all encounters that match a variety of (nullable) criteria contained in the parameter object.
`List<Encounter>`	`getEncounters(Patient who, Location loc, Date fromDate, Date toDate, Collection<Form> enteredViaForms, Collection<EncounterType> encounterTypes, Collection<Provider> providers, Collection<VisitType> visitTypes, Collection<Visit> visits, boolean includeVoided)` Deprecated. As of 2.0, replaced by `getEncounters(EncounterSearchCriteria)`
`List<Encounter>`	`getEncounters(String query, Integer start, Integer length, boolean includeVoided)` Search for encounters by patient name or patient identifier and returns a specific number of them from the specified starting position.
`List<Encounter>`	`getEncounters(String query, Integer patientId, Integer start, Integer length, boolean includeVoided)` Searches for encounters by patient id, provider identifier, location, encounter type, provider, form or provider name.
`List<Encounter>`	`getEncountersByPatient(Patient patient)` Get all encounters (not voided) for a patient, sorted by encounterDatetime ascending.
`List<Encounter>`	`getEncountersByPatient(String query)` Search for encounters by patient name or patient identifier.
`List<Encounter>`	`getEncountersByPatient(String query, boolean includeVoided)` Search for encounters by patient name or patient identifier.
`List<Encounter>`	`getEncountersByPatientId(Integer patientId)` Get encounters for a patientId
`List<Encounter>`	`getEncountersByPatientIdentifier(String identifier)` Get encounters (not voided) for a patient identifier
`List<Encounter>`	`getEncountersByVisit(Visit visit, boolean includeVoided)` Gets all encounters grouped within a given visit.
`List<Encounter>`	`getEncountersByVisitsAndPatient(Patient patient, boolean includeVoided, String query, Integer start, Integer length)` Gets encounters for the given patient.
`Integer`	`getEncountersByVisitsAndPatientCount(Patient patient, boolean includeVoided, String query)` Returns result count for `getEncountersByVisitsAndPatient(Patient, boolean, String, Integer, Integer)`.
`List<Encounter>`	`getEncountersNotAssignedToAnyVisit(Patient patient)` Gets the unvoided encounters for the specified patient that are not assigned to any visit.
`EncounterType`	`getEncounterType(Integer encounterTypeId)` Get encounterType by internal identifier
`EncounterType`	`getEncounterType(String name)` Get encounterType by exact name
`EncounterType`	`getEncounterTypeByUuid(String uuid)` Get EncounterType by its UUID
`List<EncounterVisitHandler>`	`getEncounterVisitHandlers()`
`void`	`purgeEncounter(Encounter encounter)` Completely remove an encounter from database.
`void`	`purgeEncounter(Encounter encounter, boolean cascade)` Completely remove an encounter from database.
`void`	`purgeEncounterRole(EncounterRole encounterRole)` Completely remove an encounter role from database.
`void`	`purgeEncounterType(EncounterType encounterType)` Completely remove an encounter type from database.
`EncounterRole`	`retireEncounterRole(EncounterRole encounterRole, String reason)` Retire an EncounterRole.
`EncounterType`	`retireEncounterType(EncounterType encounterType, String reason)` Retire an EncounterType.
`Encounter`	`saveEncounter(Encounter encounter)` Saves a new encounter or updates an existing encounter.
`EncounterRole`	`saveEncounterRole(EncounterRole encounterRole)` Saves a new encounter role or updates an existing encounter role.
`EncounterType`	`saveEncounterType(EncounterType encounterType)` Save a new Encounter Type or update an existing Encounter Type.
`void`	`setEncounterDAO(EncounterDAO dao)` Set the given `dao` on this encounter service.
`Encounter`	`transferEncounter(Encounter encounter, Patient patient)` Transfer encounter to another patient
`EncounterRole`	`unretireEncounterRole(EncounterRole encounterType)` Unretire an EncounterRole.
`EncounterType`	`unretireEncounterType(EncounterType encounterType)` Unretire an EncounterType.
`Encounter`	`unvoidEncounter(Encounter encounter)` Unvoid encounter record
`Encounter`	`voidEncounter(Encounter encounter, String reason)` Voiding a encounter essentially removes it from circulation

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

- Method Detail
  - setEncounterDAO
```
void setEncounterDAO(EncounterDAO dao)
```
    Set the given dao on this encounter service. The dao will act as the conduit through with all encounter calls get to the database
    
    Parameters:
    
    dao -
  - saveEncounter
```
@Authorized(value={"Add Encounters","Edit Encounters"})
Encounter saveEncounter(Encounter encounter)
                                                                         throws APIException
```
    Saves a new encounter or updates an existing encounter. If an existing encounter, this method will automatically apply encounter.patient to all encounter.obs.patient
    
    Parameters:
    
    encounter - to be saved
    
    Throws:
    
    APIException - Should save encounter with basic details Should update encounter successfully Should cascade save to contained obs Should cascade patient to orders in the encounter Should cascade save to contained obs when encounter already exists Should cascade encounter datetime to obs Should only cascade the obsdatetimes to obs with different initial obsdatetimes Should not overwrite creator if non null Should not overwrite dateCreated if non null Should not overwrite obs and orders creator or dateCreated Should not assign encounter to visit if no handler is registered Should not assign encounter to visit if the no assign handler is registered Should assign encounter to visit if the assign to existing handler is registered Should assign encounter to visit if the assign to existing or new handler is registered Should cascade save encounter providers Should cascade delete encounter providers Should cascade save encounter conditions Should void and create new obs when saving encounter Should fail if user is not supposed to edit encounters of type of given encounter Should cascade save encounter allergies
  - getEncounter
```
@Authorized(value="Get Encounters")
Encounter getEncounter(Integer encounterId)
                                                    throws APIException
```
    Get encounter by internal identifier
    
    Parameters:
    
    encounterId - encounter id
    
    Returns:
    
    encounter with given internal identifier
    
    Throws:
    
    APIException - Should throw error if given null parameter Should fail if user is not allowed to view encounter by given id Should return encounter if user is allowed to view it
  - getEncounterByUuid
```
@Authorized(value="Get Encounters")
Encounter getEncounterByUuid(String uuid)
                                                          throws APIException
```
    Get Encounter by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    encounter or null Should find object given valid uuid Should return null if no object found with given uuid
    
    Throws:
    
    APIException
  - getEncountersByPatient
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersByPatient(Patient patient)
```
    Get all encounters (not voided) for a patient, sorted by encounterDatetime ascending.
    
    Parameters:
    
    patient -
    
    Returns:
    
    List<Encounter> encounters (not voided) for a patient. Should not get voided encounters Should throw error when given null parameter
  - getEncountersByPatientId
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersByPatientId(Integer patientId)
                                                                      throws APIException
```
    Get encounters for a patientId
    
    Parameters:
    
    patientId -
    
    Returns:
    
    all encounters (not voided) for the given patient identifier
    
    Throws:
    
    APIException - Should not get voided encounters Should throw error if given a null parameter
  - getEncountersByPatientIdentifier
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersByPatientIdentifier(String identifier)
                                                                              throws APIException
```
    Get encounters (not voided) for a patient identifier
    
    Parameters:
    
    identifier -
    
    Returns:
    
    all encounters (not retired) for the given patient identifier
    
    Throws:
    
    APIException - Should not get voided encounters Should throw error if given null parameter
  - getEncounters
```
@Deprecated
 @Authorized(value="Get Encounters")
List<Encounter> getEncounters(Patient who,
                                                                               Location loc,
                                                                               Date fromDate,
                                                                               Date toDate,
                                                                               Collection<Form> enteredViaForms,
                                                                               Collection<EncounterType> encounterTypes,
                                                                               Collection<Provider> providers,
                                                                               Collection<VisitType> visitTypes,
                                                                               Collection<Visit> visits,
                                                                               boolean includeVoided)
```
    Deprecated. As of 2.0, replaced by getEncounters(EncounterSearchCriteria)
    
    Get all encounters that match a variety of (nullable) criteria. Each extra value for a parameter that is provided acts as an "and" and will reduce the number of results returned
    
    Parameters:
    
    who - the patient the encounter is for
    
    loc - the location this encounter took place
    
    fromDate - the minimum date (inclusive) this encounter took place
    
    toDate - the maximum date (exclusive) this encounter took place
    
    enteredViaForms - the form that entered this encounter must be in this list
    
    encounterTypes - the type of encounter must be in this list
    
    providers - the provider of this encounter must be in this list
    
    visitTypes - the visit types of this encounter must be in this list
    
    visits - the visits of this encounter must be in this list
    
    includeVoided - true/false to include the voided encounters or not
    
    Returns:
    
    a list of encounters ordered by increasing encounterDatetime
    
    Since:
    
    1.9 Should get encounters by location Should get encounters on or after date Should get encounters on or up to a date Should get encounters by form Should get encounters by type Should get encounters by provider Should get encounters by visit type Should get encounters by visit Should exclude voided encounters Should include voided encounters
  - getEncounters
```
@Authorized(value="Get Encounters")
List<Encounter> getEncounters(EncounterSearchCriteria encounterSearchCriteria)
```
    Get all encounters that match a variety of (nullable) criteria contained in the parameter object. Each extra value for a parameter that is provided acts as an "and" and will reduce the number of results returned
    
    Parameters:
    
    encounterSearchCriteria - the object containing search parameters
    
    Returns:
    
    a list of encounters ordered by increasing encounterDatetime
    
    Since:
    
    1.12 Should get encounters modified after specified date
  - voidEncounter
```
@Authorized(value="Edit Encounters")
Encounter voidEncounter(Encounter encounter,
                                                             String reason)
```
    Voiding a encounter essentially removes it from circulation
    
    Parameters:
    
    encounter - Encounter object to void
    
    reason - String reason that it's being voided Should void encounter and set attributes Should cascade to obs Should cascade to orders Should throw error with null reason parameter Should not void providers Should fail if user is not supposed to edit encounters of type of given encounter
  - unvoidEncounter
```
@Authorized(value="Edit Encounters")
Encounter unvoidEncounter(Encounter encounter)
                                                        throws APIException
```
    Unvoid encounter record
    
    Parameters:
    
    encounter - Encounter to be revived Should cascade unvoid to obs Should cascade unvoid to orders Should unvoid and unmark all attributes Should fail if user is not supposed to edit encounters of type of given encounter
    
    Throws:
    
    APIException
  - purgeEncounter
```
@Authorized(value="Purge Encounters")
void purgeEncounter(Encounter encounter)
                                                   throws APIException
```
    Completely remove an encounter from database. For super users only. If dereferencing encounters, use voidEncounter(org.openmrs.Encounter)
    
    Parameters:
    
    encounter - encounter object to be purged Should purgeEncounter Should fail if user is not supposed to edit encounters of type of given encounter
    
    Throws:
    
    APIException
  - purgeEncounter
```
@Authorized(value="Purge Encounters")
void purgeEncounter(Encounter encounter,
                                                          boolean cascade)
                                                   throws APIException
```
    Completely remove an encounter from database. For super users only. If dereferencing encounters, use voidEncounter(org.openmrs.Encounter)
    
    Parameters:
    
    encounter - encounter object to be purged
    
    cascade - Purge any related observations as well? Should cascade purge to obs and orders Should fail if user is not supposed to edit encounters of type of given encounter
    
    Throws:
    
    APIException
  - saveEncounterType
```
@Authorized(value="Manage Encounter Types")
EncounterType saveEncounterType(EncounterType encounterType)
                                                                     throws APIException
```
    Save a new Encounter Type or update an existing Encounter Type.
    
    Parameters:
    
    encounterType - Should save encounter type Should not overwrite creator Should not overwrite creator or date created Should not overwrite date created Should update an existing encounter type name Should throw error when trying to save encounter type when encounter types are locked
    
    Throws:
    
    APIException
  - getEncounterType
```
@Authorized(value="Get Encounter Types")
EncounterType getEncounterType(Integer encounterTypeId)
                                                                 throws APIException
```
    Get encounterType by internal identifier
    
    Parameters:
    
    encounterTypeId - Integer
    
    Returns:
    
    encounterType with given internal identifier
    
    Throws:
    
    APIException - Should throw error if given null parameter
  - getEncounterTypeByUuid
```
@Authorized(value="Get Encounter Types")
EncounterType getEncounterTypeByUuid(String uuid)
                                                                       throws APIException
```
    Get EncounterType by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    encounter type or null Should find object given valid uuid Should return null if no object found with given uuid
    
    Throws:
    
    APIException
  - getEncounterType
```
@Authorized(value="Get Encounter Types")
EncounterType getEncounterType(String name)
                                                                 throws APIException
```
    Get encounterType by exact name
    
    Parameters:
    
    name - string to match to an Encounter.name
    
    Returns:
    
    EncounterType that is not retired
    
    Throws:
    
    APIException - Should not get retired types Should return null if only retired type found Should not get by inexact name Should return null with null name parameter
  - getAllEncounterTypes
```
@Authorized(value="Get Encounter Types")
List<EncounterType> getAllEncounterTypes()
                                                                           throws APIException
```
    Get all encounter types (including retired)
    
    Returns:
    
    encounter types list
    
    Throws:
    
    APIException - Should not return retired types
  - getAllEncounterTypes
```
@Authorized(value="Get Encounter Types")
List<EncounterType> getAllEncounterTypes(boolean includeRetired)
                                                                           throws APIException
```
    Get all encounter types. If includeRetired is true, also get retired encounter types.
    
    Parameters:
    
    includeRetired -
    
    Returns:
    
    encounter types list
    
    Throws:
    
    APIException - Should not return retired types Should include retired types with true includeRetired parameter
  - findEncounterTypes
```
@Authorized(value="Get Encounter Types")
List<EncounterType> findEncounterTypes(String name)
                                                                         throws APIException
```
    Find Encounter Types with name matching the beginning of the search string. Search strings are case insensitive so that "NaMe".equals("name") is true. Includes retired EncounterTypes.
    
    Parameters:
    
    name - of the encounter type to find
    
    Returns:
    
    List<EncounterType> matching encounters
    
    Throws:
    
    APIException - Should return types by partial name match Should return types by partial case insensitive match Should include retired types in the results Should not partial match name on internal substrings Should return types ordered on name and nonretired first
  - retireEncounterType
```
@Authorized(value="Manage Encounter Types")
EncounterType retireEncounterType(EncounterType encounterType,
                                                                              String reason)
                                                                       throws APIException
```
    Retire an EncounterType. This essentially marks the given encounter type as a non-current type that shouldn't be used anymore.
    
    Parameters:
    
    encounterType - the encounter type to retire
    
    reason - required non-null purpose for retiring this encounter type
    
    Throws:
    
    APIException - Should retire type and set attributes Should throw error if given null reason parameter Should should throw error when trying to retire encounter type when encounter types are locked
  - unretireEncounterType
```
@Authorized(value="Manage Encounter Types")
EncounterType unretireEncounterType(EncounterType encounterType)
                                                                         throws APIException
```
    Unretire an EncounterType. This brings back the given encounter type and says that it can be used again
    
    Parameters:
    
    encounterType - the encounter type to unretire
    
    Throws:
    
    APIException - Should unretire type and unmark attributes Should should throw error when trying to unretire encounter type when encounter types are locked
  - purgeEncounterType
```
@Authorized(value="Purge Encounter Types")
void purgeEncounterType(EncounterType encounterType)
                                                            throws APIException
```
    Completely remove an encounter type from database.
    
    Parameters:
    
    encounterType -
    
    Throws:
    
    APIException - Should purge type Should should throw error when trying to delete encounter type when encounter types are locked
  - getEncountersByPatient
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersByPatient(String query)
                                                                    throws APIException
```
    Search for encounters by patient name or patient identifier.
    
    Parameters:
    
    query - patient name or identifier
    
    Returns:
    
    list of encounters for the given patient
    
    Throws:
    
    APIException
    
    Since:
    
    1.7
    
    See Also:
    
    getEncountersByPatient(String, boolean)
  - getEncountersByPatient
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersByPatient(String query,
                                                                           boolean includeVoided)
                                                                    throws APIException
```
    Search for encounters by patient name or patient identifier.
    
    Parameters:
    
    query - patient name or identifier
    
    includeVoided - Specifies whether voided encounters should be included
    
    Returns:
    
    list of encounters for the given patient
    
    Throws:
    
    APIException - Should get all unvoided encounters for the given patient name Should get all unvoided encounters for the given patient identifier Should throw error if given null parameter Should include voided encounters in the returned list if includedVoided is true
    
    Since:
    
    1.7
  - getEncounters
```
@Authorized(value="Get Encounters")
List<Encounter> getEncounters(String query,
                                                                  Integer start,
                                                                  Integer length,
                                                                  boolean includeVoided)
                                                           throws APIException
```
    Search for encounters by patient name or patient identifier and returns a specific number of them from the specified starting position. If start and length are not specified, then all matches are returned
    
    Parameters:
    
    query - patient name or identifier
    
    start - beginning index for the batch
    
    length - number of encounters to return in the batch
    
    includeVoided - Specifies whether voided encounters should be included
    
    Returns:
    
    list of encounters for the given patient based on batch settings
    
    Throws:
    
    APIException
    
    Since:
    
    1.8 Should get all the unique encounters that match the specified parameter values Should not return voided encounters if includeVoided is set to true Should return empty list for empty query
  - getEncounters
```
@Authorized(value="Get Encounters")
List<Encounter> getEncounters(String query,
                                                                  Integer patientId,
                                                                  Integer start,
                                                                  Integer length,
                                                                  boolean includeVoided)
                                                           throws APIException
```
    Searches for encounters by patient id, provider identifier, location, encounter type, provider, form or provider name. It returns a specific number of them from the specified starting position. If start and length are not specified, then all matches are returned
    
    Parameters:
    
    query - provider identifier, location, encounter type, provider, form or provider name
    
    patientId - the patient id
    
    start - beginning index for the batch
    
    length - number of encounters to return in the batch
    
    includeVoided - Specifies whether voided encounters should be included
    
    Returns:
    
    list of encounters for the given patient based on batch settings
    
    Throws:
    
    APIException
    
    Since:
    
    1.10 Should fetch encounters by patient id Should include voided encounters if includeVoided is set to true Should should match on provider identifier Should match on the provider name Should match on the location name Should match on the provider person name Should match on the encounter type name Should match on the form name
  - getAllEncounters
```
Map<Integer,List<Encounter>> getAllEncounters(Cohort patients)
```
    Get all encounters for a cohort of patients
    
    Parameters:
    
    patients - Cohort of patients to search
    
    Returns:
    
    Map of all encounters for specified patients. Should get all encounters for a cohort of patients
    
    Since:
    
    1.8
  - getCountOfEncounters
```
@Authorized(value="Get Encounters")
Integer getCountOfEncounters(String query,
                                                                 boolean includeVoided)
```
    Return the number of encounters matching a patient name or patient identifier
    
    Parameters:
    
    query - patient name or identifier
    
    includeVoided - Specifies whether voided encounters should be included
    
    Returns:
    
    the number of encounters matching the given search phrase
    
    Since:
    
    1.8 Should get the correct count of unique encounters
  - getEncountersByVisit
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersByVisit(Visit visit,
                                                                         boolean includeVoided)
```
    Gets all encounters grouped within a given visit.
    
    Parameters:
    
    visit - the visit.
    
    includeVoided - whether voided encounters should be returned
    
    Returns:
    
    list of encounters in the given visit. Should get active encounters by visit Should include voided encounters when includeVoided is true
    
    Since:
    
    1.9
  - getEncounterVisitHandlers
```
List<EncounterVisitHandler> getEncounterVisitHandlers()
```
    Returns:
    
    list of handlers for determining if an encounter should go into a visit. If none are found, an empty list.
    
    Since:
    
    1.9 Should return the no assignment handler Should return the existing visit only assignment handler Should return the existing or new visit assignment handler
    
    See Also:
    
    EncounterVisitHandler
  - getActiveEncounterVisitHandler
```
EncounterVisitHandler getActiveEncounterVisitHandler()
                                              throws APIException
```
    Gets the active handler for assigning visits to encounters.
    
    Returns:
    
    the active handler class.
    
    Throws:
    
    APIException - thrown if something goes wrong during the retrieval of the handler.
    
    Since:
    
    1.9
    
    See Also:
    
    EncounterVisitHandler
  - saveEncounterRole
```
@Authorized(value="Manage Encounter Roles")
EncounterRole saveEncounterRole(EncounterRole encounterRole)
                                                                     throws APIException
```
    Saves a new encounter role or updates an existing encounter role.
    
    Parameters:
    
    encounterRole - to be saved
    
    Returns:
    
    EncounterRole
    
    Throws:
    
    APIException
    
    Since:
    
    1.9 Should save encounter role with basic details Should update encounter role successfully
  - getEncounterRole
```
@Authorized(value="Get Encounter Roles")
EncounterRole getEncounterRole(Integer encounterRoleId)
                                                                 throws APIException
```
    Gets an encounter role when and internal encounter role id is provided.
    
    Parameters:
    
    encounterRoleId - to be retrieved
    
    Returns:
    
    EncounterRole
    
    Throws:
    
    APIException
    
    Since:
    
    1.9
  - purgeEncounterRole
```
@Authorized(value="Purge Encounter Roles")
void purgeEncounterRole(EncounterRole encounterRole)
                                                            throws APIException
```
    Completely remove an encounter role from database. For super users only. If dereferencing encounter roles, use retireEncounterRole(org.openmrs.Encounter, java.lang.String)
    
    Parameters:
    
    encounterRole - encounter role object to be purged
    
    Throws:
    
    APIException
    
    Since:
    
    1.9 Should purge Encounter Role
  - getAllEncounterRoles
```
@Authorized(value="Get Encounter Roles")
List<EncounterRole> getAllEncounterRoles(boolean includeRetired)
```
    Get all encounter roles based on includeRetired flag
    
    Parameters:
    
    includeRetired -
    
    Returns:
    
    List of all encounter roles
    
    Since:
    
    1.9 Should get all encounter roles based on include retired flag.
  - getEncounterRoleByUuid
```
@Authorized(value="Get Encounter Roles")
EncounterRole getEncounterRoleByUuid(String uuid)
                                                                       throws APIException
```
    Get EncounterRole by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    EncounterRole
    
    Throws:
    
    APIException
    
    Since:
    
    1.9 Should find encounter role based on uuid
  - getEncounterRoleByName
```
@Authorized(value="Get Encounter Roles")
EncounterRole getEncounterRoleByName(String name)
```
    Get EncounterRole by name
    
    Parameters:
    
    name -
    
    Returns:
    
    EncounterRole object by name
    
    Since:
    
    1.10 Should find an encounter role identified by its name
  - retireEncounterRole
```
@Authorized(value="Manage Encounter Roles")
EncounterRole retireEncounterRole(EncounterRole encounterRole,
                                                                              String reason)
                                                                       throws APIException
```
    Retire an EncounterRole. This essentially marks the given encounter role as a non-current type that shouldn't be used anymore.
    
    Parameters:
    
    encounterRole - the encounter role to retire
    
    reason - required non-null purpose for retiring this encounter role
    
    Throws:
    
    APIException
    
    Since:
    
    1.9 Should retire type and set attributes Should throw error if given null reason parameter
  - unretireEncounterRole
```
@Authorized(value="Manage Encounter Roles")
EncounterRole unretireEncounterRole(EncounterRole encounterType)
                                                                         throws APIException
```
    Unretire an EncounterRole. This brings back the given encounter role and says that it can be used again
    
    Parameters:
    
    encounterType - the encounter role to unretire
    
    Throws:
    
    APIException
    
    Since:
    
    1.9 Should unretire type and unmark attributes
  - getEncountersNotAssignedToAnyVisit
```
@Authorized(value="Get Encounters")
List<Encounter> getEncountersNotAssignedToAnyVisit(Patient patient)
                                                                                throws APIException
```
    Gets the unvoided encounters for the specified patient that are not assigned to any visit. Note that this method will return a maximum of 100 encounters.
    
    Parameters:
    
    patient - the patient to match against
    
    Returns:
    
    a list of Encounters
    
    Throws:
    
    APIException - Should return the unvoided encounters not assigned to any visit
    
    Since:
    
    1.9
  - getEncountersByVisitsAndPatient
```
@Authorized(value="Get Visits")
List<Encounter> getEncountersByVisitsAndPatient(Patient patient,
                                                                                boolean includeVoided,
                                                                                String query,
                                                                                Integer start,
                                                                                Integer length)
                                                                         throws APIException
```
    Gets encounters for the given patient. It populates results with empty encounters to include visits that have no assigned encounters.
    The empty encounters have only visit set.
    
    Parameters:
    
    patient - the patient to match
    
    includeVoided - if voided encounters or visits should be included
    
    query - filters results (defaults to return all results if null)
    
    start - index to start with (defaults to 0 if null)
    
    length - number of results to return (default to return all results if null)
    
    Returns:
    
    encounters and empty encounters with only visit set
    
    Throws:
    
    APIException
    
    Since:
    
    1.9
  - getEncountersByVisitsAndPatientCount
```
@Authorized(value="Get Visits")
Integer getEncountersByVisitsAndPatientCount(Patient patient,
                                                                             boolean includeVoided,
                                                                             String query)
                                                                      throws APIException
```
    Returns result count for getEncountersByVisitsAndPatient(Patient, boolean, String, Integer, Integer).
    
    Parameters:
    
    patient -
    
    includeVoided -
    
    query -
    
    Returns:
    
    number of results
    
    Throws:
    
    APIException
    
    Since:
    
    1.9
  - filterEncountersByViewPermissions
```
@Authorized(value="Get Encounters")
List<Encounter> filterEncountersByViewPermissions(List<Encounter> encounters,
                                                                                      User user)
```
    Filters out all encounters to which given user does not have access. If user is not specified then implementations should treat authenticated user from context as given user by default
    
    Parameters:
    
    encounters - the list of encounters to be filtered
    
    user - the user instance to filter "visible" encounters for
    
    Returns:
    
    list, that does not include encounters, which can not be shown to given user due to permissions check Should filter encounters if user is not allowed to see some encounters Should not filter all encounters when the encounter type's view privilege column is null
  - canViewAllEncounterTypes
```
boolean canViewAllEncounterTypes(User subject)
```
    Determines whether given user is granted to view all encounter types or not
    
    Parameters:
    
    subject - the user whose permission to view all encounter types will be checked
    
    Returns:
    
    true if user has access to view all types of encounters Should return true if user is granted to view all encounters Should return true when the encounter type's view privilege column is null
  - canEditAllEncounterTypes
```
boolean canEditAllEncounterTypes(User subject)
```
    Determines whether given user is granted to edit all encounter types or not
    
    Parameters:
    
    subject - the user whose permission to edit all encounter types will be checked
    
    Returns:
    
    true if user has access to edit all types of encounters Should return true if user is granted to edit all encounters Should return true when the encounter type's edit privilege column is null
  - canEditEncounter
```
boolean canEditEncounter(Encounter encounter,
                         User subject)
```
    Checks if passed in user can edit given encounter. If user is not specified, then authenticated user will be taken by default
    
    Parameters:
    
    encounter - the encounter instance to be checked
    
    subject - the user, who requests edit access
    
    Returns:
    
    true if user has privilege denoted by editPrivilege given on encounter type Should return true if user can edit encounter Should return false if user can not edit encounter Should fail if encounter is null
  - canViewEncounter
```
boolean canViewEncounter(Encounter encounter,
                         User subject)
```
    Checks if passed in user can view given encounter. If user is not specified, then authenticated user will be taken by default
    
    Parameters:
    
    encounter - the encounter instance to be checked
    
    subject - the user, who requests view access
    
    Returns:
    
    true if user has privilege denoted by viewPrivilege given on encounter type Should return true if user can view encounter Should return false if user can not view encounter Should fail if encounter is null
  - checkIfEncounterTypesAreLocked
```
void checkIfEncounterTypesAreLocked()
                             throws EncounterTypeLockedException
```
    Check if the encounter types are locked, and if so, throw exception during manipulation of encounter type
    
    Throws:
    
    EncounterTypeLockedException
  - getEncounterRolesByName
```
@Authorized(value="Get Encounter Roles")
List<EncounterRole> getEncounterRolesByName(String name)
```
    Get EncounterRoles by name
    
    Parameters:
    
    name -
    
    Returns:
    
    List of EncounterRole objects
    
    Since:
    
    1.11 Should find encounter roles based on their name
  - transferEncounter
```
@Authorized(value="Edit Encounters")
Encounter transferEncounter(Encounter encounter,
                                                                 Patient patient)
```
    Transfer encounter to another patient
    
    Parameters:
    
    encounter -
    
    patient -
    
    Returns:
    
    transferred encounter
    
    Since:
    
    1.12 Should transfer an encounter with observations but not orders to given patient Should void given encounter Should void given encounter visit if given encounter is the only encounter

Interface EncounterService

Method Summary

Methods inherited from interface org.openmrs.api.OpenmrsService

Method Detail

setEncounterDAO

saveEncounter

getEncounter

getEncounterByUuid

getEncountersByPatient

getEncountersByPatientId

getEncountersByPatientIdentifier

getEncounters

getEncounters

voidEncounter

unvoidEncounter

purgeEncounter

purgeEncounter

saveEncounterType

getEncounterType

getEncounterTypeByUuid

getEncounterType

getAllEncounterTypes

getAllEncounterTypes

findEncounterTypes

retireEncounterType

unretireEncounterType

purgeEncounterType

getEncountersByPatient

getEncountersByPatient

getEncounters

getEncounters

getAllEncounters

getCountOfEncounters

getEncountersByVisit

getEncounterVisitHandlers

getActiveEncounterVisitHandler

saveEncounterRole

getEncounterRole

purgeEncounterRole

getAllEncounterRoles

getEncounterRoleByUuid

getEncounterRoleByName

retireEncounterRole

unretireEncounterRole

getEncountersNotAssignedToAnyVisit

getEncountersByVisitsAndPatient

getEncountersByVisitsAndPatientCount

filterEncountersByViewPermissions

canViewAllEncounterTypes

canEditAllEncounterTypes

canEditEncounter

canViewEncounter

checkIfEncounterTypesAreLocked

getEncounterRolesByName

transferEncounter