Package org.odpi.openmetadata.accessservices.assetmanager.api.management

Interface GlossaryManagementInterface

All Known Implementing Classes:
GlossaryManagementClient
public interface GlossaryManagementInterface
GlossaryManagementInterface defines the client side interface for the Asset Manager OMAS that is relevant for managing glossaries. It provides the ability to define and maintain the content of glossary as well as govern it. Glossaries have a top-level root object that describe the purpose, language and intended usage of its content. Linked to the glossary's root object are the terms, categories and relationships it contains. In addition to the content, the glossary can be augmented with classifications and linked to external glossary definitions.

  • Method Details

    • createGlossary

      String createGlossary(String userId, 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:
      userId - calling user
      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

      String createGlossaryFromTemplate(String userId, String templateGUID, 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:
      userId - calling user
      templateGUID - unique identifier of the metadata element to copy
      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

      void updateGlossary(String userId, String glossaryGUID, boolean isMergeUpdate, GlossaryProperties glossaryProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the metadata element representing a glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to update
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • setGlossaryAsEditingGlossary

      void setGlossaryAsEditingGlossary(String userId, String glossaryGUID, EditingGlossaryProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary to indicate that it is an editing glossary - this means it is a collection of glossary updates that will be merged into its source glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to remove
      properties - description of the purpose of the editing glossary
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • clearGlossaryAsEditingGlossary

      void clearGlossaryAsEditingGlossary(String userId, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the editing glossary classification from the glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to remove
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • setGlossaryAsStagingGlossary

      void setGlossaryAsStagingGlossary(String userId, String glossaryGUID, StagingGlossaryProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary to indicate that it is a staging glossary - this means it is a collection of glossary updates that will be merged into another glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to remove
      properties - description of the purpose of the editing glossary
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • clearGlossaryAsStagingGlossary

      void clearGlossaryAsStagingGlossary(String userId, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the staging glossary classification from the glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to remove
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setGlossaryAsTaxonomy(String userId, String glossaryGUID, TaxonomyProperties taxonomyProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to classify
      taxonomyProperties - description of how the glossary is organized
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearGlossaryAsTaxonomy(String userId, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the taxonomy designation from the glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to unclassify
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setGlossaryAsCanonical(String userId, String glossaryGUID, CanonicalVocabularyProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to classify
      properties - description of the situations where this glossary is relevant.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearGlossaryAsCanonical(String userId, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the canonical designation from the glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to unclassify
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void removeGlossary(String userId, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the metadata element representing a glossary. This will delete the glossary and all categories and terms.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element to remove
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryElement> findGlossaries(String userId, String searchString, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryElement> getGlossariesByName(String userId, String name, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      GlossaryElement getGlossaryByGUID(String userId, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary metadata element with the supplied unique identifier.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      GlossaryElement getGlossaryForCategory(String userId, String glossaryCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary metadata element for the requested category.
      Parameters:
      userId - calling user
      glossaryCategoryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      GlossaryElement getGlossaryForTerm(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary metadata element for the requested term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      String createGlossaryCategory(String userId, String glossaryGUID, GlossaryCategoryProperties glossaryCategoryProperties, boolean isRootCategory, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary category.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the glossary where the category is located
      glossaryCategoryProperties - properties about the glossary category to store
      isRootCategory - is this category a root category?
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      effectiveTime - optional date for effective time of the query. Null means any effective time
      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

      String createGlossaryCategoryFromTemplate(String userId, String glossaryGUID, String templateGUID, 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:
      userId - calling user
      glossaryGUID - unique identifier of the glossary where the category is located
      templateGUID - unique identifier of the metadata element to copy
      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

      void updateGlossaryCategory(String userId, String glossaryCategoryGUID, boolean isMergeUpdate, GlossaryCategoryProperties glossaryCategoryProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the metadata element representing a glossary category.
      Parameters:
      userId - calling user
      glossaryCategoryGUID - unique identifier of the metadata element to update
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setupCategoryParent(String userId, String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a parent-child relationship between two categories.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearCategoryParent(String userId, String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove a parent-child relationship between two categories.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void removeGlossaryCategory(String userId, String glossaryCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the metadata element representing a glossary category.
      Parameters:
      userId - calling user
      glossaryCategoryGUID - unique identifier of the metadata element to remove
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryCategoryElement> findGlossaryCategories(String userId, String glossaryGUID, String searchString, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryCategoryElement> getCategoriesForGlossary(String userId, String glossaryGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return the list of categories associated with a glossary.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryCategoryElement> getCategoriesForTerm(String userId, String glossaryTermGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return the list of categories associated with a glossary term.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryCategoryElement> getGlossaryCategoriesByName(String userId, String glossaryGUID, String name, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      GlossaryCategoryElement getGlossaryCategoryByGUID(String userId, String glossaryCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary category metadata element with the supplied unique identifier.
      Parameters:
      userId - calling user
      glossaryCategoryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      GlossaryCategoryElement getGlossaryCategoryParent(String userId, String glossaryCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary category metadata element with the supplied unique identifier.
      Parameters:
      userId - calling user
      glossaryCategoryGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryCategoryElement> getGlossarySubCategories(String userId, String glossaryCategoryGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary category metadata element with the supplied unique identifier.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      String createGlossaryTerm(String userId, String glossaryGUID, GlossaryTermProperties glossaryTermProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary term.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the glossary where the term is located
      glossaryTermProperties - properties for the glossary term
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      effectiveTime - optional date for effective time of the query. Null means any effective time
      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

      String createControlledGlossaryTerm(String userId, String glossaryGUID, GlossaryTermProperties glossaryTermProperties, GlossaryTermStatus initialStatus, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the glossary where the term is located
      glossaryTermProperties - properties for the glossary term
      initialStatus - glossary term status to use when the object is created
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      effectiveTime - optional date for effective time of the query. Null means any effective time
      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

      String createGlossaryTermFromTemplate(String userId, String glossaryGUID, String templateGUID, 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:
      userId - calling user
      glossaryGUID - unique identifier of the glossary where the term is located
      templateGUID - unique identifier of the metadata element to copy
      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

      void updateGlossaryTerm(String userId, String glossaryTermGUID, boolean isMergeUpdate, GlossaryTermProperties glossaryTermProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the properties of the metadata element representing a glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the glossary term to update
      isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
      glossaryTermProperties - new properties for the glossary term
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void updateGlossaryTermStatus(String userId, String glossaryTermGUID, GlossaryTermStatus glossaryTermStatus, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      glossaryTermGUID - unique identifier of the glossary term to update
      glossaryTermStatus - new properties for the glossary term
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • updateGlossaryTermFromTemplate

      void updateGlossaryTermFromTemplate(String userId, String glossaryTermGUID, String templateGUID, boolean isMergeClassifications, boolean isMergeProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the glossary term using the properties and classifications from the parentGUID stored in the request body.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the glossary term to update
      templateGUID - identifier for the template glossary term
      isMergeClassifications - should the classification be merged or replace the target entity?
      isMergeProperties - should the properties be merged with the existing ones or replace them
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • moveGlossaryTerm

      void moveGlossaryTerm(String userId, String glossaryTermGUID, String newGlossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Move a glossary term from one glossary to another.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the glossary term to update
      newGlossaryGUID - identifier for the new glossary
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setupTermCategory(String userId, String glossaryCategoryGUID, String glossaryTermGUID, GlossaryTermCategorization categorizationProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Link a term to a category.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermCategory(String userId, String glossaryCategoryGUID, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Unlink a term from a category.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • getTermRelationshipTypeNames

      List<String> getTermRelationshipTypeNames(String userId) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return the list of term-to-term relationship names.
      Parameters:
      userId - calling user
      Returns:
      list of type names that are subtypes of asset
      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

      void setupTermRelationship(String userId, String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Link two terms together using a specialist relationship.
      Parameters:
      userId - calling user
      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 related to the new relationship
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void updateTermRelationship(String userId, String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the relationship properties for the two terms.
      Parameters:
      userId - calling user
      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 relationship
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermRelationship(String userId, String relationshipTypeName, String glossaryTermOneGUID, String glossaryTermTwoGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the relationship between two terms.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsAbstractConcept(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes an abstract concept.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsAbstractConcept(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the abstract concept designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • setTermAsDataField

      void setTermAsDataField(String userId, String glossaryTermGUID, DataFieldValuesProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a data field and supply properties that describe the characteristics of the data values found within.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      properties - characterizations of the data values stored in the data field
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • clearTermAsDataField

      void clearTermAsDataField(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the data field designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsDataValue(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a data value.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsDataValue(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the data value designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsActivity(String userId, String glossaryTermGUID, ActivityDescriptionProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a data value.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      properties - type of activity
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsActivity(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the activity designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsContext(String userId, String glossaryTermGUID, GlossaryTermContextDefinition contextDefinition, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a context.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      contextDefinition - more details of the context
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsContext(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the context definition designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsSpineObject(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a spine object.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsSpineObject(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the spine object designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsSpineAttribute(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes a spine attribute.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsSpineAttribute(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the spine attribute designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void setTermAsObjectIdentifier(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the glossary term to indicate that it describes an object identifier.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void clearTermAsObjectIdentifier(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the object identifier designation from the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • undoGlossaryTermUpdate

      GlossaryTermElement undoGlossaryTermUpdate(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Undo the last update to the glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      recovered 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)

    • archiveGlossaryTerm

      void archiveGlossaryTerm(String userId, String glossaryTermGUID, ArchiveProperties archiveProperties, Date effectiveTime, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Archive the metadata element representing a glossary term. This removes it from normal access. However, it is still available for lineage requests.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to archive
      archiveProperties - option parameters about the archive process
      effectiveTime - the time that the retrieved elements must be effective for
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      void removeGlossaryTerm(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the metadata element representing a glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the metadata element to remove
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryTermElement> findGlossaryTerms(String userId, String glossaryGUID, String searchString, List<GlossaryTermStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryTermElement> getTermsForGlossary(String userId, String glossaryGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary terms associated with a glossary.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryTermElement> getTermsForGlossaryCategory(String userId, String glossaryCategoryGUID, List<GlossaryTermRelationshipStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary terms associated with a glossary category.
      Parameters:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryTermElement> getRelatedTerms(String userId, String glossaryTermGUID, String relationshipTypeName, List<GlossaryTermRelationshipStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of glossary terms associated with the requested glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the glossary term 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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      List<GlossaryTermElement> getGlossaryTermsByName(String userId, String glossaryGUID, String name, List<GlossaryTermStatus> limitResultsByStatus, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) 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:
      userId - calling user
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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

      GlossaryTermElement getGlossaryTermByGUID(String userId, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary term metadata element with the supplied unique identifier.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of the requested metadata element
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • getGlossaryTermHistory

      List<GlossaryTermElement> getGlossaryTermHistory(String userId, String glossaryTermGUID, Date fromTime, Date toTime, int startFrom, int pageSize, boolean oldestFirst, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime) throws InvalidParameterException, PropertyServerException, UserNotAuthorizedException
      Retrieve all the versions of a glossary term.
      Parameters:
      userId - calling user
      glossaryTermGUID - unique identifier of object to retrieve
      fromTime - the earliest point in time from which to retrieve historical versions of the entity (inclusive)
      toTime - the latest point in time from which to retrieve historical versions of the entity (exclusive)
      startFrom - the starting element number of the historical versions to return. This is used when retrieving versions beyond the first page of results. Zero means start from the first element.
      pageSize - the maximum number of result versions that can be returned on this request. Zero means unrestricted return results size.
      oldestFirst - defining how the results should be ordered.
      forLineage - the request is to support lineage retrieval this means entities with the Memento classification can be returned
      forDuplicateProcessing - the request is for duplicate processing and so must not deduplicate
      effectiveTime - the time that the retrieved elements must be effective for (null for any time, new Date() for now)
      Returns:
      list of beans
      Throws:
      InvalidParameterException - one of the parameters is null or invalid.
      PropertyServerException - there is a problem removing the properties from the repositories.
      UserNotAuthorizedException - the requesting user is not authorized to issue this request.

    • createExternalGlossaryLink

      String createExternalGlossaryLink(String userId, ExternalGlossaryLinkProperties linkProperties) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a link to an external glossary resource. This is associated with a glossary to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.
      Parameters:
      userId - calling user
      linkProperties - properties of the link
      Returns:
      unique identifier of the external reference
      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)

    • updateExternalGlossaryLink

      void updateExternalGlossaryLink(String userId, String externalLinkGUID, boolean isMergeUpdate, ExternalGlossaryLinkProperties linkProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Update the properties of a reference to an external glossary resource.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
      linkProperties - properties of the link
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • removeExternalGlossaryLink

      void removeExternalGlossaryLink(String userId, String externalLinkGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove information about a link to an external glossary resource (and the relationships that attached it to the glossaries).
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • attachExternalLinkToGlossary

      void attachExternalLinkToGlossary(String userId, String externalLinkGUID, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Connect a glossary to a reference to an external glossary resource.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      glossaryGUID - unique identifier of the metadata element to attach
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • detachExternalLinkFromGlossary

      void detachExternalLinkFromGlossary(String userId, String externalLinkGUID, String glossaryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Disconnect a glossary from a reference to an external glossary resource.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      glossaryGUID - unique identifier of the metadata element to remove
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • getExternalLinksForGlossary

      List<ExternalGlossaryLinkElement> getExternalLinksForGlossary(String userId, String glossaryGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the list of links to external glossary resources attached to a glossary.
      Parameters:
      userId - calling user
      glossaryGUID - unique identifier of the metadata element for 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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of attached links to external glossary resources
      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)

    • getGlossariesForExternalLink

      List<GlossaryElement> getGlossariesForExternalLink(String userId, String externalLinkGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return the glossaries connected to an external glossary source.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the metadata element for the external glossary link of interest
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of glossaries
      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)

    • attachExternalCategoryLink

      void attachExternalCategoryLink(String userId, String externalLinkGUID, String glossaryCategoryGUID, ExternalGlossaryElementLinkProperties linkProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a link to an external glossary category resource. This is associated with a category to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      glossaryCategoryGUID - unique identifier for the glossary category
      linkProperties - properties of the link
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • detachExternalCategoryLink

      void detachExternalCategoryLink(String userId, String externalLinkGUID, String glossaryCategoryGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the link to an external glossary category resource.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      glossaryCategoryGUID - unique identifier for the glossary category
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • attachExternalTermLink

      void attachExternalTermLink(String userId, String externalLinkGUID, String glossaryTermGUID, ExternalGlossaryElementLinkProperties linkProperties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a link to an external glossary term resource. This is associated with a term to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      glossaryTermGUID - unique identifier for the glossary category
      linkProperties - properties of the link
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)

    • detachExternalTermLink

      void detachExternalTermLink(String userId, String externalLinkGUID, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the link to an external glossary term resource.
      Parameters:
      userId - calling user
      externalLinkGUID - unique identifier of the external reference
      glossaryTermGUID - unique identifier for the glossary category
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      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)