Package org.odpi.openmetadata.integrationservices.catalog.connector

Class GlossaryExchangeService

java.lang.Object
org.odpi.openmetadata.integrationservices.catalog.connector.GlossaryExchangeService
public class GlossaryExchangeService extends Object
GlossaryExchangeService is the client for managing resources from a glossary. This includes the glossary container, glossary categories and terms as well as relationships between them.

  • Method Details

    • isForLineage

      public boolean isForLineage()
      Return whether retrieval requests from this service are to include elements with the Memento classification attached or not.
      Returns:
      boolean flag

    • setForLineage

      public void setForLineage(boolean forLineage)
      Set up whether retrieval requests from this service are to include elements with the Memento classification attached or not.
      Parameters:
      forLineage - boolean flag

    • isForDuplicateProcessing

      public boolean isForDuplicateProcessing()
      Return whether retrieval requests from this service are to avoid merging duplicates or not.
      Returns:
      boolean flag

    • setForDuplicateProcessing

      public void setForDuplicateProcessing(boolean forDuplicateProcessing)
      Set up whether retrieval requests from this service are to avoid merging duplicates or not.
      Parameters:
      forDuplicateProcessing - boolean flag

    • createGlossary

      public String createGlossary(boolean assetManagerIsHome, ExternalIdentifierProperties externalIdentifierProperties, GlossaryProperties glossaryProperties) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent the root of a glossary. All categories and terms are linked to a single glossary. They are owned by this glossary and if the glossary is deleted, any linked terms and categories are deleted as well.
      Parameters:
      assetManagerIsHome - ensure that only the asset manager can update this asset
      externalIdentifierProperties - optional properties used to define an external identifier
      glossaryProperties - properties to store
      Returns:
      unique identifier of the new metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • createGlossaryFromTemplate

      public String createGlossaryFromTemplate(boolean assetManagerIsHome, String templateGUID, ExternalIdentifierProperties externalIdentifierProperties, TemplateProperties templateProperties, boolean deepCopy) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new glossary. All categories and terms are linked to a single glossary. They are owned by this glossary and if the glossary is deleted, any linked terms and categories are deleted as well.
      Parameters:
      assetManagerIsHome - ensure that only the asset manager can update this element
      templateGUID - unique identifier of the metadata element to copy
      externalIdentifierProperties - optional properties used to define an external identifier
      templateProperties - properties that override the template
      deepCopy - should the template creation extend to the anchored elements or just the direct entity?
      Returns:
      unique identifier of the new metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • updateGlossary

      public void updateGlossary(String glossaryGUID, String glossaryExternalIdentifier, boolean isMergeUpdate, GlossaryProperties glossaryProperties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the metadata element representing a glossary.
      Parameters:
      glossaryGUID - unique identifier of the metadata element to update
      glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
      isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
      glossaryProperties - new properties for this element
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • removeGlossary

      public void removeGlossary(String glossaryGUID, String glossaryExternalIdentifier, boolean cascadedDelete, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the metadata element representing a glossary. This will delete the glossary and all categories and terms - use with care :)
      Parameters:
      glossaryGUID - unique identifier of the metadata element to remove
      glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
      cascadedDelete - boolean indicating whether the delete request can cascade to dependent elements
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setGlossaryAsTaxonomy

      public void setGlossaryAsTaxonomy(String glossaryGUID, String glossaryExternalIdentifier, TaxonomyProperties properties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary to indicate that it can be used as a taxonomy. This means each term is attached to one, and only one category and the categories are organized as a hierarchy with a single root category. Taxonomies are used as a way of organizing assets and other related metadata. The terms in the taxonomy are linked to the assets etc. and as such they are logically categorized by the linked category.
      Parameters:
      glossaryGUID - unique identifier of the metadata element to remove
      glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
      properties - description of how the glossary is organized
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearGlossaryAsTaxonomy

      public void clearGlossaryAsTaxonomy(String glossaryGUID, String glossaryExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the taxonomy designation from the glossary.
      Parameters:
      glossaryGUID - unique identifier of the metadata element to remove
      glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setGlossaryAsCanonical

      public void setGlossaryAsCanonical(String glossaryGUID, String glossaryExternalIdentifier, CanonicalVocabularyProperties properties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify a glossary to declare that it has no two GlossaryTerm definitions with the same name. This means there is only one definition for each term. Typically, the terms are also of a similar level of granularity and are limited to a specific scope of use. Canonical vocabularies are used to semantically classify assets in an unambiguous way.
      Parameters:
      glossaryGUID - unique identifier of the metadata element to remove
      glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
      properties - description of the situations where this glossary is relevant.
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearGlossaryAsCanonical

      public void clearGlossaryAsCanonical(String glossaryGUID, String glossaryExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the canonical designation from the glossary.
      Parameters:
      glossaryGUID - unique identifier of the metadata element to remove
      glossaryExternalIdentifier - unique identifier of the glossary in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • findGlossaries

      public List<GlossaryElement> findGlossaries(String searchString, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary metadata elements that contain the search string. The search string is treated as a regular expression.
      Parameters:
      searchString - string to find in the properties
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossariesByName

      public List<GlossaryElement> getGlossariesByName(String name, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
      Parameters:
      name - name to search for
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossariesForAssetManager

      public List<GlossaryElement> getGlossariesForAssetManager(int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossaries created on behalf of this asset manager.
      Parameters:
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryByGUID

      public GlossaryElement getGlossaryByGUID(String glossaryGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary metadata element with the supplied unique identifier.
      Parameters:
      glossaryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      matching metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryForCategory

      public GlossaryElement getGlossaryForCategory(String glossaryCategoryGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary metadata element for the requested category.
      Parameters:
      glossaryCategoryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      matching metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryForTerm

      public GlossaryElement getGlossaryForTerm(String glossaryTermGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary metadata element for the requested term.
      Parameters:
      glossaryTermGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      matching metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • createGlossaryCategory

      public String createGlossaryCategory(String glossaryGUID, boolean assetManagerIsHome, ExternalIdentifierProperties externalIdentifierProperties, GlossaryCategoryProperties glossaryCategoryProperties, boolean isRootCategory, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary category.
      Parameters:
      glossaryGUID - unique identifier of anchor glossary
      assetManagerIsHome - ensure that only the asset manager can update this element
      externalIdentifierProperties - optional properties used to define an external identifier
      glossaryCategoryProperties - properties about the glossary category to store
      isRootCategory - is this category a root category?
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      unique identifier of the new glossary category
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • createGlossaryCategoryFromTemplate

      public String createGlossaryCategoryFromTemplate(String glossaryGUID, boolean assetManagerIsHome, String templateGUID, ExternalIdentifierProperties externalIdentifierProperties, TemplateProperties templateProperties, boolean deepCopy) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary category using an existing metadata element as a template.
      Parameters:
      glossaryGUID - unique identifier of the glossary where the category is located
      assetManagerIsHome - ensure that only the asset manager can update this element
      templateGUID - unique identifier of the metadata element to copy
      externalIdentifierProperties - optional properties used to define an external identifier
      templateProperties - properties that override the template
      deepCopy - should the template creation extend to the anchored elements or just the direct entity?
      Returns:
      unique identifier of the new glossary category
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • updateGlossaryCategory

      public void updateGlossaryCategory(String glossaryCategoryGUID, String glossaryCategoryExternalIdentifier, boolean isMergeUpdate, GlossaryCategoryProperties glossaryCategoryProperties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the metadata element representing a glossary category.
      Parameters:
      glossaryCategoryGUID - unique identifier of the metadata element to update
      glossaryCategoryExternalIdentifier - unique identifier of the glossary category in the external asset manager
      isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
      glossaryCategoryProperties - new properties for the metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setupCategoryParent

      public void setupCategoryParent(String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a parent-child relationship between two categories.
      Parameters:
      glossaryParentCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the super-category
      glossaryChildCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the subcategory
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearCategoryParent

      public void clearCategoryParent(String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove a parent-child relationship between two categories.
      Parameters:
      glossaryParentCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the super-category
      glossaryChildCategoryGUID - unique identifier of the glossary category in the external asset manager that is to be the subcategory
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • removeGlossaryCategory

      public void removeGlossaryCategory(String glossaryCategoryGUID, String glossaryCategoryExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the metadata element representing a glossary category.
      Parameters:
      glossaryCategoryGUID - unique identifier of the metadata element to remove
      glossaryCategoryExternalIdentifier - unique identifier of the glossary category in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • findGlossaryCategories

      public List<GlossaryCategoryElement> findGlossaryCategories(String searchString, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary category metadata elements that contain the search string. The search string is treated as a regular expression.
      Parameters:
      searchString - string to find in the properties
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • findGlossaryCategories

      public List<GlossaryCategoryElement> findGlossaryCategories(String glossaryGUID, String searchString, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary category metadata elements that contain the search string. The search string is treated as a regular expression.
      Parameters:
      glossaryGUID - optional glossary unique identifier to scope the search to a glossary.
      searchString - string to find in the properties
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getCategoriesForGlossary

      public List<GlossaryCategoryElement> getCategoriesForGlossary(String glossaryGUID, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return the list of categories associated with a glossary.
      Parameters:
      glossaryGUID - unique identifier of the glossary to query
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of metadata elements describing the categories associated with the requested glossary
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getCategoriesForTerm

      public List<GlossaryCategoryElement> getCategoriesForTerm(String glossaryTermGUID, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return the list of categories associated with a glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the glossary term to query
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of metadata elements describing the categories associated with the requested term
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryCategoriesByName

      public List<GlossaryCategoryElement> getGlossaryCategoriesByName(String name, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary category metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
      Parameters:
      name - name to search for
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryCategoriesByName

      public List<GlossaryCategoryElement> getGlossaryCategoriesByName(String glossaryGUID, String name, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary category metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
      Parameters:
      glossaryGUID - optional glossary unique identifier to scope the search to a glossary.
      name - name to search for
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryCategoryByGUID

      public GlossaryCategoryElement getGlossaryCategoryByGUID(String guid, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary category metadata element with the supplied unique identifier.
      Parameters:
      guid - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      requested metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryCategoryParent

      public GlossaryCategoryElement getGlossaryCategoryParent(String glossaryCategoryGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary category metadata element with the supplied unique identifier.
      Parameters:
      glossaryCategoryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      parent glossary category element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossarySubCategories

      public List<GlossaryCategoryElement> getGlossarySubCategories(String glossaryCategoryGUID, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary category metadata element with the supplied unique identifier.
      Parameters:
      glossaryCategoryGUID - unique identifier of the requested metadata element
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of glossary category element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • createGlossaryTerm

      public String createGlossaryTerm(String glossaryGUID, boolean assetManagerIsHome, ExternalIdentifierProperties externalIdentifierProperties, GlossaryTermProperties glossaryTermProperties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary term.
      Parameters:
      assetManagerIsHome - ensure that only the asset manager can update this element
      glossaryGUID - unique identifier of the glossary where the term is located
      externalIdentifierProperties - optional properties used to define an external identifier
      glossaryTermProperties - properties for the glossary term
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      unique identifier of the new metadata element for the glossary term
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • createControlledGlossaryTerm

      public String createControlledGlossaryTerm(boolean assetManagerIsHome, String glossaryGUID, ExternalIdentifierProperties externalIdentifierProperties, GlossaryTermProperties glossaryTermProperties, GlossaryTermStatus initialStatus, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
      Parameters:
      assetManagerIsHome - ensure that only the asset manager can update this element
      glossaryGUID - unique identifier of the glossary where the term is located
      externalIdentifierProperties - optional properties used to define an external identifier
      glossaryTermProperties - properties for the glossary term
      initialStatus - glossary term status to use when the object is created
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      unique identifier of the new metadata element for the glossary term
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • createGlossaryTermFromTemplate

      public String createGlossaryTermFromTemplate(String glossaryGUID, boolean assetManagerIsHome, String templateGUID, ExternalIdentifierProperties externalIdentifierProperties, TemplateProperties templateProperties, boolean deepCopy, boolean templateSubstitute, GlossaryTermStatus initialStatus) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary term using an existing metadata element as a template.
      Parameters:
      glossaryGUID - unique identifier of the glossary where the category is located
      assetManagerIsHome - ensure that only the asset manager can update this element
      templateGUID - unique identifier of the metadata element to copy
      externalIdentifierProperties - optional properties used to define an external identifier
      templateProperties - properties that override the template
      deepCopy - should the template creation extend to the anchored elements or just the direct entity?
      templateSubstitute - is this element a template substitute (used as the "other end" of a new/updated relationship)
      initialStatus - what status should the copy be set to
      Returns:
      unique identifier of the new metadata element for the glossary term
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • updateGlossaryTerm

      public void updateGlossaryTerm(String glossaryTermGUID, String glossaryTermExternalIdentifier, boolean isMergeUpdate, GlossaryTermProperties glossaryTermProperties, String updateDescription, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the properties of the metadata element representing a glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the glossary term to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
      glossaryTermProperties - new properties for the glossary term
      updateDescription - description of the change to the term
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • updateGlossaryTermStatus

      public void updateGlossaryTermStatus(String glossaryTermGUID, String glossaryTermExternalIdentifier, GlossaryTermStatus glossaryTermStatus, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the status of the metadata element representing a glossary term. This is only valid on a controlled glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the glossary term to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      glossaryTermStatus - new properties for the glossary term
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setupTermCategory

      public void setupTermCategory(String glossaryCategoryGUID, String glossaryTermGUID, GlossaryTermCategorization categorizationProperties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Link a term to a category.
      Parameters:
      glossaryCategoryGUID - unique identifier of the glossary category
      glossaryTermGUID - unique identifier of the glossary term
      categorizationProperties - properties for the categorization relationship
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermCategory

      public void clearTermCategory(String glossaryCategoryGUID, String glossaryTermGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Unlink a term from a category.
      Parameters:
      glossaryCategoryGUID - unique identifier of the glossary category
      glossaryTermGUID - unique identifier of the glossary term
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setupTermRelationship

      public void setupTermRelationship(String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Link two terms together using a specialist relationship.
      Parameters:
      relationshipTypeName - name of the type of relationship to create
      glossaryTermOneGUID - unique identifier of the glossary term at end 1
      glossaryTermTwoGUID - unique identifier of the glossary term at end 2
      relationshipsProperties - properties for the categorization relationship
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • updateTermRelationship

      public void updateTermRelationship(String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the relationship properties for the two terms.
      Parameters:
      relationshipTypeName - name of the type of relationship to create
      glossaryTermOneGUID - unique identifier of the glossary term at end 1
      glossaryTermTwoGUID - unique identifier of the glossary term at end 2
      relationshipsProperties - properties for the categorization relationship
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermRelationship

      public void clearTermRelationship(String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the relationship between two terms.
      Parameters:
      relationshipTypeName - name of the type of relationship to create
      glossaryTermOneGUID - unique identifier of the glossary term at end 1
      glossaryTermTwoGUID - unique identifier of the glossary term at end 2
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsAbstractConcept

      public void setTermAsAbstractConcept(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes an abstract concept.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsAbstractConcept

      public void clearTermAsAbstractConcept(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the abstract concept designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsDataValue

      public void setTermAsDataValue(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a data value.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsDataValue

      public void clearTermAsDataValue(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the data value designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsActivity

      public void setTermAsActivity(String glossaryTermGUID, String glossaryTermExternalIdentifier, ActivityDescriptionProperties properties, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a data value.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      properties - type of activity
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsActivity

      public void clearTermAsActivity(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the activity designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsContext

      public void setTermAsContext(String glossaryTermGUID, String glossaryTermExternalIdentifier, GlossaryTermContextDefinition contextDefinition, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a context.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      contextDefinition - more details of the context
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsContext

      public void clearTermAsContext(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the context definition designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsSpineObject

      public void setTermAsSpineObject(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a spine object.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsSpineObject

      public void clearTermAsSpineObject(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the spine object designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsSpineAttribute

      public void setTermAsSpineAttribute(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a spine attribute.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsSpineAttribute

      public void clearTermAsSpineAttribute(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the spine attribute designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • setTermAsObjectIdentifier

      public void setTermAsObjectIdentifier(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes an object identifier.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearTermAsObjectIdentifier

      public void clearTermAsObjectIdentifier(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the object identifier designation from the glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to update
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • removeGlossaryTerm

      public void removeGlossaryTerm(String glossaryTermGUID, String glossaryTermExternalIdentifier, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the metadata element representing a glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the metadata element to remove
      glossaryTermExternalIdentifier - unique identifier of the glossary term in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • findGlossaryTerms

      public List<GlossaryTermElement> findGlossaryTerms(String searchString, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary term metadata elements that contain the search string. The search string is treated as a regular expression.
      Parameters:
      searchString - string to find in the properties
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • findGlossaryTerms

      public List<GlossaryTermElement> findGlossaryTerms(String glossaryGUID, String searchString, List<GlossaryTermStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary term metadata elements that contain the search string. The search string is treated as a regular expression.
      Parameters:
      glossaryGUID - unique identifier of the glossary to query
      searchString - string to find in the properties
      limitResultsByStatus - By default, terms in all statuses are returned. However, it is possible to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all status values.
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getTermsForGlossary

      public List<GlossaryTermElement> getTermsForGlossary(String glossaryGUID, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary terms associated with a glossary.
      Parameters:
      glossaryGUID - unique identifier of the glossary of interest
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of associated metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getTermsForGlossaryCategory

      public List<GlossaryTermElement> getTermsForGlossaryCategory(String glossaryCategoryGUID, List<GlossaryTermRelationshipStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary terms associated with a glossary category.
      Parameters:
      glossaryCategoryGUID - unique identifier of the glossary category of interest
      limitResultsByStatus - By default, term relationships in all statuses are returned. However, it is possible to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all status values.
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of associated metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getRelatedTerms

      public List<GlossaryTermElement> getRelatedTerms(String glossaryTermGUID, String relationshipTypeName, List<GlossaryTermRelationshipStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary terms associated with the requested glossary term.
      Parameters:
      glossaryTermGUID - unique identifier of the glossary of interest
      relationshipTypeName - optional name of relationship
      limitResultsByStatus - By default, term relationships in all statuses are returned. However, it is possible to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all status values.
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of associated metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryTermsByName

      public List<GlossaryTermElement> getGlossaryTermsByName(String name, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary term metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
      Parameters:
      name - name to search for
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryTermsByName

      public List<GlossaryTermElement> getGlossaryTermsByName(String glossaryGUID, String name, List<GlossaryTermStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary term metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
      Parameters:
      glossaryGUID - unique identifier of the glossary to query
      name - name to search for
      limitResultsByStatus - By default, terms in all statuses are returned. However, it is possible to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all status values.
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      list of matching metadata elements
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGlossaryTermByGUID

      public GlossaryTermElement getGlossaryTermByGUID(String guid, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary term metadata element with the supplied unique identifier.
      Parameters:
      guid - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      Returns:
      matching metadata element
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)