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

Class GlossaryWorkflowResource

java.lang.Object
org.odpi.openmetadata.viewservices.glossaryworkflow.server.spring.GlossaryWorkflowResource
@RestController @RequestMapping("/servers/{serverName}/open-metadata/view-services/glossary-workflow/users/{userId}") public class GlossaryWorkflowResource extends Object
The GlossaryWorkflowResource provides the Spring API endpoints of the Glossary Workflow Open Metadata View Service (OMVS). This interface provides an interfaces for Egeria UIs.

  • Constructor Summary

    Constructors
    Constructor
    Description
    GlossaryWorkflowResource()
    Default constructor

  • Method Summary

    Modifier and Type
    Method
    Description
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    addElementToSubjectArea(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the element to assert that the definitions it represents are part of a subject area definition.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    addGovernanceDefinitionToElement(String serverName, String userId, String definitionGUID, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
    Link a governance definition to an element using the GovernedBy relationship.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    addOwnership(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Add or replace the ownership classification for an element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    addSecurityTags(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Add or replace the security tags for an element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    archiveGlossaryTerm(String serverName, String userId, String glossaryTermGUID, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ArchiveRequestBody requestBody)
    Archive the metadata element representing a glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearCategoryParent(String serverName, String userId, String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
    Remove a parent-child relationship between two categories.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearConfidenceClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
    Remove the confidence classification from the element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearConfidentialityClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
    Remove the confidence classification from the element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearCriticalityClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
    Remove the criticality classification from the element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearGlossaryAsCanonical(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the canonical vocabulary designation from the glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearGlossaryAsEditingGlossary(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the editing glossary designation from the glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearGlossaryAsStagingGlossary(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the staging glossary designation from the glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearGlossaryAsTaxonomy(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the taxonomy designation from the glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearOwnership(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the ownership classification from an element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearRetentionClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
    Remove the retention classification from the element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearSecurityTags(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the security tags classification from an element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearSemanticAssignment(String serverName, String userId, String elementGUID, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
    Remove a semantic assignment relationship between an element and its glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsAbstractConcept(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the abstract concept designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsActivity(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the activity designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsContext(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the context definition designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsDataField(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the data field designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsDataValue(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the data value designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsObjectIdentifier(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the object identifier designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsSpineAttribute(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the spine attribute designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermAsSpineObject(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the spine object designation from the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermCategory(String serverName, String userId, String glossaryCategoryGUID, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
    Unlink a term from a category.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    clearTermRelationship(String serverName, String userId, String glossaryTermOneGUID, String relationshipTypeName, String glossaryTermTwoGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
    Remove the relationship between two terms.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createControlledGlossaryTerm(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ControlledGlossaryTermRequestBody requestBody)
    Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createGlossary(String serverName, String userId, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableRequestBody requestBody)
    Create a new metadata element to represent the root of a glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createGlossaryCategory(String serverName, String userId, String glossaryGUID, boolean isRootCategory, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Create a new metadata element to represent a glossary category.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createGlossaryCategoryFromTemplate(String serverName, String userId, String glossaryGUID, String templateGUID, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.TemplateRequestBody requestBody)
    Create a new metadata element to represent a glossary category using an existing metadata element as a template.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createGlossaryFromTemplate(String serverName, String userId, String templateGUID, boolean deepCopy, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.TemplateRequestBody requestBody)
    Create a new metadata element to represent a glossary using an existing metadata element as a template.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createGlossaryTermFromTemplate(String serverName, String userId, String glossaryGUID, String templateGUID, boolean deepCopy, boolean templateSubstitute, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTemplateRequestBody requestBody)
    Create a new metadata element to represent a glossary term using an existing metadata element as a template.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createNote(String serverName, String userId, String noteLogGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Create a new metadata element to represent a note.
    org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse
    createNoteLog(String serverName, String userId, String elementGUID, boolean isPublic, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Create a new metadata element to represent a note log and attach it to an element (if supplied).
    org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermActivityTypeListResponse
    getGlossaryTermActivityTypes(String serverName, String userId)
    Return the list of glossary term relationship status enum values.
    org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermRelationshipStatusListResponse
    getGlossaryTermRelationshipStatuses(String serverName, String userId)
    Return the list of glossary term relationship status enum values.
    org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermStatusListResponse
    getGlossaryTermStatuses(String serverName, String userId)
    Return the list of glossary term status enum values.
    org.odpi.openmetadata.commonservices.ffdc.rest.NameListResponse
    getTermRelationshipTypeNames(String serverName, String userId)
    Return the list of term-to-term relationship names.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    moveGlossaryTerm(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Move the glossary term from one glossary to another.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeElementFromSubjectArea(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Remove the subject area designation from the identified element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeGlossary(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Remove the metadata element representing a glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeGlossaryCategory(String serverName, String userId, String glossaryCategoryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Remove the metadata element representing a glossary category.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeGlossaryTerm(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Remove the metadata element representing a glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeGovernanceDefinitionFromElement(String serverName, String userId, String definitionGUID, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
    Remove the GovernedBy relationship between a governance definition and an element.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeNote(String serverName, String userId, String noteGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Remove the metadata element representing a note.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    removeNoteLog(String serverName, String userId, String noteLogGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Remove the metadata element representing a note log.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setConfidenceClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization has that the data is complete, accurate and up-to-date.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setConfidentialityClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the level of confidentiality that any data associated with the element should be given.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setCriticalityClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify/reclassify the element (typically an asset) to indicate how critical the element (or associated resource) is to the organization.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setGlossaryAsCanonical(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify a glossary to declare that it has no two GlossaryTerm definitions with the same name.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setGlossaryAsEditingGlossary(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setGlossaryAsStagingGlossary(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setGlossaryAsTaxonomy(String serverName, String userId, String glossaryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary to indicate that it can be used as a taxonomy.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setRetentionClassification(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource) is to be retained by the organization.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsAbstractConcept(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes an abstract concept.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsActivity(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes a data value.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsContext(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes a context.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsDataField(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsDataValue(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes a data value.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsObjectIdentifier(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes an object identifier.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsSpineAttribute(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes a spine attribute.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setTermAsSpineObject(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
    Classify the glossary term to indicate that it describes a spine object.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setupCategoryParent(String serverName, String userId, String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
    Create a parent-child relationship between two categories.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setupSemanticAssignment(String serverName, String userId, String elementGUID, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
    Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute, data field or asset).
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setupTermCategory(String serverName, String userId, String glossaryCategoryGUID, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
    Link a term to a category.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    setupTermRelationship(String serverName, String userId, String glossaryTermOneGUID, String relationshipTypeName, String glossaryTermTwoGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
    Link two terms together using a specialist relationship.
    org.odpi.openmetadata.accessservices.assetmanager.rest.GlossaryTermElementResponse
    undoGlossaryTermUpdate(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
    Undo the last update to the glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateGlossary(String serverName, String userId, String glossaryGUID, boolean isMergeUpdate, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Update the metadata element representing a glossary.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateGlossaryCategory(String serverName, String userId, String glossaryCategoryGUID, boolean isMergeUpdate, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Update the metadata element representing a glossary category.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateGlossaryTerm(String serverName, String userId, String glossaryTermGUID, boolean isMergeUpdate, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Update the metadata element representing a glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateGlossaryTermFromTemplate(String serverName, String userId, String glossaryTermGUID, boolean isMergeClassifications, boolean isMergeProperties, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Update the glossary term using the properties and classifications from the parentGUID stored in the request body.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateGlossaryTermStatus(String serverName, String userId, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermStatusRequestBody requestBody)
    Update the status of the metadata element representing a glossary term.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateNote(String serverName, String userId, String noteGUID, boolean isMergeUpdate, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Update the properties of the metadata element representing a note.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateNoteLog(String serverName, String userId, String noteLogGUID, boolean isMergeUpdate, boolean isPublic, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
    Update the metadata element representing a note log.
    org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse
    updateTermRelationship(String serverName, String userId, String glossaryTermOneGUID, String relationshipTypeName, String glossaryTermTwoGUID, boolean forLineage, boolean forDuplicateProcessing, org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
    Update the relationship properties for the two terms.

    Methods inherited from class java.lang.Object

    equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • GlossaryWorkflowResource

      public GlossaryWorkflowResource()
      Default constructor

  • Method Details

    • createGlossary

      @PostMapping(path="/glossaries") public org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createGlossary(@PathVariable String serverName, @PathVariable String userId, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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.
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createGlossaryFromTemplate(@PathVariable String serverName, @PathVariable String userId, @PathVariable String templateGUID, @RequestParam(required=false,defaultValue="true") boolean deepCopy, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateGlossary(@PathVariable String serverName, @PathVariable String userId, @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 org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a glossary.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeGlossary(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setGlossaryAsEditingGlossary(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearGlossaryAsEditingGlossary(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the editing glossary designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setGlossaryAsStagingGlossary(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearGlossaryAsStagingGlossary(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the staging glossary designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setGlossaryAsTaxonomy(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearGlossaryAsTaxonomy(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the taxonomy designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setGlossaryAsCanonical(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearGlossaryAsCanonical(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the canonical vocabulary designation from the glossary.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createGlossaryCategory(@PathVariable String serverName, @PathVariable String userId, @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 org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Create a new metadata element to represent a glossary category.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createGlossaryCategoryFromTemplate(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @PathVariable String templateGUID, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateGlossaryCategory(@PathVariable String serverName, @PathVariable String userId, @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 org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a glossary category.
      Parameters:
      serverName - name of the server to route the request to
      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)?
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setupCategoryParent(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryParentCategoryGUID, @PathVariable String glossaryChildCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
      Create a parent-child relationship between two categories.
      Parameters:
      serverName - name of the server to route the request to
      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
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearCategoryParent(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryParentCategoryGUID, @PathVariable String glossaryChildCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
      Remove a parent-child relationship between two categories.
      Parameters:
      serverName - name of the server to route the request to
      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
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeGlossaryCategory(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryCategoryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a glossary category.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermStatusListResponse getGlossaryTermStatuses(@PathVariable String serverName, @PathVariable String userId)
      Return the list of glossary term status enum values.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      Returns:
      list of enum values

    • getGlossaryTermRelationshipStatuses

      @GetMapping(path="/glossaries/terms/relationships/status-list") public org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermRelationshipStatusListResponse getGlossaryTermRelationshipStatuses(@PathVariable String serverName, @PathVariable String userId)
      Return the list of glossary term relationship status enum values.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      Returns:
      list of enum values

    • getGlossaryTermActivityTypes

      @GetMapping(path="/glossaries/terms/activity-types") public org.odpi.openmetadata.viewservices.glossaryworkflow.rest.GlossaryTermActivityTypeListResponse getGlossaryTermActivityTypes(@PathVariable String serverName, @PathVariable String userId)
      Return the list of glossary term relationship status enum values.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      Returns:
      list of enum values

    • createControlledGlossaryTerm

      @PostMapping(path="/glossaries/{glossaryGUID}/terms/new-controlled") public org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createControlledGlossaryTerm(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createGlossaryTermFromTemplate(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryGUID, @PathVariable String templateGUID, @RequestParam(required=false,defaultValue="true") boolean deepCopy, @RequestParam(required=false,defaultValue="true") boolean templateSubstitute, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateGlossaryTerm(@PathVariable String serverName, @PathVariable String userId, @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 org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateGlossaryTermStatus(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateGlossaryTermFromTemplate(@PathVariable String serverName, @PathVariable String userId, @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 org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse moveGlossaryTerm(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Move the glossary term from one glossary to another.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setupTermCategory(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryCategoryGUID, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
      Link a term to a category.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermCategory(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryCategoryGUID, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
      Unlink a term from a category.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.NameListResponse getTermRelationshipTypeNames(@PathVariable String serverName, @PathVariable String userId)
      Return the list of term-to-term relationship names.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setupTermRelationship(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermOneGUID, @PathVariable String relationshipTypeName, @PathVariable String glossaryTermTwoGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
      Link two terms together using a specialist relationship.
      Parameters:
      serverName - name of the server to route the request to
      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
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateTermRelationship(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermOneGUID, @PathVariable String relationshipTypeName, @PathVariable String glossaryTermTwoGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
      Update the relationship properties for the two terms.
      Parameters:
      serverName - name of the server to route the request to
      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
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermRelationship(@PathVariable String serverName, @PathVariable String userId, @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) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
      Remove the relationship between two terms.
      Parameters:
      serverName - name of the server to route the request to
      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
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsAbstractConcept(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsAbstractConcept(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the abstract concept designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsDataField(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsDataField(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the data field designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsDataValue(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsDataValue(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the data value designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsActivity(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsActivity(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the activity designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsContext(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Classify the glossary term to indicate that it describes a context.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsContext(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the context definition designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsSpineObject(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsSpineObject(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the spine object designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsSpineAttribute(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsSpineAttribute(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the spine attribute designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setTermAsObjectIdentifier(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.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
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearTermAsObjectIdentifier(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the object identifier designation from the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.accessservices.assetmanager.rest.GlossaryTermElementResponse undoGlossaryTermUpdate(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
      Undo the last update to the glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse archiveGlossaryTerm(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ArchiveRequestBody requestBody)
      Archive the metadata element representing a glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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 org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeGlossaryTerm(@PathVariable String serverName, @PathVariable String userId, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a glossary term.
      Parameters:
      serverName - name of the server to route the request to
      userId - calling user
      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)

    • createNoteLog

      @PostMapping("/elements/{elementGUID}/note-logs") public org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createNoteLog(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="true") boolean isPublic, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Create a new metadata element to represent a note log and attach it to an element (if supplied). Any supplied element becomes the note log's anchor, causing the note log to be deleted if/when the element is deleted.
      Parameters:
      serverName - name of the server instances for this request
      userId - calling user
      elementGUID - unique identifier of the element where the note log is located
      isPublic - is this element visible to other people.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties to control the type of the request
      Returns:
      unique identifier of the new note log 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)

    • updateNoteLog

      @PostMapping("/note-logs/{noteLogGUID}/update") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateNoteLog(@PathVariable String serverName, @PathVariable String userId, @PathVariable String noteLogGUID, @RequestParam(required=false,defaultValue="false") boolean isMergeUpdate, @RequestParam(required=false,defaultValue="true") boolean isPublic, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Update the metadata element representing a note log.
      Parameters:
      serverName - name of the server instances for this request
      userId - calling user
      noteLogGUID - unique identifier of the metadata element to update
      isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
      isPublic - is this element visible to other people.
      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)

    • removeNoteLog

      @PostMapping("/note-logs/{noteLogGUID}/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeNoteLog(@PathVariable String serverName, @PathVariable String userId, @PathVariable String noteLogGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a note log.
      Parameters:
      serverName - name of the server instances for this request
      userId - calling user
      noteLogGUID - 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)

    • createNote

      @PostMapping("/note-logs/{noteLogGUID}/notes") public org.odpi.openmetadata.commonservices.ffdc.rest.GUIDResponse createNote(@PathVariable String serverName, @PathVariable String userId, @PathVariable String noteLogGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Create a new metadata element to represent a note.
      Parameters:
      serverName - name of the server instances for this request
      userId - calling user
      noteLogGUID - unique identifier of the element where the note is located
      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:
      unique identifier of the new metadata element for the note 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)

    • updateNote

      @PostMapping("/note-logs/notes/{noteGUID}/update") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse updateNote(@PathVariable String serverName, @PathVariable String userId, @PathVariable String noteGUID, @RequestParam(required=false,defaultValue="false") boolean isMergeUpdate, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Update the properties of the metadata element representing a note.
      Parameters:
      userId - calling user
      serverName - name of the server instances for this request
      noteGUID - unique identifier of the note 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 - 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)

    • removeNote

      @PostMapping("/note-logs/notes/{noteGUID}/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeNote(@PathVariable String serverName, @PathVariable String userId, @PathVariable String noteGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ReferenceableUpdateRequestBody requestBody)
      Remove the metadata element representing a note.
      Parameters:
      serverName - name of the server instances for this request
      userId - calling user
      noteGUID - 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)

    • setConfidenceClassification

      @PostMapping(path="/elements/{elementGUID}/confidence") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setConfidenceClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization has that the data is complete, accurate and up-to-date. The level of confidence is expressed by the levelIdentifier property.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to classify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearConfidenceClassification

      @PostMapping(path="/elements/{elementGUID}/confidence/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearConfidenceClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
      Remove the confidence classification from the element. This normally occurs when the organization has lost track of the level of confidence to assign to the element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to unclassify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • setCriticalityClassification

      @PostMapping(path="/elements/{elementGUID}/criticality") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setCriticalityClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Classify/reclassify the element (typically an asset) to indicate how critical the element (or associated resource) is to the organization. The level of criticality is expressed by the levelIdentifier property.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to classify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearCriticalityClassification

      @PostMapping(path="/elements/{elementGUID}/criticality/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearCriticalityClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
      Remove the criticality classification from the element. This normally occurs when the organization has lost track of the level of criticality to assign to the element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to unclassify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • setConfidentialityClassification

      @PostMapping(path="/elements/{elementGUID}/confidentiality") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setConfidentialityClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the level of confidentiality that any data associated with the element should be given. If the classification is attached to a glossary term, the level of confidentiality is a suggestion for any element linked to the glossary term via the SemanticAssignment classification. The level of confidence is expressed by the levelIdentifier property.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to classify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearConfidentialityClassification

      @PostMapping(path="/elements/{elementGUID}/confidentiality/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearConfidentialityClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
      Remove the confidence classification from the element. This normally occurs when the organization has lost track of the level of confidentiality to assign to the element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to unclassify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • setRetentionClassification

      @PostMapping(path="/elements/{elementGUID}/retention") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setRetentionClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource) is to be retained by the organization. The policy to apply to the element/resource is captured by the retentionBasis property. The dates after which the element/resource is archived and then deleted are specified in the archiveAfter and deleteAfter properties respectively.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to classify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearRetentionClassification

      @PostMapping(path="/elements/{elementGUID}/retention/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearRetentionClassification(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.commonservices.ffdc.rest.EffectiveTimeRequestBody requestBody)
      Remove the retention classification from the element. This normally occurs when the organization has lost track of, or no longer needs to track the retention period to assign to the element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the metadata element to unclassify
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for the request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • addSecurityTags

      @PostMapping(path="/elements/{elementGUID}/security-tags") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse addSecurityTags(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Add or replace the security tags for an element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of element to attach to
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - list of security labels and properties
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearSecurityTags

      @PostMapping(path="/elements/{elementGUID}/security-tags/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearSecurityTags(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the security tags classification from an element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of element
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - null request body
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • addOwnership

      @PostMapping(path="/elements/{elementGUID}/ownership") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse addOwnership(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Add or replace the ownership classification for an element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - element to link it to - its type must inherit from Referenceable.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for classification request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearOwnership

      @PostMapping(path="/elements/{elementGUID}/ownership/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearOwnership(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the ownership classification from an element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - element where the classification needs to be removed.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for classification request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • addElementToSubjectArea

      @PostMapping(path="/elements/{elementGUID}/subject-area-member") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse addElementToSubjectArea(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Classify the element to assert that the definitions it represents are part of a subject area definition.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - 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 for classification request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • removeElementFromSubjectArea

      @PostMapping(path="/elements/{elementGUID}/subject-area-member/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeElementFromSubjectArea(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.ClassificationRequestBody requestBody)
      Remove the subject area designation from the identified element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - 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 for classification request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • setupSemanticAssignment

      @PostMapping(path="/elements/{elementGUID}/semantic-assignment/terms/{glossaryTermGUID}") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse setupSemanticAssignment(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
      Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute, data field or asset). This relationship indicates that the data associated with the element meaning matches the description in the glossary term.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the element that is being assigned to the glossary term
      glossaryTermGUID - unique identifier of the glossary term that provides the meaning
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for relationship request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • clearSemanticAssignment

      @PostMapping(path="/elements/{elementGUID}/semantic-assignment/terms/{glossaryTermGUID}/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse clearSemanticAssignment(@PathVariable String serverName, @PathVariable String userId, @PathVariable String elementGUID, @PathVariable String glossaryTermGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
      Remove a semantic assignment relationship between an element and its glossary term.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      elementGUID - unique identifier of the element that is being assigned to the glossary term
      glossaryTermGUID - unique identifier of the glossary term that provides the meaning
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for relationship request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • addGovernanceDefinitionToElement

      @PostMapping(path="/elements/{elementGUID}/governed-by/definition/{definitionGUID}") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse addGovernanceDefinitionToElement(@PathVariable String serverName, @PathVariable String userId, @PathVariable String definitionGUID, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.RelationshipRequestBody requestBody)
      Link a governance definition to an element using the GovernedBy relationship.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      definitionGUID - identifier of the governance definition to link
      elementGUID - unique identifier of the metadata element to link
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      requestBody - properties for relationship request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

    • removeGovernanceDefinitionFromElement

      @PostMapping(path="/elements/{elementGUID}/governed-by/definition/{definitionGUID}/remove") public org.odpi.openmetadata.commonservices.ffdc.rest.VoidResponse removeGovernanceDefinitionFromElement(@PathVariable String serverName, @PathVariable String userId, @PathVariable String definitionGUID, @PathVariable String elementGUID, @RequestParam(required=false,defaultValue="false") boolean forLineage, @RequestParam(required=false,defaultValue="false") boolean forDuplicateProcessing, @RequestBody(required=false) org.odpi.openmetadata.viewservices.glossaryworkflow.rest.EffectiveTimeQueryRequestBody requestBody)
      Remove the GovernedBy relationship between a governance definition and an element.
      Parameters:
      serverName - name of the server instance to connect to
      userId - calling user
      definitionGUID - identifier of the governance definition to link
      elementGUID - 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 for relationship request
      Returns:
      void or InvalidParameterException full path or userId is null or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem