ConceptService (OpenMRS 1.8.5-SNAPSHOT API)

All Superinterfaces:: OpenmrsService

All Known Implementing Classes:: ConceptServiceImpl

@Transactional
public interface ConceptService
extends OpenmrsService

Contains methods pertaining to creating/updating/deleting/retiring Concepts, Drugs, Concept Proposals, and all other things 'Concept'.

To get a list of concepts:

 
 List<Concept> concepts = Context.getConceptService().getAllConcepts();

To get a single concept:

 
 // if there is a concept row in the database with concept_id = 3845
 Concept concept = Context.getConceptService().getConcept(3845);
 
 String name = concept.getPreferredName(Context.getLocale()).getName();

To save a concept to the database

   Concept concept = new Concept();
   concept.setConceptClass(Context.getConceptService().getConceptClass(3));
   concept.setDatatype(Context.getConceptService().getConceptDatatype(17));
   concept.setName...
   ... // and other required values on the concept
   Context.getConceptService().saveConcept(concept);

See Also:: Context

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`checkIfLocked()` Check if the concepts are locked and if so, throw exception during manipulation of concept
`Iterator<Concept>`	`conceptIterator()` Returns an iterator for all concepts, including retired and expired.
`void`	`convertBooleanConceptToCoded(Concept conceptToChange)` Changes the datatype of a concept from boolean to coded when it has observations it is associated to.
`void`	`createConcept(Concept concept)` Deprecated. use #saveConcept(Concept)
`void`	`createConcept(ConceptNumeric concept)` Deprecated. use #saveConcept(Concept)
`void`	`createDrug(Drug drug)` Deprecated. use #saveDrug(Drug)
`void`	`deleteConcept(Concept concept)` Deprecated. use #purgeConcept(Concept concept)
`List<ConceptSearchResult>`	`findConceptAnswers(String phrase, Locale locale, Concept concept)` Finds concepts that are possible value coded answers to concept parameter
`List<ConceptWord>`	`findConceptAnswers(String phrase, Locale locale, Concept concept, boolean includeRetired)` Deprecated. use `findConceptAnswers(String, Locale, Concept)`
`List<ConceptWord>`	`findConcepts(String phrase, List<Locale> searchLocales, boolean includeRetired, List<ConceptClass> requireClasses, List<ConceptClass> excludeClasses, List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes)` Deprecated. use `getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)`
`List<ConceptWord>`	`findConcepts(String phrase, Locale locale, boolean includeRetired)` Deprecated. use `getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)`
`List<ConceptWord>`	`findConcepts(String phrase, Locale locale, boolean includeRetired, int start, int size)` Deprecated. Use `getConceptWords(String, List, boolean, List, List, List, List, Concept, Integer, Integer)`
`List<ConceptWord>`	`findConcepts(String phrase, Locale locale, boolean includeRetired, List<ConceptClass> requireClasses, List<ConceptClass> excludeClasses, List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes)` Deprecated. use `getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)`
`List<Drug>`	`findDrugs(String phrase, boolean includeVoided)` Deprecated. Use `getDrugs(String)`
`List<ConceptProposal>`	`findMatchingConceptProposals(String text)` Deprecated. use `getConceptProposals(String)`
`List<Concept>`	`findProposedConcepts(String text)` Deprecated. Use `getProposedConcepts(String)`
`List<ConceptClass>`	`getAllConceptClasses()` Return a list of concept classes currently in the database
`List<ConceptClass>`	`getAllConceptClasses(boolean includeRetired)` Return a list of concept classes currently in the database
`List<ConceptDatatype>`	`getAllConceptDatatypes()` Return a list of all concept datatypes currently in the database
`List<ConceptDatatype>`	`getAllConceptDatatypes(boolean includeRetired)` Return a list of concept datatypes currently in the database
`List<ConceptNameTag>`	`getAllConceptNameTags()` Get all the concept name tags defined in the database, included voided ones
`List<ConceptProposal>`	`getAllConceptProposals(boolean includeCompleted)` Get a List of all concept proposals
`List<Concept>`	`getAllConcepts()` Return a list of unretired concepts sorted by concept id ascending and
`List<Concept>`	`getAllConcepts(String sortBy, boolean asc, boolean includeRetired)` Return a list of concepts sorted on sortBy in dir direction (asc/desc)
`List<ConceptSource>`	`getAllConceptSources()` Return a list of concept sources currently in the database that are not voided
`List<Drug>`	`getAllDrugs()` Return a list of drugs currently in the database that are not retired
`List<Drug>`	`getAllDrugs(boolean includeRetired)` Get drugs by concept.
`Concept`	`getConcept(Integer conceptId)` Gets the concept with the given id
`Concept`	`getConcept(String conceptIdOrName)` Get Concept by id or name convenience method
`ConceptAnswer`	`getConceptAnswer(Integer conceptAnswerId)` Gets the ConceptAnswer with the given id
`ConceptAnswer`	`getConceptAnswerByUuid(String uuid)` Get ConceptAnswer by its UUID
`List<ConceptWord>`	`getConceptAnswers(String phrase, Locale locale, Concept concept)` Deprecated. use `findConceptAnswers(String, Locale, Concept)`
`Concept`	`getConceptByIdOrName(String idOrName)` Deprecated. use `getConcept(String)`
`Concept`	`getConceptByMapping(String code, String sourceName)` Looks up a concept via `ConceptMap` This will return the `Concept` which contains a `ConceptMap` entry whose `sourceCode` is equal to the passed `conceptCode` and whose `ConceptSource` has either a `name` or `hl7Code` that is equal to the passed `mappingCode`.
`Concept`	`getConceptByMapping(String code, String sourceName, Boolean includeRetired)` Looks up a concept via `ConceptMap` This will return the `Concept` which contains a `ConceptMap` entry whose `sourceCode` is equal to the passed `conceptCode` and whose `ConceptSource` has either a `name` or `hl7Code` that is equal to the passed `mappingCode` .
`Concept`	`getConceptByName(String name)` Return a Concept that matches the name exactly
`Concept`	`getConceptByUuid(String uuid)` Get Concept by its UUID
`ConceptClass`	`getConceptClass(Integer conceptClassId)` Return a Concept class matching the given identifier
`ConceptClass`	`getConceptClassByName(String name)` Return a Concept class matching the given name
`ConceptClass`	`getConceptClassByUuid(String uuid)` Get ConceptClass by its UUID
`List<ConceptClass>`	`getConceptClasses()` Deprecated. use `getAllConceptClasses(boolean)`
`ConceptComplex`	`getConceptComplex(Integer conceptId)` Get a ComplexConcept with the given conceptId
`ConceptDatatype`	`getConceptDatatype(Integer i)` Return a ConceptDatatype matching the given identifier
`ConceptDatatype`	`getConceptDatatypeByName(String name)` Return a Concept datatype matching the given name
`ConceptDatatype`	`getConceptDatatypeByUuid(String uuid)` Get ConceptDatatype by its UUID
`List<ConceptDatatype>`	`getConceptDatatypes(String name)` Deprecated. you probably want to use `getConceptDatatypeByName(String)`
`ConceptDescription`	`getConceptDescriptionByUuid(String uuid)` Get ConceptDescription by its UUID
`ConceptName`	`getConceptName(Integer conceptNameId)` Gets the concept-name with the given id
`ConceptName`	`getConceptNameByUuid(String uuid)` Get ConceptName by its UUID
`ConceptNameTag`	`getConceptNameTag(Integer id)` Gets the `ConceptNameTag` with the given database primary key
`ConceptNameTag`	`getConceptNameTagByName(String tag)` Search for a ConceptNameTag by name
`ConceptNameTag`	`getConceptNameTagByUuid(String uuid)` Get ConceptNameTag by its UUID
`ConceptNumeric`	`getConceptNumeric(Integer conceptId)` Get the ConceptNumeric with the given id
`ConceptNumeric`	`getConceptNumericByUuid(String uuid)` Get ConceptNumeric by its UUID
`ConceptProposal`	`getConceptProposal(Integer conceptProposalId)` Get a ConceptProposal by conceptProposalId
`ConceptProposal`	`getConceptProposalByUuid(String uuid)` Get ConceptProposal by its UUID
`List<ConceptProposal>`	`getConceptProposals(boolean includeCompleted)` Deprecated. use `getAllConceptProposals(boolean)`
`List<ConceptProposal>`	`getConceptProposals(String text)` Find matching concept proposals
`List<ConceptSearchResult>`	`getConcepts(String phrase, List<Locale> locales, boolean includeRetired, List<ConceptClass> requireClasses, List<ConceptClass> excludeClasses, List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes, Concept answersToConcept, Integer start, Integer size)` Searches for concepts by the given parameters
`List<ConceptSearchResult>`	`getConcepts(String phrase, Locale locale, boolean includeRetired)` Searches for concepts with the given parameters
`List<Concept>`	`getConcepts(String sortBy, String dir)` Deprecated. use `getAllConcepts(String, boolean, boolean)`
`List<Concept>`	`getConceptsByAnswer(Concept concept)` Returns all possible Concepts to which this concept is a value-coded answer.
`List<Concept>`	`getConceptsByClass(ConceptClass cc)`
`List<Concept>`	`getConceptsByConceptSet(Concept concept)` Return a List of all concepts within a concept set
`List<ConceptMap>`	`getConceptsByConceptSource(ConceptSource conceptSource)` Looks up a list of ConceptMaps for a given ConceptSource
`List<Concept>`	`getConceptsByMapping(String code, String sourceName)` Looks up a concept via `ConceptMap` This will return the list of concepts `Concept`s which contain a `ConceptMap` entry whose `sourceCode` is equal to the passed `conceptCode` and whose `ConceptSource` has either a `name` or `hl7Code` that is equal to the passed `mappingCode`
`List<Concept>`	`getConceptsByMapping(String code, String sourceName, boolean includeRetired)` Looks up a concept via `ConceptMap` This will return the list of `Concept`s which contain a `ConceptMap` entry whose `sourceCode` is equal to the passed `conceptCode` and whose `ConceptSource` has either a `name` or `hl7Code` that is equal to the passed `mappingCode`.
`List<Concept>`	`getConceptsByName(String name)` Returns a list of concepts matching any part of a concept name, this method is case insensitive to the concept name string
`List<Concept>`	`getConceptsByName(String name, Locale locale, Boolean exactLocale)` Returns a list of concepts with the same name in the given locale.
`ConceptSet`	`getConceptSetByUuid(String uuid)` Get ConceptSet by its UUID
`List<ConceptSet>`	`getConceptSets(Concept concept)` Deprecated. use `getConceptSetsByConcept(Concept)`
`List<ConceptSet>`	`getConceptSetsByConcept(Concept concept)` Return a list of the concept sets with concept_set matching concept
`List<Concept>`	`getConceptsInSet(Concept concept)` Deprecated. use `getConceptsByConceptSet(Concept)`
`ConceptSource`	`getConceptSource(Integer i)` Return a Concept source matching the given concept source id
`ConceptSource`	`getConceptSourceByName(String conceptSourceName)` Lookup a ConceptSource by its name property
`ConceptSource`	`getConceptSourceByUuid(String uuid)` Get ConceptSource by its UUID
`List<Concept>`	`getConceptsWithDrugsInFormulary()` Convenience method for finding concepts associated with drugs in formulary.
`List<ConceptWord>`	`getConceptWords(String phrase, List<Locale> locales, boolean includeRetired, List<ConceptClass> requireClasses, List<ConceptClass> excludeClasses, List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes, Concept answersToConcept, Integer start, Integer size)` Deprecated. use `getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)`
`List<ConceptWord>`	`getConceptWords(String phrase, Locale locale)` Deprecated. use `#getConcepts(String, Locale)` that returns a list of ConceptSearchResults
`Integer`	`getCountOfConcepts(String phrase, List<Locale> locales, boolean includeRetired, List<ConceptClass> requireClasses, List<ConceptClass> excludeClasses, List<ConceptDatatype> requireDatatypes, List<ConceptDatatype> excludeDatatypes, Concept answersToConcept)` Return the number of concepts matching a search phrase and the specified arguments
`Integer`	`getCountOfDrugs(String drugName, Concept concept, boolean searchOnPhrase, boolean searchDrugConceptNames, boolean includeRetired)` Return the number of drugs with matching names or concept drug names
`Drug`	`getDrug(Integer drugId)` Get the Drug with the given id
`Drug`	`getDrug(String drugNameOrId)` Return the drug object corresponding to the given name or drugId
`Drug`	`getDrugByNameOrId(String drugId)` Return the drug object corresponding to the given name or drugId
`Drug`	`getDrugByUuid(String uuid)` Get Drug by its UUID
`List<Drug>`	`getDrugs()` Deprecated. use `getAllDrugs()`
`List<Drug>`	`getDrugs(Concept concept)` Deprecated. Use `getDrugsByConcept(Concept)`
`List<Drug>`	`getDrugs(String phrase)` <<<<<<< HEAD Find drugs in the system.
`List<Drug>`	`getDrugs(String drugName, Concept concept, boolean searchOnPhrase, boolean searchDrugConceptNames, boolean includeRetired, Integer start, Integer length)` Returns a list of drugs with matching names or concept drug names and returns a specific number of them from the specified starting position.
`List<Drug>`	`getDrugsByConcept(Concept concept)` Return a list of drugs associated with the given concept
`Concept`	`getFalseConcept()` Returns the FALSE concept
`Set<Locale>`	`getLocalesOfConceptNames()` Gets the set of unique Locales used by existing concept names.
`Integer`	`getMaxConceptId()` Gets the highest concept-id used by a concept.
`Concept`	`getNextConcept(Concept concept)` Finds the next concept in the dictionary that has the next largest concept id
`Concept`	`getPrevConcept(Concept concept)` Finds the previous concept in the dictionary that has the next lowest concept id
`List<Concept>`	`getProposedConcepts(String text)` Find matching proposed concepts
`List<Concept>`	`getQuestionsForAnswer(Concept concept)` Deprecated. use #getConceptsByAnswer(Concept)
`List<ConceptSet>`	`getSetsContainingConcept(Concept concept)` Find all sets that the given concept is a member of
`Concept`	`getTrueConcept()` Returns the TRUE concept
`boolean`	`hasAnyObservation(Concept concept)` Checks if there are any observations (including voided observations) for a concept.
`boolean`	`hasAnyObservation(ConceptName conceptName)` Checks if there are any observations (including voided observations) using a conceptName.
`Concept`	`mapConceptProposalToConcept(ConceptProposal cp, Concept mappedConcept)` Maps a concept proposal to a concept
`Concept`	`mapConceptProposalToConcept(ConceptProposal cp, Concept mappedConcept, Locale locale)` Maps a concept proposal to a concept
`void`	`proposeConcept(ConceptProposal conceptProposal)` Deprecated. use `saveConceptProposal(ConceptProposal)`
`void`	`purgeConcept(Concept conceptOrConceptNumeric)` Completely purge a `Concept` or `ConceptNumeric` from the database.
`void`	`purgeConceptClass(ConceptClass cc)` Purge a ConceptClass
`void`	`purgeConceptDatatype(ConceptDatatype cd)` Purge a ConceptDatatype.
`void`	`purgeConceptProposal(ConceptProposal cp)` Removes a concept proposal from the database entirely.
`ConceptSource`	`purgeConceptSource(ConceptSource cs)` Delete ConceptSource
`void`	`purgeDrug(Drug drug)` Completely purge a Drug from the database.
`void`	`rejectConceptProposal(ConceptProposal cp)` Deprecated. use `ConceptProposal.rejectConceptProposal()`
`Concept`	`retireConcept(Concept conceptOrConceptNumeric, String reason)` Retiring a concept essentially removes it from circulation
`ConceptSource`	`retireConceptSource(ConceptSource cs, String reason)` This effectively removes a concept source from the database.
`Drug`	`retireDrug(Drug drug, String reason)` Retiring a Drug essentially removes it from circulation
`Concept`	`saveConcept(Concept concept)` Save or update the given `Concept` or `ConceptNumeric` in the database
`ConceptClass`	`saveConceptClass(ConceptClass cc)` Creates or updates a concept class
`ConceptDatatype`	`saveConceptDatatype(ConceptDatatype cd)` Create or update a ConceptDatatype
`ConceptNameTag`	`saveConceptNameTag(ConceptNameTag nameTag)` Creates a new Concept name tag if none exists.
`ConceptProposal`	`saveConceptProposal(ConceptProposal conceptProposal)` Saves/updates/proposes a concept proposal
`ConceptSource`	`saveConceptSource(ConceptSource conceptSource)` Create a new ConceptSource
`Drug`	`saveDrug(Drug drug)` Save or update the given `Drug` in the database.
`void`	`setConceptDAO(ConceptDAO dao)` Sets the data access object for Concepts.
`Drug`	`unretireDrug(Drug drug)` Marks a drug that is currently retired as not retired.
`void`	`updateConcept(Concept concept)` Deprecated. use #saveConcept(Concept)
`void`	`updateConcept(ConceptNumeric concept)` Deprecated. use #saveConcept(Concept)
`void`	`updateConceptIndex(Concept concept)` Iterates over the words in names and synonyms (for each locale) and updates the concept index, note that this only updates the index of the specified concept.
`void`	`updateConceptIndexes()` Iterates over all concepts and calls upddateConceptIndexes(Concept concept)
`void`	`updateConceptIndexes(Integer conceptIdStart, Integer conceptIdEnd)` Iterates over all concepts with conceptIds between `conceptIdStart` and `conceptIdEnd` (inclusive) and calls updateConceptIndexes(concept)
`void`	`updateConceptSetDerived()` Iterates over all concepts calling updateConceptSetDerived(concept)
`void`	`updateConceptSetDerived(Concept concept)` Updates the concept set derived business table for this concept (bursting the concept sets)
`void`	`updateConceptWord(Concept concept)` Deprecated. use `updateConceptWord(Concept)`
`void`	`updateConceptWords()` Deprecated. use `updateConceptWords()`
`void`	`updateConceptWords(Integer conceptIdStart, Integer conceptIdEnd)` Deprecated. use `updateConceptIndexes(Integer, Integer)`
`void`	`updateDrug(Drug drug)` Deprecated. use #saveDrug(Drug)
`void`	`voidConcept(Concept concept, String reason)` Deprecated. use `retireConcept(Concept, String)`

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

Method Detail

setConceptDAO
```
void setConceptDAO(ConceptDAO dao)
```
Sets the data access object for Concepts. The dao is used for saving and getting concepts to/from the database

Parameters:

dao - The data access object to use

createConcept

@Deprecated
 @Authorized(value="Manage Concepts")
void createConcept(Concept concept)
                                                              throws APIException

Deprecated. use #saveConcept(Concept)

Throws:: APIException

createConcept

@Deprecated
 @Authorized(value="Manage Concepts")
void createConcept(ConceptNumeric concept)
                                                              throws APIException

Deprecated. use #saveConcept(Concept)

Throws:: APIException

updateConcept

@Deprecated
 @Authorized(value="Manage Concepts")
void updateConcept(Concept concept)
                                                              throws APIException

Deprecated. use #saveConcept(Concept)

Throws:: APIException

getConceptByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConceptByUuid(String uuid)
```
Get Concept by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

updateConcept

@Deprecated
 @Authorized(value="Manage Concepts")
void updateConcept(ConceptNumeric concept)
                                                              throws APIException

Deprecated. use #saveConcept(Concept)

Throws:: APIException

createDrug

@Deprecated
 @Authorized(value="Manage Concepts")
void createDrug(Drug drug)
                                                           throws APIException

Deprecated. use #saveDrug(Drug)

Throws:: APIException

updateDrug

@Deprecated
 @Authorized(value="Manage Concepts")
void updateDrug(Drug drug)
                                                           throws APIException

Deprecated. use #saveDrug(Drug)

Throws:: APIException

deleteConcept

@Deprecated
 @Authorized(value="Purge Concepts")
void deleteConcept(Concept concept)
                                                             throws APIException

Deprecated. use #purgeConcept(Concept concept)

Throws:: APIException

voidConcept

@Deprecated
 @Authorized(value="Manage Concepts")
void voidConcept(Concept concept,
                                                                   String reason)
                                                            throws APIException

Deprecated. use retireConcept(Concept, String)

Throws:: APIException

saveConcept
```
@Authorized(value="Manage Concepts")
Concept saveConcept(Concept concept)
                                                  throws APIException
```
Save or update the given Concept or ConceptNumeric in the database
If this is a new concept, the returned concept will have a new Concept.getConceptId() inserted into it that was generated by the database

Parameters:

concept - The Concept or ConceptNumeric to save or update

Returns:

the Concept or ConceptNumeric that was saved or updated

Throws:

APIException

ConceptsLockedException

ConceptInUseException

Should:

put generated concept id onto returned concept, create new concept in database, update concept already existing in database, generate id for new concept if none is specified, keep id for new concept if one is specified, save non ConceptNumeric object as conceptNumeric, save a ConceptNumeric as a concept, save a new ConceptNumeric, void the conceptName if the text of the name has changed, create a new conceptName when the old name is changed, set a preferred name for each locale if none is marked, not fail when a duplicate name is edited to a unique value

saveDrug
```
@Authorized(value="Manage Concepts")
Drug saveDrug(Drug drug)
                                            throws APIException
```
Save or update the given Drug in the database. If this is a new drug, the returned drug object will have a new Drug.getDrugId() inserted into it that was generated by the database

Parameters:

drug - The Drug to save or update

Returns:

the Drug that was saved or updated

Throws:

APIException

Should:

put generated drug id onto returned drug, create new drug in database, update drug already existing in database

purgeConcept
```
@Authorized(value="Purge Concepts")
void purgeConcept(Concept conceptOrConceptNumeric)
                                               throws APIException
```
Completely purge a Concept or ConceptNumeric from the database. This should not typically be used unless desperately needed. Most should just be retired. See retireConcept(Concept, String)

Parameters:

conceptOrConceptNumeric - The Concept or ConceptNumeric to remove from the system

Throws:

APIException

Should:

fail if any of the conceptNames of the concept is being used by an obs

retireConcept

@Authorized(value="Manage Concepts")
Concept retireConcept(Concept conceptOrConceptNumeric,
                                                           String reason)
                                                    throws APIException

Retiring a concept essentially removes it from circulation

Parameters:: conceptOrConceptNumeric - The Concept or ConceptNumeric to retire; reason - The retire reason
Returns:: the retired Concept or ConceptNumeric
Throws:: APIException

retireDrug

@Authorized(value="Manage Concepts")
Drug retireDrug(Drug drug,
                                                     String reason)
                                              throws APIException

Retiring a Drug essentially removes it from circulation

Parameters:: drug - The Drug to retire; reason - The retire reason
Returns:: the retired Drug
Throws:: APIException

unretireDrug
```
@Authorized(value="Manage Concepts")
Drug unretireDrug(Drug drug)
                                                throws APIException
```
Marks a drug that is currently retired as not retired.

Parameters:

drug - that is current set as retired

Returns:

the given drug, marked as not retired now, and saved to the db

Throws:

APIException

Should:

mark drug as retired, not change attributes of drug that is already retired

purgeDrug
```
@Authorized(value="Purge Concepts")
void purgeDrug(Drug drug)
                                            throws APIException
```
Completely purge a Drug from the database. This should not typically be used unless desperately needed. Most Drugs should just be retired.

Parameters:

drug - The Drug to remove from the system

Throws:

APIException

getConcept

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConcept(Integer conceptId)
                                                                              throws APIException

Gets the concept with the given id

Parameters:: conceptId -
Returns:: the matching Concept object
Throws:: APIException

getConceptName

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptName getConceptName(Integer conceptNameId)
                                                                                      throws APIException

Gets the concept-name with the given id

Parameters:: conceptNameId -
Returns:: the matching Concept object
Throws:: APIException

getConceptAnswer

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptAnswer getConceptAnswer(Integer conceptAnswerId)
                                                                                          throws APIException

Gets the ConceptAnswer with the given id

Parameters:: conceptAnswerId -
Returns:: the matching ConceptAnswer object
Throws:: APIException

getDrug

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Drug getDrug(Integer drugId)
                                                                        throws APIException

Get the Drug with the given id

Parameters:: drugId -
Returns:: the matching Drug object
Throws:: APIException

getConceptNumeric

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptNumeric getConceptNumeric(Integer conceptId)
                                                                                            throws APIException

Get the ConceptNumeric with the given id

Parameters:: conceptId - The ConceptNumeric id
Returns:: the matching ConceptNumeric object
Throws:: APIException

getConceptClass

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptClass getConceptClass(Integer conceptClassId)
                                                                                        throws APIException

Return a Concept class matching the given identifier

Parameters:: conceptClassId - the concept class identifier
Returns:: the matching ConceptClass
Throws:: APIException

getAllConcepts

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getAllConcepts()
                                                                                        throws APIException

Return a list of unretired concepts sorted by concept id ascending and

Returns:: a List object containing all of the sorted concepts
Throws:: APIException

getAllConcepts

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getAllConcepts(String sortBy,
                                                                                               boolean asc,
                                                                                               boolean includeRetired)
                                                                                        throws APIException

Return a list of concepts sorted on sortBy in dir direction (asc/desc)

Parameters:: sortBy - The property name to sort by; if null or invalid, concept_id is used.; asc - true = sort ascending; false = sort descending; includeRetired - If true, retired concepts will also be returned
Returns:: a List object containing all of the sorted concepts
Throws:: APIException

getConcepts

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConcepts(String sortBy,
                                                                                                         String dir)
                                                                                                  throws APIException

Deprecated. use getAllConcepts(String, boolean, boolean)

Throws:: APIException

getConceptsByName
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByName(String name)
                                                                                           throws APIException
```
Returns a list of concepts matching any part of a concept name, this method is case insensitive to the concept name string

Parameters:

name - The search string

Returns:

a List object containing all of the matching concepts

Throws:

APIException

Should:

pass irrespective of the case of the passed parameter

getConceptByName
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConceptByName(String name)
                                                                                    throws APIException
```
Return a Concept that matches the name exactly

Parameters:

name - The search string

Returns:

the found Concept

Throws:

APIException

Should:

get concept by name, get concept by partial name, return null given null parameter, find concepts with names in more specific locales, find concepts with names in more generic locales, find concepts with names in same specific locale, return null given blank string

getConceptByIdOrName

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConceptByIdOrName(String idOrName)
                                                                                                     throws APIException

Deprecated. use getConcept(String)

Get Concepts by id or name

Note: this just calls other impl methods; no DAO of its own

Parameters:: idOrName -
Returns:: the found Concept
Throws:: APIException

getConcept

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConcept(String conceptIdOrName)
                                                                              throws APIException

Get Concept by id or name convenience method

Parameters:: conceptIdOrName -
Returns:: the found Concept
Throws:: APIException
Should:: return null given null parameter

getConceptWords

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> getConceptWords(String phrase,
                                                                                                                 List<Locale> locales,
                                                                                                                 boolean includeRetired,
                                                                                                                 List<ConceptClass> requireClasses,
                                                                                                                 List<ConceptClass> excludeClasses,
                                                                                                                 List<ConceptDatatype> requireDatatypes,
                                                                                                                 List<ConceptDatatype> excludeDatatypes,
                                                                                                                 Concept answersToConcept,
                                                                                                                 Integer start,
                                                                                                                 Integer size)
                                                                                                          throws APIException

Deprecated. use getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)

Throws:: APIException

getConceptWords

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> getConceptWords(String phrase,
                                                                                                                 Locale locale)
                                                                                                          throws APIException

Deprecated. use #getConcepts(String, Locale) that returns a list of ConceptSearchResults

Throws:: APIException

findConcepts

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> findConcepts(String phrase,
                                                                                                              Locale locale,
                                                                                                              boolean includeRetired)
                                                                                                       throws APIException

Deprecated. use getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)

Throws:: APIException

findConcepts

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> findConcepts(String phrase,
                                                                                                              Locale locale,
                                                                                                              boolean includeRetired,
                                                                                                              List<ConceptClass> requireClasses,
                                                                                                              List<ConceptClass> excludeClasses,
                                                                                                              List<ConceptDatatype> requireDatatypes,
                                                                                                              List<ConceptDatatype> excludeDatatypes)
                                                                                                       throws APIException

Deprecated. use getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)

Throws:: APIException

getDrugByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Drug getDrugByUuid(String uuid)
```
Get Drug by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

findConcepts

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> findConcepts(String phrase,
                                                                                                              Locale locale,
                                                                                                              boolean includeRetired,
                                                                                                              int start,
                                                                                                              int size)
                                                                                                       throws APIException

Deprecated. Use getConceptWords(String, List, boolean, List, List, List, List, Concept, Integer, Integer)

Throws:: APIException

getDrug

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Drug getDrug(String drugNameOrId)
                                                                        throws APIException

Return the drug object corresponding to the given name or drugId

Parameters:: drugNameOrId - String name or drugId to match exactly on
Returns:: matching Drug object
Throws:: APIException

getDrugByNameOrId

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Drug getDrugByNameOrId(String drugId)
                                                                                  throws APIException

Return the drug object corresponding to the given name or drugId

Parameters:: drugId - String
Returns:: matching Drug object
Throws:: APIException

getDrugs

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getDrugs()
                                                                                            throws APIException

Deprecated. use getAllDrugs()

Throws:: APIException

getAllDrugs

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getAllDrugs()
                                                                                  throws APIException

Return a list of drugs currently in the database that are not retired

Returns:: a List object containing all drugs
Throws:: APIException

getDrugs

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getDrugs(Concept concept)
                                                                                            throws APIException

Deprecated. Use getDrugsByConcept(Concept)

Throws:: APIException

getDrugsByConcept

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getDrugsByConcept(Concept concept)
                                                                                        throws APIException

Return a list of drugs associated with the given concept

Parameters:: concept -
Returns:: a List object containing all matching drugs
Throws:: APIException

getAllDrugs
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getAllDrugs(boolean includeRetired)
```
Get drugs by concept. This method is the utility method that should be used to generically retrieve all Drugs in the system.

Parameters:

includeRetired - If true then the search will include voided Drugs

Returns:

A List object containing all matching Drugs

findDrugs

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> findDrugs(String phrase,
                                                                                                    boolean includeVoided)
                                                                                             throws APIException

Deprecated. Use getDrugs(String)

Throws:: APIException

getDrugs
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getDrugs(String phrase)
                                                                               throws APIException
```
<<<<<<< HEAD Find drugs in the system. The string search can match either drug.name or drug.concept.name, drug.drugId or drug.concept.conceptId ======= Find drugs in the system. The string search can match either drug.name or drug.concept.name >>>>>>> 12753ad5d3d397a5fb31b8a79a8b5a14cf3b57fc

Parameters:

phrase - Search phrase

Returns:

A List object containing all Drug matches <<<<<<< HEAD

Throws:

APIException

Should:

return drugs by drug id, return drugs by drug concept id, not fail if there is no drug by given id ======= >>>>>>> 12753ad5d3d397a5fb31b8a79a8b5a14cf3b57fc

getConceptsByClass

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByClass(ConceptClass cc)
                                                                                            throws APIException

Parameters:: cc - ConceptClass
Returns:: Returns all concepts in a given class
Throws:: APIException

getConceptClasses

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concept Classes")
List<ConceptClass> getConceptClasses()
                                                                                                                    throws APIException

Deprecated. use getAllConceptClasses(boolean)

Return a list of concept classes currently in the database

Returns:: List object with all ConceptClass objects
Throws:: APIException

getConceptClassByName

@Transactional(readOnly=true)
 @Authorized(value="View Concept Classes")
ConceptClass getConceptClassByName(String name)
                                                                                                     throws APIException

Return a Concept class matching the given name

Parameters:: name -
Returns:: ConceptClass matching the given name
Throws:: APIException

getAllConceptClasses

@Transactional(readOnly=true)
 @Authorized(value="View Concept Classes")
List<ConceptClass> getAllConceptClasses()
                                                                                                          throws APIException

Return a list of concept classes currently in the database

Returns:: List object with all ConceptClass objects
Throws:: APIException

getAllConceptClasses

@Transactional(readOnly=true)
 @Authorized(value="View Concept Classes")
List<ConceptClass> getAllConceptClasses(boolean includeRetired)
                                                                                                          throws APIException

Return a list of concept classes currently in the database

Parameters:: includeRetired - include retired concept classes in the search results?
Returns:: List object with all ConceptClass objects
Throws:: APIException

getConceptClassByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concept Classes")
ConceptClass getConceptClassByUuid(String uuid)
```
Get ConceptClass by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptAnswerByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptAnswer getConceptAnswerByUuid(String uuid)
```
Get ConceptAnswer by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptNameByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptName getConceptNameByUuid(String uuid)
```
Get ConceptName by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptSetByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptSet getConceptSetByUuid(String uuid)
```
Get ConceptSet by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptSourceByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concept Sources")
ConceptSource getConceptSourceByUuid(String uuid)
```
Get ConceptSource by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

saveConceptClass

@Authorized(value="Manage Concept Classes")
ConceptClass saveConceptClass(ConceptClass cc)
                                                                   throws APIException

Creates or updates a concept class

Parameters:: cc - ConceptClass to create or update
Throws:: APIException

purgeConceptClass

@Authorized(value="Purge Concept Classes")
void purgeConceptClass(ConceptClass cc)
                                                           throws APIException

Purge a ConceptClass

Parameters:: cc - ConceptClass to delete
Throws:: APIException

saveConceptDatatype

@Authorized(value="Manage Concept Datatypes")
ConceptDatatype saveConceptDatatype(ConceptDatatype cd)
                                                                           throws APIException

Create or update a ConceptDatatype

Parameters:: cd - ConceptDatatype to create or update
Throws:: APIException

purgeConceptDatatype

@Authorized(value="Purge Concept Datatypes")
void purgeConceptDatatype(ConceptDatatype cd)
                                                                throws APIException

Purge a ConceptDatatype. This removes the concept datatype from the database completely.

Parameters:: cd - ConceptDatatype to purge
Throws:: APIException

getAllConceptDatatypes

@Transactional(readOnly=true)
 @Authorized(value="View Concept Datatypes")
List<ConceptDatatype> getAllConceptDatatypes()
                                                                                                                 throws APIException

Return a list of all concept datatypes currently in the database

Returns:: List of ConceptDatatypes
Throws:: APIException

getAllConceptDatatypes

@Transactional(readOnly=true)
 @Authorized(value="View Concept Datatypes")
List<ConceptDatatype> getAllConceptDatatypes(boolean includeRetired)
                                                                                                                 throws APIException

Return a list of concept datatypes currently in the database

Parameters:: includeRetired - boolean - include the retired datatypes?
Returns:: List of ConceptDatatypes
Throws:: APIException

getConceptDatatypes

@Transactional(readOnly=true)
 @Authorized(value="View Concept Datatypes")
 @Deprecated
List<ConceptDatatype> getConceptDatatypes(String name)
                                                                                                                           throws APIException

Deprecated. you *probably* want to use getConceptDatatypeByName(String)

Find concept datatypes that contain the given name string

Parameters:: name -
Returns:: List object of ConceptDatatypes matching the string
Throws:: APIException

getConceptDatatype

@Transactional(readOnly=true)
 @Authorized(value="View Concept Datatypes")
ConceptDatatype getConceptDatatype(Integer i)
                                                                                                       throws APIException

Return a ConceptDatatype matching the given identifier

Parameters:: i - Integer for the requested ConceptDatatype
Returns:: ConceptDatatype matching the given identifier
Throws:: APIException

getConceptDatatypeByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concept Datatypes")
ConceptDatatype getConceptDatatypeByUuid(String uuid)
```
Get ConceptDatatype by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptDatatypeByName

@Transactional(readOnly=true)
 @Authorized(value="View Concept Datatypes")
ConceptDatatype getConceptDatatypeByName(String name)
                                                                                                             throws APIException

Return a Concept datatype matching the given name

Parameters:: name -
Returns:: ConceptDatatype matching the given name
Throws:: APIException
Should:: return an exact match on name, not return a fuzzy match on name

updateConceptSetDerived

@Authorized(value="Manage Concepts")
void updateConceptSetDerived(Concept concept)
                                                           throws APIException

Updates the concept set derived business table for this concept (bursting the concept sets)

Parameters:: concept -
Throws:: APIException

updateConceptSetDerived

@Authorized(value="Manage Concepts")
void updateConceptSetDerived()
                                                           throws APIException

Iterates over all concepts calling updateConceptSetDerived(concept)

Throws:: APIException

getConceptSets

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptSet> getConceptSets(Concept concept)
                                                                                                        throws APIException

Deprecated. use getConceptSetsByConcept(Concept)

Throws:: APIException

getConceptSetsByConcept
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptSet> getConceptSetsByConcept(Concept concept)
                                                                                                    throws APIException
```
Return a list of the concept sets with concept_set matching concept
For example to find all concepts for ARVs, you would do getConceptSets(getConcept("ANTIRETROVIRAL MEDICATIONS")) and then take the conceptIds from the resulting list.

Parameters:

concept - The concept representing the concept set

Returns:

A List object containing all matching ConceptSets

Throws:

APIException

getConceptsInSet

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsInSet(Concept concept)
                                                                                                       throws APIException

Deprecated. use getConceptsByConceptSet(Concept)

Throws:: APIException

getConceptsByConceptSet

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByConceptSet(Concept concept)
                                                                                                 throws APIException

Return a List of all concepts within a concept set

Parameters:: concept - The concept representing the concept set
Returns:: A List object containing all objects within the ConceptSet
Throws:: APIException

getSetsContainingConcept

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptSet> getSetsContainingConcept(Concept concept)
                                                                                                     throws APIException

Find all sets that the given concept is a member of

Parameters:: concept -
Returns:: A List object with all parent concept sets
Throws:: APIException

getConceptProposals

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
List<ConceptProposal> getConceptProposals(boolean includeCompleted)
                                                                                                                           throws APIException

Deprecated. use getAllConceptProposals(boolean)

Throws:: APIException

getAllConceptProposals

@Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
List<ConceptProposal> getAllConceptProposals(boolean includeCompleted)
                                                                                                                 throws APIException

Get a List of all concept proposals

Parameters:: includeCompleted - boolean - include completed proposals as well?
Returns:: a List object of all found ConceptProposals
Throws:: APIException

getConceptNumericByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptNumeric getConceptNumericByUuid(String uuid)
```
Get ConceptNumeric by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptProposal

@Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
ConceptProposal getConceptProposal(Integer conceptProposalId)
                                                                                                       throws APIException

Get a ConceptProposal by conceptProposalId

Parameters:: conceptProposalId - the Integer concept proposal Id
Returns:: the found ConceptProposal
Throws:: APIException

getConceptProposals

@Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
List<ConceptProposal> getConceptProposals(String text)
                                                                                                              throws APIException

Find matching concept proposals

Parameters:: text -
Returns:: a List object containing matching concept proposals
Throws:: APIException

findProposedConcepts

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
List<Concept> findProposedConcepts(String text)
                                                                                                                    throws APIException

Deprecated. Use getProposedConcepts(String)

Throws:: APIException

getProposedConcepts

@Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
List<Concept> getProposedConcepts(String text)
                                                                                                      throws APIException

Find matching proposed concepts

Parameters:: text -
Returns:: a List object containing matching proposed concepts
Throws:: APIException

findConcepts

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> findConcepts(String phrase,
                                                                                                              List<Locale> searchLocales,
                                                                                                              boolean includeRetired,
                                                                                                              List<ConceptClass> requireClasses,
                                                                                                              List<ConceptClass> excludeClasses,
                                                                                                              List<ConceptDatatype> requireDatatypes,
                                                                                                              List<ConceptDatatype> excludeDatatypes)

Deprecated. use getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)

proposeConcept

@Deprecated
 @Authorized(value="Add Concept Proposals")
void proposeConcept(ConceptProposal conceptProposal)
                                                                     throws APIException

Deprecated. use saveConceptProposal(ConceptProposal)

Throws:: APIException

saveConceptProposal

@Authorized(value={"Add Concept Proposals","Edit Concept Proposals"})
ConceptProposal saveConceptProposal(ConceptProposal conceptProposal)
                                                                                                   throws APIException

Saves/updates/proposes a concept proposal

Parameters:: conceptProposal - The ConceptProposal to save
Returns:: the saved/updated ConceptProposal object
Throws:: APIException

purgeConceptProposal

@Authorized(value="Purge Concept Proposals")
void purgeConceptProposal(ConceptProposal cp)
                                                                throws APIException

Removes a concept proposal from the database entirely.

Parameters:: cp -
Throws:: APIException

mapConceptProposalToConcept

@Authorized(value="Manage Concepts")
Concept mapConceptProposalToConcept(ConceptProposal cp,
                                                                         Concept mappedConcept)
                                                                  throws APIException

Maps a concept proposal to a concept

Parameters:: cp -; mappedConcept -
Returns:: the mappedConcept
Throws:: APIException
Should:: not require mapped concept on reject action, allow rejecting proposals, throw APIException when mapping to null concept

mapConceptProposalToConcept

@Authorized(value="Manage Concepts")
Concept mapConceptProposalToConcept(ConceptProposal cp,
                                                                         Concept mappedConcept,
                                                                         Locale locale)
                                                                  throws APIException

Maps a concept proposal to a concept

Parameters:: cp -; mappedConcept -; locale - of concept proposal
Returns:: the mappedConcept
Throws:: APIException
Since:: 1.8.5
Should:: not require mapped concept on reject action, allow rejecting proposals, throw APIException when mapping to null concept, set value coded name when add synonym is selected, not set value coded name when add concept is selected, fail when adding a duplicate syonymn

rejectConceptProposal

@Deprecated
 @Authorized(value="Edit Concept Proposals")
void rejectConceptProposal(ConceptProposal cp)
                                                                             throws APIException

Deprecated. use ConceptProposal.rejectConceptProposal()

Throws:: APIException

findMatchingConceptProposals

@Deprecated
 @Authorized(value="Add Concept Proposals")
List<ConceptProposal> findMatchingConceptProposals(String text)

Deprecated. use getConceptProposals(String)

findConceptAnswers

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptWord> findConceptAnswers(String phrase,
                                                                                                                    Locale locale,
                                                                                                                    Concept concept,
                                                                                                                    boolean includeRetired)
                                                                                                             throws APIException

Deprecated. use findConceptAnswers(String, Locale, Concept)

Throws:: APIException

getConceptAnswers

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
 @Deprecated
List<ConceptWord> getConceptAnswers(String phrase,
                                                                                                                   Locale locale,
                                                                                                                   Concept concept)
                                                                                                            throws APIException

Deprecated. use findConceptAnswers(String, Locale, Concept)

Throws:: APIException

getQuestionsForAnswer

@Deprecated
 @Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getQuestionsForAnswer(Concept concept)
                                                                                                            throws APIException

Deprecated. use #getConceptsByAnswer(Concept)

Throws:: APIException

getConceptsByAnswer
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByAnswer(Concept concept)
                                                                                             throws APIException
```
Returns all possible Concepts to which this concept is a value-coded answer. To navigate in the other direction, i.e., from Concept to its answers use Concept.getAnswers()

Parameters:

concept -

Returns:

A List containing all possible questions to which this concept is a valued_Coded answer

Throws:

APIException

getPrevConcept

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getPrevConcept(Concept concept)
                                                                                  throws APIException

Finds the previous concept in the dictionary that has the next lowest concept id

Parameters:: concept - the offset Concept
Returns:: the foundConcept
Throws:: APIException

getNextConcept

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getNextConcept(Concept concept)
                                                                                  throws APIException

Finds the next concept in the dictionary that has the next largest concept id

Parameters:: concept - the offset Concept
Returns:: the foundConcept
Throws:: APIException

checkIfLocked
```
@Transactional(readOnly=true)
void checkIfLocked()
                                          throws ConceptsLockedException
```
Check if the concepts are locked and if so, throw exception during manipulation of concept

Throws:

ConceptsLockedException

getConceptProposalByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concept Proposals")
ConceptProposal getConceptProposalByUuid(String uuid)
```
Get ConceptProposal by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptsWithDrugsInFormulary

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsWithDrugsInFormulary()
                                                                                                         throws APIException

Convenience method for finding concepts associated with drugs in formulary.

Returns:: A List object of all concepts that occur as a Drug.concept.
Throws:: APIException

updateConceptWord

@Deprecated
 @Authorized(value="Manage Concepts")
void updateConceptWord(Concept concept)
                                                                  throws APIException

Deprecated. use updateConceptWord(Concept)

Throws:: APIException

updateConceptWords

@Deprecated
 @Authorized(value="Manage Concepts")
void updateConceptWords()
                                                                   throws APIException

Deprecated. use updateConceptWords()

Throws:: APIException

getConceptNameTagByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptNameTag getConceptNameTagByUuid(String uuid)
```
Get ConceptNameTag by its UUID

Parameters:

uuid -

Returns:

the conceptNameTag with a matching uuid

See Also:

Concept.setPreferredName(ConceptName), Concept.setFullySpecifiedName(ConceptName), Concept.setShortName(ConceptName)

Should:

find object given valid uuid, return null if no object found with given uuid

updateConceptWords

@Deprecated
 @Authorized(value="Manage Concepts")
void updateConceptWords(Integer conceptIdStart,
                                                                          Integer conceptIdEnd)
                                                                   throws APIException

Deprecated. use updateConceptIndexes(Integer, Integer)

Throws:: APIException

getConceptComplex
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptComplex getConceptComplex(Integer conceptId)
```
Get a ComplexConcept with the given conceptId

Parameters:

conceptId - of the ComplexConcept

Returns:

a ConceptComplex object

Since:

1.5

Should:

return a concept complex object

getConceptNameTagByName
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptNameTag getConceptNameTagByName(String tag)
```
Search for a ConceptNameTag by name

Parameters:

tag - String name of ConceptNameTag

Returns:

ConceptNameTag matching the given String tag

See Also:

Concept.getPreferredName(Locale), Concept.getFullySpecifiedName(Locale), Concept.getShortNameInLocale(Locale), Concept.getShortestName(Locale, Boolean)

getLocalesOfConceptNames
```
@Transactional(readOnly=true)
Set<Locale> getLocalesOfConceptNames()
```
Gets the set of unique Locales used by existing concept names.

Returns:

set of used Locales

getAllConceptSources

@Transactional(readOnly=true)
 @Authorized(value="View Concept Sources")
List<ConceptSource> getAllConceptSources()
                                                                                                           throws APIException

Return a list of concept sources currently in the database that are not voided

Returns:: List of Concept source objects
Throws:: APIException

getConceptSource

@Transactional(readOnly=true)
 @Authorized(value="View Concept Sources")
ConceptSource getConceptSource(Integer i)
                                                                                                 throws APIException

Return a Concept source matching the given concept source id

Parameters:: i - Integer conceptSourceId
Returns:: ConceptSource
Throws:: APIException

saveConceptSource
```
@Authorized(value="Manage Concept Sources")
ConceptSource saveConceptSource(ConceptSource conceptSource)
                                                                     throws APIException
```
Create a new ConceptSource

Parameters:

conceptSource - ConceptSource to create

Throws:

APIException

Should:

not set creator if one is supplied already, not set date created if one is supplied already, save a ConceptSource with a null hl7Code, not save a ConceptSource if voided is null

purgeConceptSource

@Authorized(value="Purge Concept Sources")
ConceptSource purgeConceptSource(ConceptSource cs)
                                                                     throws APIException

Delete ConceptSource

Parameters:: cs - ConceptSource object delete
Throws:: APIException

retireConceptSource
```
@Authorized(value="Purge Concept Sources")
ConceptSource retireConceptSource(ConceptSource cs,
                                                                             String reason)
                                                                      throws APIException
```
This effectively removes a concept source from the database. The source can still be referenced by old data, but no new data should use this source.

Parameters:

cs - the concept source to retire

reason - why the concept source is to be retired, must not be empty of null

Returns:

the retired concept source

Throws:

APIException

Should:

retire concept source

saveConceptNameTag
```
@Authorized(value="Manage Concept Name tags")
ConceptNameTag saveConceptNameTag(ConceptNameTag nameTag)
```
Creates a new Concept name tag if none exists. If a tag exists with the same name then that existing tag is returned.

Parameters:

nameTag - the concept name tag to be saved

Returns:

the newly created or existing concept name tag

Should:

save a concept name tag if tag does not exist, not save a concept name tag if tag exists

getMaxConceptId
```
@Transactional(readOnly=true)
Integer getMaxConceptId()
```
Gets the highest concept-id used by a concept.

Returns:

highest concept-id

conceptIterator
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Iterator<Concept> conceptIterator()
```
Returns an iterator for all concepts, including retired and expired.

Returns:

the Iterator

Should:

start with the smallest concept id, iterate over all concepts

getConceptByMapping
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConceptByMapping(String code,
                                                                                              String sourceName)
                                                                                       throws APIException
```
Looks up a concept via ConceptMap This will return the Concept which contains a ConceptMap entry whose sourceCode is equal to the passed conceptCode and whose ConceptSource has either a name or hl7Code that is equal to the passed mappingCode. Delegates to getConceptByMapping(code,sourceName,includeRetired) with includeRetired=true

Parameters:

code - the code associated with a concept within a given ConceptSource

sourceName - the name or hl7Code of the ConceptSource to check

Returns:

the Concept that has the given mapping, or null if no Concept found

Throws:

APIException

Should:

get concept with given code and and source hl7 code, get concept with given code and source name, return null if source code does not exist, return null if mapping does not exist

getConceptByMapping
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Concept getConceptByMapping(String code,
                                                                                              String sourceName,
                                                                                              Boolean includeRetired)
                                                                                       throws APIException
```
Looks up a concept via ConceptMap This will return the Concept which contains a ConceptMap entry whose sourceCode is equal to the passed conceptCode and whose ConceptSource has either a name or hl7Code that is equal to the passed mappingCode . Operates under the assumption that each mappingCode in a ConceptSource references one and only one non-retired {@link Concept): if the underlying dao method returns more than one non-retired concept, this method will throw an exception; if the underlying dao method returns more than one concept, but only one non-retired concept, this method will return the non-retired concept; if the dao only returns retired concepts, this method will simply return the first concept in the list returns by the dao method; retired concepts can be excluded by setting the includeRetired parameter to false, but the above logic still applies

Parameters:

code - the code associated with a concept within a given ConceptSource

sourceName - the name or hl7Code of the ConceptSource to check

includeRetired - whether or not to include retired concepts

Returns:

the Concept that has the given mapping, or null if no Concept found

Throws:

APIException

Should:

get concept with given code and and source hl7 code, get concept with given code and source name, return null if source code does not exist, return null if mapping does not exist

getConceptsByMapping
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByMapping(String code,
                                                                                                     String sourceName)
                                                                                              throws APIException
```
Looks up a concept via ConceptMap This will return the list of concepts Concepts which contain a ConceptMap entry whose sourceCode is equal to the passed conceptCode and whose ConceptSource has either a name or hl7Code that is equal to the passed mappingCode

Parameters:

code - the code associated with a concept within a given ConceptSource

sourceName - the name or hl7Code of the ConceptSource to check

Returns:

the list of non-voided Concepts that has the given mapping, or null if no Concept found

Throws:

APIException - if the specified source+code maps to more than one concept

Since:

1.8

Should:

get concepts with given code and and source hl7 code, get concepts with given code and source name, return empty list if source code does not exist, return empty list if mapping does not exist, include retired concepts

getConceptsByMapping
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByMapping(String code,
                                                                                                     String sourceName,
                                                                                                     boolean includeRetired)
                                                                                              throws APIException
```
Looks up a concept via ConceptMap This will return the list of Concepts which contain a ConceptMap entry whose sourceCode is equal to the passed conceptCode and whose ConceptSource has either a name or hl7Code that is equal to the passed mappingCode. Delegates to getConceptsByMapping(code,sourceName,includeRetired) with includeRetired=true

Parameters:

code - the code associated with a concept within a given ConceptSource

sourceName - the name or hl7Code of the ConceptSource to check

includeRetired - whether or not to include retired concepts

Returns:

the list of non-voided Concepts that has the given mapping, or null if no Concept found

Throws:

APIException - if the specified source+code maps to more than one concept

Since:

1.8

Should:

get concepts with given code and and source hl7 code, get concepts with given code and source name, return empty list if source code does not exist, return empty list if mapping does not exist

getAllConceptNameTags
```
@Transactional(readOnly=true)
List<ConceptNameTag> getAllConceptNameTags()
```
Get all the concept name tags defined in the database, included voided ones

Returns:

a list of the concept name tags stored in the

Since:

1.5

getConceptNameTag
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptNameTag getConceptNameTag(Integer id)
```
Gets the ConceptNameTag with the given database primary key

Parameters:

id - the concept name tag id to find

Returns:

the matching ConceptNameTag or null if none found

Since:

1.5

getConceptDescriptionByUuid
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptDescription getConceptDescriptionByUuid(String uuid)
```
Get ConceptDescription by its UUID

Parameters:

uuid -

Returns:

Should:

find object given valid uuid, return null if no object found with given uuid

getConceptSourceByName

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
ConceptSource getConceptSourceByName(String conceptSourceName)
                                                                                                throws APIException

Lookup a ConceptSource by its name property

Parameters:: conceptSourceName -
Returns:: ConceptSource
Throws:: APIException
Should:: get ConceptSource with the given name, return null if no ConceptSource with that name is found

getConceptsByConceptSource

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptMap> getConceptsByConceptSource(ConceptSource conceptSource)
                                                                                                       throws APIException

Looks up a list of ConceptMaps for a given ConceptSource

Parameters:: conceptSource -
Returns:: a List object
Throws:: APIException
Should:: return a List of ConceptMaps if concept mappings found, return empty List of ConceptMaps if none found

hasAnyObservation
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
boolean hasAnyObservation(Concept concept)
```
Checks if there are any observations (including voided observations) for a concept.

Parameters:

concept - which used or not used by an observation

Returns:

boolean true if the concept is used by an observation

Throws:

APIException

getTrueConcept
```
@Transactional(readOnly=true)
Concept getTrueConcept()
```
Returns the TRUE concept

Returns:

true concept

Should:

return the true concept

getFalseConcept
```
@Transactional(readOnly=true)
Concept getFalseConcept()
```
Returns the FALSE concept

Returns:

false concept

Should:

return the false concept

convertBooleanConceptToCoded
```
@Authorized(value="Manage Concepts")
void convertBooleanConceptToCoded(Concept conceptToChange)
                                                                throws APIException
```
Changes the datatype of a concept from boolean to coded when it has observations it is associated to.

Parameters:

conceptToChange - the concept which to change

Throws:

APIException

Should:

convert the datatype of a boolean concept to coded, fail if the datatype of the concept is not boolean, explicitly add true concept as a value_Coded answer, explicitly add false concept as a value_Coded answer

hasAnyObservation
```
@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
boolean hasAnyObservation(ConceptName conceptName)
                                                                                     throws APIException
```
Checks if there are any observations (including voided observations) using a conceptName.

Parameters:

conceptName - which is used or not used by an observation

Returns:

boolean true if the conceptName is used by an observation otherwise false

Throws:

APIException

Since:

Version 1.7

getConcepts

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptSearchResult> getConcepts(String phrase,
                                                                                                        List<Locale> locales,
                                                                                                        boolean includeRetired,
                                                                                                        List<ConceptClass> requireClasses,
                                                                                                        List<ConceptClass> excludeClasses,
                                                                                                        List<ConceptDatatype> requireDatatypes,
                                                                                                        List<ConceptDatatype> excludeDatatypes,
                                                                                                        Concept answersToConcept,
                                                                                                        Integer start,
                                                                                                        Integer size)
                                                                                                 throws APIException

Searches for concepts by the given parameters

Parameters:: phrase - matched to the start of any word in any of the names of a concept; locales - List to restrict to; includeRetired - boolean if false, will exclude retired concepts; requireClasses - List to restrict to; excludeClasses - List to leave out of results; requireDatatypes - List to restrict to; excludeDatatypes - List to leave out of results; answersToConcept - all results will be a possible answer to this concept; start - all results less than this number will be removed; size - if non zero, all results after start + size will be removed
Returns:: a list of conceptSearchResults
Throws:: APIException
Since:: 1.8
Should:: return the best matched name as the first item in the searchResultsList, return concept search results that match unique concepts, return a search result whose concept name contains all word tokens

findConceptAnswers

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptSearchResult> findConceptAnswers(String phrase,
                                                                                                               Locale locale,
                                                                                                               Concept concept)
                                                                                                        throws APIException

Finds concepts that are possible value coded answers to concept parameter

Parameters:: phrase -; locale -; concept - the answers to match on
Returns:: a list of conceptSearchResults
Throws:: APIException
Since:: 1.8

updateConceptIndex
```
@Authorized(value="Manage Concepts")
void updateConceptIndex(Concept concept)
                                                      throws APIException
```
Iterates over the words in names and synonyms (for each locale) and updates the concept index, note that this only updates the index of the specified concept. Use updateConceptIndexes() if you wish to update the entire concept index.

Parameters:

concept - the concept whose index is to be updated

Throws:

APIException

Since:

1.8

updateConceptIndexes

@Authorized(value="Manage Concepts")
void updateConceptIndexes()
                                                        throws APIException

Iterates over all concepts and calls upddateConceptIndexes(Concept concept)

Throws:: APIException
Since:: 1.8

updateConceptIndexes

@Authorized(value="Manage Concepts")
void updateConceptIndexes(Integer conceptIdStart,
                                                               Integer conceptIdEnd)
                                                        throws APIException

Iterates over all concepts with conceptIds between conceptIdStart and conceptIdEnd (inclusive) and calls updateConceptIndexes(concept)

Parameters:: conceptIdStart - starts update with this concept_id; conceptIdEnd - ends update with this concept_id
Throws:: APIException
Since:: 1.8

getConcepts

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<ConceptSearchResult> getConcepts(String phrase,
                                                                                                        Locale locale,
                                                                                                        boolean includeRetired)
                                                                                                 throws APIException

Searches for concepts with the given parameters

Parameters:: phrase - the string to search against; locale - the locale in which to search for the concepts; includeRetired - Specifies whether to include retired concepts
Returns:: a list ConceptSearchResults
Throws:: APIException
Since:: 1.8

getCountOfConcepts

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Integer getCountOfConcepts(String phrase,
                                                                                             List<Locale> locales,
                                                                                             boolean includeRetired,
                                                                                             List<ConceptClass> requireClasses,
                                                                                             List<ConceptClass> excludeClasses,
                                                                                             List<ConceptDatatype> requireDatatypes,
                                                                                             List<ConceptDatatype> excludeDatatypes,
                                                                                             Concept answersToConcept)

Return the number of concepts matching a search phrase and the specified arguments

Parameters:: phrase - matched to the start of any word in any of the names of a concept; locales - List to restrict to; includeRetired - Specifies whether to include retired concepts; requireClasses - List to restrict to; excludeClasses - List to leave out of results; requireDatatypes - List to restrict to; excludeDatatypes - List to leave out of results; answersToConcept - all results will be a possible answer to this concept
Returns:: the number of concepts matching the given search phrase
Throws:: APIException
Since:: 1.8

getCountOfDrugs

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
Integer getCountOfDrugs(String drugName,
                                                                                          Concept concept,
                                                                                          boolean searchOnPhrase,
                                                                                          boolean searchDrugConceptNames,
                                                                                          boolean includeRetired)
                                                                                   throws APIException

Return the number of drugs with matching names or concept drug names

Parameters:: drugName - the name of the drug; concept - the drug concept; searchOnPhrase - Specifies if the search should match names starting with or contain the text; searchDrugConceptNames - Specifies whether a search on concept names for the drug's concept should be done or not; includeRetired - specifies whether to include retired drugs
Returns:: the number of matching drugs
Throws:: APIException
Since:: 1.8

getDrugs

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Drug> getDrugs(String drugName,
                                                                                      Concept concept,
                                                                                      boolean searchOnPhrase,
                                                                                      boolean searchDrugConceptNames,
                                                                                      boolean includeRetired,
                                                                                      Integer start,
                                                                                      Integer length)
                                                                               throws APIException

Returns a list of drugs with matching names or concept drug names 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:: drugName - the name of the drug; concept - the drug concept; searchOnPhrase - Specifies if the search should match names starting with or contain the text; searchDrugConceptNames - Specifies whether a search on concept names for the drug's concept should be done or not; includeRetired - specifies whether to include retired drugs; start - beginning index for the batch; length - number of drugs to return in the batch
Returns:: a list of matching drugs
Throws:: APIException
Since:: 1.8

getConceptsByName

@Transactional(readOnly=true)
 @Authorized(value="View Concepts")
List<Concept> getConceptsByName(String name,
                                                                                                  Locale locale,
                                                                                                  Boolean exactLocale)
                                                                                           throws APIException

Returns a list of concepts with the same name in the given locale.

This method is case insensitive. It searches for exactly matching names and close matching locales (if exactLocale = false). It considers only non-voided names and all concepts.

Parameters:: name -; locale - null = all locales; exactLocale - false if search for both global and country specific, true if null
Returns:: the list of concepts
Throws:: APIException
Since:: 1.9, 1.8.4
Should:: return concepts for all countries and global language given language only locale, return concepts for specific country and global language given language and country locale

Interface ConceptService

Method Summary

Methods inherited from interface org.openmrs.api.OpenmrsService

Method Detail

setConceptDAO

createConcept

createConcept

updateConcept

getConceptByUuid

updateConcept

createDrug

updateDrug

deleteConcept

voidConcept

saveConcept

saveDrug

purgeConcept

retireConcept

retireDrug

unretireDrug

purgeDrug

getConcept

getConceptName

getConceptAnswer

getDrug

getConceptNumeric

getConceptClass

getAllConcepts

getAllConcepts

getConcepts

getConceptsByName

getConceptByName

getConceptByIdOrName

getConcept

getConceptWords

getConceptWords

findConcepts

findConcepts

getDrugByUuid

findConcepts

getDrug

getDrugByNameOrId

getDrugs

getAllDrugs

getDrugs

getDrugsByConcept

getAllDrugs

findDrugs

getDrugs

getConceptsByClass

getConceptClasses

getConceptClassByName

getAllConceptClasses

getAllConceptClasses

getConceptClassByUuid

getConceptAnswerByUuid

getConceptNameByUuid

getConceptSetByUuid

getConceptSourceByUuid

saveConceptClass

purgeConceptClass

saveConceptDatatype

purgeConceptDatatype

getAllConceptDatatypes

getAllConceptDatatypes

getConceptDatatypes

getConceptDatatype

getConceptDatatypeByUuid

getConceptDatatypeByName

updateConceptSetDerived

updateConceptSetDerived

getConceptSets

getConceptSetsByConcept

getConceptsInSet

getConceptsByConceptSet

getSetsContainingConcept

getConceptProposals

getAllConceptProposals

getConceptNumericByUuid

getConceptProposal