org.openmrs.api

Interface PatientSetService

All Superinterfaces:

OpenmrsService

All Known Implementing Classes:

PatientSetServiceImpl

public interface PatientSetService
extends OpenmrsService

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	PatientSetService.BooleanOperator
static class	PatientSetService.GroupMethod
static class	PatientSetService.Modifier
static class	PatientSetService.PatientLocationMethod
static class	PatientSetService.TimeModifier

Method Summary

Modifier and Type	Method and Description
Cohort	convertPatientIdentifier(List<String> identifiers) TODO write something here
Cohort	getAllPatients()
Map<Integer,Map<String,Object>>	getCharacteristics(Cohort patients) TODO write something here
Integer	getCountOfPatients()
Map<Integer,List<DrugOrder>>	getCurrentDrugOrders(Cohort ps, Concept drugSet)
Map<Integer,PatientProgram>	getCurrentPatientPrograms(Cohort ps, Program program)
Map<Integer,PatientState>	getCurrentStates(Cohort ps, ProgramWorkflow wf) Gets statistical information about current states of patients within given cohort for specific program workflow
Map<Integer,List<DrugOrder>>	getDrugOrders(Cohort ps, Concept drugSet)
Map<Integer,Object>	getEncounterAttrsByType(Cohort patients, List<EncounterType> encTypes, String attr) TODO write something here
Map<Integer,Encounter>	getEncounters(Cohort patients) This method returns a map of patients matched against their most recent encounters given a Cohort of patients, see EncounterService.getAllEncounters(Cohort) which gets a map of patient matched against lists of all their encounters.
List<Encounter>	getEncountersByForm(Cohort patients, List<Form> form) Gets a list of encounters associated with the given form, filtered by the given patient set.
Map<Integer,Encounter>	getEncountersByType(Cohort patients, EncounterType encType) TODO write something here
Map<Integer,Encounter>	getEncountersByType(Cohort patients, List<EncounterType> encType) TODO write something here
Map<Integer,Object>	getFirstEncounterAttrsByType(Cohort patients, List<EncounterType> encTypes, String attr) TODO write something here
Map<Integer,Encounter>	getFirstEncountersByType(Cohort patients, EncounterType encType) TODO write something here
Map<Integer,Encounter>	getFirstEncountersByType(Cohort patients, List<EncounterType> types) TODO write something here
Cohort	getInverseOfCohort(Cohort cohort) Equivalent to Cohort.subtract(PatientSetService.getAllPatients(), cohort) but may eventually perform faster by delegating to the database.
Map<Integer,List<Obs>>	getObservations(Cohort patients, Concept concept)
Map<Integer,List<Obs>>	getObservations(Cohort patients, Concept concept, Date fromDate, Date toDate) Date range is inclusive of both endpoints
Map<Integer,List<List<Object>>>	getObservationsValues(Cohort patients, Concept c) TODO write something here
Map<Integer,List<List<Object>>>	getObservationsValues(Cohort patients, Concept c, List<String> attributes, Integer limit, boolean showMostRecentFirst) Returns a mapping from patient id to obs for concept c
Map<Integer,Object>	getPatientAttributes(Cohort patients, String classNameDotProperty, boolean returnAll) TODO write something here
Map<Integer,Object>	getPatientAttributes(Cohort patients, String className, String property, boolean returnAll) TODO write something here
Map<Integer,String>	getPatientIdentifierStringsByType(Cohort patients, PatientIdentifierType type) Gets a map of patient identifiers values by identifier type, indexed by patient primary key.
Map<Integer,PatientProgram>	getPatientPrograms(Cohort ps, Program program) Gets program enrollment data for the given cohort in the given program.
List<Patient>	getPatients(Collection<Integer> patientIds) TODO write something here
Cohort	getPatients(Integer start, Integer size) Get a batch of patients that are not voided in the database
Cohort	getPatientsByCharacteristics(String gender, Date minBirthdate, Date maxBirthdate)
Cohort	getPatientsByCharacteristics(String gender, Date minBirthdate, Date maxBirthdate, Integer minAge, Integer maxAge, Boolean aliveOnly, Boolean deadOnly) Get patients by specified gender, birthdate range, age range, and alive status (all optional)
Cohort	getPatientsByCharacteristics(String gender, Date minBirthdate, Date maxBirthdate, Integer minAge, Integer maxAge, Boolean aliveOnly, Boolean deadOnly, Date effectiveDate) Get patients by specified gender, birthdate range, age range, and alive status (all optional)
Cohort	getPatientsByProgramAndState(Program program, List<ProgramWorkflowState> stateList, Date fromDate, Date toDate) Gets patients who are enrolled in the given program or in the given state(s) at the specified time
Cohort	getPatientsHavingDateObs(Integer conceptId, Date startTime, Date endTime)
Cohort	getPatientsHavingDrugOrder(Collection<Integer> patientIds, Collection<Integer> takingIds, Date onDate) Returns a Cohort of patient who had drug orders for a set of drugs active on a certain date.
Cohort	getPatientsHavingDrugOrder(Collection<Integer> patientIds, Collection<Integer> drugIds, PatientSetService.GroupMethod groupMethod, Date fromDate, Date toDate) Returns a Cohort of patient who had drug orders for a set of drugs active between a pair of dates.
Cohort	getPatientsHavingDrugOrder(List<Drug> drug, List<Concept> drugConcept, Date startDateFrom, Date startDateTo, Date stopDateFrom, Date stopDateTo, Boolean discontinued, List<Concept> discontinuedReason)
Cohort	getPatientsHavingEncounters(EncounterType encounterType, Location location, Form form, Date fromDate, Date toDate, Integer minCount, Integer maxCount) Searches for patients who have encounters as described by the arguments to this method
Cohort	getPatientsHavingEncounters(List<EncounterType> encounterTypeList, Location location, Form form, Date fromDate, Date toDate, Integer minCount, Integer maxCount) Gets patients who have encounters as described by the parameters specified (all optional)
Cohort	getPatientsHavingLocation(Integer locationId)
Cohort	getPatientsHavingLocation(Integer locationId, PatientSetService.PatientLocationMethod method)
Cohort	getPatientsHavingLocation(Location loc)
Cohort	getPatientsHavingLocation(Location loc, PatientSetService.PatientLocationMethod method)
Cohort	getPatientsHavingNumericObs(Integer conceptId, PatientSetService.TimeModifier timeModifier, PatientSetService.Modifier modifier, Number value, Date fromDate, Date toDate)
Cohort	getPatientsHavingObs(Integer conceptId, PatientSetService.TimeModifier timeModifier, PatientSetService.Modifier modifier, Object value, Date fromDate, Date toDate) Searches for patients who have observations as described by the arguments to this method
Cohort	getPatientsHavingPersonAttribute(PersonAttributeType attribute, String value) At least one of attribute and value must be non-null
Cohort	getPatientsHavingTextObs(Concept concept, String value, PatientSetService.TimeModifier timeModifier)
Cohort	getPatientsHavingTextObs(Integer conceptId, String value, PatientSetService.TimeModifier timeModifier)
Cohort	getPatientsInProgram(Program program, Date fromDate, Date toDate)
Map<Integer,Object>	getPersonAttributes(Cohort patients, String attributeName, String joinClass, String joinProperty, String outputColumn, boolean returnAll)
Map<Integer,List<Relationship>>	getRelationships(Cohort ps, RelationshipType relType)
Map<Integer,List<Person>>	getRelatives(Cohort ps, RelationshipType relType, boolean forwards)
Map<Integer,String>	getShortPatientDescriptions(Collection<Integer> patientIds)
void	setPatientSetDAO(PatientSetDAO dao)

Methods inherited from interface org.openmrs.api.OpenmrsService

onShutdown, onStartup

Method Detail

setPatientSetDAO

void setPatientSetDAO(PatientSetDAO dao)

getAllPatients

Cohort getAllPatients()
               throws DAOException

Throws:

DAOException

getPatientsByCharacteristics

Cohort getPatientsByCharacteristics(String gender,
                                    Date minBirthdate,
                                    Date maxBirthdate)
                             throws DAOException

Throws:

DAOException

getPatientsByCharacteristics

Cohort getPatientsByCharacteristics(String gender,
                                    Date minBirthdate,
                                    Date maxBirthdate,
                                    Integer minAge,
                                    Integer maxAge,
                                    Boolean aliveOnly,
                                    Boolean deadOnly)
                             throws DAOException

Get patients by specified gender, birthdate range, age range, and alive status (all optional)

Parameters:

gender -

minBirthdate -

maxBirthdate -

minAge -

maxAge -

aliveOnly -

deadOnly -

Returns:

Cohort with all matching patients

Throws:

DAOException

Expected Behavior:

Should get all patients when no parameters given

Should get patients of given gender

Should get patients born before date

Should get patients born after date

Should get patients born between dates

Should get patients who are alive

Should get patients who are dead

getPatientsByCharacteristics

Cohort getPatientsByCharacteristics(String gender,
                                    Date minBirthdate,
                                    Date maxBirthdate,
                                    Integer minAge,
                                    Integer maxAge,
                                    Boolean aliveOnly,
                                    Boolean deadOnly,
                                    Date effectiveDate)
                             throws DAOException

Get patients by specified gender, birthdate range, age range, and alive status (all optional)

Parameters:

gender -

minBirthdate -

maxBirthdate -

minAge -

maxAge -

aliveOnly -

deadOnly -

effectiveDate -

Returns:

Cohort with all matching patients

Throws:

DAOException

Expected Behavior:

Should get all patients when no parameters given

Should get patients of given gender

Should get patients born before date

Should get patients born after date

Should get patients born between dates

Should get patients who are alive

Should get patients who are dead

Should not get patients born after effectiveDate

getPatientsHavingNumericObs

Cohort getPatientsHavingNumericObs(Integer conceptId,
                                   PatientSetService.TimeModifier timeModifier,
                                   PatientSetService.Modifier modifier,
                                   Number value,
                                   Date fromDate,
                                   Date toDate)

getPatientsHavingObs

Cohort getPatientsHavingObs(Integer conceptId,
                            PatientSetService.TimeModifier timeModifier,
                            PatientSetService.Modifier modifier,
                            Object value,
                            Date fromDate,
                            Date toDate)

Searches for patients who have observations as described by the arguments to this method

Parameters:

conceptId -

timeModifier -

modifier -

value -

fromDate -

toDate -

Returns:

all patients with observations matching the arguments to this method

Expected Behavior:

Should get patients by concept and true boolean value

Should get patients by concept and false boolean value

getPatientsHavingEncounters

Cohort getPatientsHavingEncounters(EncounterType encounterType,
                                   Location location,
                                   Form form,
                                   Date fromDate,
                                   Date toDate,
                                   Integer minCount,
                                   Integer maxCount)

Searches for patients who have encounters as described by the arguments to this method

Parameters:

encounterType -

location -

form -

fromDate -

toDate -

minCount -

maxCount -

Returns:

all patients with encounters matching the arguments to this method

Expected Behavior:

Should get all patients with encounters when no parameters specified

getPatientsHavingEncounters

Cohort getPatientsHavingEncounters(List<EncounterType> encounterTypeList,
                                   Location location,
                                   Form form,
                                   Date fromDate,
                                   Date toDate,
                                   Integer minCount,
                                   Integer maxCount)

Gets patients who have encounters as described by the parameters specified (all optional)

Parameters:

encounterTypeList -

location -

form -

fromDate -

toDate -

minCount -

maxCount -

Returns:

Cohort with matching Patients

Expected Behavior:

Should get all patients with encounters when no parameters specified

Should get patients with encounters of type

Should get patients with encounters of multiple types

Should get patients with encounters at location

Should get patients with encounters from form

Should get patients with encounters before date

Should get patients with encounters after date

Should get patients with encounters between dates

Should get patients with at least n encounters

Should get patients with at most n encounters

Should get all patients with encounters when passed an empty encounterTypeList

getPatientsByProgramAndState

Cohort getPatientsByProgramAndState(Program program,
                                    List<ProgramWorkflowState> stateList,
                                    Date fromDate,
                                    Date toDate)

Gets patients who are enrolled in the given program or in the given state(s) at the specified time

Parameters:

program -

stateList -

fromDate -

toDate -

Returns:

Cohort with matching Patients

Expected Behavior:

Should get all patients in any program given null parameters

Should get patients in program

Should get patients in program from date

Should get patients in program to date

Should get patients in program between dates

Should get patients in state

Should get patients in states

Should get patients in state from date

Should get patients in state to date

Should get patients in state between dates

getPatientsInProgram

Cohort getPatientsInProgram(Program program,
                            Date fromDate,
                            Date toDate)

getPatientsHavingDateObs

Cohort getPatientsHavingDateObs(Integer conceptId,
                                Date startTime,
                                Date endTime)

getPatientsHavingTextObs

Cohort getPatientsHavingTextObs(Concept concept,
                                String value,
                                PatientSetService.TimeModifier timeModifier)

getPatientsHavingTextObs

Cohort getPatientsHavingTextObs(Integer conceptId,
                                String value,
                                PatientSetService.TimeModifier timeModifier)

getPatientsHavingLocation

Cohort getPatientsHavingLocation(Location loc)

getPatientsHavingLocation

Cohort getPatientsHavingLocation(Location loc,
                                 PatientSetService.PatientLocationMethod method)

getPatientsHavingLocation

Cohort getPatientsHavingLocation(Integer locationId)

getPatientsHavingLocation

Cohort getPatientsHavingLocation(Integer locationId,
                                 PatientSetService.PatientLocationMethod method)

getPatientsHavingDrugOrder

Cohort getPatientsHavingDrugOrder(Collection<Integer> patientIds,
                                  Collection<Integer> takingIds,
                                  Date onDate)

Returns a Cohort of patient who had drug orders for a set of drugs active on a certain date. Can also be used to find patient with no drug orders on that date.

Parameters:

patientIds - Collection of patientIds you're interested in. NULL means all patients.

takingIds - Collection of drugIds the patient is taking. (Or the empty set to mean "any drug" or NULL to mean "no drugs")

onDate - Which date to look at the patients' drug orders. (NULL defaults to now().)

getPatientsHavingDrugOrder

Cohort getPatientsHavingDrugOrder(Collection<Integer> patientIds,
                                  Collection<Integer> drugIds,
                                  PatientSetService.GroupMethod groupMethod,
                                  Date fromDate,
                                  Date toDate)

Returns a Cohort of patient who had drug orders for a set of drugs active between a pair of dates. Can also be used to find patient with no drug orders on that date.

Parameters:

patientIds - Collection of patientIds you're interested in. NULL means all patients.

drugIds - Collection of drugIds the patient is taking. (Or the empty set to mean "any drug" or NULL to mean "no drugs")

groupMethod - whether to do NONE, ALL, or ANY of the list of specified ids.

fromDate - Beginning of date range to look at (NULL defaults to toDate if that isn't null, or now() if it is.)

toDate - End of date range to look at (NULL defaults to fromDate if that isn't null, or now() if it is.)

Returns:

Cohort with matching Patients

Expected Behavior:

Should get all patients with drug orders given null parameters

Should get patients with no drug orders

Should get patients with drug orders for drugs

Should get patients with no drug orders for drugs

Should get patients with drug orders from date

Should get patients with drug orders to date

Should get patients with drug order for drug between dates

getPatientsHavingDrugOrder

Cohort getPatientsHavingDrugOrder(List<Drug> drug,
                                  List<Concept> drugConcept,
                                  Date startDateFrom,
                                  Date startDateTo,
                                  Date stopDateFrom,
                                  Date stopDateTo,
                                  Boolean discontinued,
                                  List<Concept> discontinuedReason)

Returns:

A Cohort of patients who had drug order for particular drugs or generics, with start dates within a range, with end dates within a range, and a reason for discontinuation.

getPatientsHavingPersonAttribute

Cohort getPatientsHavingPersonAttribute(PersonAttributeType attribute,
                                        String value)

At least one of attribute and value must be non-null

Parameters:

attribute - if not null, look for this attribute

value - if not null, look for this value

Returns:

Cohort of patients who have a person attribute (optionally) with attributeType of attribute and (optionally) value of value.

getShortPatientDescriptions

Map<Integer,String> getShortPatientDescriptions(Collection<Integer> patientIds)

getObservations

Map<Integer,List<Obs>> getObservations(Cohort patients,
                                       Concept concept)

getObservations

Map<Integer,List<Obs>> getObservations(Cohort patients,
                                       Concept concept,
                                       Date fromDate,
                                       Date toDate)

Date range is inclusive of both endpoints

getObservationsValues

Map<Integer,List<List<Object>>> getObservationsValues(Cohort patients,
                                                      Concept c)

TODO write something here

Parameters:

patients -

c -

Returns:

Map<patientId, List<Obs values>>

getObservationsValues

Map<Integer,List<List<Object>>> getObservationsValues(Cohort patients,
                                                      Concept c,
                                                      List<String> attributes,
                                                      Integer limit,
                                                      boolean showMostRecentFirst)

Returns a mapping from patient id to obs for concept c

The returned List< attribute value > is [obs value, attr value, attr value, attr value...] The returned List<List< attribute value >> represents the obs rows

Parameters:

patients - the cohort to restrict to. if null, then all patients are fetched

c - the concept to look for in obs.concept_id

attributes - list of attributes

limit - the number of patients to limit the results to. If null or less than zero, return all

showMostRecentFirst - if true, obs with the highest obsDatetime will be first in the List<List<Object>>

Returns:

Map<patientId, List<List< attribute value >>>

getEncountersByType

Map<Integer,Encounter> getEncountersByType(Cohort patients,
                                           EncounterType encType)

TODO write something here

Parameters:

patients - Cohort of patients to search

encType - the type of the encounter

Returns:

Map<Integer, Encounter> of patientId to encounters matching a specific type

getEncounterAttrsByType

Map<Integer,Object> getEncounterAttrsByType(Cohort patients,
                                            List<EncounterType> encTypes,
                                            String attr)

TODO write something here

Parameters:

patients - Cohort of patients to search

encTypes - List<EncounterType> to include in the search

attr - String of attributes to get

Returns:

Map<Integer, Object> of encounter attributes

getEncountersByType

Map<Integer,Encounter> getEncountersByType(Cohort patients,
                                           List<EncounterType> encType)

TODO write something here

Parameters:

patients - Cohort of patients to search

encType - List<EncounterType> to include in the search

Returns:

Map<Integer, Encounter> of patientId to encounters matching a specific type

getEncounters

Map<Integer,Encounter> getEncounters(Cohort patients)

This method returns a map of patients matched against their most recent encounters given a Cohort of patients, see EncounterService.getAllEncounters(Cohort) which gets a map of patient matched against lists of all their encounters.

Parameters:

patients - Cohort of patients to search

Returns:

Map<Integer, Encounter> of all encounters for specified patients.

See Also:

EncounterService.getAllEncounters(Cohort)

getFirstEncountersByType

Map<Integer,Encounter> getFirstEncountersByType(Cohort patients,
                                                EncounterType encType)

TODO write something here

Parameters:

patients - Cohort of patients to search

encType -

Returns:

Map<Integer, Encounter> of patientId to first encounters of specified patients, from a specific type

getFirstEncountersByType

Map<Integer,Encounter> getFirstEncountersByType(Cohort patients,
                                                List<EncounterType> types)

TODO write something here

Parameters:

patients - Cohort of patients to search

types - List<EncounterType> to include in the search

Returns:

Map<Integer, Encounter> of patientId to first encounters of specified patients, from a specific list of types

getFirstEncounterAttrsByType

Map<Integer,Object> getFirstEncounterAttrsByType(Cohort patients,
                                                 List<EncounterType> encTypes,
                                                 String attr)

TODO write something here

Parameters:

patients - Cohort of patients to search

encTypes - List<EncounterType> to include in the search

attr -

Returns:

Map<Integer, Object> of patientId to first encounters properties

getPatientAttributes

Map<Integer,Object> getPatientAttributes(Cohort patients,
                                         String className,
                                         String property,
                                         boolean returnAll)

TODO write something here

Parameters:

patients - Cohort of patients to search

className -

property -

returnAll -

Returns:

Map<Integer, Object> of patientId to patient properties

getPatientAttributes

Map<Integer,Object> getPatientAttributes(Cohort patients,
                                         String classNameDotProperty,
                                         boolean returnAll)

TODO write something here

Parameters:

patients -

classNameDotProperty -

returnAll -

Returns:

Map<Integer, Object> of patientId to patient properties

getPersonAttributes

Map<Integer,Object> getPersonAttributes(Cohort patients,
                                        String attributeName,
                                        String joinClass,
                                        String joinProperty,
                                        String outputColumn,
                                        boolean returnAll)

Parameters:

patients -

attributeName -

joinClass -

joinProperty -

outputColumn -

returnAll -

Returns:

Map<Integer, Object> of patientId to person properties

Expected Behavior:

Should return person attributes of type Location

getCharacteristics

Map<Integer,Map<String,Object>> getCharacteristics(Cohort patients)

TODO write something here

Parameters:

patients - Cohort of patients to look up

Returns:

Map<Integer,Map<String,Object>> with characteristics of specified patients

getPatientIdentifierStringsByType

Map<Integer,String> getPatientIdentifierStringsByType(Cohort patients,
                                                      PatientIdentifierType type)

Gets a map of patient identifiers values by identifier type, indexed by patient primary key.

Parameters:

patients - Cohort of patients to look up

type - PatientIdentifierType to retrieve

Returns:

Map of patient identifiers (strings) for all patients in the specified cohort

convertPatientIdentifier

Cohort convertPatientIdentifier(List<String> identifiers)

TODO write something here

Parameters:

identifiers - List of String patient identifiers

Returns:

Cohort of patients matching specified identifiers

getPatients

List<Patient> getPatients(Collection<Integer> patientIds)

TODO write something here

Parameters:

patientIds -

Returns:

List of matching patients

getCurrentStates

Map<Integer,PatientState> getCurrentStates(Cohort ps,
                                           ProgramWorkflow wf)

Gets statistical information about current states of patients within given cohort for specific program workflow

Parameters:

ps - the patient's cohort object

wf - the program workflow instance

Returns:

map containing statistic information about patient states in cohort

Expected Behavior:

Should return an empty map if cohort is empty

getCurrentPatientPrograms

Map<Integer,PatientProgram> getCurrentPatientPrograms(Cohort ps,
                                                      Program program)

getPatientPrograms

Map<Integer,PatientProgram> getPatientPrograms(Cohort ps,
                                               Program program)

Gets program enrollment data for the given cohort in the given program. The behavior is not specified if a patient is enrolled in the same program twice simultaneously.

Parameters:

ps - the cohort to get data for

program - the program to look for enrollments in

Returns:

a Map from patientId to PatientProgram

Expected Behavior:

Should get program enrollments for the given cohort

getRelationships

Map<Integer,List<Relationship>> getRelationships(Cohort ps,
                                                 RelationshipType relType)

getRelatives

Map<Integer,List<Person>> getRelatives(Cohort ps,
                                       RelationshipType relType,
                                       boolean forwards)

getCurrentDrugOrders

Map<Integer,List<DrugOrder>> getCurrentDrugOrders(Cohort ps,
                                                  Concept drugSet)

Returns:

all active drug orders whose drug concept is in the given set (or all drugs if that's null)

getDrugOrders

Map<Integer,List<DrugOrder>> getDrugOrders(Cohort ps,
                                           Concept drugSet)

Returns:

all active or finished drug orders whose drug concept is in the given set (or all drugs if that's null)

Expected Behavior:

Should return an empty list if cohort is empty

getEncountersByForm

List<Encounter> getEncountersByForm(Cohort patients,
                                    List<Form> form)

Gets a list of encounters associated with the given form, filtered by the given patient set.

Parameters:

patients - Cohort of the patients to filter by (null will return all encounters for all patients)

form - List<Form> of the forms to filter by

getInverseOfCohort

Cohort getInverseOfCohort(Cohort cohort)

Equivalent to Cohort.subtract(PatientSetService.getAllPatients(), cohort) but may eventually perform faster by delegating to the database. (The current implementation has *not* been optimized.)

Parameters:

cohort -

Returns:

inverse of the given cohort

Since:

1.8

getCountOfPatients

Integer getCountOfPatients()

Returns:

number of unvoided patients in the database

Since:

1.8

getPatients

Cohort getPatients(Integer start,
                   Integer size)

Get a batch of patients that are not voided in the database

Parameters:

start - the starting index

size - the number of patients to get in this batch

Returns:

a Cohort with patient ids

Since:

1.8