ConceptServiceImpl (OpenMRS 2.7.0-SNAPSHOT API)

java.lang.Object
- org.openmrs.api.impl.BaseOpenmrsService
- - org.openmrs.api.impl.ConceptServiceImpl

All Implemented Interfaces:

ConceptService, OpenmrsService
```
@Transactional
public class ConceptServiceImpl
extends BaseOpenmrsService
implements ConceptService
```
Default Implementation of ConceptService service layer classes

See Also:

to access these methods

Constructor Summary

Constructors
Constructor and Description

ConceptServiceImpl()

Constructors
Constructor and Description
`ConceptServiceImpl()`

Method Summary

All Methods Static Methods Instance Methods Concrete 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 i)` 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 tagName)` 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 cp)` 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 c)` 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 conceptSourceId)` 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 searchOnPhrase, boolean searchDrugConceptNames, boolean includeRetired, Integer start, Integer length)` Returns a list of drugs with matching names or concept drug names and returns a specific number of them from the specified starting position.
`List<Drug>`	`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 c)` 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 c)` 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.
`static boolean`	`isValidUuidFormat(String uuid)` Determines if the passed string is in valid uuid format By OpenMRS standards, a uuid must be 36 characters in length and not contain whitespace, but we do not enforce that a uuid be in the "canonical" form, with alphanumerics seperated by dashes, since the MVP dictionary does not use this format (We also are being slightly lenient and accepting uuids that are 37 or 38 characters in length, since the uuid data field is 38 characters long)
`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 concept)` 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 concept, 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 class org.openmrs.api.impl.BaseOpenmrsService
onShutdown, onStartup

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

- Constructor Detail
  - ConceptServiceImpl
```
public ConceptServiceImpl()
```
- Method Detail
  - setConceptDAO
```
public void setConceptDAO(ConceptDAO dao)
```
    Description copied from interface: ConceptService
    
    Sets the data access object for Concepts. The dao is used for saving and getting concepts to/from the database
    
    Specified by:
    
    setConceptDAO in interface ConceptService
    
    Parameters:
    
    dao - The data access object to use
    
    See Also:
    
    ConceptService.setConceptDAO(org.openmrs.api.db.ConceptDAO)
  - saveConcept
```
@CacheEvict(value="conceptIdsByMapping",
            allEntries=true)
public Concept saveConcept(Concept concept)
                                                                                          throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    saveConcept in interface ConceptService
    
    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
    
    See Also:
    
    Should return the concept with new conceptID if creating new concept Should return the concept with same conceptID if updating existing concept Should leave preferred name preferred if set Should set default preferred name to fully specified first Should not set default preferred name to short or index terms Should force set flag if set members exist
  - saveDrug
```
public Drug saveDrug(Drug drug)
              throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    saveDrug in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.saveDrug(org.openmrs.Drug)
  - purgeConcept
```
public void purgeConcept(Concept concept)
                  throws APIException
```
    Description copied from interface: ConceptService
    
    Completely purge a Concept or ConceptNumeric from the database. This should not typically be used unless desperately needed. Most should just be retired. See ConceptService.retireConcept(Concept, String)
    
    Specified by:
    
    purgeConcept in interface ConceptService
    
    Parameters:
    
    concept - 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
    
    See Also:
    
    ConceptService.purgeConcept(Concept)
  - retireConcept
```
public Concept retireConcept(Concept concept,
                             String reason)
                      throws APIException
```
    Description copied from interface: ConceptService
    
    Retiring a concept essentially removes it from circulation
    
    Specified by:
    
    retireConcept in interface ConceptService
    
    Parameters:
    
    concept - 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
    
    See Also:
    
    ConceptService.retireConcept(org.openmrs.Concept, java.lang.String)
  - retireDrug
```
public Drug retireDrug(Drug drug,
                       String reason)
                throws APIException
```
    Description copied from interface: ConceptService
    
    Retiring a Drug essentially removes it from circulation
    
    Specified by:
    
    retireDrug in interface ConceptService
    
    Parameters:
    
    drug - The Drug to retire
    
    reason - The retire reason
    
    Returns:
    
    the retired Drug Should retire the given Drug
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.retireDrug(org.openmrs.Drug, java.lang.String)
  - unretireDrug
```
public Drug unretireDrug(Drug drug)
                  throws APIException
```
    Description copied from interface: ConceptService
    
    Marks a drug that is currently retired as not retired.
    
    Specified by:
    
    unretireDrug in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.unretireDrug(org.openmrs.Drug)
  - purgeDrug
```
public void purgeDrug(Drug drug)
               throws APIException
```
    Description copied from interface: ConceptService
    
    Completely purge a Drug from the database. This should not typically be used unless desperately needed. Most Drugs should just be retired.
    
    Specified by:
    
    purgeDrug in interface ConceptService
    
    Parameters:
    
    drug - The Drug to remove from the system
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.purgeDrug(org.openmrs.Drug)
  - getConcept
```
@Transactional(readOnly=true)
public Concept getConcept(Integer conceptId)
                                                 throws APIException
```
    Description copied from interface: ConceptService
    
    Gets the concept with the given id
    
    Specified by:
    
    getConcept in interface ConceptService
    
    Returns:
    
    the matching Concept object
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConcept(java.lang.Integer)
  - getConceptByReference
```
@Transactional(readOnly=true)
public Concept getConceptByReference(String conceptRef)
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptByReference in interface ConceptService
    
    Parameters:
    
    conceptRef - the concept string identifier
    
    Returns:
    
    the concept if it exists otherwise null
    
    See Also:
    
    ConceptService.getConceptByReference(String conceptRef)
  - getConceptName
```
@Transactional(readOnly=true)
public ConceptName getConceptName(Integer conceptNameId)
                                                         throws APIException
```
    Description copied from interface: ConceptService
    
    Gets the concept-name with the given id
    
    Specified by:
    
    getConceptName in interface ConceptService
    
    Returns:
    
    the matching Concept object
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConceptName(java.lang.Integer)
  - getConceptAnswer
```
@Transactional(readOnly=true)
public ConceptAnswer getConceptAnswer(Integer conceptAnswerId)
                                                             throws APIException
```
    Description copied from interface: ConceptService
    
    Gets the ConceptAnswer with the given id
    
    Specified by:
    
    getConceptAnswer in interface ConceptService
    
    Returns:
    
    the matching ConceptAnswer object
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConceptAnswer(java.lang.Integer)
  - getDrug
```
@Transactional(readOnly=true)
public Drug getDrug(Integer drugId)
                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Get the Drug with the given id
    
    Specified by:
    
    getDrug in interface ConceptService
    
    Returns:
    
    the matching Drug object
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getDrug(java.lang.Integer)
  - getConceptNumeric
```
@Transactional(readOnly=true)
public ConceptNumeric getConceptNumeric(Integer conceptId)
                                                               throws APIException
```
    Description copied from interface: ConceptService
    
    Get the ConceptNumeric with the given id
    
    Specified by:
    
    getConceptNumeric in interface ConceptService
    
    Parameters:
    
    conceptId - The ConceptNumeric id
    
    Returns:
    
    the matching ConceptNumeric object
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConceptNumeric(java.lang.Integer)
  - getConceptComplex
```
@Transactional(readOnly=true)
public ConceptComplex getConceptComplex(Integer conceptId)
```
    Description copied from interface: ConceptService
    
    Get a ComplexConcept with the given conceptId
    
    Specified by:
    
    getConceptComplex in interface ConceptService
    
    Parameters:
    
    conceptId - of the ComplexConcept
    
    Returns:
    
    a ConceptComplex object
    
    See Also:
    
    ConceptService.getConceptComplex(java.lang.Integer)
  - getAllConcepts
```
@Transactional(readOnly=true)
public List<Concept> getAllConcepts()
                                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Return a list of unretired concepts sorted by concept id ascending and
    
    Specified by:
    
    getAllConcepts in interface ConceptService
    
    Returns:
    
    a List<Concept> object containing all of the sorted concepts
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getAllConcepts()
  - getAllConcepts
```
@Transactional(readOnly=true)
public List<Concept> getAllConcepts(String sortBy,
                                                                  boolean asc,
                                                                  boolean includeRetired)
                                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Return a list of concepts sorted on sortBy in dir direction (asc/desc)
    
    Specified by:
    
    getAllConcepts in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getAllConcepts(java.lang.String, boolean, boolean)
  - getConceptsByName
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByName(String name)
                                                              throws APIException
```
    Description copied from interface: ConceptService
    
    Returns a list of concepts matching any part of a concept name, this method is case insensitive to the concept name string
    
    Specified by:
    
    getConceptsByName in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptsByName(java.lang.String)
  - getConceptByName
```
@Transactional(readOnly=true)
public Concept getConceptByName(String name)
```
    Description copied from interface: ConceptService
    
    Return a Concept that matches the name exactly
    
    Specified by:
    
    getConceptByName in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptByName(java.lang.String)
  - getConcept
```
@Transactional(readOnly=true)
public Concept getConcept(String conceptIdOrName)
```
    Description copied from interface: ConceptService
    
    Get Concept by id or name convenience method
    
    Specified by:
    
    getConcept in interface ConceptService
    
    Returns:
    
    the found Concept
    
    See Also:
    
    ConceptService.getConcept(java.lang.String)
  - getDrug
```
@Transactional(readOnly=true)
public Drug getDrug(String drugNameOrId)
```
    Description copied from interface: ConceptService
    
    Return the drug object corresponding to the given name or drugId
    
    Specified by:
    
    getDrug in interface ConceptService
    
    Parameters:
    
    drugNameOrId - String name or drugId to match exactly on
    
    Returns:
    
    matching Drug object
    
    See Also:
    
    ConceptService.getDrug(java.lang.String)
  - getAllDrugs
```
@Transactional(readOnly=true)
public List<Drug> getAllDrugs()
```
    Description copied from interface: ConceptService
    
    Return a list of drugs currently in the database that are not retired
    
    Specified by:
    
    getAllDrugs in interface ConceptService
    
    Returns:
    
    a List<Drug> object containing all drugs Should return a list of all drugs
    
    See Also:
    
    ConceptService.getAllDrugs()
  - getAllDrugs
```
@Transactional(readOnly=true)
public List<Drug> getAllDrugs(boolean includeRetired)
```
    Description copied from interface: ConceptService
    
    Get drugs by concept. This method is the utility method that should be used to generically retrieve all Drugs in the system.
    
    Specified by:
    
    getAllDrugs in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getAllDrugs(boolean)
  - getDrugsByConcept
```
@Transactional(readOnly=true)
public List<Drug> getDrugsByConcept(Concept concept)
```
    Description copied from interface: ConceptService
    
    Return a list of drugs associated with the given concept
    
    Specified by:
    
    getDrugsByConcept in interface ConceptService
    
    Returns:
    
    a List<Drug> object containing all matching drugs
    
    See Also:
    
    ConceptService.getDrugsByConcept(org.openmrs.Concept)
  - getDrugs
```
@Transactional(readOnly=true)
public List<Drug> getDrugs(String phrase)
```
    Description copied from interface: ConceptService
    
    Find drugs in the system. The string search can match either drug.name or drug.concept.name, drug.drugId or drug.concept.conceptId
    
    Specified by:
    
    getDrugs in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getDrugs(java.lang.String)
  - getConceptsByClass
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByClass(ConceptClass cc)
```
    Specified by:
    
    getConceptsByClass in interface ConceptService
    
    Parameters:
    
    cc - ConceptClass
    
    Returns:
    
    Returns all concepts in a given class
    
    See Also:
    
    ConceptService.getConceptsByClass(org.openmrs.ConceptClass)
  - getAllConceptClasses
```
@Transactional(readOnly=true)
public List<ConceptClass> getAllConceptClasses(boolean includeRetired)
```
    Description copied from interface: ConceptService
    
    Return a list of concept classes currently in the database
    
    Specified by:
    
    getAllConceptClasses in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getAllConceptClasses(boolean)
  - getConceptClass
```
@Transactional(readOnly=true)
public ConceptClass getConceptClass(Integer i)
```
    Description copied from interface: ConceptService
    
    Return a Concept class matching the given identifier
    
    Specified by:
    
    getConceptClass in interface ConceptService
    
    Parameters:
    
    i - the concept class identifier
    
    Returns:
    
    the matching ConceptClass
    
    See Also:
    
    ConceptService.getConceptClass(java.lang.Integer)
  - getConceptClassByName
```
@Transactional(readOnly=true)
public ConceptClass getConceptClassByName(String name)
```
    Description copied from interface: ConceptService
    
    Return a Concept class matching the given name
    
    Specified by:
    
    getConceptClassByName in interface ConceptService
    
    Returns:
    
    ConceptClass matching the given name
    
    See Also:
    
    ConceptService.getConceptClassByName(java.lang.String)
  - getAllConceptClasses
```
@Transactional(readOnly=true)
public List<ConceptClass> getAllConceptClasses()
                                                                      throws APIException
```
    Description copied from interface: ConceptService
    
    Return a list of concept classes currently in the database
    
    Specified by:
    
    getAllConceptClasses in interface ConceptService
    
    Returns:
    
    List<ConceptClass> object with all ConceptClass objects Should return a list of all concept classes
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getAllConceptClasses(boolean)
  - saveConceptClass
```
public ConceptClass saveConceptClass(ConceptClass cc)
                              throws APIException
```
    Description copied from interface: ConceptService
    
    Creates or updates a concept class
    
    Specified by:
    
    saveConceptClass in interface ConceptService
    
    Parameters:
    
    cc - ConceptClass to create or update
    
    Throws:
    
    APIException - Should save the the given ConceptClass
    
    See Also:
    
    ConceptService.saveConceptClass(org.openmrs.ConceptClass)
  - purgeConceptClass
```
public void purgeConceptClass(ConceptClass cc)
```
    Description copied from interface: ConceptService
    
    Purge a ConceptClass
    
    Specified by:
    
    purgeConceptClass in interface ConceptService
    
    Parameters:
    
    cc - ConceptClass to delete
    
    See Also:
    
    ConceptService.purgeConceptClass(org.openmrs.ConceptClass)
  - purgeConceptNameTag
```
public void purgeConceptNameTag(ConceptNameTag cnt)
```
    Description copied from interface: ConceptService
    
    Purge a ConceptNameTag
    
    Specified by:
    
    purgeConceptNameTag in interface ConceptService
    
    Parameters:
    
    cnt - ConceptNameTag to delete
    
    See Also:
    
    ConceptService.purgeConceptNameTag(org.openmrs.ConceptNameTag)
  - getAllConceptDatatypes
```
@Transactional(readOnly=true)
public List<ConceptDatatype> getAllConceptDatatypes()
```
    Description copied from interface: ConceptService
    
    Return a list of all concept datatypes currently in the database
    
    Specified by:
    
    getAllConceptDatatypes in interface ConceptService
    
    Returns:
    
    List of ConceptDatatypes Should give a list of all concept datatypes
    
    See Also:
    
    ConceptService.getAllConceptDatatypes()
  - getAllConceptDatatypes
```
@Transactional(readOnly=true)
public List<ConceptDatatype> getAllConceptDatatypes(boolean includeRetired)
                                                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Return a list of concept datatypes currently in the database
    
    Specified by:
    
    getAllConceptDatatypes in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getAllConceptDatatypes(boolean)
  - getConceptDatatype
```
@Transactional(readOnly=true)
public ConceptDatatype getConceptDatatype(Integer i)
```
    Description copied from interface: ConceptService
    
    Return a ConceptDatatype matching the given identifier
    
    Specified by:
    
    getConceptDatatype in interface ConceptService
    
    Parameters:
    
    i - Integer for the requested ConceptDatatype
    
    Returns:
    
    ConceptDatatype matching the given identifier
    
    See Also:
    
    ConceptService.getConceptDatatype(java.lang.Integer)
  - getConceptDatatypeByName
```
@Transactional(readOnly=true)
public ConceptDatatype getConceptDatatypeByName(String name)
```
    Description copied from interface: ConceptService
    
    Return a Concept datatype matching the given name
    
    Specified by:
    
    getConceptDatatypeByName in interface ConceptService
    
    Returns:
    
    ConceptDatatype matching the given name
    
    See Also:
    
    ConceptService.getConceptDatatypeByName(java.lang.String)
  - getConceptSetsByConcept
```
@Transactional(readOnly=true)
public List<ConceptSet> getConceptSetsByConcept(Concept concept)
                                                                       throws APIException
```
    Description copied from interface: ConceptService
    
    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.
    
    Specified by:
    
    getConceptSetsByConcept in interface ConceptService
    
    Parameters:
    
    concept - The concept representing the concept set
    
    Returns:
    
    A List<ConceptSet> object containing all matching ConceptSets
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConceptSetsByConcept(org.openmrs.Concept)
  - getConceptsByConceptSet
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByConceptSet(Concept c)
```
    Description copied from interface: ConceptService
    
    Return a List of all concepts within a concept set
    
    Specified by:
    
    getConceptsByConceptSet in interface ConceptService
    
    Parameters:
    
    c - The concept representing the concept set
    
    Returns:
    
    A List<Concept> object containing all objects within the ConceptSet
    
    See Also:
    
    ConceptService.getConceptsByConceptSet(Concept)
  - getSetsContainingConcept
```
@Transactional(readOnly=true)
public List<ConceptSet> getSetsContainingConcept(Concept concept)
```
    Description copied from interface: ConceptService
    
    Find all sets that the given concept is a member of
    
    Specified by:
    
    getSetsContainingConcept in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getSetsContainingConcept(org.openmrs.Concept)
  - getConceptProposal
```
@Transactional(readOnly=true)
public ConceptProposal getConceptProposal(Integer conceptProposalId)
```
    Description copied from interface: ConceptService
    
    Get a ConceptProposal by conceptProposalId
    
    Specified by:
    
    getConceptProposal in interface ConceptService
    
    Parameters:
    
    conceptProposalId - the Integer concept proposal Id
    
    Returns:
    
    the found ConceptProposal
    
    See Also:
    
    ConceptService.getConceptProposal(java.lang.Integer)
  - getAllConceptProposals
```
@Transactional(readOnly=true)
public List<ConceptProposal> getAllConceptProposals(boolean includeCompleted)
```
    Description copied from interface: ConceptService
    
    Get a List of all concept proposals
    
    Specified by:
    
    getAllConceptProposals in interface ConceptService
    
    Parameters:
    
    includeCompleted - boolean - include completed proposals as well?
    
    Returns:
    
    a List<ConceptProposal> object of all found ConceptProposals
    
    See Also:
    
    ConceptService.getAllConceptProposals(boolean)
  - getConceptProposals
```
@Transactional(readOnly=true)
public List<ConceptProposal> getConceptProposals(String cp)
```
    Description copied from interface: ConceptService
    
    Find matching concept proposals
    
    Specified by:
    
    getConceptProposals in interface ConceptService
    
    Returns:
    
    a List<ConceptProposal> object containing matching concept proposals
    
    See Also:
    
    ConceptService.getConceptProposals(java.lang.String)
  - getProposedConcepts
```
@Transactional(readOnly=true)
public List<Concept> getProposedConcepts(String text)
```
    Description copied from interface: ConceptService
    
    Find matching proposed concepts
    
    Specified by:
    
    getProposedConcepts in interface ConceptService
    
    Returns:
    
    a List<Concept> object containing matching proposed concepts
    
    See Also:
    
    ConceptService.getProposedConcepts(java.lang.String)
  - saveConceptProposal
```
public ConceptProposal saveConceptProposal(ConceptProposal conceptProposal)
                                    throws APIException
```
    Description copied from interface: ConceptService
    
    Saves/updates/proposes a concept proposal
    
    Specified by:
    
    saveConceptProposal in interface ConceptService
    
    Parameters:
    
    conceptProposal - The ConceptProposal to save
    
    Returns:
    
    the saved/updated ConceptProposal object
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.saveConceptProposal(org.openmrs.ConceptProposal)
  - purgeConceptProposal
```
public void purgeConceptProposal(ConceptProposal cp)
                          throws APIException
```
    Description copied from interface: ConceptService
    
    Removes a concept proposal from the database entirely.
    
    Specified by:
    
    purgeConceptProposal in interface ConceptService
    
    Throws:
    
    APIException - Should purge the given concept proposal
    
    See Also:
    
    ConceptService.purgeConceptProposal(org.openmrs.ConceptProposal)
  - mapConceptProposalToConcept
```
public Concept mapConceptProposalToConcept(ConceptProposal cp,
                                           Concept mappedConcept,
                                           Locale locale)
                                    throws APIException
```
    Description copied from interface: ConceptService
    
    Maps a concept proposal to a concept
    
    Specified by:
    
    mapConceptProposalToConcept in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.mapConceptProposalToConcept(ConceptProposal, Concept, Locale)
  - mapConceptProposalToConcept
```
public Concept mapConceptProposalToConcept(ConceptProposal cp,
                                           Concept mappedConcept)
                                    throws APIException
```
    Description copied from interface: ConceptService
    
    Maps a concept proposal to a concept
    
    Specified by:
    
    mapConceptProposalToConcept in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.mapConceptProposalToConcept(org.openmrs.ConceptProposal, org.openmrs.Concept)
  - getConceptsByAnswer
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByAnswer(Concept concept)
                                                                throws APIException
```
    Description copied from interface: ConceptService
    
    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()
    
    Specified by:
    
    getConceptsByAnswer in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptsByAnswer(org.openmrs.Concept)
  - getPrevConcept
```
@Transactional(readOnly=true)
public Concept getPrevConcept(Concept c)
```
    Description copied from interface: ConceptService
    
    Finds the previous concept in the dictionary that has the next lowest concept id
    
    Specified by:
    
    getPrevConcept in interface ConceptService
    
    Parameters:
    
    c - the offset Concept
    
    Returns:
    
    the foundConcept
    
    See Also:
    
    ConceptService.getPrevConcept(org.openmrs.Concept)
  - getNextConcept
```
@Transactional(readOnly=true)
public Concept getNextConcept(Concept c)
```
    Description copied from interface: ConceptService
    
    Finds the next concept in the dictionary that has the next largest concept id
    
    Specified by:
    
    getNextConcept in interface ConceptService
    
    Parameters:
    
    c - the offset Concept
    
    Returns:
    
    the foundConcept
    
    See Also:
    
    ConceptService.getNextConcept(org.openmrs.Concept)
  - checkIfLocked
```
@Transactional(readOnly=true)
public void checkIfLocked()
                                                 throws ConceptsLockedException
```
    Description copied from interface: ConceptService
    
    Check if the concepts are locked and if so, throw exception during manipulation of concept
    
    Specified by:
    
    checkIfLocked in interface ConceptService
    
    Throws:
    
    ConceptsLockedException
    
    See Also:
    
    ConceptService.checkIfLocked()
  - getConceptsWithDrugsInFormulary
```
@Transactional(readOnly=true)
public List<Concept> getConceptsWithDrugsInFormulary()
```
    Description copied from interface: ConceptService
    
    Convenience method for finding concepts associated with drugs in formulary.
    
    Specified by:
    
    getConceptsWithDrugsInFormulary in interface ConceptService
    
    Returns:
    
    A List<Concept> object of all concepts that occur as a Drug.concept.
    
    See Also:
    
    ConceptService.getConceptsWithDrugsInFormulary()
  - getMaxConceptId
```
@Transactional(readOnly=true)
public Integer getMaxConceptId()
```
    Description copied from interface: ConceptService
    
    Gets the highest concept-id used by a concept.
    
    Specified by:
    
    getMaxConceptId in interface ConceptService
    
    Returns:
    
    highest concept-id Should give the maximum concept-id
    
    See Also:
    
    ConceptService.getMaxConceptId()
  - getConceptNameTagByName
```
@Transactional(readOnly=true)
public ConceptNameTag getConceptNameTagByName(String tagName)
```
    Description copied from interface: ConceptService
    
    Search for a ConceptNameTag by name
    
    Specified by:
    
    getConceptNameTagByName in interface ConceptService
    
    Parameters:
    
    tagName - String name of ConceptNameTag
    
    Returns:
    
    ConceptNameTag matching the given String tag
    
    See Also:
    
    ConceptService.getConceptNameTagByName(java.lang.String)
  - getLocalesOfConceptNames
```
@Transactional(readOnly=true)
public Set<Locale> getLocalesOfConceptNames()
```
    Description copied from interface: ConceptService
    
    Gets the set of unique Locales used by existing concept names.
    
    Specified by:
    
    getLocalesOfConceptNames in interface ConceptService
    
    Returns:
    
    set of used Locales Should return a list of matching locales
    
    See Also:
    
    ConceptService.getLocalesOfConceptNames()
  - getConceptSource
```
@Transactional(readOnly=true)
public ConceptSource getConceptSource(Integer conceptSourceId)
```
    Description copied from interface: ConceptService
    
    Return a Concept source matching the given concept source id
    
    Specified by:
    
    getConceptSource in interface ConceptService
    
    Parameters:
    
    conceptSourceId - Integer conceptSourceId
    
    Returns:
    
    ConceptSource
    
    See Also:
    
    ConceptService.getConceptSource(java.lang.Integer)
  - getAllConceptSources
```
@Transactional(readOnly=true)
public List<ConceptSource> getAllConceptSources(boolean includeRetired)
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getAllConceptSources in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getAllConceptSources(boolean)
  - purgeConceptSource
```
@CacheEvict(value="conceptIdsByMapping",
            allEntries=true)
public ConceptSource purgeConceptSource(ConceptSource cs)
                                                                                                       throws APIException
```
    Description copied from interface: ConceptService
    
    Delete ConceptSource
    
    Specified by:
    
    purgeConceptSource in interface ConceptService
    
    Parameters:
    
    cs - ConceptSource object delete
    
    Throws:
    
    APIException - Should purge the given concept source
    
    See Also:
    
    ConceptService.purgeConceptSource(org.openmrs.ConceptSource)
  - retireConceptSource
```
public ConceptSource retireConceptSource(ConceptSource cs,
                                         String reason)
                                  throws APIException
```
    Description copied from interface: ConceptService
    
    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.
    
    Specified by:
    
    retireConceptSource in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.retireConceptSource(org.openmrs.ConceptSource, String)
  - saveConceptSource
```
@CacheEvict(value="conceptIdsByMapping",
            allEntries=true)
public ConceptSource saveConceptSource(ConceptSource conceptSource)
                                                                                                      throws APIException
```
    Description copied from interface: ConceptService
    
    Create a new ConceptSource
    
    Specified by:
    
    saveConceptSource in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.saveConceptSource(org.openmrs.ConceptSource)
  - saveConceptNameTag
```
public ConceptNameTag saveConceptNameTag(ConceptNameTag nameTag)
```
    Description copied from interface: ConceptService
    
    Creates a new Concept name tag if none exists. If a tag exists with the same name then that existing tag is returned.
    
    Specified by:
    
    saveConceptNameTag in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.saveConceptNameTag(org.openmrs.ConceptNameTag)
  - conceptIterator
```
@Transactional(readOnly=true)
public Iterator<Concept> conceptIterator()
```
    Description copied from interface: ConceptService
    
    Returns an iterator for all concepts, including retired and expired.
    
    Specified by:
    
    conceptIterator in interface ConceptService
    
    Returns:
    
    the Iterator Should start with the smallest concept id Should iterate over all concepts
    
    See Also:
    
    ConceptService.conceptIterator()
  - getConceptByUuid
```
@Transactional(readOnly=true)
public Concept getConceptByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get Concept by its UUID
    
    Specified by:
    
    getConceptByUuid in interface ConceptService
    
    Returns:
    
    concept or null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getConceptByUuid(java.lang.String)
  - getConceptClassByUuid
```
@Transactional(readOnly=true)
public ConceptClass getConceptClassByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptClass by its UUID
    
    Specified by:
    
    getConceptClassByUuid in interface ConceptService
    
    Returns:
    
    concept class or null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getConceptClassByUuid(java.lang.String)
  - getConceptAnswerByUuid
```
@Transactional(readOnly=true)
public ConceptAnswer getConceptAnswerByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptAnswer by its UUID
    
    Specified by:
    
    getConceptAnswerByUuid in interface ConceptService
    
    Returns:
    
    concept answer or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptNameByUuid
```
@Transactional(readOnly=true)
public ConceptName getConceptNameByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptName by its UUID
    
    Specified by:
    
    getConceptNameByUuid in interface ConceptService
    
    Returns:
    
    concept name or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptSetByUuid
```
public ConceptSet getConceptSetByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptSet by its UUID
    
    Specified by:
    
    getConceptSetByUuid in interface ConceptService
    
    Returns:
    
    concept set or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptSourceByUuid
```
@Transactional(readOnly=true)
public ConceptSource getConceptSourceByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptSource by its UUID
    
    Specified by:
    
    getConceptSourceByUuid in interface ConceptService
    
    Returns:
    
    concept source or null Should find object given valid uuid Should return null if no object found with given uuid
  - getConceptDatatypeByUuid
```
@Transactional(readOnly=true)
public ConceptDatatype getConceptDatatypeByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptDatatype by its UUID
    
    Specified by:
    
    getConceptDatatypeByUuid in interface ConceptService
    
    Returns:
    
    concept data type or null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getConceptDatatypeByUuid(java.lang.String)
  - getConceptNumericByUuid
```
@Transactional(readOnly=true)
public ConceptNumeric getConceptNumericByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptNumeric by its UUID
    
    Specified by:
    
    getConceptNumericByUuid in interface ConceptService
    
    Returns:
    
    concept numeric or null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getConceptNumericByUuid(java.lang.String)
  - getConceptProposalByUuid
```
@Transactional(readOnly=true)
public ConceptProposal getConceptProposalByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptProposal by its UUID
    
    Specified by:
    
    getConceptProposalByUuid in interface ConceptService
    
    Returns:
    
    concept proposal or null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getConceptProposalByUuid(java.lang.String)
  - getDrugByUuid
```
@Transactional(readOnly=true)
public Drug getDrugByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get Drug by its UUID
    
    Specified by:
    
    getDrugByUuid in interface ConceptService
    
    Returns:
    
    drug of null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getDrugByUuid(java.lang.String)
  - getDrugIngredientByUuid
```
@Transactional(readOnly=true)
public DrugIngredient getDrugIngredientByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get Drug Ingredient by its UUID
    
    Specified by:
    
    getDrugIngredientByUuid in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getDrugIngredientByUuid(java.lang.String)
  - getConceptDescriptionByUuid
```
@Transactional(readOnly=true)
public ConceptDescription getConceptDescriptionByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptDescription by its UUID
    
    Specified by:
    
    getConceptDescriptionByUuid in interface ConceptService
    
    Returns:
    
    concept description or null Should find object given valid uuid Should return null if no object found with given uuid
    
    See Also:
    
    ConceptService.getConceptDescriptionByUuid(java.lang.String)
  - getConceptNameTagByUuid
```
@Transactional(readOnly=true)
public ConceptNameTag getConceptNameTagByUuid(String uuid)
```
    Description copied from interface: ConceptService
    
    Get ConceptNameTag by its UUID
    
    Specified by:
    
    getConceptNameTagByUuid in interface ConceptService
    
    Returns:
    
    the conceptNameTag with a matching uuid
    
    See Also:
    
    ConceptService.getConceptNameTagByUuid(java.lang.String)
  - getAllConceptNameTags
```
@Transactional(readOnly=true)
public List<ConceptNameTag> getAllConceptNameTags()
```
    Description copied from interface: ConceptService
    
    Get all the concept name tags defined in the database, included voided ones
    
    Specified by:
    
    getAllConceptNameTags in interface ConceptService
    
    Returns:
    
    a list of the concept name tags stored in the dataset Should return a list of all concept name tags
    
    See Also:
    
    ConceptService.getAllConceptNameTags()
  - getConceptNameTag
```
@Transactional(readOnly=true)
public ConceptNameTag getConceptNameTag(Integer id)
```
    Description copied from interface: ConceptService
    
    Gets the ConceptNameTag with the given database primary key
    
    Specified by:
    
    getConceptNameTag in interface ConceptService
    
    Parameters:
    
    id - the concept name tag id to find
    
    Returns:
    
    the matching ConceptNameTag or null if none found
    
    See Also:
    
    ConceptService.getConceptNameTag(java.lang.Integer)
  - getConceptByMapping
```
@Transactional(readOnly=true)
public Concept getConceptByMapping(String code,
                                                                 String sourceName)
                                                          throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptByMapping(java.lang.String, java.lang.String)
  - getConceptByMapping
```
@Transactional(readOnly=true)
public Concept getConceptByMapping(String code,
                                                                 String sourceName,
                                                                 Boolean includeRetired)
                                                          throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptByMapping(java.lang.String, java.lang.String, java.lang.Boolean)
  - getConceptsByMapping
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByMapping(String code,
                                                                        String sourceName)
                                                                 throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptsByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptsByMapping(java.lang.String, java.lang.String)
  - getConceptsByMapping
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByMapping(String code,
                                                                        String sourceName,
                                                                        boolean includeRetired)
                                                                 throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptsByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptsByMapping(java.lang.String, java.lang.String, boolean)
  - getConceptIdsByMapping
```
@Transactional(readOnly=true)
 @Cacheable(value="conceptIdsByMapping")
public List<Integer> getConceptIdsByMapping(String code,
                                                                                                                   String sourceName,
                                                                                                                   boolean includeRetired)
                                                                                                            throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptIdsByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptIdsByMapping(java.lang.String, java.lang.String, boolean)
  - getFalseConcept
```
@Transactional(readOnly=true)
public Concept getFalseConcept()
```
    Description copied from interface: ConceptService
    
    Returns the FALSE concept
    
    Specified by:
    
    getFalseConcept in interface ConceptService
    
    Returns:
    
    false concept Should return the false concept
    
    See Also:
    
    ConceptService.getFalseConcept()
  - getTrueConcept
```
@Transactional(readOnly=true)
public Concept getTrueConcept()
```
    Description copied from interface: ConceptService
    
    Returns the TRUE concept
    
    Specified by:
    
    getTrueConcept in interface ConceptService
    
    Returns:
    
    true concept Should return the true concept
    
    See Also:
    
    ConceptService.getTrueConcept()
  - getUnknownConcept
```
@Transactional(readOnly=true)
public Concept getUnknownConcept()
```
    Description copied from interface: ConceptService
    
    Returns the UNKNOWN concept
    
    Specified by:
    
    getUnknownConcept in interface ConceptService
    
    Returns:
    
    unknown concept Should return the unknown concept
    
    See Also:
    
    ConceptService.getUnknownConcept()
  - getConceptSourceByName
```
@Transactional(readOnly=true)
public ConceptSource getConceptSourceByName(String conceptSourceName)
                                                                   throws APIException
```
    Description copied from interface: ConceptService
    
    Lookup a ConceptSource by its name property
    
    Specified by:
    
    getConceptSourceByName in interface ConceptService
    
    Returns:
    
    ConceptSource
    
    Throws:
    
    APIException - Should get ConceptSource with the given name Should return null if no ConceptSource with that name is found
    
    See Also:
    
    ConceptService.getConceptSourceByName(java.lang.String)
  - getConceptSourceByUniqueId
```
@Transactional(readOnly=true)
public ConceptSource getConceptSourceByUniqueId(String uniqueId)
                                                                       throws APIException
```
    Description copied from interface: ConceptService
    
    Get a ConceptSource by its unique id.
    
    Specified by:
    
    getConceptSourceByUniqueId in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptSourceByUniqueId(java.lang.String)
  - getConceptSourceByHL7Code
```
@Transactional(readOnly=true)
public ConceptSource getConceptSourceByHL7Code(String hl7Code)
                                                                      throws APIException
```
    Description copied from interface: ConceptService
    
    Get a ConceptSource by its hl7Code.
    
    Specified by:
    
    getConceptSourceByHL7Code in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptSourceByHL7Code(java.lang.String)
  - hasAnyObservation
```
@Transactional(readOnly=true)
public boolean hasAnyObservation(Concept concept)
```
    Description copied from interface: ConceptService
    
    Checks if there are any observations (including voided observations) for a concept.
    
    Specified by:
    
    hasAnyObservation in interface ConceptService
    
    Parameters:
    
    concept - which used or not used by an observation
    
    Returns:
    
    boolean true if the concept is used by an observation
    
    See Also:
    
    ConceptService.hasAnyObservation(org.openmrs.Concept)
  - convertBooleanConceptToCoded
```
public void convertBooleanConceptToCoded(Concept conceptToChange)
                                  throws APIException
```
    Description copied from interface: ConceptService
    
    Changes the datatype of a concept from boolean to coded when it has observations it is associated to.
    
    Specified by:
    
    convertBooleanConceptToCoded in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.convertBooleanConceptToCoded(org.openmrs.Concept)
  - hasAnyObservation
```
@Transactional(readOnly=true)
public boolean hasAnyObservation(ConceptName conceptName)
                                                        throws APIException
```
    Description copied from interface: ConceptService
    
    Checks if there are any observations (including voided observations) using a conceptName.
    
    Specified by:
    
    hasAnyObservation in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.hasAnyObservation(org.openmrs.ConceptName)
  - findConceptAnswers
```
@Transactional(readOnly=true)
public List<ConceptSearchResult> findConceptAnswers(String phrase,
                                                                                  Locale locale,
                                                                                  Concept concept)
                                                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Finds concepts that are possible value coded answers to concept parameter
    
    Specified by:
    
    findConceptAnswers in interface ConceptService
    
    concept - the answers to match on
    
    Returns:
    
    a list of conceptSearchResults
    
    Throws:
    
    APIException - Should return a list of all matching concept search results
    
    See Also:
    
    ConceptService.findConceptAnswers(String, Locale, Concept)
  - getConceptStopWords
```
@Transactional(readOnly=true)
public List<String> getConceptStopWords(Locale locale)
```
    Description copied from interface: ConceptService
    
    Gets the list of ConceptStopWord for given locale
    
    Specified by:
    
    getConceptStopWords in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptStopWords(java.util.Locale)
  - saveConceptStopWord
```
public ConceptStopWord saveConceptStopWord(ConceptStopWord conceptStopWord)
                                    throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    saveConceptStopWord in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.saveConceptStopWord(org.openmrs.ConceptStopWord)
  - deleteConceptStopWord
```
public void deleteConceptStopWord(Integer conceptStopWordId)
                           throws APIException
```
    Description copied from interface: ConceptService
    
    Delete the given ConceptStopWord in the database
    
    Specified by:
    
    deleteConceptStopWord in interface ConceptService
    
    Parameters:
    
    conceptStopWordId - The ConceptStopWord to delete
    
    Throws:
    
    APIException - Should delete the given concept stop word from the database
    
    See Also:
    
    ConceptService.deleteConceptStopWord(Integer)
  - getAllConceptStopWords
```
@Transactional(readOnly=true)
public List<ConceptStopWord> getAllConceptStopWords()
```
    Description copied from interface: ConceptService
    
    Get all the concept stop words
    
    Specified by:
    
    getAllConceptStopWords in interface ConceptService
    
    Returns:
    
    List of ConceptStopWord Should return all the concept stop words Should return empty list if nothing found
    
    See Also:
    
    ConceptService.getAllConceptStopWords()
  - getConcepts
```
@Transactional(readOnly=true)
public 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
```
    Description copied from interface: ConceptService
    
    Searches for concepts by the given parameters.
    
    Specified by:
    
    getConcepts in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConcepts(String, List, boolean, List, List, List, List, Concept, Integer, Integer)
  - updateConceptIndex
```
public void updateConceptIndex(Concept concept)
                        throws APIException
```
    Description copied from interface: ConceptService
    
    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 ConceptService.updateConceptIndexes() if you wish to update the entire concept index.
    
    Specified by:
    
    updateConceptIndex in interface ConceptService
    
    Parameters:
    
    concept - the concept whose index is to be updated
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.updateConceptIndex(Concept)
  - updateConceptIndexes
```
@CacheEvict(value="conceptIdsByMapping",
            allEntries=true)
public void updateConceptIndexes()
                                                                                                throws APIException
```
    Description copied from interface: ConceptService
    
    Iterates over all concepts and calls updateConceptIndexes(Concept concept)
    
    Specified by:
    
    updateConceptIndexes in interface ConceptService
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.updateConceptIndexes()
  - getCountOfConcepts
```
@Transactional(readOnly=true)
public Integer getCountOfConcepts(String phrase,
                                                                List<Locale> locales,
                                                                boolean includeRetired,
                                                                List<ConceptClass> requireClasses,
                                                                List<ConceptClass> excludeClasses,
                                                                List<ConceptDatatype> requireDatatypes,
                                                                List<ConceptDatatype> excludeDatatypes,
                                                                Concept answersToConcept)
```
    Description copied from interface: ConceptService
    
    Return the number of concepts matching a search phrase and the specified arguments
    
    Specified by:
    
    getCountOfConcepts in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getCountOfConcepts(String, List, boolean, List, List, List, List, Concept)
  - getCountOfDrugs
```
@Transactional(readOnly=true)
public Integer getCountOfDrugs(String drugName,
                                                             Concept concept,
                                                             boolean searchOnPhrase,
                                                             boolean searchDrugConceptNames,
                                                             boolean includeRetired)
                                                      throws APIException
```
    Description copied from interface: ConceptService
    
    Return the number of drugs with matching names or concept drug names
    
    Specified by:
    
    getCountOfDrugs in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getCountOfDrugs(String, Concept, boolean, boolean, boolean)
  - getDrugs
```
@Transactional(readOnly=true)
public List<Drug> getDrugs(String drugName,
                                                         Concept concept,
                                                         boolean searchOnPhrase,
                                                         boolean searchDrugConceptNames,
                                                         boolean includeRetired,
                                                         Integer start,
                                                         Integer length)
                                                  throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getDrugs in interface ConceptService
    
    Parameters:
    
    drugName - the name of the drug
    
    concept - the drug concept
    
    searchOnPhrase - (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
    
    See Also:
    
    ConceptService.getDrugs(String, Concept, boolean, boolean, boolean, Integer, Integer)
  - getConcepts
```
@Transactional(readOnly=true)
public List<ConceptSearchResult> getConcepts(String phrase,
                                                                           Locale locale,
                                                                           boolean includeRetired)
                                                                    throws APIException
```
    Description copied from interface: ConceptService
    
    Searches for concepts with the given parameters
    
    Specified by:
    
    getConcepts in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConcepts(String, Locale, boolean)
  - getDrugsByIngredient
```
@Transactional(readOnly=true)
public List<Drug> getDrugsByIngredient(Concept ingredient)
                                                              throws APIException
```
    Description copied from interface: ConceptService
    
    Gets drugs by the given ingredient, which can be either the drug itself or any ingredient.
    
    Specified by:
    
    getDrugsByIngredient in interface ConceptService
    
    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
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getDrugsByIngredient(org.openmrs.Concept)
  - getConceptMappingsToSource
```
@Transactional(readOnly=true)
public List<ConceptMap> getConceptMappingsToSource(ConceptSource conceptSource)
                                                                          throws APIException
```
    Description copied from interface: ConceptService
    
    Returns a list of mappings from concepts to terms in the given reference terminology
    
    Specified by:
    
    getConceptMappingsToSource in interface ConceptService
    
    Returns:
    
    a List<ConceptMap> object
    
    Throws:
    
    APIException - Should return a List of ConceptMaps from the given source
    
    See Also:
    
    ConceptService.getConceptMappingsToSource(ConceptSource)
  - getActiveConceptMapTypes
```
@Transactional(readOnly=true)
public List<ConceptMapType> getActiveConceptMapTypes()
                                                                            throws APIException
```
    Description copied from interface: ConceptService
    
    Returns a list of concept map types currently in the database excluding hidden ones
    
    Specified by:
    
    getActiveConceptMapTypes in interface ConceptService
    
    Returns:
    
    List of concept map type objects
    
    Throws:
    
    APIException - Should return all the concept map types excluding hidden ones
    
    See Also:
    
    ConceptService.getActiveConceptMapTypes()
  - getConceptMapTypes
```
@Transactional(readOnly=true)
public List<ConceptMapType> getConceptMapTypes(boolean includeRetired,
                                                                             boolean includeHidden)
                                                                      throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getConceptMapTypes in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptMapTypes(boolean, boolean)
  - getConceptMapType
```
@Transactional(readOnly=true)
public ConceptMapType getConceptMapType(Integer conceptMapTypeId)
                                                               throws APIException
```
    Description copied from interface: ConceptService
    
    Return a concept map type matching the given concept map type id
    
    Specified by:
    
    getConceptMapType in interface ConceptService
    
    Parameters:
    
    conceptMapTypeId - Integer concept map type id
    
    Returns:
    
    ConceptMapType
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConceptMapType(Integer)
  - getConceptMapTypeByUuid
```
@Transactional(readOnly=true)
public ConceptMapType getConceptMapTypeByUuid(String uuid)
                                                                     throws APIException
```
    Description copied from interface: ConceptService
    
    Return a concept map type matching the given uuid
    
    Specified by:
    
    getConceptMapTypeByUuid in interface ConceptService
    
    Parameters:
    
    uuid - the uuid to search against
    
    Returns:
    
    ConceptMapType
    
    Throws:
    
    APIException - Should return a conceptMapType matching the specified uuid
    
    See Also:
    
    ConceptService.getConceptMapTypeByUuid(String)
  - getConceptMapTypeByName
```
@Transactional(readOnly=true)
public ConceptMapType getConceptMapTypeByName(String name)
                                                                     throws APIException
```
    Description copied from interface: ConceptService
    
    Return a concept map type matching the given name
    
    Specified by:
    
    getConceptMapTypeByName in interface ConceptService
    
    Parameters:
    
    name - the name to search against
    
    Returns:
    
    ConceptMapType
    
    Throws:
    
    APIException - Should return a conceptMapType matching the specified name Should be case insensitive
    
    See Also:
    
    ConceptService.getConceptMapTypeByName(java.lang.String)
  - saveConceptMapType
```
public ConceptMapType saveConceptMapType(ConceptMapType conceptMapType)
                                  throws APIException
```
    Description copied from interface: ConceptService
    
    Saves or updates the specified concept map type in the database
    
    Specified by:
    
    saveConceptMapType in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.saveConceptMapType(org.openmrs.ConceptMapType)
  - retireConceptMapType
```
public ConceptMapType retireConceptMapType(ConceptMapType conceptMapType,
                                           String retireReason)
                                    throws APIException
```
    Description copied from interface: ConceptService
    
    Retiring a concept map type essentially removes it from circulation
    
    Specified by:
    
    retireConceptMapType in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.retireConceptMapType(org.openmrs.ConceptMapType, java.lang.String)
  - unretireConceptMapType
```
public ConceptMapType unretireConceptMapType(ConceptMapType conceptMapType)
                                      throws APIException
```
    Description copied from interface: ConceptService
    
    Marks a concept map type that is currently retired as not retired.
    
    Specified by:
    
    unretireConceptMapType in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.unretireConceptMapType(org.openmrs.ConceptMapType)
  - purgeConceptMapType
```
public void purgeConceptMapType(ConceptMapType conceptMapType)
                         throws APIException
```
    Description copied from interface: ConceptService
    
    Completely purges a concept map type from the database
    
    Specified by:
    
    purgeConceptMapType in interface ConceptService
    
    Parameters:
    
    conceptMapType - the concept map type to purge from the database
    
    Throws:
    
    APIException - Should delete the specified conceptMapType from the database
    
    See Also:
    
    ConceptService.purgeConceptMapType(org.openmrs.ConceptMapType)
  - getAllConceptReferenceTerms
```
@Transactional(readOnly=true)
public List<ConceptReferenceTerm> getAllConceptReferenceTerms()
                                                                                     throws APIException
```
    Description copied from interface: ConceptService
    
    Gets a list of all concept reference terms saved in the database
    
    Specified by:
    
    getAllConceptReferenceTerms in interface ConceptService
    
    Returns:
    
    a list of concept reference terms
    
    Throws:
    
    APIException - Should return all concept reference terms in the database
    
    See Also:
    
    ConceptService.getAllConceptReferenceTerms()
  - getConceptReferenceTerms
```
@Transactional(readOnly=true)
public List<ConceptReferenceTerm> getConceptReferenceTerms(boolean includeRetired)
                                                                                  throws APIException
```
    Description copied from interface: ConceptService
    
    Gets a list of concept reference terms saved in the database
    
    Specified by:
    
    getConceptReferenceTerms in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptReferenceTerms(boolean)
  - getConceptReferenceTerm
```
@Transactional(readOnly=true)
public ConceptReferenceTerm getConceptReferenceTerm(Integer conceptReferenceTermId)
                                                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Gets the concept reference term with the specified concept reference term id
    
    Specified by:
    
    getConceptReferenceTerm in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptReferenceTerm(java.lang.Integer)
  - getConceptReferenceTermByUuid
```
@Transactional(readOnly=true)
public ConceptReferenceTerm getConceptReferenceTermByUuid(String uuid)
                                                                                 throws APIException
```
    Description copied from interface: ConceptService
    
    Gets the concept reference term with the specified uuid
    
    Specified by:
    
    getConceptReferenceTermByUuid in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptReferenceTermByUuid(java.lang.String)
  - getConceptReferenceTermByName
```
@Transactional(readOnly=true)
public ConceptReferenceTerm getConceptReferenceTermByName(String name,
                                                                                        ConceptSource conceptSource)
                                                                                 throws APIException
```
    Description copied from interface: ConceptService
    
    Gets a concept reference term with the specified name from the specified concept source ignoring all retired ones
    
    Specified by:
    
    getConceptReferenceTermByName in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptReferenceTermByName(java.lang.String, org.openmrs.ConceptSource)
  - getConceptReferenceTermByCode
```
@Transactional(readOnly=true)
public ConceptReferenceTerm getConceptReferenceTermByCode(String code,
                                                                                        ConceptSource conceptSource)
                                                                                 throws APIException
```
    Description copied from interface: ConceptService
    
    Gets a concept reference term with the specified code from the specified concept source
    
    Specified by:
    
    getConceptReferenceTermByCode in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptReferenceTermByCode(java.lang.String, org.openmrs.ConceptSource)
  - getConceptReferenceTermByCode
```
@Transactional(readOnly=true)
public List<ConceptReferenceTerm> getConceptReferenceTermByCode(String code,
                                                                                              ConceptSource conceptSource,
                                                                                              boolean includeRetired)
                                                                                       throws APIException
```
    Description copied from interface: ConceptService
    
    Gets a list of concept reference terms with the specified code from the specified concept source
    
    Specified by:
    
    getConceptReferenceTermByCode in interface ConceptService
    
    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
  - saveConceptReferenceTerm
```
@CacheEvict(value="conceptIdsByMapping",
            allEntries=true)
public ConceptReferenceTerm saveConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)
                                                                                                                    throws APIException
```
    Description copied from interface: ConceptService
    
    Stores the specified concept reference term to the database
    
    Specified by:
    
    saveConceptReferenceTerm in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.saveConceptReferenceTerm(org.openmrs.ConceptReferenceTerm)
  - retireConceptReferenceTerm
```
public ConceptReferenceTerm retireConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm,
                                                       String retireReason)
                                                throws APIException
```
    Description copied from interface: ConceptService
    
    Retiring a concept reference term essentially removes it from circulation
    
    Specified by:
    
    retireConceptReferenceTerm in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.retireConceptReferenceTerm(ConceptReferenceTerm, String)
  - unretireConceptReferenceTerm
```
public ConceptReferenceTerm unretireConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)
                                                  throws APIException
```
    Description copied from interface: ConceptService
    
    Marks a concept reference term that is currently retired as not retired.
    
    Specified by:
    
    unretireConceptReferenceTerm in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.unretireConceptReferenceTerm(org.openmrs.ConceptReferenceTerm)
  - purgeConceptReferenceTerm
```
@CacheEvict(value="conceptIdsByMapping",
            allEntries=true)
public void purgeConceptReferenceTerm(ConceptReferenceTerm conceptReferenceTerm)
                                                                                                     throws APIException
```
    Description copied from interface: ConceptService
    
    Purges the specified concept reference term from the database
    
    Specified by:
    
    purgeConceptReferenceTerm in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.purgeConceptReferenceTerm(org.openmrs.ConceptReferenceTerm)
  - getConceptReferenceTerms
```
@Transactional(readOnly=true)
public List<ConceptReferenceTerm> getConceptReferenceTerms(String query,
                                                                                         ConceptSource conceptSource,
                                                                                         Integer start,
                                                                                         Integer length,
                                                                                         boolean includeRetired)
                                                                                  throws APIException
```
    Description copied from interface: ConceptService
    
    Finds the concept reference term in the database that have a code or name that contains the specified search phrase.
    
    Specified by:
    
    getConceptReferenceTerms in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptReferenceTerms(java.lang.String, org.openmrs.ConceptSource, java.lang.Integer, java.lang.Integer, boolean)
  - getCountOfConceptReferenceTerms
```
@Transactional(readOnly=true)
public Integer getCountOfConceptReferenceTerms(String query,
                                                                             ConceptSource conceptSource,
                                                                             boolean includeRetired)
```
    Description copied from interface: ConceptService
    
    Returns the count of concept reference terms that match the specified arguments
    
    Specified by:
    
    getCountOfConceptReferenceTerms in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getCountOfConceptReferenceTerms(String, ConceptSource, boolean)
  - getReferenceTermMappingsTo
```
@Transactional(readOnly=true)
public List<ConceptReferenceTermMap> getReferenceTermMappingsTo(ConceptReferenceTerm term)
                                                                                       throws APIException
```
    Description copied from interface: ConceptService
    
    Fetches all the ConceptReferenceTermMap where the specified reference term is the termB i.e mappings added to other terms pointing to it
    
    Specified by:
    
    getReferenceTermMappingsTo in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getReferenceTermMappingsTo(ConceptReferenceTerm)
  - getConceptsByName
```
@Transactional(readOnly=true)
public List<Concept> getConceptsByName(String name,
                                                                     Locale locale,
                                                                     Boolean exactLocale)
                                                              throws APIException
```
    Description copied from interface: ConceptService
    
    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.
    
    Specified by:
    
    getConceptsByName in interface ConceptService
    
    locale - null = all locales
    
    exactLocale - false if search for both global and country specific, true if null
    
    Returns:
    
    the list of concepts
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getConceptsByName(java.lang.String, java.util.Locale, java.lang.Boolean)
  - getDefaultConceptMapType
```
@Transactional(readOnly=true)
public ConceptMapType getDefaultConceptMapType()
                                                                      throws APIException
```
    Description copied from interface: ConceptService
    
    Gets the concept map type to be used as the default. It is specified by the concept.defaultConceptMapType global property.
    
    Specified by:
    
    getDefaultConceptMapType in interface ConceptService
    
    Returns:
    
    the ConceptMapType
    
    Throws:
    
    APIException - Should return same as by default Should return type as set in gp
    
    See Also:
    
    ConceptService.getDefaultConceptMapType()
  - isConceptNameDuplicate
```
public boolean isConceptNameDuplicate(ConceptName name)
```
    Description copied from interface: ConceptService
    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
    Specified by:
    
    isConceptNameDuplicate in interface ConceptService
    
    Returns:
    
    true if it is a duplicate name
    
    See Also:
    
    ConceptService.isConceptNameDuplicate(org.openmrs.ConceptName)
  - getDrugs
```
@Transactional(readOnly=true)
public List<Drug> getDrugs(String searchPhrase,
                                                         Locale locale,
                                                         boolean exactLocale,
                                                         boolean includeRetired)
                                                  throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getDrugs in interface ConceptService
    
    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
    
    Throws:
    
    APIException
    
    See Also:
    
    ConceptService.getDrugs(String, java.util.Locale, boolean, boolean)
  - getDrugsByMapping
```
@Transactional(readOnly=true)
public List<Drug> getDrugsByMapping(String code,
                                                                  ConceptSource conceptSource,
                                                                  Collection<ConceptMapType> withAnyOfTheseTypes,
                                                                  boolean includeRetired)
                                                           throws APIException
```
    Description copied from interface: ConceptService
    
    Fetches all drugs with reference mappings to the specified concept source that match the specified code and concept map types
    
    Specified by:
    
    getDrugsByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getDrugsByMapping(String, ConceptSource, Collection, boolean)
  - getDrugByMapping
```
@Transactional(readOnly=true)
public Drug getDrugByMapping(String code,
                                                           ConceptSource conceptSource,
                                                           Collection<ConceptMapType> withAnyOfTheseTypesOrOrderOfPreference)
                                                    throws APIException
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getDrugByMapping in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getDrugByMapping(String, org.openmrs.ConceptSource, java.util.Collection)
  - getOrderableConcepts
```
@Transactional(readOnly=true)
public List<ConceptSearchResult> getOrderableConcepts(String phrase,
                                                                                    List<Locale> locales,
                                                                                    boolean includeRetired,
                                                                                    Integer start,
                                                                                    Integer length)
```
    Description copied from interface: ConceptService
    
    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
    
    Specified by:
    
    getOrderableConcepts in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getOrderableConcepts(String, java.util.List, boolean, Integer, Integer)
  - getAllConceptAttributeTypes
```
@Transactional(readOnly=true)
public List<ConceptAttributeType> getAllConceptAttributeTypes()
```
    Specified by:
    
    getAllConceptAttributeTypes in interface ConceptService
    
    Returns:
    
    all ConceptAttributeTypes
    
    See Also:
    
    ConceptService.getAllConceptAttributeTypes()
  - saveConceptAttributeType
```
public ConceptAttributeType saveConceptAttributeType(ConceptAttributeType conceptAttributeType)
```
    Description copied from interface: ConceptService
    
    Creates or updates the given concept attribute type in the database
    
    Specified by:
    
    saveConceptAttributeType in interface ConceptService
    
    Returns:
    
    the ConceptAttributeType created/saved
    
    See Also:
    
    ConceptService.saveConceptAttributeType(ConceptAttributeType)
  - getConceptAttributeType
```
@Transactional(readOnly=true)
public ConceptAttributeType getConceptAttributeType(Integer id)
```
    Specified by:
    
    getConceptAttributeType in interface ConceptService
    
    Returns:
    
    the ConceptAttributeType with the given internal id
    
    See Also:
    
    ConceptService.getConceptAttributeType(Integer)
  - getConceptAttributeTypeByUuid
```
@Transactional(readOnly=true)
public ConceptAttributeType getConceptAttributeTypeByUuid(String uuid)
```
    Specified by:
    
    getConceptAttributeTypeByUuid in interface ConceptService
    
    Returns:
    
    the ConceptAttributeType with the given uuid
    
    See Also:
    
    ConceptService.getConceptAttributeTypeByUuid(String)
  - purgeConceptAttributeType
```
public void purgeConceptAttributeType(ConceptAttributeType conceptAttributeType)
```
    Description copied from interface: ConceptService
    
    Completely removes a concept attribute type from the database
    
    Specified by:
    
    purgeConceptAttributeType in interface ConceptService
    
    See Also:
    
    ConceptService.purgeConceptAttributeType(ConceptAttributeType)
  - getConceptAttributeTypes
```
@Transactional(readOnly=true)
public List<ConceptAttributeType> getConceptAttributeTypes(String name)
                                                                                  throws APIException
```
    Description copied from interface: ConceptService
    
    Find concept attribute types matching the given parameters. Retired types are included in the results
    
    Specified by:
    
    getConceptAttributeTypes in interface ConceptService
    
    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
    
    See Also:
    
    ConceptService.getConceptAttributeTypes(String)
  - getConceptAttributeTypeByName
```
@Transactional(readOnly=true)
public ConceptAttributeType getConceptAttributeTypeByName(String exactName)
```
    Description copied from interface: ConceptService
    
    Retrieves a ConceptAttributeType object based on the name provided
    
    Specified by:
    
    getConceptAttributeTypeByName in interface ConceptService
    
    Returns:
    
    the ConceptAttributeType with the specified name
    
    See Also:
    
    ConceptService.getConceptAttributeTypeByName(String)
  - retireConceptAttributeType
```
public ConceptAttributeType retireConceptAttributeType(ConceptAttributeType conceptAttributeType,
                                                       String reason)
```
    Description copied from interface: ConceptService
    
    Retire a concept attribute type
    
    Specified by:
    
    retireConceptAttributeType in interface ConceptService
    
    Parameters:
    
    conceptAttributeType - the concept attribute type to be retired
    
    reason - for retiring the concept attribute type
    
    Returns:
    
    the retired concept attribute type
    
    See Also:
    
    ConceptService.retireConceptAttributeType(ConceptAttributeType, String)
  - unretireConceptAttributeType
```
public ConceptAttributeType unretireConceptAttributeType(ConceptAttributeType conceptAttributeType)
```
    Description copied from interface: ConceptService
    
    Un-Retire a concept attribute type
    
    Specified by:
    
    unretireConceptAttributeType in interface ConceptService
    
    Parameters:
    
    conceptAttributeType - the concept type attribute to unretire
    
    Returns:
    
    the unretire concept attribute type
    
    See Also:
    
    ConceptService.unretireConceptAttributeType(ConceptAttributeType)
  - getConceptAttributeByUuid
```
@Transactional(readOnly=true)
public ConceptAttribute getConceptAttributeByUuid(String uuid)
```
    Specified by:
    
    getConceptAttributeByUuid in interface ConceptService
    
    Returns:
    
    the ConceptAttribute with the given uuid
    
    See Also:
    
    ConceptService.getConceptAttributeByUuid(String)
  - hasAnyConceptAttribute
```
@Transactional(readOnly=true)
public boolean hasAnyConceptAttribute(ConceptAttributeType conceptAttributeType)
```
    Specified by:
    
    hasAnyConceptAttribute in interface ConceptService
    
    Returns:
    
    boolean true if the concept attribute type is used by a concept
    
    See Also:
    
    ConceptService.hasAnyConceptAttribute(ConceptAttributeType)
  - isValidUuidFormat
```
public static boolean isValidUuidFormat(String uuid)
```
    Determines if the passed string is in valid uuid format By OpenMRS standards, a uuid must be 36 characters in length and not contain whitespace, but we do not enforce that a uuid be in the "canonical" form, with alphanumerics seperated by dashes, since the MVP dictionary does not use this format (We also are being slightly lenient and accepting uuids that are 37 or 38 characters in length, since the uuid data field is 38 characters long)

Class ConceptServiceImpl

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.openmrs.api.OpenmrsService

Constructor Detail

ConceptServiceImpl

Method Detail

setConceptDAO

saveConcept

saveDrug

purgeConcept

retireConcept

retireDrug

unretireDrug

purgeDrug

getConcept

getConceptByReference

getConceptName

getConceptAnswer

getDrug

getConceptNumeric

getConceptComplex

getAllConcepts

getAllConcepts

getConceptsByName

getConceptByName

getConcept

getDrug

getAllDrugs

getAllDrugs

getDrugsByConcept

getDrugs

getConceptsByClass

getAllConceptClasses

getConceptClass

getConceptClassByName

getAllConceptClasses

saveConceptClass

purgeConceptClass

purgeConceptNameTag

getAllConceptDatatypes

getAllConceptDatatypes

getConceptDatatype

getConceptDatatypeByName

getConceptSetsByConcept

getConceptsByConceptSet

getSetsContainingConcept

getConceptProposal

getAllConceptProposals

getConceptProposals

getProposedConcepts

saveConceptProposal

purgeConceptProposal

mapConceptProposalToConcept

mapConceptProposalToConcept

getConceptsByAnswer

getPrevConcept

getNextConcept

checkIfLocked

getConceptsWithDrugsInFormulary

getMaxConceptId

getConceptNameTagByName

getLocalesOfConceptNames

getConceptSource

getAllConceptSources

purgeConceptSource

retireConceptSource

saveConceptSource

saveConceptNameTag

conceptIterator

getConceptByUuid

getConceptClassByUuid

getConceptAnswerByUuid

getConceptNameByUuid

getConceptSetByUuid

getConceptSourceByUuid

getConceptDatatypeByUuid

getConceptNumericByUuid