ConceptService (OpenMRS 2.7.0-SNAPSHOT API)

All Superinterfaces:: OpenmrsService

All Known Implementing Classes:: ConceptServiceImpl

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
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`	`deleteConceptStopWord(Integer conceptStopWordId)` Delete the given `ConceptStopWord` in the database
`List<ConceptSearchResult>`	`findConceptAnswers(String phrase, Locale locale, Concept concept)` Finds concepts that are possible value coded answers to concept parameter
`List<ConceptMapType>`	`getActiveConceptMapTypes()` Returns a list of concept map types currently in the database excluding hidden ones
`List<ConceptAttributeType>`	`getAllConceptAttributeTypes()`
`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<ConceptReferenceTerm>`	`getAllConceptReferenceTerms()` Gets a list of all concept reference terms saved in the database
`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(boolean includeRetired)` Return a list of concept sources currently in the database Whether or not to return retired concept sources is decided by the boolean includeRetired param
`List<ConceptStopWord>`	`getAllConceptStopWords()` Get all the concept stop words
`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
`ConceptAttribute`	`getConceptAttributeByUuid(String uuid)`
`ConceptAttributeType`	`getConceptAttributeType(Integer id)`
`ConceptAttributeType`	`getConceptAttributeTypeByName(String exactName)` Retrieves a ConceptAttributeType object based on the name provided
`ConceptAttributeType`	`getConceptAttributeTypeByUuid(String uuid)`
`List<ConceptAttributeType>`	`getConceptAttributeTypes(String name)` Find concept attribute types matching the given parameters.
`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`	`getConceptByReference(String conceptRef)` Get the concept by conceptRef where the conceptRef can either be: 1) an integer id like 5090 2) a mapping type id like "XYZ:HT" 3) a uuid like "a3e12268-74bf-11df-9768-17cfc9833272" 4) a name like "PLATELETS" 5) the fully qualified name of a Java constant which contains one of the above
`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
`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
`ConceptDescription`	`getConceptDescriptionByUuid(String uuid)` Get ConceptDescription by its UUID
`List<Integer>`	`getConceptIdsByMapping(String code, String sourceName, boolean includeRetired)` Looks up concepts via `ConceptMap` This will return the list of ids for all `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<ConceptMap>`	`getConceptMappingsToSource(ConceptSource conceptSource)` Returns a list of mappings from concepts to terms in the given reference terminology
`ConceptMapType`	`getConceptMapType(Integer conceptMapTypeId)` Return a concept map type matching the given concept map type id
`ConceptMapType`	`getConceptMapTypeByName(String name)` Return a concept map type matching the given name
`ConceptMapType`	`getConceptMapTypeByUuid(String uuid)` Return a concept map type matching the given uuid
`List<ConceptMapType>`	`getConceptMapTypes(boolean includeRetired, boolean includeHidden)` Returns a list of concept map types currently in the database including or excluding retired and hidden ones as specified by the includeRetired and includeHidden arguments
`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(String text)` Find matching concept proposals
`ConceptReferenceTerm`	`getConceptReferenceTerm(Integer conceptReferenceTermId)` Gets the concept reference term with the specified concept reference term id
`ConceptReferenceTerm`	`getConceptReferenceTermByCode(String code, ConceptSource conceptSource)` Gets a concept reference term with the specified code from the specified concept source
`List<ConceptReferenceTerm>`	`getConceptReferenceTermByCode(String code, ConceptSource conceptSource, boolean includeRetired)` Gets a list of concept reference terms with the specified code from the specified concept source
`ConceptReferenceTerm`	`getConceptReferenceTermByName(String name, ConceptSource conceptSource)` Gets a concept reference term with the specified name from the specified concept source ignoring all retired ones
`ConceptReferenceTerm`	`getConceptReferenceTermByUuid(String uuid)` Gets the concept reference term with the specified uuid
`List<ConceptReferenceTerm>`	`getConceptReferenceTerms(boolean includeRetired)` Gets a list of concept reference terms saved in the database
`List<ConceptReferenceTerm>`	`getConceptReferenceTerms(String query, ConceptSource conceptSource, Integer start, Integer length, boolean includeRetired)` Finds the concept reference term in the database that have a code or name that contains the specified search phrase.
`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>`	`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<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>`	`getConceptSetsByConcept(Concept concept)` 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.
`ConceptSource`	`getConceptSource(Integer i)` Return a Concept source matching the given concept source id
`ConceptSource`	`getConceptSourceByHL7Code(String hl7Code)` Get a ConceptSource by its hl7Code.
`ConceptSource`	`getConceptSourceByName(String conceptSourceName)` Lookup a ConceptSource by its name property
`ConceptSource`	`getConceptSourceByUniqueId(String uniqueId)` Get a ConceptSource by its unique id.
`ConceptSource`	`getConceptSourceByUuid(String uuid)` Get ConceptSource by its UUID
`List<String>`	`getConceptStopWords(Locale locale)` Gets the list of `ConceptStopWord` for given locale
`List<Concept>`	`getConceptsWithDrugsInFormulary()` Convenience method for finding concepts associated with drugs in formulary.
`Integer`	`getCountOfConceptReferenceTerms(String query, ConceptSource conceptSource, boolean includeRetired)` Returns the count of concept reference terms that match the specified arguments
`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
`ConceptMapType`	`getDefaultConceptMapType()` Gets the concept map type to be used as the default.
`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`	`getDrugByMapping(String code, ConceptSource conceptSource, Collection<ConceptMapType> withAnyOfTheseTypesOrOrderOfPreference)` Gets the "best" matching drug, i.e. matching the earliest ConceptMapType passed in e.g.
`Drug`	`getDrugByUuid(String uuid)` Get Drug by its UUID
`DrugIngredient`	`getDrugIngredientByUuid(String uuid)` Get Drug Ingredient by its UUID
`List<Drug>`	`getDrugs(String phrase)` Find drugs in the system.
`List<Drug>`	`getDrugs(String drugName, Concept concept, boolean searchKeywords, 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>`	`getDrugs(String searchPhrase, Locale locale, boolean exactLocale, boolean includeRetired)` Fetches un retired drugs that match the specified search phrase.
`List<Drug>`	`getDrugsByConcept(Concept concept)` Return a list of drugs associated with the given concept
`List<Drug>`	`getDrugsByIngredient(Concept ingredient)` Gets drugs by the given ingredient, which can be either the drug itself or any ingredient.
`List<Drug>`	`getDrugsByMapping(String code, ConceptSource conceptSource, Collection<ConceptMapType> withAnyOfTheseTypes, boolean includeRetired)` Fetches all drugs with reference mappings to the specified concept source that match the specified code and concept map types
`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
`List<ConceptSearchResult>`	`getOrderableConcepts(String phrase, List<Locale> locales, boolean includeRetired, Integer start, Integer length)` An Orderable concept is one where its conceptClass has a mapping in the order_type_class_map table.
`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<ConceptReferenceTermMap>`	`getReferenceTermMappingsTo(ConceptReferenceTerm term)` Fetches all the `ConceptReferenceTermMap` where the specified reference term is the termB i.e mappings added to other terms pointing to it
`List<ConceptSet>`	`getSetsContainingConcept(Concept concept)` Find all sets that the given concept is a member of
`Concept`	`getTrueConcept()` Returns the TRUE concept
`Concept`	`getUnknownConcept()` Returns the UNKNOWN concept
`boolean`	`hasAnyConceptAttribute(ConceptAttributeType conceptAttributeType)`
`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.
`boolean`	`isConceptNameDuplicate(ConceptName name)` Determines if the given concept name is a duplicate.
`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`	`purgeConcept(Concept conceptOrConceptNumeric)` Completely purge a `Concept` or `ConceptNumeric` from the database.
`void`	`purgeConceptAttributeType(ConceptAttributeType conceptAttributeType)` Completely removes a concept attribute type from the database
`void`	`purgeConceptClass(ConceptClass cc)` Purge a ConceptClass
`void`	`purgeConceptMapType(ConceptMapType conceptMapType)` Completely purges a concept map type from the database
`void`	`purgeConceptNameTag(ConceptNameTag cnt)` Purge a ConceptNameTag
`void`	`purgeConceptProposal(ConceptProposal cp)` Removes a concept proposal from the database entirely.
`void`	`purgeConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)` Purges the specified concept reference term from the database
`ConceptSource`	`purgeConceptSource(ConceptSource cs)` Delete ConceptSource
`void`	`purgeDrug(Drug drug)` Completely purge a Drug from the database.
`Concept`	`retireConcept(Concept conceptOrConceptNumeric, String reason)` Retiring a concept essentially removes it from circulation
`ConceptAttributeType`	`retireConceptAttributeType(ConceptAttributeType conceptAttributeType, String reason)` Retire a concept attribute type
`ConceptMapType`	`retireConceptMapType(ConceptMapType conceptMapType, String retireReason)` Retiring a concept map type essentially removes it from circulation
`ConceptReferenceTerm`	`retireConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm, String retireReason)` Retiring a concept reference term 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 If this is a new concept, the returned concept will have a new `Concept.getConceptId()` inserted into it that was generated by the database
`ConceptAttributeType`	`saveConceptAttributeType(ConceptAttributeType conceptAttributeType)` Creates or updates the given concept attribute type in the database
`ConceptClass`	`saveConceptClass(ConceptClass cc)` Creates or updates a concept class
`ConceptMapType`	`saveConceptMapType(ConceptMapType conceptMapType)` Saves or updates the specified concept map type in the database
`ConceptNameTag`	`saveConceptNameTag(ConceptNameTag nameTag)` Creates a new Concept name tag if none exists.
`ConceptProposal`	`saveConceptProposal(ConceptProposal conceptProposal)` Saves/updates/proposes a concept proposal
`ConceptReferenceTerm`	`saveConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)` Stores the specified concept reference term to the database
`ConceptSource`	`saveConceptSource(ConceptSource conceptSource)` Create a new ConceptSource
`ConceptStopWord`	`saveConceptStopWord(ConceptStopWord conceptStopWord)` Save the given `ConceptStopWord` in the database If this is a new concept stop word, the returned concept stop word will have a new `ConceptStopWord.getConceptStopWordId()` inserted into it that was generated by the database
`Drug`	`saveDrug(Drug drug)` Save or update the given `Drug` in the database.
`void`	`setConceptDAO(ConceptDAO dao)` Sets the data access object for Concepts.
`ConceptAttributeType`	`unretireConceptAttributeType(ConceptAttributeType conceptAttributeType)` Un-Retire a concept attribute type
`ConceptMapType`	`unretireConceptMapType(ConceptMapType conceptMapType)` Marks a concept map type that is currently retired as not retired.
`ConceptReferenceTerm`	`unretireConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)` Marks a concept reference term that is currently retired as not retired.
`Drug`	`unretireDrug(Drug drug)` Marks a drug that is currently retired as not retired.
`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 updateConceptIndexes(Concept concept)

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
  - getConceptByUuid
```
@Authorized(value="Get Concepts")
Concept getConceptByUuid(String uuid)
```
    Get Concept by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept or null Should find object given valid uuid Should return null if no object found with given uuid
  - 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 Should create new concept in database Should update concept already existing in database Should generate id for new concept if none is specified Should keep id for new concept if one is specified Should save non ConceptNumeric object as conceptNumeric Should save non ConceptComplex object as conceptComplex Should save changes between concept numeric and complex Should save a ConceptNumeric as a concept Should save a new ConceptNumeric Should void the conceptName if the text of the name has changed Should create a new conceptName when the old name is changed Should set a preferred name for each locale if none is marked Should not fail when a duplicate name is edited to a unique value Should create a reference term for a concept mapping on the fly when editing a concept Should create a reference term for a concept mapping on the fly when creating a concept Should add new concept name Should not set audit info if the concept is not edited Should set audit info if an item is removed from any of its child collections Should set audit info if any item in the child collections is edited Should set audit info if an item is added to any of its child collections Should pass when saving a concept after removing a name Should save a conceptNumeric with allowDecimal 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 Should create new drug in database Should 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 purge the concept if not being used by an obs 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 - Should fail if no reason is given Should retire the given concept
  - 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 Should retire the given 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 not retired Should not change attributes of drug that is already not 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 - Should purge the given drug
  - getConcept
```
@Authorized(value="Get Concepts")
Concept getConcept(Integer conceptId)
                                              throws APIException
```
    Gets the concept with the given id
    
    Parameters:
    
    conceptId -
    
    Returns:
    
    the matching Concept object
    
    Throws:
    
    APIException
  - getConceptName
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concepts")
ConceptAnswer getConceptAnswer(Integer conceptAnswerId)
                                                          throws APIException
```
    Gets the ConceptAnswer with the given id
    
    Parameters:
    
    conceptAnswerId -
    
    Returns:
    
    the matching ConceptAnswer object
    
    Throws:
    
    APIException
  - getDrug
```
@Authorized(value="Get Concepts")
Drug getDrug(Integer drugId)
                                        throws APIException
```
    Get the Drug with the given id
    
    Parameters:
    
    drugId -
    
    Returns:
    
    the matching Drug object
    
    Throws:
    
    APIException
  - getConceptNumeric
```
@Authorized(value="Get 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
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concepts")
List<Concept> getAllConcepts()
                                                        throws APIException
```
    Return a list of unretired concepts sorted by concept id ascending and
    
    Returns:
    
    a List<Concept> object containing all of the sorted concepts
    
    Throws:
    
    APIException
  - getAllConcepts
```
@Authorized(value="Get 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<Concept> object containing all of the sorted concepts
    
    Throws:
    
    APIException - Should order by concept id and include retired when given no parameters Should order by concept id descending when set asc parameter to false Should exclude retired concepts when set includeRetired to false Should order by a concept name field Should order by a concept field
  - getConceptsByName
```
@Authorized(value="Get 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<Concept> object containing all of the matching concepts Should pass irrespective of the case of the passed parameter
    
    Throws:
    
    APIException
  - getConceptByName
```
@Authorized(value="Get Concepts")
Concept getConceptByName(String name)
                                                    throws APIException
```
    Return a Concept that matches the name exactly
    
    Parameters:
    
    name - The search string
    
    Returns:
    
    the found Concept Should get concept by name Should return null given null parameter Should find concepts with names in more specific locales Should find concepts with names in more generic locales Should find concepts with names in same specific locale Should return null given blank string
    
    Throws:
    
    APIException
  - getConcept
```
@Authorized(value="Get 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
  - getConceptByReference
```
@Authorized(value="Get Concepts")
Concept getConceptByReference(String conceptRef)
```
    Get the concept by conceptRef where the conceptRef can either be: 1) an integer id like 5090 2) a mapping type id like "XYZ:HT" 3) a uuid like "a3e12268-74bf-11df-9768-17cfc9833272" 4) a name like "PLATELETS" 5) the fully qualified name of a Java constant which contains one of the above
    
    Parameters:
    
    conceptRef - the concept string identifier
    
    Returns:
    
    the concept if it exists otherwise null
    
    Since:
    
    2.6.0
  - getDrugByUuid
```
@Authorized(value="Get Concepts")
Drug getDrugByUuid(String uuid)
```
    Get Drug by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    drug of null Should find object given valid uuid Should return null if no object found with given uuid
  - getDrugIngredientByUuid
```
@Authorized(value="Get Concepts")
DrugIngredient getDrugIngredientByUuid(String uuid)
```
    Get Drug Ingredient by its UUID
    
    Parameters:
    
    uuid - the uuid for the drug ingredient to get
    
    Returns:
    
    the drug ingredient if found, else null Should find object given valid uuid Should return null if no object found with given uuid
  - getDrug
```
@Authorized(value="Get 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 - Should return the matching drug object Should return null if no matching drug is found
  - getAllDrugs
```
@Authorized(value="Get Concepts")
List<Drug> getAllDrugs()
                                                  throws APIException
```
    Return a list of drugs currently in the database that are not retired
    
    Returns:
    
    a List<Drug> object containing all drugs Should return a list of all drugs
    
    Throws:
    
    APIException
  - getDrugsByConcept
```
@Authorized(value="Get Concepts")
List<Drug> getDrugsByConcept(Concept concept)
                                                        throws APIException
```
    Return a list of drugs associated with the given concept
    
    Parameters:
    
    concept -
    
    Returns:
    
    a List<Drug> object containing all matching drugs
    
    Throws:
    
    APIException
  - getAllDrugs
```
@Authorized(value="Get 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<Drug> object containing all matching Drugs Should return all drugs including retired ones if given true Should return all drugs excluding retired ones if given false
  - getDrugs
```
@Authorized(value="Get Concepts")
List<Drug> getDrugs(String phrase)
                                               throws APIException
```
    Find drugs in the system. The string search can match either drug.name or drug.concept.name, drug.drugId or drug.concept.conceptId
    
    Parameters:
    
    phrase - Search phrase
    
    Returns:
    
    A List<Drug> object containing all Drug matches Should not return drugs that are retired Should return drugs by drug id Should return drugs by drug concept id Should not fail if there is no drug by given id
    
    Throws:
    
    APIException
  - getConceptsByClass
```
@Authorized(value="Get Concepts")
List<Concept> getConceptsByClass(ConceptClass cc)
                                                            throws APIException
```
    Parameters:
    
    cc - ConceptClass
    
    Returns:
    
    Returns all concepts in a given class
    
    Throws:
    
    APIException - Should not fail due to no name in search
  - getConceptClassByName
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concept Classes")
List<ConceptClass> getAllConceptClasses()
                                                                          throws APIException
```
    Return a list of concept classes currently in the database
    
    Returns:
    
    List<ConceptClass> object with all ConceptClass objects Should return a list of all concept classes
    
    Throws:
    
    APIException
  - getAllConceptClasses
```
@Authorized(value="Get 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<ConceptClass> object with all ConceptClass objects Should return all concept classes including retired ones when given true Should return all concept classes excluding retired ones when given false
    
    Throws:
    
    APIException
  - getConceptClassByUuid
```
@Authorized(value="Get Concept Classes")
ConceptClass getConceptClassByUuid(String uuid)
```
    Get ConceptClass by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept class or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptAnswerByUuid
```
@Authorized(value="Get Concepts")
ConceptAnswer getConceptAnswerByUuid(String uuid)
```
    Get ConceptAnswer by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept answer or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptNameByUuid
```
@Authorized(value="Get Concepts")
ConceptName getConceptNameByUuid(String uuid)
```
    Get ConceptName by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept name or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptSetByUuid
```
@Authorized(value="Get Concepts")
ConceptSet getConceptSetByUuid(String uuid)
```
    Get ConceptSet by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept set or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptSourceByUuid
```
@Authorized(value="Get Concept Sources")
ConceptSource getConceptSourceByUuid(String uuid)
```
    Get ConceptSource by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept source or null Should find object given valid uuid Should 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 - Should save the the given ConceptClass
  - purgeConceptClass
```
@Authorized(value="Purge Concept Classes")
void purgeConceptClass(ConceptClass cc)
                                                           throws APIException
```
    Purge a ConceptClass
    
    Parameters:
    
    cc - ConceptClass to delete
    
    Throws:
    
    APIException - Should delete the given ConceptClass
  - purgeConceptNameTag
```
@Authorized(value="Manage Concept Name tags")
void purgeConceptNameTag(ConceptNameTag cnt)
                                                                throws APIException
```
    Purge a ConceptNameTag
    
    Parameters:
    
    cnt - ConceptNameTag to delete
    
    Throws:
    
    APIException
    
    Since:
    
    1.10 Should delete the specified conceptNameTag from the database
  - getAllConceptDatatypes
```
@Authorized(value="Get Concept Datatypes")
List<ConceptDatatype> getAllConceptDatatypes()
                                                                                 throws APIException
```
    Return a list of all concept datatypes currently in the database
    
    Returns:
    
    List of ConceptDatatypes Should give a list of all concept datatypes
    
    Throws:
    
    APIException
  - getAllConceptDatatypes
```
@Authorized(value="Get 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 Should return all concept datatypes including retired ones when given true Should return all concept datatypes excluding retired ones when given false
    
    Throws:
    
    APIException
  - getConceptDatatype
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concept Datatypes")
ConceptDatatype getConceptDatatypeByUuid(String uuid)
```
    Get ConceptDatatype by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept data type or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptDatatypeByName
```
@Authorized(value="Get 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 Should not return a fuzzy match on name
  - getConceptSetsByConcept
```
@Authorized(value="Get 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<ConceptSet> object containing all matching ConceptSets
    
    Throws:
    
    APIException
  - getConceptsByConceptSet
```
@Authorized(value="Get 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<Concept> object containing all objects within the ConceptSet
    
    Throws:
    
    APIException
  - getSetsContainingConcept
```
@Authorized(value="Get Concepts")
List<ConceptSet> getSetsContainingConcept(Concept concept)
                                                                     throws APIException
```
    Find all sets that the given concept is a member of
    
    Parameters:
    
    concept -
    
    Returns:
    
    A List<ConceptSet> object with all parent concept sets Should give a list of ConceptSet containing the given Concept Should give an empty list if no matching ConceptSet is found Should give an empty list if concept id is null
    
    Throws:
    
    APIException
  - getAllConceptProposals
```
@Authorized(value="Get 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<ConceptProposal> object of all found ConceptProposals
    
    Throws:
    
    APIException - Should return all concept proposals including retired ones when given true Should return all concept proposals excluding retired ones when given false
  - getConceptNumericByUuid
```
@Authorized(value="Get Concepts")
ConceptNumeric getConceptNumericByUuid(String uuid)
```
    Get ConceptNumeric by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept numeric or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptProposal
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concept Proposals")
List<ConceptProposal> getConceptProposals(String text)
                                                                              throws APIException
```
    Find matching concept proposals
    
    Parameters:
    
    text -
    
    Returns:
    
    a List<ConceptProposal> object containing matching concept proposals
    
    Throws:
    
    APIException
  - getProposedConcepts
```
@Authorized(value="Get Concept Proposals")
List<Concept> getProposedConcepts(String text)
                                                                      throws APIException
```
    Find matching proposed concepts
    
    Parameters:
    
    text -
    
    Returns:
    
    a List<Concept> object containing matching proposed concepts
    
    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 - Should purge the given concept proposal
  - 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 Should allow rejecting proposals Should 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 - Should not require mapped concept on reject action Should allow rejecting proposals Should throw APIException when mapping to null concept Should set value coded name when add synonym is selected Should not set value coded name when add concept is selected Should fail when adding a duplicate synonym
  - getConceptsByAnswer
```
@Authorized(value="Get 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<Concept> containing all possible questions to which this concept is a valued_Coded answer
    
    Throws:
    
    APIException - Should return an empty list if concept id is null
  - getPrevConcept
```
@Authorized(value="Get 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 - Should return the concept previous to the given concept
  - getNextConcept
```
@Authorized(value="Get 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 - Should return the concept next to the given concept
  - checkIfLocked
```
@Authorized(value="Get Concepts")
void checkIfLocked()
                                              throws ConceptsLockedException
```
    Check if the concepts are locked and if so, throw exception during manipulation of concept
    
    Throws:
    
    ConceptsLockedException
  - getConceptProposalByUuid
```
@Authorized(value="Get Concept Proposals")
ConceptProposal getConceptProposalByUuid(String uuid)
```
    Get ConceptProposal by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept proposal or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptsWithDrugsInFormulary
```
@Authorized(value="Get Concepts")
List<Concept> getConceptsWithDrugsInFormulary()
                                                                         throws APIException
```
    Convenience method for finding concepts associated with drugs in formulary.
    
    Returns:
    
    A List<Concept> object of all concepts that occur as a Drug.concept.
    
    Throws:
    
    APIException - Should give a list of all matching concepts
  - getConceptNameTagByUuid
```
@Authorized(value="Get 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), Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptComplex
```
@Authorized(value="Get 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
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concepts")
Set<Locale> getLocalesOfConceptNames()
```
    Gets the set of unique Locales used by existing concept names.
    
    Returns:
    
    set of used Locales Should return a list of matching locales
  - getAllConceptSources
```
@Authorized(value="Get Concept Sources")
List<ConceptSource> getAllConceptSources(boolean includeRetired)
                                                                           throws APIException
```
    Return a list of concept sources currently in the database Whether or not to return retired concept sources is decided by the boolean includeRetired param
    
    Parameters:
    
    includeRetired - whether or not to include retired sources
    
    Returns:
    
    List of Concept source objects Should return all concept sources including retired ones when given true Should return all concept sources excluding retired ones when given false
    
    Throws:
    
    APIException
  - getConceptSource
```
@Authorized(value="Get 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 Should not set date created if one is supplied already Should save a ConceptSource with a null hl7Code Should 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 - Should purge the given concept source
  - 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 Should not save a concept name tag if tag exists Should not save a concept name tag if tag is null, empty or whitespace Should save a concept name tag if tag is supplied Should save an edited concept name tag
  - getMaxConceptId
```
@Authorized(value="Get Concepts")
Integer getMaxConceptId()
```
    Gets the highest concept-id used by a concept.
    
    Returns:
    
    highest concept-id Should give the maximum concept-id
  - conceptIterator
```
@Authorized(value="Get Concepts")
Iterator<Concept> conceptIterator()
```
    Returns an iterator for all concepts, including retired and expired.
    
    Returns:
    
    the Iterator Should start with the smallest concept id Should iterate over all concepts
  - getConceptByMapping
```
@Authorized(value="Get 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 Should get concept with given code and source name Should return null if source code does not exist Should return null if mapping does not exist
  - getConceptByMapping
```
@Authorized(value="Get 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 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 Should get concept with given code and source name Should return null if source code does not exist Should return null if mapping does not exist
  - getConceptsByMapping
```
@Authorized(value="Get 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 Should get concepts with given code and and source hl7 code Should get concepts with given code and source name Should return empty list if source code does not exist Should return empty list if mapping does not exist Should include retired concepts
    
    Since:
    
    1.8
  - getConceptsByMapping
```
@Authorized(value="Get 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 Should get concepts with given code and and source hl7 code Should get concepts with given code and source name Should return empty list if source code does not exist Should return empty list if mapping does not exist
    
    Since:
    
    1.8
  - getConceptIdsByMapping
```
@Authorized(value="Get Concepts")
List<Integer> getConceptIdsByMapping(String code,
                                                                       String sourceName,
                                                                       boolean includeRetired)
                                                                throws APIException
```
    Looks up concepts via ConceptMap This will return the list of ids for all 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
    
    includeRetired - whether or not to include retired concepts
    
    Returns:
    
    the list ids for all non-voided Concepts that have the given mapping, or an empty List if none found
    
    Throws:
    
    APIException - if the specified source+code maps to more than one concept
    
    Since:
    
    2.3
  - getAllConceptNameTags
```
@Authorized(value="Get Concepts")
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 dataset Should return a list of all concept name tags
    
    Since:
    
    1.5
  - getConceptNameTag
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concepts")
ConceptDescription getConceptDescriptionByUuid(String uuid)
```
    Get ConceptDescription by its UUID
    
    Parameters:
    
    uuid -
    
    Returns:
    
    concept description or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptSourceByName
```
@Authorized(value="Get Concept Sources")
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 Should return null if no ConceptSource with that name is found
  - getConceptSourceByUniqueId
```
@Authorized(value="Get Concept Sources")
ConceptSource getConceptSourceByUniqueId(String uniqueId)
                                                                           throws APIException
```
    Get a ConceptSource by its unique id.
    
    Parameters:
    
    uniqueId - the unique id
    
    Returns:
    
    the concept source matching given unique id
    
    Throws:
    
    APIException - Should get concept source with the given unique id Should return null if no concept source with given unique id is found Should return null if given an empty string Should fail if given null
  - getConceptSourceByHL7Code
```
@Authorized(value="Get Concept Sources")
ConceptSource getConceptSourceByHL7Code(String hl7Code)
                                                                          throws APIException
```
    Get a ConceptSource by its hl7Code.
    
    Parameters:
    
    hl7Code - the hl7Code
    
    Returns:
    
    the concept source matching given hl7Code
    
    Throws:
    
    APIException - Should get concept source with the given hl7Code Should return null if no concept source with given hl7Code is found Should return null if given an empty string Should fail if given null
  - hasAnyObservation
```
@Authorized(value="Get 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
```
@Authorized(value="Get Concepts")
Concept getTrueConcept()
```
    Returns the TRUE concept
    
    Returns:
    
    true concept Should return the true concept
  - getFalseConcept
```
@Authorized(value="Get Concepts")
Concept getFalseConcept()
```
    Returns the FALSE concept
    
    Returns:
    
    false concept Should return the false concept
  - getUnknownConcept
```
@Authorized(value="Get Concepts")
Concept getUnknownConcept()
```
    Returns the UNKNOWN concept
    
    Returns:
    
    unknown concept Should return the unknown 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 Should fail if the datatype of the concept is not boolean Should explicitly add true concept as a value_Coded answer Should explicitly add false concept as a value_Coded answer
  - hasAnyObservation
```
@Authorized(value="Get 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
```
@Authorized(value="Get 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 (if blank/null, matches all concepts)
    
    locales - List<Locale> to restrict to
    
    includeRetired - boolean if false, will exclude retired concepts
    
    requireClasses - List<ConceptClass> to restrict to
    
    excludeClasses - List<ConceptClass> to leave out of results
    
    requireDatatypes - List<ConceptDatatype> to restrict to
    
    excludeDatatypes - List<ConceptDatatype> 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 - Should return concept search results that match unique concepts Should return a search result whose concept name contains all word tokens as first Should return a search result for phrase with stop words Should not return concepts with matching names that are voided Should return preferred names higher Should find concept by full code
    
    Since:
    
    1.8
  - findConceptAnswers
```
@Authorized(value="Get 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 - Should return a list of all matching concept search results
    
    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 updateConceptIndexes(Concept concept)
    
    Throws:
    
    APIException
    
    Since:
    
    1.8
  - getConcepts
```
@Authorized(value="Get 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 (if blank/null, matches all concepts)
    
    locale - the locale in which to search for the concepts
    
    includeRetired - Specifies whether to include retired concepts
    
    Returns:
    
    a list ConceptSearchResults
    
    Throws:
    
    APIException - Should give a list of ConceptSearchResult for the matching Concepts
    
    Since:
    
    1.8
  - getCountOfConcepts
```
@Authorized(value="Get 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<Locale> to restrict to
    
    includeRetired - Specifies whether to include retired concepts
    
    requireClasses - List<ConceptClass> to restrict to
    
    excludeClasses - List<ConceptClass> to leave out of results
    
    requireDatatypes - List<ConceptDatatype> to restrict to
    
    excludeDatatypes - List<ConceptDatatype> 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 Should return a count of unique concepts
  - getCountOfDrugs
```
@Authorized(value="Get 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 - Should return the total number of matching drugs
    
    Since:
    
    1.8
  - getDrugs
```
@Authorized(value="Get Concepts")
List<Drug> getDrugs(String drugName,
                                                      Concept concept,
                                                      boolean searchKeywords,
                                                      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
    
    searchKeywords - (since 1.11) Specifies whether the search should match keywords or just phrase
    
    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 Should return a list of matching drugs
  - getConceptStopWords
```
@Authorized(value="Get Concepts")
List<String> getConceptStopWords(Locale locale)
```
    Gets the list of ConceptStopWord for given locale
    
    Parameters:
    
    locale - The locale in which to search for the ConceptStopWord
    
    Returns:
    
    list of concept stop words for given locale Should return list of concept stop words for given locale Should return empty list if no stop words are found for the given locale Should return default Locale ConceptStopWord if Locale is null
    
    Since:
    
    1.8
  - saveConceptStopWord
```
@Authorized(value="Manage Concept Stop Words")
ConceptStopWord saveConceptStopWord(ConceptStopWord conceptStopWord)
                                                                            throws APIException
```
    Save the given ConceptStopWord in the database
    If this is a new concept stop word, the returned concept stop word will have a new ConceptStopWord.getConceptStopWordId() inserted into it that was generated by the database
    
    Parameters:
    
    conceptStopWord - The ConceptStopWord to save or update
    
    Returns:
    
    the ConceptStopWord that was saved or updated
    
    Throws:
    
    APIException - Should generated concept stop word id onto returned concept stop word Should save concept stop word into database Should assign default Locale Should save concept stop word in uppercase Should fail if a duplicate conceptStopWord in a locale is added
    
    Since:
    
    1.8
  - deleteConceptStopWord
```
@Authorized(value="Manage Concept Stop Words")
void deleteConceptStopWord(Integer conceptStopWordId)
                                                                   throws APIException
```
    Delete the given ConceptStopWord in the database
    
    Parameters:
    
    conceptStopWordId - The ConceptStopWord to delete
    
    Throws:
    
    APIException - Should delete the given concept stop word from the database
    
    Since:
    
    1.8
  - getAllConceptStopWords
```
@Authorized(value="Get Concepts")
List<ConceptStopWord> getAllConceptStopWords()
```
    Get all the concept stop words
    
    Returns:
    
    List of ConceptStopWord Should return all the concept stop words Should return empty list if nothing found
    
    Since:
    
    1.8
  - getDrugsByIngredient
```
@Authorized(value="Get Concepts")
List<Drug> getDrugsByIngredient(Concept ingredient)
```
    Gets drugs by the given ingredient, which can be either the drug itself or any ingredient.
    
    Returns:
    
    the list of drugs Should return drugs matched by intermediate concept Should return drugs matched by drug concept Should return empty list if nothing found Should raise exception if no concept is given
    
    Since:
    
    1.10
  - getActiveConceptMapTypes
```
@Authorized(value="Get Concept Map Types")
List<ConceptMapType> getActiveConceptMapTypes()
                                                                                  throws APIException
```
    Returns a list of concept map types currently in the database excluding hidden ones
    
    Returns:
    
    List of concept map type objects
    
    Throws:
    
    APIException - Should return all the concept map types excluding hidden ones
    
    Since:
    
    1.9
  - getConceptMapTypes
```
@Authorized(value="Get Concept Map Types")
List<ConceptMapType> getConceptMapTypes(boolean includeRetired,
                                                                                   boolean includeHidden)
                                                                            throws APIException
```
    Returns a list of concept map types currently in the database including or excluding retired and hidden ones as specified by the includeRetired and includeHidden arguments
    
    Parameters:
    
    includeRetired - specifies if retired concept map types should be included
    
    Returns:
    
    List of concept map type objects
    
    Throws:
    
    APIException - Should return all the concept map types if includeRetired and hidden are set to true Should return only un retired concept map types if includeRetired is set to false Should not include hidden concept map types if includeHidden is set to false
    
    Since:
    
    1.9
  - getConceptMapType
```
@Authorized(value="Get Concept Map Types")
ConceptMapType getConceptMapType(Integer conceptMapTypeId)
                                                                     throws APIException
```
    Return a concept map type matching the given concept map type id
    
    Parameters:
    
    conceptMapTypeId - Integer concept map type id
    
    Returns:
    
    ConceptMapType
    
    Throws:
    
    APIException
    
    Since:
    
    1.9
  - getConceptMapTypeByUuid
```
@Authorized(value="Get Concept Map Types")
ConceptMapType getConceptMapTypeByUuid(String uuid)
                                                                           throws APIException
```
    Return a concept map type matching the given uuid
    
    Parameters:
    
    uuid - the uuid to search against
    
    Returns:
    
    ConceptMapType
    
    Throws:
    
    APIException - Should return a conceptMapType matching the specified uuid
    
    Since:
    
    1.9
  - getConceptMapTypeByName
```
@Authorized(value="Get Concept Map Types")
ConceptMapType getConceptMapTypeByName(String name)
                                                                           throws APIException
```
    Return a concept map type matching the given name
    
    Parameters:
    
    name - the name to search against
    
    Returns:
    
    ConceptMapType
    
    Throws:
    
    APIException - Should return a conceptMapType matching the specified name Should be case insensitive
    
    Since:
    
    1.9
  - saveConceptMapType
```
@Authorized(value="Manage Concept Map Types")
ConceptMapType saveConceptMapType(ConceptMapType conceptMapType)
                                                                         throws APIException
```
    Saves or updates the specified concept map type in the database
    
    Parameters:
    
    conceptMapType - the concept map type to save
    
    Returns:
    
    the saved conceptMapType
    
    Throws:
    
    APIException - Should add the specified concept map type to the database and assign to it an id Should update an existing concept map type
    
    Since:
    
    1.9
  - retireConceptMapType
```
@Authorized(value="Manage Concept Map Types")
ConceptMapType retireConceptMapType(ConceptMapType conceptMapType,
                                                                                  String retireReason)
                                                                           throws APIException
```
    Retiring a concept map type essentially removes it from circulation
    
    Parameters:
    
    conceptMapType - the concept map type to retire
    
    retireReason - the reason why the concept map type is being retired
    
    Returns:
    
    the retired concept map type
    
    Throws:
    
    APIException - Should retire the specified conceptMapType with the given retire reason Should should set the default retire reason if none is given
    
    Since:
    
    1.9
  - unretireConceptMapType
```
@Authorized(value="Manage Concept Map Types")
ConceptMapType unretireConceptMapType(ConceptMapType conceptMapType)
                                                                             throws APIException
```
    Marks a concept map type that is currently retired as not retired.
    
    Parameters:
    
    conceptMapType - the concept map type to unretire
    
    Returns:
    
    the unretired concept map type
    
    Throws:
    
    APIException - Should unretire the specified concept map type and drop all retire related fields
    
    Since:
    
    1.9
  - purgeConceptMapType
```
@Authorized(value="Purge Concept Map Types")
void purgeConceptMapType(ConceptMapType conceptMapType)
                                                               throws APIException
```
    Completely purges a concept map type from the database
    
    Parameters:
    
    conceptMapType - the concept map type to purge from the database
    
    Throws:
    
    APIException - Should delete the specified conceptMapType from the database
    
    Since:
    
    1.9
  - getConceptMappingsToSource
```
@Authorized(value="Get Concepts")
List<ConceptMap> getConceptMappingsToSource(ConceptSource conceptSource)
                                                                       throws APIException
```
    Returns a list of mappings from concepts to terms in the given reference terminology
    
    Parameters:
    
    conceptSource -
    
    Returns:
    
    a List<ConceptMap> object
    
    Throws:
    
    APIException - Should return a List of ConceptMaps from the given source
    
    Since:
    
    1.9
  - getAllConceptReferenceTerms
```
@Authorized(value="Get Concept Reference Terms")
List<ConceptReferenceTerm> getAllConceptReferenceTerms()
                                                                                                 throws APIException
```
    Gets a list of all concept reference terms saved in the database
    
    Returns:
    
    a list of concept reference terms
    
    Throws:
    
    APIException - Should return all concept reference terms in the database
    
    Since:
    
    1.9
  - getConceptReferenceTerms
```
@Authorized(value="Get Concept Reference Terms")
List<ConceptReferenceTerm> getConceptReferenceTerms(boolean includeRetired)
                                                                                              throws APIException
```
    Gets a list of concept reference terms saved in the database
    
    Parameters:
    
    includeRetired - specifies if retired concept reference terms should be included
    
    Returns:
    
    a list of concept reference terms
    
    Throws:
    
    APIException - Should return all the concept reference terms if includeRetired is set to true Should return only un retired concept reference terms if includeRetired is set to false
    
    Since:
    
    1.9
  - getConceptReferenceTerm
```
@Authorized(value="Get Concept Reference Terms")
ConceptReferenceTerm getConceptReferenceTerm(Integer conceptReferenceTermId)
                                                                                       throws APIException
```
    Gets the concept reference term with the specified concept reference term id
    
    Parameters:
    
    conceptReferenceTermId - the concept reference term id to search against
    
    Returns:
    
    the concept reference term object with the given concept reference term id
    
    Throws:
    
    APIException
    
    Since:
    
    1.9
  - getConceptReferenceTermByUuid
```
@Authorized(value="Get Concept Reference Terms")
ConceptReferenceTerm getConceptReferenceTermByUuid(String uuid)
                                                                                             throws APIException
```
    Gets the concept reference term with the specified uuid
    
    Parameters:
    
    uuid - the uuid to search against
    
    Returns:
    
    the concept reference term object with the given uuid
    
    Throws:
    
    APIException - Should return the concept reference term that matches the given uuid
    
    Since:
    
    1.9
  - getConceptReferenceTermByName
```
@Authorized(value="Get Concept Reference Terms")
ConceptReferenceTerm getConceptReferenceTermByName(String name,
                                                                                                    ConceptSource conceptSource)
                                                                                             throws APIException
```
    Gets a concept reference term with the specified name from the specified concept source ignoring all retired ones
    
    Parameters:
    
    name - the name to match against
    
    conceptSource - the concept source to match against
    
    Returns:
    
    concept reference term object
    
    Throws:
    
    APIException - Should return a concept reference term that matches the given name from the given source Should be case insensitive Should return null if no concept reference term is found
    
    Since:
    
    1.9
  - getConceptReferenceTermByCode
```
@Authorized(value="Get Concept Reference Terms")
ConceptReferenceTerm getConceptReferenceTermByCode(String code,
                                                                                                    ConceptSource conceptSource)
                                                                                             throws APIException
```
    Gets a concept reference term with the specified code from the specified concept source
    
    Parameters:
    
    code - the code to match against
    
    conceptSource - the concept source to match against
    
    Returns:
    
    concept reference term object
    
    Throws:
    
    APIException - Should return a concept reference term that matches the given code from the given source
    
    Since:
    
    1.9
  - getConceptReferenceTermByCode
```
@Authorized(value="Get Concept Reference Terms")
List<ConceptReferenceTerm> getConceptReferenceTermByCode(String code,
                                                                                                          ConceptSource conceptSource,
                                                                                                          boolean includeRetired)
                                                                                                   throws APIException
```
    Gets a list of concept reference terms with the specified code from the specified concept source
    
    Parameters:
    
    code - the code to match against
    
    conceptSource - the concept source to match against
    
    includeRetired - specifies if retired concept reference terms should be included
    
    Returns:
    
    concept reference term object
    
    Throws:
    
    APIException - Should return a list of concept reference terms that matches the given code from the given source
    
    Since:
    
    2.7
  - saveConceptReferenceTerm
```
@Authorized(value="Manage Concept Reference Terms")
ConceptReferenceTerm saveConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)
                                                                                           throws APIException
```
    Stores the specified concept reference term to the database
    
    Parameters:
    
    conceptReferenceTerm - the concept reference term object to save
    
    Returns:
    
    the saved concept reference term object
    
    Throws:
    
    APIException - Should add a concept reference term to the database and assign an id to it Should update changes to the concept reference term in the database
    
    Since:
    
    1.9
  - retireConceptReferenceTerm
```
@Authorized(value="Manage Concept Reference Terms")
ConceptReferenceTerm retireConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm,
                                                                                                    String retireReason)
                                                                                             throws APIException
```
    Retiring a concept reference term essentially removes it from circulation
    
    Parameters:
    
    conceptReferenceTerm - the concept reference term object to retire
    
    retireReason - the reason why the concept reference term is being retired
    
    Returns:
    
    the retired concept reference term object
    
    Throws:
    
    APIException - Should retire the specified concept reference term with the given retire reason Should should set the default retire reason if none is given
    
    Since:
    
    1.9
  - unretireConceptReferenceTerm
```
@Authorized(value="Manage Concept Reference Terms")
ConceptReferenceTerm unretireConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)
                                                                                               throws APIException
```
    Marks a concept reference term that is currently retired as not retired.
    
    Parameters:
    
    conceptReferenceTerm - the concept reference term to unretire
    
    Returns:
    
    the unretired concept reference term
    
    Throws:
    
    APIException - Should unretire the specified concept reference term and drop all retire related fields
    
    Since:
    
    1.9
  - purgeConceptReferenceTerm
```
@Authorized(value="Purge Concept Reference Terms")
void purgeConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)
                                                                           throws APIException
```
    Purges the specified concept reference term from the database
    
    Parameters:
    
    conceptReferenceTerm - the concept reference term object to purge
    
    Throws:
    
    APIException - Should purge the given concept reference term Should fail if given concept reference term is in use
    
    Since:
    
    1.9
  - getConceptReferenceTerms
```
@Authorized(value="Get Concept Reference Terms")
List<ConceptReferenceTerm> getConceptReferenceTerms(String query,
                                                                                                     ConceptSource conceptSource,
                                                                                                     Integer start,
                                                                                                     Integer length,
                                                                                                     boolean includeRetired)
                                                                                              throws APIException
```
    Finds the concept reference term in the database that have a code or name that contains the specified search phrase.
    
    Parameters:
    
    query - the string to match against the reference term names or codes
    
    conceptSource - the concept source from which the terms should be looked up
    
    start - beginning index for the batch
    
    length - number of terms to return in the batch
    
    includeRetired - specifies if the retired terms should be included
    
    Returns:
    
    a list if ConceptReferenceTerms
    
    Throws:
    
    APIException - Should return unique terms with a code or name containing the search phrase Should return only the concept reference terms from the given concept source
    
    Since:
    
    1.9
  - getCountOfConceptReferenceTerms
```
@Authorized(value="Get Concept Reference Terms")
Integer getCountOfConceptReferenceTerms(String query,
                                                                                         ConceptSource conceptSource,
                                                                                         boolean includeRetired)
                                                                                  throws APIException
```
    Returns the count of concept reference terms that match the specified arguments
    
    Parameters:
    
    query - the string to match against the reference term names
    
    conceptSource - the concept source from which the terms should be looked up
    
    includeRetired - specifies if retired concept reference terms should be included
    
    Returns:
    
    the count of matching concept reference terms
    
    Throws:
    
    APIException - Should include retired terms if includeRetired is set to true Should not include retired terms if includeRetired is set to false
    
    Since:
    
    1.9
  - getReferenceTermMappingsTo
```
@Authorized(value="Get Concept Reference Terms")
List<ConceptReferenceTermMap> getReferenceTermMappingsTo(ConceptReferenceTerm term)
                                                                                                   throws APIException
```
    Fetches all the ConceptReferenceTermMap where the specified reference term is the termB i.e mappings added to other terms pointing to it
    
    Parameters:
    
    term - the term to match against
    
    Returns:
    
    a list of ConceptReferenceTermMaps
    
    Throws:
    
    APIException - Should return all concept reference term maps where the specified term is the termB
    
    Since:
    
    1.9
  - getConceptsByName
```
@Authorized(value="Get 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 Should return concepts for specific country and global language given language and country locale
  - getDefaultConceptMapType
```
@Authorized(value="Get Concept Map Types")
ConceptMapType getDefaultConceptMapType()
                                                                            throws APIException
```
    Gets the concept map type to be used as the default. It is specified by the concept.defaultConceptMapType global property.
    
    Returns:
    
    the ConceptMapType
    
    Throws:
    
    APIException - Should return same as by default Should return type as set in gp
    
    Since:
    
    1.9
  - isConceptNameDuplicate
```
@Authorized(value="Get Concepts")
boolean isConceptNameDuplicate(ConceptName name)
```
    Determines if the given concept name is a duplicate.
    Concept name is considered duplicate if it is a default non-retired name for a non-voided concept and there is another name, which is:
    1. equal ignoring case
    2. non voided
    3. in same locale or in same general language
    4. non-retired and different concept
    5. default name for concept
    Parameters:
    
    name -
    
    Returns:
    
    true if it is a duplicate name
    
    Since:
    
    1.11
  - getDrugs
```
@Authorized(value="Get Concepts")
List<Drug> getDrugs(String searchPhrase,
                                                      Locale locale,
                                                      boolean exactLocale,
                                                      boolean includeRetired)
```
    Fetches un retired drugs that match the specified search phrase. The logic matches on drug names, concept names of the associated concepts or the concept reference term codes of the drug reference term mappings
    
    Parameters:
    
    searchPhrase - The string to match against
    
    locale - The locale to match against when searching in drug concept names
    
    exactLocale - If false then concepts with names in a broader locale will be matched e.g in case en_GB is passed in then en will be matched
    
    includeRetired - Specifies if retired drugs that match should be included or not
    
    Returns:
    
    A list of matching drugs
    
    Since:
    
    1.10 Should get drugs with names matching the search phrase Should include retired drugs if includeRetired is set to true Should get drugs linked to concepts with names that match the phrase Should get drugs linked to concepts with names that match the phrase and locale Should get drugs linked to concepts with names that match the phrase and related locales Should get drugs that have mappings with reference term codes that match the phrase Should return unique drugs Should return all drugs with a matching term code or drug name or concept name Should reject a null search phrase
  - getDrugsByMapping
```
@Authorized(value="Get Concepts")
List<Drug> getDrugsByMapping(String code,
                                                               ConceptSource conceptSource,
                                                               Collection<ConceptMapType> withAnyOfTheseTypes,
                                                               boolean includeRetired)
                                                        throws APIException
```
    Fetches all drugs with reference mappings to the specified concept source that match the specified code and concept map types
    
    Parameters:
    
    code - the code the reference term code to match on
    
    conceptSource - the concept source on which to match on
    
    withAnyOfTheseTypes - the ConceptMapTypes to match on
    
    includeRetired - specifies if retired drugs should be included or not
    
    Returns:
    
    the list of Drug
    
    Throws:
    
    APIException - Should get a list of all drugs that match on all the parameter values Should return retired and non-retired drugs if includeRetired is set to true Should return empty list if no matches are found Should match on the code Should match on the concept source Should match on the map types Should fail if no code and concept source and withAnyOfTheseTypes are provided Should exclude duplicate matches Should fail if source is null
    
    Since:
    
    1.10
  - getDrugByMapping
```
@Authorized(value="Get Concepts")
Drug getDrugByMapping(String code,
                                                        ConceptSource conceptSource,
                                                        Collection<ConceptMapType> withAnyOfTheseTypesOrOrderOfPreference)
                                                 throws APIException
```
    Gets the "best" matching drug, i.e. matching the earliest ConceptMapType passed in e.g. getDrugByMapping("12345", rxNorm, Arrays.asList(sameAs, narrowerThan)) If there are multiple matches for the highest-priority ConceptMapType, throw an exception
    
    Parameters:
    
    code - the code the reference term code to match on
    
    conceptSource - the concept source to match on
    
    withAnyOfTheseTypesOrOrderOfPreference - the ConceptMapTypes to match on
    
    Returns:
    
    the Drug
    
    Throws:
    
    APIException - Should return a drug that matches the code and source Should return a drug that matches the code and source and the best map type Should fail if multiple drugs are found matching the best map type Should return null if no match found Should fail if no code and concept source and withAnyOfTheseTypes are provided Should fail if source is null
    
    Since:
    
    1.10
  - getOrderableConcepts
```
@Authorized(value="Get Concepts")
List<ConceptSearchResult> getOrderableConcepts(String phrase,
                                                                                 List<Locale> locales,
                                                                                 boolean includeRetired,
                                                                                 Integer start,
                                                                                 Integer length)
```
    An Orderable concept is one where its conceptClass has a mapping in the order_type_class_map table. This method searches for orderable concepts which match the specified arguments
    
    Parameters:
    
    phrase - the phrase to match on
    
    locales - list of locales to match on
    
    includeRetired - include retired concepts or not
    
    start - start index of search results
    
    length - number of concept results to be returned
    
    Returns:
    
    List of ConceptSearchResults
    
    Since:
    
    1.10 Should get orderable concepts Should return an empty list if no concept search result is found
  - getAllConceptAttributeTypes
```
@Authorized(value="Get Concept Attribute Types")
List<ConceptAttributeType> getAllConceptAttributeTypes()
```
    Returns:
    
    all ConceptAttributeTypes
    
    Since:
    
    2.0 Should return all concept attribute types including retired ones
  - saveConceptAttributeType
```
@Authorized(value="Manage Concept Attribute Types")
ConceptAttributeType saveConceptAttributeType(ConceptAttributeType conceptAttributeType)
```
    Creates or updates the given concept attribute type in the database
    
    Parameters:
    
    conceptAttributeType -
    
    Returns:
    
    the ConceptAttributeType created/saved
    
    Since:
    
    2.0 Should create a new concept attribute type Should edit an existing concept attribute type
  - getConceptAttributeType
```
@Authorized(value="Get Concept Attribute Types")
ConceptAttributeType getConceptAttributeType(Integer id)
```
    Parameters:
    
    id -
    
    Returns:
    
    the ConceptAttributeType with the given internal id
    
    Since:
    
    2.0 Should return the concept attribute type with the given id Should return null if no concept attribute type exists with the given id
  - getConceptAttributeTypeByUuid
```
@Authorized(value="Get Concept Attribute Types")
ConceptAttributeType getConceptAttributeTypeByUuid(String uuid)
```
    Parameters:
    
    uuid -
    
    Returns:
    
    the ConceptAttributeType with the given uuid
    
    Since:
    
    2.0 Should return the concept attribute type with the given uuid Should return null if no concept attribute type exists with the given uuid
  - purgeConceptAttributeType
```
@Authorized(value="Purge Concept Attribute Types")
void purgeConceptAttributeType(ConceptAttributeType conceptAttributeType)
```
    Completely removes a concept attribute type from the database
    
    Parameters:
    
    conceptAttributeType -
    
    Since:
    
    2.0 Should completely remove a concept attribute type
  - getConceptAttributeTypes
```
@Authorized(value="Get Concept Attribute Types")
List<ConceptAttributeType> getConceptAttributeTypes(String name)
                                                                                              throws APIException
```
    Find concept attribute types matching the given parameters. Retired types are included in the results
    
    Parameters:
    
    name - (optional) The name of type
    
    Returns:
    
    list of ConceptAttributeTypes that matches name partially or completely
    
    Throws:
    
    APIException - Should return concept attribute types performing fuzzy match on given name Should return empty list when no concept attribute types match given name
    
    Since:
    
    2.0
  - getConceptAttributeTypeByName
```
@Authorized(value="Get Concept Attribute Types")
ConceptAttributeType getConceptAttributeTypeByName(String exactName)
```
    Retrieves a ConceptAttributeType object based on the name provided
    
    Parameters:
    
    exactName -
    
    Returns:
    
    the ConceptAttributeType with the specified name
    
    Since:
    
    2.0 Should return the concept attribute type with the exact specified name Should return null if no concept attribute type exists with the exact specified name
  - retireConceptAttributeType
```
@Authorized(value="Manage Concept Attribute Types")
ConceptAttributeType retireConceptAttributeType(ConceptAttributeType conceptAttributeType,
                                                                                                    String reason)
```
    Retire a concept attribute type
    
    Parameters:
    
    conceptAttributeType - the concept attribute type to be retired
    
    reason - for retiring the concept attribute type
    
    Returns:
    
    the retired concept attribute type
    
    Since:
    
    2.0 Should retire concept type attribute
  - unretireConceptAttributeType
```
@Authorized(value="Manage Concept Attribute Types")
ConceptAttributeType unretireConceptAttributeType(ConceptAttributeType conceptAttributeType)
```
    Un-Retire a concept attribute type
    
    Parameters:
    
    conceptAttributeType - the concept type attribute to unretire
    
    Returns:
    
    the unretire concept attribute type
    
    Since:
    
    2.0 Should unretire a concept attribute type
  - getConceptAttributeByUuid
```
@Authorized(value="Get Concepts")
ConceptAttribute getConceptAttributeByUuid(String uuid)
```
    Parameters:
    
    uuid -
    
    Returns:
    
    the ConceptAttribute with the given uuid
    
    Since:
    
    2.0 Should get the concept attribute with the given uuid Should return null if no concept attribute has the given uuid
  - hasAnyConceptAttribute
```
@Authorized(value="Get Concepts")
boolean hasAnyConceptAttribute(ConceptAttributeType conceptAttributeType)
```
    Parameters:
    
    conceptAttributeType -
    
    Returns:
    
    boolean true if the concept attribute type is used by a concept
    
    Since:
    
    2.0 Checks if there are any concept attributes (including voided attributes) for a concept attribute type.

Interface ConceptService

Method Summary

Methods inherited from interface org.openmrs.api.OpenmrsService

Method Detail

setConceptDAO

getConceptByUuid

saveConcept

saveDrug

purgeConcept

retireConcept

retireDrug

unretireDrug

purgeDrug

getConcept

getConceptName

getConceptAnswer

getDrug

getConceptNumeric

getConceptClass

getAllConcepts

getAllConcepts

getConceptsByName

getConceptByName

getConcept

getConceptByReference

getDrugByUuid

getDrugIngredientByUuid

getDrug

getAllDrugs

getDrugsByConcept

getAllDrugs

getDrugs

getConceptsByClass

getConceptClassByName

getAllConceptClasses

getAllConceptClasses

getConceptClassByUuid

getConceptAnswerByUuid

getConceptNameByUuid

getConceptSetByUuid

getConceptSourceByUuid

saveConceptClass

purgeConceptClass

purgeConceptNameTag

getAllConceptDatatypes

getAllConceptDatatypes

getConceptDatatype

getConceptDatatypeByUuid

getConceptDatatypeByName

getConceptSetsByConcept

getConceptsByConceptSet

getSetsContainingConcept

getAllConceptProposals

getConceptNumericByUuid

getConceptProposal

getConceptProposals

getProposedConcepts

saveConceptProposal

purgeConceptProposal

mapConceptProposalToConcept

mapConceptProposalToConcept

getConceptsByAnswer

getPrevConcept

getNextConcept

checkIfLocked

getConceptProposalByUuid

getConceptsWithDrugsInFormulary

getConceptNameTagByUuid

getConceptComplex

getConceptNameTagByName

getLocalesOfConceptNames

getAllConceptSources

getConceptSource

saveConceptSource

purgeConceptSource

retireConceptSource

saveConceptNameTag

getMaxConceptId

conceptIterator

getConceptByMapping