org.openmrs.api.impl

Class PersonServiceImpl

java.lang.Object

org.openmrs.api.impl.BaseOpenmrsService

org.openmrs.api.impl.PersonServiceImpl

All Implemented Interfaces:

OpenmrsService, PersonService

@Transactional
public class PersonServiceImpl
extends BaseOpenmrsService
implements PersonService

Default implementation of the PersonService

Which implementation to use is determined by Spring. See the spring application context file in /metadata/api/spring/applicatContext-service.xml

See Also:

PersonService, Context

Nested Class Summary

Nested classes/interfaces inherited from interface org.openmrs.api.PersonService

PersonService.ATTR_VIEW_TYPE

Constructor Summary

Constructors

Constructor and Description
PersonServiceImpl()

Method Summary

Modifier and Type	Method and Description
void	checkIfPersonAttributeTypesAreLocked() Check if the person attribute types are locked, and if they are throws an exception during manipulation of a person attribute type
List<PersonAttributeType>	getAllPersonAttributeTypes() Get all PersonAttributeTypes in the database
List<PersonAttributeType>	getAllPersonAttributeTypes(boolean includeRetired) Get all PersonAttributeTypes in the database with the option of including the retired types
List<PersonMergeLog>	getAllPersonMergeLogs(boolean deserialize) Gets all the PersonMergeLog objects from the model
List<Relationship>	getAllRelationships() Get list of relationships that are not voided
List<Relationship>	getAllRelationships(boolean includeVoided) Get list of relationships optionally including the voided ones or not
List<RelationshipType>	getAllRelationshipTypes() Get all relationshipTypes Includes retired relationship types
List<RelationshipType>	getAllRelationshipTypes(boolean includeRetired) Get all relationshipTypes with the option of including the retired types
PersonMergeLog	getLosingPersonMergeLog(Person person, boolean deserialize) Gets the PersonMergeLog where person p is the loser.
List<Person>	getPeople(String searchPhrase, Boolean dead) Find a person matching the searchPhrase search string
List<Person>	getPeople(String searchPhrase, Boolean dead, Boolean voided)
Person	getPerson(Integer personId) Gets a person by internal id
PersonAddress	getPersonAddressByUuid(String uuid) Get PersonAddress by its UUID
PersonAttribute	getPersonAttribute(Integer id) Get a PersonAttribute from the database with the given PersonAttributeid
PersonAttribute	getPersonAttributeByUuid(String uuid) Get PersonAttribute by its UUID
PersonAttributeType	getPersonAttributeType(Integer typeId) Get the PersonAttributeType given the type's PersonAttributeTypeId
PersonAttributeType	getPersonAttributeTypeByName(String typeName) Get the PersonAttributeType given the type's name
PersonAttributeType	getPersonAttributeTypeByUuid(String uuid) Gets a person attribute type with the given uuid.
List<PersonAttributeType>	getPersonAttributeTypes(OpenmrsConstants.PERSON_TYPE personType, PersonService.ATTR_VIEW_TYPE viewType) Gets the types defined for the given person type (person, user, patient) and the given type of view (one person vs many person objects)
List<PersonAttributeType>	getPersonAttributeTypes(String exactName, String format, Integer foreignKey, Boolean searchable) Find person attribute types matching the given parameters.
Person	getPersonByUuid(String uuid) Get Person by its UUID
PersonMergeLog	getPersonMergeLogByUuid(String uuid, boolean deserialize) Gets a PersonMergeLog object from the model using the UUID identifier.
PersonName	getPersonName(Integer personNameId) Get PersonName by its personNameId
PersonName	getPersonNameByUuid(String uuid) Get PersonName by its UUID
Relationship	getRelationship(Integer relationshipId) Get relationship by internal relationship identifier
Relationship	getRelationshipByUuid(String uuid) Get Relationship by its UUID
Map<Person,List<Person>>	getRelationshipMap(RelationshipType relType) Get all relationships for a given type of relationship mapped from the personA to all of the personB's
List<Relationship>	getRelationships(Person fromPerson, Person toPerson, RelationshipType relType) Get relationships stored in the database that
List<Relationship>	getRelationships(Person fromPerson, Person toPerson, RelationshipType relType, Date effectiveDate) Get relationships stored in the database that are active on the passed date
List<Relationship>	getRelationships(Person fromPerson, Person toPerson, RelationshipType relType, Date startEffectiveDate, Date endEffectiveDate) Get relationships stored in the database that were active during the specified date range
List<Relationship>	getRelationshipsByPerson(Person p) Get list of relationships that include Person in person_id or relative_id Does not include voided relationships
List<Relationship>	getRelationshipsByPerson(Person p, Date effectiveDate) Get list of relationships that include Person in person_id or relative_id.
RelationshipType	getRelationshipType(Integer relationshipTypeId) Get relationshipType by internal identifier
RelationshipType	getRelationshipTypeByName(String relationshipTypeName) Find relationshipType by exact name match
RelationshipType	getRelationshipTypeByUuid(String uuid) Gets the relationship type with the given uuid.
List<RelationshipType>	getRelationshipTypes(String searchString) Get relationshipTypes by searching through the names and loosely matching to the given searchString
List<RelationshipType>	getRelationshipTypes(String relationshipTypeName, Boolean preferred) Find relationshipTypes by exact name match and/or preferred status
Set<Person>	getSimilarPeople(String name, Integer birthyear, String gender) Find a similar person given the attributes.
List<PersonMergeLog>	getWinningPersonMergeLogs(Person person, boolean deserialize) Gets PersonMergeLog objects by winning person p.
PersonName	parsePersonName(String name) Parses a name into a PersonName (separate Given, Middle, and Family names)
void	purgePerson(Person person) Purges a person from the database (cannot be undone)
void	purgePersonAttributeType(PersonAttributeType type) Purges a PersonAttribute type from the database (cannot be undone)
void	purgeRelationship(Relationship relationship) Purges a relationship from the database (cannot be undone)
void	purgeRelationshipType(RelationshipType relationshipType) Purge relationship type from the database (cannot be undone)
PersonAttributeType	retirePersonAttributeType(PersonAttributeType type, String retiredReason) Retire a Person Attribute Type
RelationshipType	retireRelationshipType(RelationshipType type, String retiredReason) Retire a Person Relationship Type
Person	savePerson(Person person) Creates or updates a Person in the database
PersonAddress	savePersonAddress(PersonAddress personAddress) Inserts or updates the given personAddress object in the database
PersonAttributeType	savePersonAttributeType(PersonAttributeType type) Save the given person attribute type in the database.
PersonMergeLog	savePersonMergeLog(PersonMergeLog personMergeLog) Builds the serialized data from PersonMergeLog.getPersonMergeLogData(), sets the mergedData String, and the creator and date if null.
PersonName	savePersonName(PersonName personName) Inserts or updates the given personName object in the database
Relationship	saveRelationship(Relationship relationship) Create or update a relationship between people.
RelationshipType	saveRelationshipType(RelationshipType relationshipType) Inserts or updates the given relationship type object in the database
void	setPersonDAO(PersonDAO dao) Sets the DAO for this service.
void	unretirePersonAttributeType(PersonAttributeType type) Unretires a PersonAttribute type from the database (can be undone)
RelationshipType	unretireRelationshipType(RelationshipType relationshipType) Unretire a Person Relationship Type
Person	unvoidPerson(Person person) Effectively resurrects this person in the db.
PersonAddress	unvoidPersonAddress(PersonAddress personAddress) Unvoid PersonAddress in the database, effectively marking this as a valid PersonAddress again
PersonName	unvoidPersonName(PersonName personName) Unvoid PersonName in the database, effectively marking this as a valid personName again
Relationship	unvoidRelationship(Relationship relationship) Unvoid Relationship in the database, effectively marking this as a valid relationship again
Person	voidPerson(Person person, String reason) Effectively removes this person from the system.
PersonAddress	voidPersonAddress(PersonAddress personAddress, String voidReason) Voids the given PersonAddress, effectively deleting the personAddress, from the end-user's point of view.
PersonName	voidPersonName(PersonName personName, String voidReason) Voids the given PersonName, effectively deleting the name, from the end-user's point of view.
Relationship	voidRelationship(Relationship relationship, String voidReason) Voids the given Relationship, effectively removing it from openmrs.

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

onShutdown, onStartup

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.openmrs.api.OpenmrsService

onShutdown, onStartup

Constructor Detail

PersonServiceImpl

public PersonServiceImpl()

Method Detail

setPersonDAO

public void setPersonDAO(PersonDAO dao)

Description copied from interface: PersonService

Sets the DAO for this service. This is done through spring injection

Specified by:

setPersonDAO in interface PersonService

Parameters:

dao - DAO for this service

See Also:

PersonService.setPersonDAO(org.openmrs.api.db.PersonDAO)

getSimilarPeople

@Transactional(readOnly=true)
public Set<Person> getSimilarPeople(String name,
                                                                  Integer birthyear,
                                                                  String gender)
                                                           throws APIException

Description copied from interface: PersonService

Find a similar person given the attributes. This does a very loose lookup with the nameSearch parameter. This does a very loose lookup on birthyear as well. Any person with a null/missing birthdate is included and anyone with a birthyear plus/minus one year from the given birthyear is also included

Specified by:

getSimilarPeople in interface PersonService

Parameters:

name - string to search the person's name for

birthyear - the year of birth to restrict

gender - The gender field to search on (Typically just "M" or "F")

Returns:

Set<Person> object with all people matching criteria

Throws:

APIException - Should accept greater than three names Should match single search to any name part Should match two word search to any name part Should match three word search to any name part Should match search to familyName2

See Also:

PersonService.getSimilarPeople(java.lang.String, java.lang.Integer, java.lang.String)

getPeople

@Transactional(readOnly=true)
public List<Person> getPeople(String searchPhrase,
                                                            Boolean dead)
                                                     throws APIException

Description copied from interface: PersonService

Find a person matching the searchPhrase search string

Specified by:

getPeople in interface PersonService

Parameters:

searchPhrase - person name to match on

dead - if true will return only dead patients, if false will return only alive patients, if null will return both

Returns:

list of person objects matches the parameters Should match search to familyName2

Throws:

APIException

See Also:

PersonService.getPeople(String, Boolean)

getPeople

public List<Person> getPeople(String searchPhrase,
                              Boolean dead,
                              Boolean voided)
                       throws APIException

Specified by:

getPeople in interface PersonService

Throws:

APIException

getAllPersonAttributeTypes

@Transactional(readOnly=true)
public List<PersonAttributeType> getAllPersonAttributeTypes()
                                                                                   throws APIException

Description copied from interface: PersonService

Get all PersonAttributeTypes in the database

Specified by:

getAllPersonAttributeTypes in interface PersonService

Returns:

All person attribute types including the retired ones Should return all person attribute types including retired

Throws:

APIException

See Also:

PersonService.getAllPersonAttributeTypes()

getAllPersonAttributeTypes

@Transactional(readOnly=true)
public List<PersonAttributeType> getAllPersonAttributeTypes(boolean includeRetired)
                                                                                   throws APIException

Description copied from interface: PersonService

Get all PersonAttributeTypes in the database with the option of including the retired types

Specified by:

getAllPersonAttributeTypes in interface PersonService

Parameters:

includeRetired - boolean - include retired attribute types as well?

Returns:

List<PersonAttributeType> object of all PersonAttributeTypes, possibly including retired ones Should return all person attribute types including retired when include retired is true Should return all person attribute types excluding retired when include retired is false

Throws:

APIException

See Also:

PersonService.getAllPersonAttributeTypes(boolean)

getPersonAttributeTypeByName

@Transactional(readOnly=true)
public PersonAttributeType getPersonAttributeTypeByName(String typeName)
                                                                               throws APIException

Description copied from interface: PersonService

Get the PersonAttributeType given the type's name

Specified by:

getPersonAttributeTypeByName in interface PersonService

Returns:

the PersonAttributeType that has the given name or null if none found Should return person attribute type when name matches given typeName Should return null when no person attribute type match given typeName

Throws:

APIException

See Also:

PersonService.getPersonAttributeTypeByName(java.lang.String)

purgePersonAttributeType

public void purgePersonAttributeType(PersonAttributeType type)
                              throws APIException

Description copied from interface: PersonService

Purges a PersonAttribute type from the database (cannot be undone)

Specified by:

purgePersonAttributeType in interface PersonService

Parameters:

type - type to be purged from the database

Throws:

APIException - Should delete person attribute type from database Should throw an error when trying to delete person attribute type while person attribute types are locked

See Also:

PersonService.purgePersonAttributeType(org.openmrs.PersonAttributeType)

savePersonAttributeType

public PersonAttributeType savePersonAttributeType(PersonAttributeType type)
                                            throws APIException

Description copied from interface: PersonService

Save the given person attribute type in the database.
If the given type's Id is not empty, then also need to change any global property which is in OpenmrsConstants.GLOBAL_PROPERTIES_OF_PERSON_ATTRIBUTES and reference this given type, prior to saving this given type.

Specified by:

savePersonAttributeType in interface PersonService

Returns:

the saved person attribute type

Throws:

APIException - Should set the date created and creator on new Should set the date changed and changed by on update Should update any global property which reference this type Should throw an error when trying to save person attribute type while person attribute types are locked

See Also:

PersonService.savePersonAttributeType(org.openmrs.PersonAttributeType)

retirePersonAttributeType

public PersonAttributeType retirePersonAttributeType(PersonAttributeType type,
                                                     String retiredReason)
                                              throws APIException

Description copied from interface: PersonService

Retire a Person Attribute Type

Specified by:

retirePersonAttributeType in interface PersonService

retiredReason - Should throw an error when trying to retire person attribute type while person attribute types are locked

Throws:

APIException

See Also:

PersonService.retirePersonAttributeType(PersonAttributeType, String)

getPersonAttributeTypes

@Transactional(readOnly=true)
public List<PersonAttributeType> getPersonAttributeTypes(String exactName,
                                                                                       String format,
                                                                                       Integer foreignKey,
                                                                                       Boolean searchable)
                                                                                throws APIException

Description copied from interface: PersonService

Find person attribute types matching the given parameters. Retired types are included in the results

Specified by:

getPersonAttributeTypes in interface PersonService

Parameters:

exactName - (optional) The name of type

format - (optional) The format for this type

foreignKey - (optional) The foreign key

searchable - (optional) if true only returns searchable types, if false returns only nonsearchable and if null returns all

Returns:

list of PersonAttributeTypes matching the given parameters

Throws:

APIException - Should return person attribute types matching given parameters Should return empty list when no person attribute types match given parameters

See Also:

PersonService.getPersonAttributeTypes(java.lang.String, java.lang.String, java.lang.Integer, java.lang.Boolean)

unretirePersonAttributeType

public void unretirePersonAttributeType(PersonAttributeType type)
                                 throws APIException

Description copied from interface: PersonService

Unretires a PersonAttribute type from the database (can be undone)

Specified by:

unretirePersonAttributeType in interface PersonService

Parameters:

type - type to be restored from the database

Throws:

APIException - Should restore person attribute type from database Should throw an error when trying to unretire person attribute type while person attribute types are locked

getPersonAttributeType

@Transactional(readOnly=true)
public PersonAttributeType getPersonAttributeType(Integer typeId)

Description copied from interface: PersonService

Get the PersonAttributeType given the type's PersonAttributeTypeId

Specified by:

getPersonAttributeType in interface PersonService

Parameters:

typeId - PersonAttributeType.personAttributeTypeId to match on

Returns:

the type matching this id or null if none was found Should return null when no person attribute with the given id exist

See Also:

PersonService.getPersonAttributeType(java.lang.Integer)

getPersonAttribute

@Transactional(readOnly=true)
public PersonAttribute getPersonAttribute(Integer id)

Description copied from interface: PersonService

Get a PersonAttribute from the database with the given PersonAttributeid

Specified by:

getPersonAttribute in interface PersonService

Parameters:

id - the PersonAttribute.personAttributeId to match on

Returns:

the matching PersonAttribute or null if none was found

See Also:

PersonService.getPersonAttribute(java.lang.Integer)

getRelationship

@Transactional(readOnly=true)
public Relationship getRelationship(Integer relationshipId)
                                                           throws APIException

Description copied from interface: PersonService

Get relationship by internal relationship identifier

Specified by:

getRelationship in interface PersonService

Returns:

Relationship the relationship to match on or null if none found

Throws:

APIException - Should return relationship with given id Should return null when relationship with given id does not exist

See Also:

PersonService.getRelationship(java.lang.Integer)

getRelationshipType

@Transactional(readOnly=true)
public RelationshipType getRelationshipType(Integer relationshipTypeId)
                                                                   throws APIException

Description copied from interface: PersonService

Get relationshipType by internal identifier

Specified by:

getRelationshipType in interface PersonService

Returns:

relationshipType with given internal identifier or null if none found

Throws:

APIException - Should return relationship type with the given relationship type id Should return null when no relationship type matches given relationship type id

See Also:

PersonService.getRelationshipType(java.lang.Integer)

getRelationshipTypeByName

@Transactional(readOnly=true)
public RelationshipType getRelationshipTypeByName(String relationshipTypeName)
                                                                         throws APIException

Description copied from interface: PersonService

Find relationshipType by exact name match

Specified by:

getRelationshipTypeByName in interface PersonService

Parameters:

relationshipTypeName - name to match on

Returns:

RelationshipType with given name or null if none found

Throws:

APIException - Should return null when no relationship type match the given name

See Also:

PersonService.getRelationshipTypeByName(java.lang.String)

purgePerson

public void purgePerson(Person person)
                 throws APIException

Description copied from interface: PersonService

Purges a person from the database (cannot be undone)

Specified by:

purgePerson in interface PersonService

Parameters:

person - person to be purged from the database

Throws:

APIException - Should delete person from the database

See Also:

PersonService.purgePerson(org.openmrs.Person)

savePerson

public Person savePerson(Person person)
                  throws APIException

Description copied from interface: PersonService

Creates or updates a Person in the database

Specified by:

savePerson in interface PersonService

Parameters:

person - person to be created or updated

Returns:

person who was created or updated

Throws:

APIException - Should create new object when person id is null Should update existing object when person id is not null Should set the preferred name and address if none is specified Should not set the preferred name and address if they already exist Should not set a voided name or address as preferred

See Also:

PersonService.savePerson(org.openmrs.Person)

voidPerson

public Person voidPerson(Person person,
                         String reason)
                  throws APIException

Description copied from interface: PersonService

Effectively removes this person from the system. Voids Patient and retires Users as well.

Specified by:

voidPerson in interface PersonService

Parameters:

person - person to be voided

reason - reason for voiding person

Returns:

the person that was voided Should return voided person with given reason Should void patient Should retire users

Throws:

APIException

See Also:

PersonService.voidPerson(org.openmrs.Person, java.lang.String)

unvoidPerson

public Person unvoidPerson(Person person)
                    throws APIException

Description copied from interface: PersonService

Effectively resurrects this person in the db. Unvoids Patient as well.

Specified by:

unvoidPerson in interface PersonService

Parameters:

person - person to be revived

Returns:

the person that was unvoided Should unvoid the given person Should unvoid patient Should not unretire users

Throws:

APIException

See Also:

PersonService.unvoidPerson(org.openmrs.Person)

getPerson

@Transactional(readOnly=true)
public Person getPerson(Integer personId)
                                               throws APIException

Description copied from interface: PersonService

Gets a person by internal id

Specified by:

getPerson in interface PersonService

Parameters:

personId - internal identifier of person to get

Returns:

Person person with given internal identifier

Throws:

APIException - Should return null when no person has the given id

See Also:

PersonService.getPerson(java.lang.Integer)

getAllRelationships

@Transactional(readOnly=true)
public List<Relationship> getAllRelationships()
                                                                     throws APIException

Description copied from interface: PersonService

Get list of relationships that are not voided

Specified by:

getAllRelationships in interface PersonService

Returns:

non-voided Relationship list

Throws:

APIException

See Also:

PersonService.getAllRelationships()

getAllRelationships

@Transactional(readOnly=true)
public List<Relationship> getAllRelationships(boolean includeVoided)
                                                                     throws APIException

Description copied from interface: PersonService

Get list of relationships optionally including the voided ones or not

Specified by:

getAllRelationships in interface PersonService

Parameters:

includeVoided - true/false whether to include the voided relationships

Returns:

non-voided Relationship list

Throws:

APIException - Should return all relationship including voided when include voided equals true Should return all relationship excluding voided when include voided equals false

See Also:

PersonService.getAllRelationships(boolean)

getRelationships

@Transactional(readOnly=true)
public List<Relationship> getRelationships(Person fromPerson,
                                                                         Person toPerson,
                                                                         RelationshipType relType)
                                                                  throws APIException

Description copied from interface: PersonService

Get relationships stored in the database that

Specified by:

getRelationships in interface PersonService

Parameters:

fromPerson - (optional) Person to in the person_id column

toPerson - (optional) Person in the relative_id column

relType - (optional) The RelationshipType to match

Returns:

relationships matching the given parameters

Throws:

APIException - Should fetch relationships matching the given from person Should fetch relationships matching the given to person Should fetch relationships matching the given rel type Should return empty list when no relationship matching given parameters exist

See Also:

PersonService.getRelationships(org.openmrs.Person, org.openmrs.Person, org.openmrs.RelationshipType)

getRelationships

@Transactional(readOnly=true)
public List<Relationship> getRelationships(Person fromPerson,
                                                                         Person toPerson,
                                                                         RelationshipType relType,
                                                                         Date effectiveDate)
                                                                  throws APIException

Description copied from interface: PersonService

Get relationships stored in the database that are active on the passed date

Specified by:

getRelationships in interface PersonService

Parameters:

fromPerson - (optional) Person to in the person_id column

toPerson - (optional) Person in the relative_id column

relType - (optional) The RelationshipType to match

effectiveDate - (optional) The date during which the relationship was effective

Returns:

relationships matching the given parameters

Throws:

APIException - Should fetch relationships matching the given from person Should fetch relationships matching the given to person Should fetch relationships matching the given rel type Should return empty list when no relationship matching given parameters exist Should fetch relationships that were active during effectiveDate

See Also:

PersonService.getRelationships(org.openmrs.Person, org.openmrs.Person, org.openmrs.RelationshipType, java.util.Date)

getRelationships

@Transactional(readOnly=true)
public List<Relationship> getRelationships(Person fromPerson,
                                                                         Person toPerson,
                                                                         RelationshipType relType,
                                                                         Date startEffectiveDate,
                                                                         Date endEffectiveDate)
                                                                  throws APIException

Description copied from interface: PersonService

Get relationships stored in the database that were active during the specified date range

Specified by:

getRelationships in interface PersonService

Parameters:

fromPerson - (optional) Person to in the person_id column

toPerson - (optional) Person in the relative_id column

relType - (optional) The RelationshipType to match

startEffectiveDate - (optional) The date during which the relationship was effective (lower bound)

endEffectiveDate - (optional) The date during which the relationship was effective (upper bound)

Returns:

relationships matching the given parameters

Throws:

APIException - Should fetch relationships matching the given from person Should fetch relationships matching the given to person Should fetch relationships matching the given rel type Should return empty list when no relationship matching given parameters exist Should fetch relationships that were active during the specified date range

See Also:

PersonService.getRelationships(org.openmrs.Person, org.openmrs.Person, org.openmrs.RelationshipType, java.util.Date, java.util.Date)

getRelationshipsByPerson

@Transactional(readOnly=true)
public List<Relationship> getRelationshipsByPerson(Person p)
                                                                          throws APIException

Description copied from interface: PersonService

Get list of relationships that include Person in person_id or relative_id Does not include voided relationships

Specified by:

getRelationshipsByPerson in interface PersonService

Parameters:

p - person object listed on either side of the relationship

Returns:

Relationship list

Throws:

APIException - Should only get unvoided relationships Should fetch relationships associated with the given person Should fetch unvoided relationships only

See Also:

PersonService.getRelationshipsByPerson(org.openmrs.Person)

getRelationshipsByPerson

@Transactional(readOnly=true)
public List<Relationship> getRelationshipsByPerson(Person p,
                                                                                 Date effectiveDate)
                                                                          throws APIException

Description copied from interface: PersonService

Get list of relationships that include Person in person_id or relative_id. Does not include voided relationships. Accepts an effectiveDate parameter which, if supplied, will limit the returned relationships to those that were active on the given date. Such active relationships include those that have a startDate that is null or less than or equal to the effectiveDate, and that have an endDate that is null or greater than or equal to the effectiveDate.

Specified by:

getRelationshipsByPerson in interface PersonService

Parameters:

p - person object listed on either side of the relationship

effectiveDate - effective date of relationship

Returns:

Relationship list

Throws:

APIException - Should only get unvoided relationships Should only get unvoided relationships regardless of effective date Should fetch relationships associated with the given person Should fetch relationships that were active during effectiveDate

See Also:

PersonService.getRelationshipsByPerson(org.openmrs.Person, java.util.Date)

purgeRelationship

public void purgeRelationship(Relationship relationship)
                       throws APIException

Description copied from interface: PersonService

Purges a relationship from the database (cannot be undone)

Specified by:

purgeRelationship in interface PersonService

Parameters:

relationship - relationship to be purged from the database

Throws:

APIException - Should delete relationship from the database

See Also:

PersonService.purgeRelationship(org.openmrs.Relationship)

saveRelationship

public Relationship saveRelationship(Relationship relationship)
                              throws APIException

Description copied from interface: PersonService

Create or update a relationship between people. Saves the given relationship to the database

Specified by:

saveRelationship in interface PersonService

Parameters:

relationship - relationship to be created or updated

Returns:

relationship that was created or updated

Throws:

APIException - Should create new object when relationship id is null Should update existing object when relationship id is not null

See Also:

PersonService.saveRelationship(org.openmrs.Relationship)

voidRelationship

public Relationship voidRelationship(Relationship relationship,
                                     String voidReason)
                              throws APIException

Description copied from interface: PersonService

Voids the given Relationship, effectively removing it from openmrs.

Specified by:

voidRelationship in interface PersonService

Parameters:

relationship - Relationship to void

voidReason - String reason the relationship is being voided.

Returns:

the newly saved relationship

Throws:

APIException - Should void relationship with the given reason

See Also:

PersonService.voidRelationship(org.openmrs.Relationship, java.lang.String)

unvoidRelationship

public Relationship unvoidRelationship(Relationship relationship)
                                throws APIException

Description copied from interface: PersonService

Unvoid Relationship in the database, effectively marking this as a valid relationship again

Specified by:

unvoidRelationship in interface PersonService

Parameters:

relationship - Relationship to unvoid

Returns:

the newly unvoided relationship

Throws:

APIException - Should unvoid voided relationship

See Also:

PersonService.unvoidRelationship(org.openmrs.Relationship)

getAllRelationshipTypes

@Transactional(readOnly=true)
public List<RelationshipType> getAllRelationshipTypes()
                                                                             throws APIException

Description copied from interface: PersonService

Get all relationshipTypes Includes retired relationship types

Specified by:

getAllRelationshipTypes in interface PersonService

Returns:

relationshipType list

Throws:

APIException - Should return all relationship types

See Also:

PersonService.getAllRelationshipTypes()

getRelationshipTypes

@Transactional(readOnly=true)
public List<RelationshipType> getRelationshipTypes(String searchString)
                                                                          throws APIException

Description copied from interface: PersonService

Get relationshipTypes by searching through the names and loosely matching to the given searchString

Specified by:

getRelationshipTypes in interface PersonService

Parameters:

searchString - string to match to a relationship type name

Returns:

list of relationship types or empty list if none found

Throws:

APIException - Should return empty list when no relationship type match the search string

See Also:

PersonService.getRelationshipTypes(java.lang.String)

getRelationshipTypes

@Transactional(readOnly=true)
public List<RelationshipType> getRelationshipTypes(String relationshipTypeName,
                                                                                 Boolean preferred)
                                                                          throws APIException

Description copied from interface: PersonService

Find relationshipTypes by exact name match and/or preferred status

Specified by:

getRelationshipTypes in interface PersonService

Parameters:

relationshipTypeName - name to match on

preferred - if true, returns on preferred types, if false returns only the nonpreferred types. if null returns both

Returns:

RelationshipTypes with given name and preferred status

Throws:

APIException - Should return list of preferred relationship type matching given name Should return empty list when no preferred relationship type match the given name

See Also:

PersonService.getRelationshipTypes(java.lang.String, java.lang.Boolean)

purgeRelationshipType

public void purgeRelationshipType(RelationshipType relationshipType)
                           throws APIException

Description copied from interface: PersonService

Purge relationship type from the database (cannot be undone)

Specified by:

purgeRelationshipType in interface PersonService

Parameters:

relationshipType - relationship type to be purged

Throws:

APIException - Should delete relationship type from the database

See Also:

PersonService.purgeRelationshipType(org.openmrs.RelationshipType)

saveRelationshipType

public RelationshipType saveRelationshipType(RelationshipType relationshipType)
                                      throws APIException

Description copied from interface: PersonService

Inserts or updates the given relationship type object in the database

Specified by:

saveRelationshipType in interface PersonService

Parameters:

relationshipType - type to be created or updated

Returns:

relationship type that was created or updated

Throws:

APIException - Should create new object when relationship type id is null Should update existing object when relationship type id is not null Should fail if the description is not specified

See Also:

PersonService.saveRelationshipType(org.openmrs.RelationshipType)

getPersonAttributeTypes

@Transactional(readOnly=true)
public List<PersonAttributeType> getPersonAttributeTypes(OpenmrsConstants.PERSON_TYPE personType,
                                                                                       PersonService.ATTR_VIEW_TYPE viewType)
                                                                                throws APIException

Description copied from interface: PersonService

Gets the types defined for the given person type (person, user, patient) and the given type of view (one person vs many person objects)

Specified by:

getPersonAttributeTypes in interface PersonService

Parameters:

personType - PERSON, USER, PATIENT, or null. Both PERSON and null mean to return attr types for both patients and users

viewType - whether this is a listing or viewing or null for both listing and viewing

Returns:

list of PersonAttributeTypes that should be displayed

Throws:

APIException

See Also:

PersonService.getPersonAttributeTypes(org.openmrs.util.OpenmrsConstants.PERSON_TYPE, org.openmrs.api.PersonService.ATTR_VIEW_TYPE)

parsePersonName

public PersonName parsePersonName(String name)
                           throws APIException

Description copied from interface: PersonService

Parses a name into a PersonName (separate Given, Middle, and Family names)

Specified by:

parsePersonName in interface PersonService

Parameters:

name - person name to be parsed

Returns:

parsed person name Should parse two person name with comma Should parse two person name without comma Should not fail when ending with whitespace Should not fail when ending with a comma Should parse four person name

Throws:

APIException

See Also:

PersonService.parsePersonName(java.lang.String)

voidPersonName

public PersonName voidPersonName(PersonName personName,
                                 String voidReason)
                          throws APIException

Description copied from interface: PersonService

Voids the given PersonName, effectively deleting the name, from the end-user's point of view.

Specified by:

voidPersonName in interface PersonService

Parameters:

personName - PersonName to void

voidReason - String reason the personName is being voided.

Returns:

the newly saved personName

Throws:

APIException - Should void personName with the given reason

See Also:

PersonService.voidPersonName(org.openmrs.PersonName, String)

unvoidPersonName

public PersonName unvoidPersonName(PersonName personName)
                            throws APIException

Description copied from interface: PersonService

Unvoid PersonName in the database, effectively marking this as a valid personName again

Specified by:

unvoidPersonName in interface PersonService

Parameters:

personName - PersonName to unvoid

Returns:

the newly unvoided personName

Throws:

APIException - Should unvoid voided personName

See Also:

PersonService.unvoidPersonName(org.openmrs.PersonName)

savePersonName

public PersonName savePersonName(PersonName personName)
                          throws APIException

Description copied from interface: PersonService

Inserts or updates the given personName object in the database

Specified by:

savePersonName in interface PersonService

Parameters:

personName - to be created or updated

Returns:

personName that was created or updated

Throws:

APIException - Should fail if you try to void the last non voided name

See Also:

PersonService.savePersonName(org.openmrs.PersonName)

getRelationshipMap

@Transactional(readOnly=true)
public Map<Person,List<Person>> getRelationshipMap(RelationshipType relType)
                                                                          throws APIException

Description copied from interface: PersonService

Get all relationships for a given type of relationship mapped from the personA to all of the personB's

Specified by:

getRelationshipMap in interface PersonService

Parameters:

relType - type of relationship for which to retrieve all relationships

Returns:

all relationships for the given type of relationship

Throws:

APIException - Should return empty map when no relationship has the matching relationship type

See Also:

PersonService.getRelationshipMap(org.openmrs.RelationshipType)

getPersonAttributeTypeByUuid

@Transactional(readOnly=true)
public PersonAttributeType getPersonAttributeTypeByUuid(String uuid)

Description copied from interface: PersonService

Gets a person attribute type with the given uuid.

Specified by:

getPersonAttributeTypeByUuid in interface PersonService

Parameters:

uuid - the universally unique identifier to lookup

Returns:

a person attribute type with the given uuid Should find object given valid uuid Should return null if no object found with given uuid

See Also:

PersonService.getPersonAttributeTypeByUuid(java.lang.String)

getPersonByUuid

@Transactional(readOnly=true)
public Person getPersonByUuid(String uuid)
                                                     throws APIException

Description copied from interface: PersonService

Get Person by its UUID

Specified by:

getPersonByUuid in interface PersonService

Returns:

person or null Should find object given valid uuid Should return null if no object found with given uuid

Throws:

APIException

See Also:

PersonService.getPersonByUuid(java.lang.String)

getPersonAddressByUuid

@Transactional(readOnly=true)
public PersonAddress getPersonAddressByUuid(String uuid)
                                                                   throws APIException

Description copied from interface: PersonService

Get PersonAddress by its UUID

Specified by:

getPersonAddressByUuid in interface PersonService

Returns:

person address or null Should find object given valid uuid Should return null if no object found with given uuid

Throws:

APIException

getPersonAttributeByUuid

@Transactional(readOnly=true)
public PersonAttribute getPersonAttributeByUuid(String uuid)
                                                                       throws APIException

Description copied from interface: PersonService

Get PersonAttribute by its UUID

Specified by:

getPersonAttributeByUuid in interface PersonService

Returns:

person attribute or null Should find object given valid uuid Should return null if no object found with given uuid

Throws:

APIException

getPersonName

@Transactional(readOnly=true)
public PersonName getPersonName(Integer personNameId)

Description copied from interface: PersonService

Get PersonName by its personNameId

Specified by:

getPersonName in interface PersonService

Returns:

person name or null Should find PersonName given valid personNameId Should return null if no object found with given personNameId

See Also:

PersonService.getPersonName(java.lang.Integer)

getPersonNameByUuid

@Transactional(readOnly=true)
public PersonName getPersonNameByUuid(String uuid)
                                                             throws APIException

Description copied from interface: PersonService

Get PersonName by its UUID

Specified by:

getPersonNameByUuid in interface PersonService

Returns:

person name or null Should find object given valid uuid Should return null if no object found with given uuid

Throws:

APIException

See Also:

PersonService.getPersonNameByUuid(java.lang.String)

savePersonMergeLog

public PersonMergeLog savePersonMergeLog(PersonMergeLog personMergeLog)
                                  throws SerializationException,
                                         APIException

Description copied from interface: PersonService

Builds the serialized data from PersonMergeLog.getPersonMergeLogData(), sets the mergedData String, and the creator and date if null. It then saves the PersonMergeLog object to the model.

Specified by:

savePersonMergeLog in interface PersonService

Parameters:

personMergeLog - the PersonMergeLog object to save.

Returns:

the persisted PersonMergeLog object

Throws:

SerializationException

APIException

See Also:

PersonService.savePersonMergeLog(PersonMergeLog)

getPersonMergeLogByUuid

@Transactional(readOnly=true)
public PersonMergeLog getPersonMergeLogByUuid(String uuid,
                                                                            boolean deserialize)
                                                                     throws SerializationException,
                                                                            APIException

Description copied from interface: PersonService

Gets a PersonMergeLog object from the model using the UUID identifier. Deserializes the

Specified by:

getPersonMergeLogByUuid in interface PersonService

Returns:

person merge log object

Throws:

SerializationException

APIException - Should require uuid Should retrieve personMergeLog without deserializing data Should retrieve personMergeLog and deserialize data

See Also:

PersonService.getPersonMergeLogByUuid(String, boolean)

getAllPersonMergeLogs

@Transactional(readOnly=true)
public List<PersonMergeLog> getAllPersonMergeLogs(boolean deserialize)
                                                                         throws SerializationException

Description copied from interface: PersonService

Gets all the PersonMergeLog objects from the model

Specified by:

getAllPersonMergeLogs in interface PersonService

Returns:

list of PersonMergeLog objects

Throws:

SerializationException - Should retrieve all PersonMergeLogs from the model Should retrieve all PersonMergeLogs and deserialize them

See Also:

PersonService.getAllPersonMergeLogs(boolean)

getWinningPersonMergeLogs

@Transactional(readOnly=true)
public List<PersonMergeLog> getWinningPersonMergeLogs(Person person,
                                                                                    boolean deserialize)
                                                                             throws SerializationException

Description copied from interface: PersonService

Gets PersonMergeLog objects by winning person p. Useful for to getting all persons merged into p.

Specified by:

getWinningPersonMergeLogs in interface PersonService

Parameters:

person - the winning person

Returns:

List of PersonMergeLog objects

Throws:

SerializationException - Should retrieve PersonMergeLogs by winner

See Also:

PersonService.getWinningPersonMergeLogs(Person, boolean)

getLosingPersonMergeLog

@Transactional(readOnly=true)
public PersonMergeLog getLosingPersonMergeLog(Person person,
                                                                            boolean deserialize)
                                                                     throws SerializationException

Description copied from interface: PersonService

Gets the PersonMergeLog where person p is the loser. Useful for getting the person that p was merged into.

Specified by:

getLosingPersonMergeLog in interface PersonService

Parameters:

person - the losing person

Returns:

The PersonMergeLog object

Throws:

SerializationException - Should find PersonMergeLog by loser

See Also:

PersonService.getLosingPersonMergeLog(Person, boolean)

getRelationshipByUuid

@Transactional(readOnly=true)
public Relationship getRelationshipByUuid(String uuid)
                                                                 throws APIException

Description copied from interface: PersonService

Get Relationship by its UUID

Specified by:

getRelationshipByUuid in interface PersonService

Returns:

relationship or null Should find object given valid uuid Should return null if no object found with given uuid

Throws:

APIException

See Also:

PersonService.getRelationshipByUuid(java.lang.String)

getRelationshipTypeByUuid

@Transactional(readOnly=true)
public RelationshipType getRelationshipTypeByUuid(String uuid)
                                                                         throws APIException

Description copied from interface: PersonService

Gets the relationship type with the given uuid.

Specified by:

getRelationshipTypeByUuid in interface PersonService

Returns:

relationship type or null

Throws:

APIException - Should find object given valid uuid Should return null if no object found with given uuid

See Also:

PersonService.getRelationshipTypeByUuid(java.lang.String)

getAllRelationshipTypes

@Transactional(readOnly=true)
public List<RelationshipType> getAllRelationshipTypes(boolean includeRetired)
                                                                             throws APIException

Description copied from interface: PersonService

Get all relationshipTypes with the option of including the retired types

Specified by:

getAllRelationshipTypes in interface PersonService

Parameters:

includeRetired - boolean - include retired relationshipTypes as well?

Returns:

relationshipType list

Throws:

APIException

See Also:

PersonService.getAllRelationshipTypes(boolean)

retireRelationshipType

public RelationshipType retireRelationshipType(RelationshipType type,
                                               String retiredReason)
                                        throws APIException

Description copied from interface: PersonService

Retire a Person Relationship Type

Specified by:

retireRelationshipType in interface PersonService

Throws:

APIException

See Also:

PersonService.retireRelationshipType(org.openmrs.RelationshipType, java.lang.String)

unretireRelationshipType

public RelationshipType unretireRelationshipType(RelationshipType relationshipType)

Description copied from interface: PersonService

Unretire a Person Relationship Type

Specified by:

unretireRelationshipType in interface PersonService

Parameters:

relationshipType - retiredReason

See Also:

PersonService.unretireRelationshipType(org.openmrs.RelationshipType)

voidPersonAddress

public PersonAddress voidPersonAddress(PersonAddress personAddress,
                                       String voidReason)

Description copied from interface: PersonService

Voids the given PersonAddress, effectively deleting the personAddress, from the end-user's point of view.

Specified by:

voidPersonAddress in interface PersonService

Parameters:

personAddress - PersonAddress to void

voidReason - String reason the personAddress is being voided.

Returns:

the newly saved personAddress

See Also:

PersonService.voidPersonAddress(org.openmrs.PersonAddress, String)

unvoidPersonAddress

public PersonAddress unvoidPersonAddress(PersonAddress personAddress)
                                  throws APIException

Description copied from interface: PersonService

Unvoid PersonAddress in the database, effectively marking this as a valid PersonAddress again

Specified by:

unvoidPersonAddress in interface PersonService

Parameters:

personAddress - PersonAddress to unvoid

Returns:

the newly unvoided personAddress

Throws:

APIException - Should unvoid voided personAddress

See Also:

PersonService.unvoidPersonAddress(org.openmrs.PersonAddress)

savePersonAddress

public PersonAddress savePersonAddress(PersonAddress personAddress)

Description copied from interface: PersonService

Inserts or updates the given personAddress object in the database

Specified by:

savePersonAddress in interface PersonService

Parameters:

personAddress - PersonAddress to be created or updated

Returns:

personAddress that was created or updated

See Also:

PersonService.savePersonAddress(org.openmrs.PersonAddress)

checkIfPersonAttributeTypesAreLocked

public void checkIfPersonAttributeTypesAreLocked()

Description copied from interface: PersonService

Check if the person attribute types are locked, and if they are throws an exception during manipulation of a person attribute type

Specified by:

checkIfPersonAttributeTypesAreLocked in interface PersonService