Package org.odpi.openmetadata.viewservices.glossarymanager.server.spring

Class GlossaryManagerResource

java.lang.Object
org.odpi.openmetadata.viewservices.glossarymanager.server.spring.GlossaryManagerResource
@RestController @RequestMapping("/servers/{serverName}/api/open-metadata/glossary-manager") public class GlossaryManagerResource extends Object
The GlossaryManagerResource provides the Spring API endpoints of the Glossary Manager Open Metadata View Service (OMVS). This interface provides a service for Egeria UIs.

  • Constructor Details

    • GlossaryManagerResource

      public GlossaryManagerResource()
      Default constructor

  • Method Details

    • createGlossary

      @PostMapping(path="/glossaries") public GUIDResponse createGlossary(@PathVariable String serverName, @RequestBody ReferenceableRequestBody requestBody)
      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:
      serverName - name of the server to route the request to.
      requestBody - properties to store
      Returns:
      unique identifier of the new metadata element or 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

      @PostMapping(path="/glossaries/from-template/{templateGUID}") public GUIDResponse createGlossaryFromTemplate(@PathVariable String serverName, @PathVariable String templateGUID, @RequestParam(required=false,defaultValue="true") boolean deepCopy, @RequestBody TemplateRequestBody requestBody)
      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:
      serverName - name of the server to route the request to
      templateGUID - unique identifier of the metadata element to copy
      deepCopy - should the template creation extend to the anchored elements or just the direct entity?
      requestBody - properties that override the template
      Returns:
      unique identifier of the new metadata element or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/update") public VoidResponse updateGlossary(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean isMergeUpdate, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a glossary.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to update
      isMergeUpdate - should the properties be merged with the existing properties or completely over-write them
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - new properties for this element
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/remove") public VoidResponse removeGlossary(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a glossary. This will delete the glossary and all categories and terms.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-editing-glossary") public VoidResponse setGlossaryAsEditingGlossary(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ClassificationRequestBody requestBody)
      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:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-editing-glossary/remove") public VoidResponse clearGlossaryAsEditingGlossary(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the editing glossary designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - correlation properties for the external asset manager
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-staging-glossary") public VoidResponse setGlossaryAsStagingGlossary(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ClassificationRequestBody requestBody)
      Classify the glossary to indicate that it is a staging glossary - this means it is a collection of glossary updates that will be transferred into another glossary.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-staging-glossary/remove") public VoidResponse clearGlossaryAsStagingGlossary(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the staging glossary designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - correlation properties for the external asset manager
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-taxonomy") public VoidResponse setGlossaryAsTaxonomy(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ClassificationRequestBody requestBody)
      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:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-taxonomy/remove") public VoidResponse clearGlossaryAsTaxonomy(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the taxonomy designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - correlation properties for the external asset manager
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-canonical-vocabulary") public VoidResponse setGlossaryAsCanonical(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ClassificationRequestBody requestBody)
      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:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - description of the situations where this glossary is relevant.
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/is-canonical-vocabulary/remove") public VoidResponse clearGlossaryAsCanonical(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the canonical vocabulary designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - correlation properties for the external asset manager
      Returns:
      void or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/categories") public GUIDResponse createGlossaryCategory(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean isRootCategory, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ReferenceableUpdateRequestBody requestBody)
      Create a new metadata element to represent a glossary category.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the glossary where the category is located
      isRootCategory - is this category a root category?
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties about the glossary category to store
      Returns:
      unique identifier of the new glossary category or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/categories/from-template/{templateGUID}") public GUIDResponse createGlossaryCategoryFromTemplate(@PathVariable String serverName, @PathVariable String glossaryGUID, @PathVariable String templateGUID, @RequestBody TemplateRequestBody requestBody)
      Create a new metadata element to represent a glossary category using an existing metadata element as a template.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the glossary where the category is located
      templateGUID - unique identifier of the metadata element to copy
      requestBody - properties that override the template
      Returns:
      unique identifier of the new glossary category or 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

      @PostMapping(path="/glossaries/categories/{glossaryCategoryGUID}/update") public VoidResponse updateGlossaryCategory(@PathVariable String serverName, @PathVariable String glossaryCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean isMergeUpdate, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a glossary category.
      Parameters:
      serverName - name of the server to route the request to
      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)?
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - new properties for the metadata element
      Returns:
      void or 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

      @PostMapping(path="/glossaries/categories/{glossaryParentCategoryGUID}/subcategories/{glossaryChildCategoryGUID}") public VoidResponse setupCategoryParent(@PathVariable String serverName, @PathVariable String glossaryParentCategoryGUID, @PathVariable String glossaryChildCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) RelationshipRequestBody requestBody)
      Create a parent-child relationship between two categories.
      Parameters:
      serverName - name of the server to route the request to
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/categories/{glossaryParentCategoryGUID}/subcategories/{glossaryChildCategoryGUID}/remove") public VoidResponse clearCategoryParent(@PathVariable String serverName, @PathVariable String glossaryParentCategoryGUID, @PathVariable String glossaryChildCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) EffectiveTimeQueryRequestBody requestBody)
      Remove a parent-child relationship between two categories.
      Parameters:
      serverName - name of the server to route the request to
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/categories/{glossaryCategoryGUID}/remove") public VoidResponse removeGlossaryCategory(@PathVariable String serverName, @PathVariable String glossaryCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a glossary category.
      Parameters:
      serverName - name of the server to route the request to
      glossaryCategoryGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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)

    • getGlossaryTermStatuses

      @GetMapping(path="/glossaries/terms/status-list") public GlossaryTermStatusListResponse getGlossaryTermStatuses(@PathVariable String serverName)
      Return the list of glossary term status enum values.
      Parameters:
      serverName - name of the server to route the request to
      Returns:
      list of enum values

    • getGlossaryTermRelationshipStatuses

      @GetMapping(path="/glossaries/terms/relationships/status-list") public GlossaryTermRelationshipStatusListResponse getGlossaryTermRelationshipStatuses(@PathVariable String serverName)
      Return the list of glossary term relationship status enum values.
      Parameters:
      serverName - name of the server to route the request to
      Returns:
      list of enum values

    • getGlossaryTermActivityTypes

      @GetMapping(path="/glossaries/terms/activity-types") public GlossaryTermActivityTypeListResponse getGlossaryTermActivityTypes(@PathVariable String serverName)
      Return the list of glossary term relationship status enum values.
      Parameters:
      serverName - name of the server to route the request to
      Returns:
      list of enum values

    • createControlledGlossaryTerm

      @PostMapping(path="/glossaries/{glossaryGUID}/terms/new-controlled") public GUIDResponse createControlledGlossaryTerm(@PathVariable String serverName, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ControlledGlossaryTermRequestBody requestBody)
      Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the glossary where the new term is to be located
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the glossary term
      Returns:
      unique identifier of the new metadata element for the glossary term or 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

      @PostMapping(path="/glossaries/{glossaryGUID}/terms/from-template/{templateGUID}") public GUIDResponse createGlossaryTermFromTemplate(@PathVariable String serverName, @PathVariable String glossaryGUID, @PathVariable String templateGUID, @RequestParam(required=false,defaultValue="true") boolean deepCopy, @RequestParam(required=false,defaultValue="true") boolean templateSubstitute, @RequestBody GlossaryTemplateRequestBody requestBody)
      Create a new metadata element to represent a glossary term using an existing metadata element as a template.
      Parameters:
      serverName - name of the server to route the request to
      glossaryGUID - unique identifier of the glossary where the term is located
      templateGUID - unique identifier of the metadata element to copy
      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)
      requestBody - properties that override the template
      Returns:
      unique identifier of the new metadata element for the glossary term or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/update") public VoidResponse updateGlossaryTerm(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean isMergeUpdate, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the glossary term to update
      isMergeUpdate - should the properties be merged with the existing properties or completely over-write them
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - new properties for the glossary term
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/status") public VoidResponse updateGlossaryTermStatus(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody GlossaryTermStatusRequestBody requestBody)
      Update the status of the metadata element representing a glossary term. This is only valid on a controlled glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the glossary term to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - status and correlation properties
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/update/from-template") public VoidResponse updateGlossaryTermFromTemplate(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean isMergeClassifications, @RequestParam(required=false,defaultValue="false") boolean isMergeProperties, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ReferenceableUpdateRequestBody requestBody)
      Update the glossary term using the properties and classifications from the parentGUID stored in the request body.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the glossary term to update
      isMergeClassifications - should the classification be merged or replace the target entity?
      isMergeProperties - should the properties be merged with the existing ones or replace them
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - status and correlation properties
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/move") public VoidResponse moveGlossaryTerm(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ReferenceableUpdateRequestBody requestBody)
      Move the glossary term from one glossary to another.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the glossary term to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - status and correlation properties
      Returns:
      void or 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

      @PostMapping(path="/glossaries/categories/{glossaryCategoryGUID}/terms/{glossaryTermGUID}") public VoidResponse setupTermCategory(@PathVariable String serverName, @PathVariable String glossaryCategoryGUID, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody RelationshipRequestBody requestBody)
      Link a term to a category.
      Parameters:
      serverName - name of the server to route the request to
      glossaryCategoryGUID - unique identifier of the glossary category
      glossaryTermGUID - unique identifier of the glossary term
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the categorization relationship
      Returns:
      void or 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

      @PostMapping(path="/glossaries/categories/{glossaryCategoryGUID}/terms/{glossaryTermGUID}/remove") public VoidResponse clearTermCategory(@PathVariable String serverName, @PathVariable String glossaryCategoryGUID, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) EffectiveTimeQueryRequestBody requestBody)
      Unlink a term from a category.
      Parameters:
      serverName - name of the server to route the request to
      glossaryCategoryGUID - unique identifier of the glossary category
      glossaryTermGUID - unique identifier of the glossary term
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - asset manager identifiers
      Returns:
      void or 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

      @GetMapping(path="/glossaries/terms/relationships/type-names") public NameListResponse getTermRelationshipTypeNames(@PathVariable String serverName)
      Return the list of term-to-term relationship names.
      Parameters:
      serverName - name of the server instance to connect to
      Returns:
      list of type names that are subtypes of asset or throws InvalidParameterException full path or userId is null or throws PropertyServerException problem accessing property server or throws UserNotAuthorizedException security access problem.

    • setupTermRelationship

      @PostMapping(path="/glossaries/terms/{glossaryTermOneGUID}/relationships/{relationshipTypeName}/terms/{glossaryTermTwoGUID}") public VoidResponse setupTermRelationship(@PathVariable String serverName, @PathVariable String glossaryTermOneGUID, @PathVariable String relationshipTypeName, @PathVariable String glossaryTermTwoGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody RelationshipRequestBody requestBody)
      Link two terms together using a specialist relationship.
      Parameters:
      serverName - name of the server to route the request to
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the relationship
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermOneGUID}/relationships/{relationshipTypeName}/terms/{glossaryTermTwoGUID}/update") public VoidResponse updateTermRelationship(@PathVariable String serverName, @PathVariable String glossaryTermOneGUID, @PathVariable String relationshipTypeName, @PathVariable String glossaryTermTwoGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody RelationshipRequestBody requestBody)
      Update the relationship properties for the two terms.
      Parameters:
      serverName - name of the server to route the request to
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the relationship
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermOneGUID}/relationships/{relationshipTypeName}/terms/{glossaryTermTwoGUID}/remove") public VoidResponse clearTermRelationship(@PathVariable String serverName, @PathVariable String glossaryTermOneGUID, @PathVariable String relationshipTypeName, @PathVariable String glossaryTermTwoGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) EffectiveTimeQueryRequestBody requestBody)
      Remove the relationship between two terms.
      Parameters:
      serverName - name of the server to route the request to
      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
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties of the relationship
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-abstract-concept") public VoidResponse setTermAsAbstractConcept(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes an abstract concept.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-abstract-concept/remove") public VoidResponse clearTermAsAbstractConcept(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the abstract concept designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-data-field") public VoidResponse setTermAsDataField(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      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:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-data-field/remove") public VoidResponse clearTermAsDataField(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the data field designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-data-value") public VoidResponse setTermAsDataValue(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes a data value.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-data-value/remove") public VoidResponse clearTermAsDataValue(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the data value designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-activity") public VoidResponse setTermAsActivity(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes a data value.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - type of activity and correlators
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-activity/remove") public VoidResponse clearTermAsActivity(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the activity designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-context-definition") public VoidResponse setTermAsContext(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes a context.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - more details of the context
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-context-definition/remove") public VoidResponse clearTermAsContext(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the context definition designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-spine-object") public VoidResponse setTermAsSpineObject(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes a spine object.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-spine-object/remove") public VoidResponse clearTermAsSpineObject(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the spine object designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-spine-attribute") public VoidResponse setTermAsSpineAttribute(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes a spine attribute.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-spine-attribute/remove") public VoidResponse clearTermAsSpineAttribute(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the spine attribute designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-object-identifier") public VoidResponse setTermAsObjectIdentifier(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes an object identifier.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/is-object-identifier/remove") public VoidResponse clearTermAsObjectIdentifier(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ClassificationRequestBody requestBody)
      Remove the object identifier designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/undo") public GlossaryTermElementResponse undoGlossaryTermUpdate(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) EffectiveTimeQueryRequestBody requestBody)
      Undo the last update to the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to update
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/archive") public VoidResponse archiveGlossaryTerm(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ArchiveRequestBody requestBody)
      Archive the metadata element representing a glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to archive
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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

      @PostMapping(path="/glossaries/terms/{glossaryTermGUID}/remove") public VoidResponse removeGlossaryTerm(@PathVariable String serverName, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a glossary term.
      Parameters:
      serverName - name of the server to route the request to
      glossaryTermGUID - unique identifier of the metadata element to remove
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
      Returns:
      void or 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)