java.lang.Object
- org.odpi.openmetadata.accessservices.assetmanager.handlers.GlossaryExchangeHandler

```
public class GlossaryExchangeHandler
extends Object
```
GlossaryExchangeHandler is the server side handler for managing glossary content.

Constructor Summary

Constructors
Constructor	Description
`GlossaryExchangeHandler(String serviceName, String serverName, InvalidParameterHandler invalidParameterHandler, RepositoryHandler repositoryHandler, OMRSRepositoryHelper repositoryHelper, String localServerUserId, OpenMetadataServerSecurityVerifier securityVerifier, List<String> supportedZones, List<String> defaultZones, List<String> publishZones, AuditLog auditLog)`	Construct the glossary exchange handler with information needed to work with glossary related objects for Asset Manager OMAS.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`attachExternalCategoryLink(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, String externalLinkGUID, ExternalGlossaryElementLinkProperties linkProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Create a link to an external glossary category resource.
`void`	`attachExternalLinkToGlossary(String userId, String assetManagerGUID, String assetManagerName, String glossaryGUID, String externalLinkGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Connect a glossary to a reference to an external glossary resource.
`void`	`attachExternalTermLink(String userId, String assetManagerGUID, String assetManagerName, String glossaryTermGUID, String externalLinkGUID, ExternalGlossaryElementLinkProperties linkProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Create a link to an external glossary term resource.
`void`	`clearCategoryParent(String userId, String assetManagerGUID, String assetManagerName, String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove a parent-child relationship between two categories.
`void`	`clearGlossaryAsCanonical(String userId, MetadataCorrelationProperties correlationProperties, String glossaryGUID, String methodName)`	Remove the canonical designation from the glossary.
`void`	`clearGlossaryAsTaxonomy(String userId, MetadataCorrelationProperties correlationProperties, String glossaryGUID, String methodName)`	Remove the taxonomy designation from the glossary.
`void`	`clearTermAsAbstractConcept(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the abstract concept designation from the glossary term.
`void`	`clearTermAsActivity(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the activity designation from the glossary term.
`void`	`clearTermAsContext(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the context definition designation from the glossary term.
`void`	`clearTermAsDataValue(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the data value designation from the glossary term.
`void`	`clearTermAsObjectIdentifier(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the object identifier designation from the glossary term.
`void`	`clearTermAsSpineAttribute(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the spine attribute designation from the glossary term.
`void`	`clearTermAsSpineObject(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the spine object designation from the glossary term.
`void`	`clearTermCategory(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Unlink a term from a category.
`void`	`clearTermRelationship(String userId, String assetManagerGUID, String assetManagerName, String glossaryTermOneGUID, String relationshipTypeName, String glossaryTermTwoGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the relationship between two terms.
`String`	`createControlledGlossaryTerm(String userId, String glossaryGUID, MetadataCorrelationProperties correlationProperties, GlossaryTermProperties glossaryTermProperties, GlossaryTermStatus initialStatus, String methodName)`	Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.
`String`	`createExternalGlossaryLink(String userId, String assetManagerGUID, String assetManagerName, ExternalGlossaryLinkProperties linkProperties, String methodName)`	Create a link to an external glossary resource.
`String`	`createGlossary(String userId, MetadataCorrelationProperties correlationProperties, GlossaryProperties glossaryProperties, String methodName)`	Create a new metadata element to represent the root of a glossary.
`String`	`createGlossaryCategory(String userId, String glossaryGUID, MetadataCorrelationProperties correlationProperties, GlossaryCategoryProperties glossaryCategoryProperties, String methodName)`	Create a new metadata element to represent a glossary category.
`String`	`createGlossaryCategoryFromTemplate(String userId, MetadataCorrelationProperties correlationProperties, String templateGUID, TemplateProperties templateProperties, String methodName)`	Create a new metadata element to represent a glossary category using an existing metadata element as a template.
`String`	`createGlossaryFromTemplate(String userId, MetadataCorrelationProperties correlationProperties, String templateGUID, TemplateProperties templateProperties, String methodName)`	Create a new metadata element to represent a glossary using an existing metadata element as a template.
`String`	`createGlossaryTerm(String userId, String glossaryGUID, MetadataCorrelationProperties correlationProperties, GlossaryTermProperties glossaryTermProperties, String methodName)`	Create a new metadata element to represent a glossary term.
`String`	`createGlossaryTermFromTemplate(String userId, MetadataCorrelationProperties correlationProperties, String templateGUID, TemplateProperties templateProperties, String methodName)`	Create a new metadata element to represent a glossary term using an existing metadata element as a template.
`void`	`detachExternalCategoryLink(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, String externalLinkGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the link to an external glossary category resource.
`void`	`detachExternalLinkFromGlossary(String userId, String assetManagerGUID, String assetManagerName, String glossaryGUID, String externalLinkGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Disconnect a glossary from a reference to an external glossary resource.
`void`	`detachExternalTermLink(String userId, String assetManagerGUID, String assetManagerName, String glossaryTermGUID, String externalLinkGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the link to an external glossary term resource.
`List<GlossaryElement>`	`findGlossaries(String userId, String assetManagerGUID, String assetManagerName, String searchString, String searchStringParameterName, int startFrom, int pageSize, String methodName)`	Retrieve the list of glossary metadata elements that contain the search string.
`List<GlossaryCategoryElement>`	`findGlossaryCategories(String userId, String assetManagerGUID, String assetManagerName, String searchString, String searchStringParameterName, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing, String methodName)`	Retrieve the list of glossary category metadata elements that contain the search string.
`List<GlossaryTermElement>`	`findGlossaryTerms(String userId, String assetManagerGUID, String assetManagerName, String searchString, String searchStringParameterName, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the list of glossary term metadata elements that contain the search string.
`List<GlossaryCategoryElement>`	`getCategoriesForGlossary(String userId, String assetManagerGUID, String assetManagerName, String glossaryGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Return the list of categories associated with a glossary.
`List<ExternalGlossaryLinkElement>`	`getExternalLinksForGlossary(String userId, String glossaryGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the list of links to external glossary resources attached to a glossary.
`List<GlossaryElement>`	`getGlossariesByName(String userId, String assetManagerGUID, String assetManagerName, String name, String nameParameterName, int startFrom, int pageSize, String methodName)`	Retrieve the list of glossary metadata elements with a matching qualified or display name.
`List<GlossaryElement>`	`getGlossariesForAssetManager(String userId, String assetManagerGUID, String assetManagerName, int startFrom, int pageSize, String methodName)`	Retrieve the list of glossaries created by this caller.
`List<GlossaryElement>`	`getGlossariesForExternalLink(String userId, String assetManagerGUID, String assetManagerName, String externalLinkGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Return the glossaries connected to an external glossary source.
`GlossaryElement`	`getGlossaryByGUID(String userId, String assetManagerGUID, String assetManagerName, String openMetadataGUID, String methodName)`	Retrieve the glossary metadata element with the supplied unique identifier.
`List<GlossaryCategoryElement>`	`getGlossaryCategoriesByName(String userId, String assetManagerGUID, String assetManagerName, String name, String nameParameterName, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the list of glossary category metadata elements with a matching qualified or display name.
`GlossaryCategoryElement`	`getGlossaryCategoryByGUID(String userId, String assetManagerGUID, String assetManagerName, String openMetadataGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the glossary category metadata element with the supplied unique identifier.
`GlossaryCategoryElement`	`getGlossaryCategoryParent(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the glossary category metadata element with the supplied unique identifier.
`List<GlossaryCategoryElement>`	`getGlossarySubCategories(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the glossary category metadata element with the supplied unique identifier.
`GlossaryTermElement`	`getGlossaryTermByGUID(String userId, String assetManagerGUID, String assetManagerName, String guid, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the glossary term metadata element with the supplied unique identifier.
`List<GlossaryTermElement>`	`getGlossaryTermsByName(String userId, String assetManagerGUID, String assetManagerName, String name, String nameParameterName, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the list of glossary term metadata elements with a matching qualified or display name.
`List<GlossaryTermElement>`	`getTermsForGlossary(String userId, String assetManagerGUID, String assetManagerName, String glossaryGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the list of glossary terms associated with a glossary.
`List<GlossaryTermElement>`	`getTermsForGlossaryCategory(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Retrieve the list of glossary terms associated with a glossary category.
`void`	`removeExternalGlossaryLink(String userId, String assetManagerGUID, String assetManagerName, String externalLinkGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove information about a link to an external glossary resource (and the relationships that attached it to the glossaries).
`void`	`removeGlossary(String userId, MetadataCorrelationProperties correlationProperties, String glossaryGUID, String methodName)`	Remove the metadata element representing a glossary.
`void`	`removeGlossaryCategory(String userId, MetadataCorrelationProperties correlationProperties, String glossaryCategoryGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the metadata element representing a glossary category.
`void`	`removeGlossaryTerm(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Remove the metadata element representing a glossary term.
`void`	`setGlossaryAsCanonical(String userId, MetadataCorrelationProperties correlationProperties, String glossaryGUID, String scope, String methodName)`	Classify a glossary to declare that it has no two GlossaryTerm definitions with the same name.
`void`	`setGlossaryAsTaxonomy(String userId, MetadataCorrelationProperties correlationProperties, String glossaryGUID, String organizingPrinciple, String methodName)`	Classify the glossary to indicate that it can be used as a taxonomy.
`void`	`setTermAsAbstractConcept(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes an abstract concept.
`void`	`setTermAsActivity(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, GlossaryTermActivityType activityType, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes a data value.
`void`	`setTermAsContext(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, GlossaryTermContextDefinition contextDefinition, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes a context.
`void`	`setTermAsDataValue(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes a data value.
`void`	`setTermAsObjectIdentifier(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes an object identifier.
`void`	`setTermAsSpineAttribute(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes a spine attribute.
`void`	`setTermAsSpineObject(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Classify the glossary term to indicate that it describes a spine object.
`void`	`setupCategoryParent(String userId, String assetManagerGUID, String assetManagerName, String glossaryParentCategoryGUID, String glossaryChildCategoryGUID, Date effectiveFrom, Date effectiveTo, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Create a parent-child relationship between two categories.
`void`	`setupTermCategory(String userId, String assetManagerGUID, String assetManagerName, String glossaryCategoryGUID, String glossaryTermGUID, GlossaryTermCategorization categorizationProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Link a term to a category.
`void`	`setupTermRelationship(String userId, String assetManagerGUID, String assetManagerName, String glossaryTermOneGUID, String relationshipTypeName, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Link two terms together using a specialist relationship.
`void`	`updateExternalGlossaryLink(String userId, String assetManagerGUID, String assetManagerName, String externalLinkGUID, ExternalGlossaryLinkProperties linkProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Update the properties of a reference to an external glossary resource.
`void`	`updateGlossary(String userId, MetadataCorrelationProperties correlationProperties, String glossaryGUID, GlossaryProperties glossaryProperties, boolean isMergeUpdate, String methodName)`	Update the metadata element representing a glossary.
`void`	`updateGlossaryCategory(String userId, MetadataCorrelationProperties correlationProperties, String glossaryCategoryGUID, GlossaryCategoryProperties glossaryCategoryProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Update the metadata element representing a glossary category.
`void`	`updateGlossaryTerm(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, GlossaryTermProperties glossaryTermProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Update the properties of the metadata element representing a glossary term.
`void`	`updateGlossaryTermStatus(String userId, MetadataCorrelationProperties correlationProperties, String glossaryTermGUID, GlossaryTermStatus glossaryTermStatus, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Update the status of the metadata element representing a glossary term.
`void`	`updateTermRelationship(String userId, String glossaryTermOneGUID, String relationshipTypeName, String glossaryTermTwoGUID, GlossaryTermRelationship relationshipsProperties, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime, String methodName)`	Update the relationship properties for the two terms.

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

Constructor Detail

GlossaryExchangeHandler

public GlossaryExchangeHandler(String serviceName,
                               String serverName,
                               InvalidParameterHandler invalidParameterHandler,
                               RepositoryHandler repositoryHandler,
                               OMRSRepositoryHelper repositoryHelper,
                               String localServerUserId,
                               OpenMetadataServerSecurityVerifier securityVerifier,
                               List<String> supportedZones,
                               List<String> defaultZones,
                               List<String> publishZones,
                               AuditLog auditLog)

Construct the glossary exchange handler with information needed to work with glossary related objects for Asset Manager OMAS.

Parameters:: serviceName - name of this service; serverName - name of the local server; invalidParameterHandler - handler for managing parameter errors; repositoryHandler - manages calls to the repository services; repositoryHelper - provides utilities for manipulating the repository services objects; localServerUserId - userId for this server; securityVerifier - open metadata security services verifier; supportedZones - list of zones that the access service is allowed to serve instances from.; defaultZones - list of zones that the access service should set in all new instances.; publishZones - list of zones that the access service sets up in published instances.; auditLog - destination for audit log events.

Method Detail

createGlossary
```
public String createGlossary(String userId,
                             MetadataCorrelationProperties correlationProperties,
                             GlossaryProperties glossaryProperties,
                             String methodName)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
Create a new metadata element to represent the root of a glossary. All categories and terms are linked to a single glossary. They are owned by this glossary and if the glossary is deleted, any linked terms and categories are deleted as well.

Parameters:

userId - calling user

correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata

glossaryProperties - properties to store

methodName - calling method

Returns:

unique identifier of the new metadata element

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

createGlossaryFromTemplate
```
public String createGlossaryFromTemplate(String userId,
                                         MetadataCorrelationProperties correlationProperties,
                                         String templateGUID,
                                         TemplateProperties templateProperties,
                                         String methodName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException
```
Create a new metadata element to represent a glossary using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new glossary. All categories and terms are linked to a single glossary. They are owned by this glossary and if the glossary is deleted, any linked terms and categories are deleted as well.

Parameters:

userId - calling user

correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata

templateGUID - unique identifier of the metadata element to copy

templateProperties - properties that override the template

methodName - calling method

Returns:

unique identifier of the new metadata element

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

updateGlossary
```
public void updateGlossary(String userId,
                           MetadataCorrelationProperties correlationProperties,
                           String glossaryGUID,
                           GlossaryProperties glossaryProperties,
                           boolean isMergeUpdate,
                           String methodName)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
```
Update the metadata element representing a glossary.

Parameters:

userId - calling user

correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata

glossaryGUID - unique identifier of the metadata element to update

glossaryProperties - new properties for this element

isMergeUpdate - should the properties be merged with the existing properties or completely over-write them

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

removeGlossary
```
public void removeGlossary(String userId,
                           MetadataCorrelationProperties correlationProperties,
                           String glossaryGUID,
                           String methodName)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException
```
Remove the metadata element representing a glossary. This will delete the glossary and all categories and terms because the Anchors classifications are set up in these elements.

Parameters:

userId - calling user

correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata

glossaryGUID - unique identifier of the metadata element to remove

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

setGlossaryAsTaxonomy
```
public void setGlossaryAsTaxonomy(String userId,
                                  MetadataCorrelationProperties correlationProperties,
                                  String glossaryGUID,
                                  String organizingPrinciple,
                                  String methodName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException
```
Classify the glossary to indicate that it can be used as a taxonomy. This means each term is attached to one, and only one category and the categories are organized as a hierarchy with a single root category. Taxonomies are used as a way of organizing assets and other related metadata. The terms in the taxonomy are linked to the assets etc. and as such they are logically categorized by the linked category.

Parameters:

userId - calling user

correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata

glossaryGUID - unique identifier of the metadata element to remove

organizingPrinciple - description of how the glossary is organized

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

clearGlossaryAsTaxonomy

public void clearGlossaryAsTaxonomy(String userId,
                                    MetadataCorrelationProperties correlationProperties,
                                    String glossaryGUID,
                                    String methodName)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException

Remove the taxonomy designation from the glossary.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryGUID - unique identifier of the metadata element to remove; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setGlossaryAsCanonical
```
public void setGlossaryAsCanonical(String userId,
                                   MetadataCorrelationProperties correlationProperties,
                                   String glossaryGUID,
                                   String scope,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException
```
Classify a glossary to declare that it has no two GlossaryTerm definitions with the same name. This means there is only one definition for each term. Typically, the terms are also of a similar level of granularity and are limited to a specific scope of use. Canonical vocabularies are used to semantically classify assets in an unambiguous way.

Parameters:

userId - calling user

correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata

glossaryGUID - unique identifier of the metadata element to remove

scope - description of the situations where this glossary is relevant.

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

clearGlossaryAsCanonical

public void clearGlossaryAsCanonical(String userId,
                                     MetadataCorrelationProperties correlationProperties,
                                     String glossaryGUID,
                                     String methodName)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException

Remove the canonical designation from the glossary.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryGUID - unique identifier of the metadata element to remove; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

findGlossaries

public List<GlossaryElement> findGlossaries(String userId,
                                            String assetManagerGUID,
                                            String assetManagerName,
                                            String searchString,
                                            String searchStringParameterName,
                                            int startFrom,
                                            int pageSize,
                                            String methodName)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException

Retrieve the list of glossary metadata elements that contain the search string. The search string is treated as a regular expression.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; searchString - string to find in the properties; searchStringParameterName - name of parameter for search string; startFrom - paging start point; pageSize - maximum results that can be returned; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossariesByName

public List<GlossaryElement> getGlossariesByName(String userId,
                                                 String assetManagerGUID,
                                                 String assetManagerName,
                                                 String name,
                                                 String nameParameterName,
                                                 int startFrom,
                                                 int pageSize,
                                                 String methodName)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException

Retrieve the list of glossary metadata elements with a matching qualified or display name. There are no wildcards supported on this request.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; name - name to search for; nameParameterName - name of parameter supplying name value; startFrom - paging start point; pageSize - maximum results that can be returned; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossariesForAssetManager

public List<GlossaryElement> getGlossariesForAssetManager(String userId,
                                                          String assetManagerGUID,
                                                          String assetManagerName,
                                                          int startFrom,
                                                          int pageSize,
                                                          String methodName)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException

Retrieve the list of glossaries created by this caller.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; startFrom - paging start point; pageSize - maximum results that can be returned; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossaryByGUID

public GlossaryElement getGlossaryByGUID(String userId,
                                         String assetManagerGUID,
                                         String assetManagerName,
                                         String openMetadataGUID,
                                         String methodName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException

Retrieve the glossary metadata element with the supplied unique identifier.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; openMetadataGUID - unique identifier of the requested metadata element; methodName - calling method
Returns:: matching metadata element
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

createGlossaryCategory

public String createGlossaryCategory(String userId,
                                     String glossaryGUID,
                                     MetadataCorrelationProperties correlationProperties,
                                     GlossaryCategoryProperties glossaryCategoryProperties,
                                     String methodName)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException

Create a new metadata element to represent a glossary category.

Parameters:: userId - calling user; glossaryGUID - unique identifier of the glossary where the category is located; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryCategoryProperties - properties about the glossary category to store; methodName - calling method
Returns:: unique identifier of the new glossary category
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

createGlossaryCategoryFromTemplate

public String createGlossaryCategoryFromTemplate(String userId,
                                                 MetadataCorrelationProperties correlationProperties,
                                                 String templateGUID,
                                                 TemplateProperties templateProperties,
                                                 String methodName)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException

Create a new metadata element to represent a glossary category using an existing metadata element as a template.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; templateGUID - unique identifier of the metadata element to copy; templateProperties - properties that override the template; methodName - calling method
Returns:: unique identifier of the new glossary category
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

updateGlossaryCategory

public void updateGlossaryCategory(String userId,
                                   MetadataCorrelationProperties correlationProperties,
                                   String glossaryCategoryGUID,
                                   GlossaryCategoryProperties glossaryCategoryProperties,
                                   boolean forLineage,
                                   boolean forDuplicateProcessing,
                                   Date effectiveTime,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException

Update the metadata element representing a glossary category.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryCategoryGUID - unique identifier of the metadata element to update; glossaryCategoryProperties - new properties for the metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setupCategoryParent
```
public void setupCategoryParent(String userId,
                                String assetManagerGUID,
                                String assetManagerName,
                                String glossaryParentCategoryGUID,
                                String glossaryChildCategoryGUID,
                                Date effectiveFrom,
                                Date effectiveTo,
                                boolean forLineage,
                                boolean forDuplicateProcessing,
                                Date effectiveTime,
                                String methodName)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
Create a parent-child relationship between two categories.

Parameters:

userId - calling user

assetManagerGUID - unique identifier of software server capability representing the caller

assetManagerName - unique name of software server capability representing the caller

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

effectiveFrom - the time that the relationship element must be effective from (null for any time, new Date() for now)

effectiveTo - the time that the relationship must be effective to (null for any time, new Date() for now)

forLineage - return elements marked with the Memento classification?

forDuplicateProcessing - do not merge elements marked as duplicates?

effectiveTime - optional date for effective time of the query. Null means any effective time

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

clearCategoryParent
```
public void clearCategoryParent(String userId,
                                String assetManagerGUID,
                                String assetManagerName,
                                String glossaryParentCategoryGUID,
                                String glossaryChildCategoryGUID,
                                boolean forLineage,
                                boolean forDuplicateProcessing,
                                Date effectiveTime,
                                String methodName)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException
```
Remove a parent-child relationship between two categories.

Parameters:

userId - calling user

assetManagerGUID - unique identifier of software server capability representing the caller

assetManagerName - unique name of software server capability representing the caller

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?

effectiveTime - optional date for effective time of the query. Null means any effective time

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid

UserNotAuthorizedException - the user is not authorized to issue this request

PropertyServerException - there is a problem reported in the open metadata server(s)

removeGlossaryCategory

public void removeGlossaryCategory(String userId,
                                   MetadataCorrelationProperties correlationProperties,
                                   String glossaryCategoryGUID,
                                   boolean forLineage,
                                   boolean forDuplicateProcessing,
                                   Date effectiveTime,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException

Remove the metadata element representing a glossary category.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

findGlossaryCategories

public List<GlossaryCategoryElement> findGlossaryCategories(String userId,
                                                            String assetManagerGUID,
                                                            String assetManagerName,
                                                            String searchString,
                                                            String searchStringParameterName,
                                                            int startFrom,
                                                            int pageSize,
                                                            Date effectiveTime,
                                                            boolean forLineage,
                                                            boolean forDuplicateProcessing,
                                                            String methodName)
                                                     throws InvalidParameterException,
                                                            UserNotAuthorizedException,
                                                            PropertyServerException

Retrieve the list of glossary category metadata elements that contain the search string. The search string is treated as a regular expression.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; searchString - string to find in the properties; searchStringParameterName - name of parameter for searchString; startFrom - paging start point; pageSize - maximum results that can be returned; effectiveTime - optional date for effective time of the query. Null means any effective time; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getCategoriesForGlossary

public List<GlossaryCategoryElement> getCategoriesForGlossary(String userId,
                                                              String assetManagerGUID,
                                                              String assetManagerName,
                                                              String glossaryGUID,
                                                              int startFrom,
                                                              int pageSize,
                                                              boolean forLineage,
                                                              boolean forDuplicateProcessing,
                                                              Date effectiveTime,
                                                              String methodName)
                                                       throws InvalidParameterException,
                                                              UserNotAuthorizedException,
                                                              PropertyServerException

Return the list of categories associated with a glossary.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryGUID - unique identifier of the glossary to query; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of metadata elements describing the categories associated with the requested glossary
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossaryCategoriesByName

public List<GlossaryCategoryElement> getGlossaryCategoriesByName(String userId,
                                                                 String assetManagerGUID,
                                                                 String assetManagerName,
                                                                 String name,
                                                                 String nameParameterName,
                                                                 int startFrom,
                                                                 int pageSize,
                                                                 boolean forLineage,
                                                                 boolean forDuplicateProcessing,
                                                                 Date effectiveTime,
                                                                 String methodName)
                                                          throws InvalidParameterException,
                                                                 UserNotAuthorizedException,
                                                                 PropertyServerException

Retrieve the list of glossary category metadata elements with a matching qualified or display name. There are no wildcards supported on this request.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; name - name to search for; nameParameterName - parameter name; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossaryCategoryParent

public GlossaryCategoryElement getGlossaryCategoryParent(String userId,
                                                         String assetManagerGUID,
                                                         String assetManagerName,
                                                         String glossaryCategoryGUID,
                                                         boolean forLineage,
                                                         boolean forDuplicateProcessing,
                                                         Date effectiveTime,
                                                         String methodName)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException

Retrieve the glossary category metadata element with the supplied unique identifier.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryCategoryGUID - unique identifier of the requested metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: parent glossary category element
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossarySubCategories

public List<GlossaryCategoryElement> getGlossarySubCategories(String userId,
                                                              String assetManagerGUID,
                                                              String assetManagerName,
                                                              String glossaryCategoryGUID,
                                                              int startFrom,
                                                              int pageSize,
                                                              boolean forLineage,
                                                              boolean forDuplicateProcessing,
                                                              Date effectiveTime,
                                                              String methodName)
                                                       throws InvalidParameterException,
                                                              UserNotAuthorizedException,
                                                              PropertyServerException

Retrieve the glossary category metadata element with the supplied unique identifier.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryCategoryGUID - unique identifier of the requested metadata element; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of glossary category element
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossaryCategoryByGUID

public GlossaryCategoryElement getGlossaryCategoryByGUID(String userId,
                                                         String assetManagerGUID,
                                                         String assetManagerName,
                                                         String openMetadataGUID,
                                                         boolean forLineage,
                                                         boolean forDuplicateProcessing,
                                                         Date effectiveTime,
                                                         String methodName)
                                                  throws InvalidParameterException,
                                                         UserNotAuthorizedException,
                                                         PropertyServerException

Retrieve the glossary category metadata element with the supplied unique identifier.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; openMetadataGUID - unique identifier of the requested metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: requested metadata element
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

createGlossaryTerm

public String createGlossaryTerm(String userId,
                                 String glossaryGUID,
                                 MetadataCorrelationProperties correlationProperties,
                                 GlossaryTermProperties glossaryTermProperties,
                                 String methodName)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException

Create a new metadata element to represent a glossary term.

Parameters:: userId - calling user; glossaryGUID - unique identifier of the glossary where the term is located; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryTermProperties - properties for the glossary term; methodName - calling method
Returns:: unique identifier of the new metadata element for the glossary term
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

createControlledGlossaryTerm

public String createControlledGlossaryTerm(String userId,
                                           String glossaryGUID,
                                           MetadataCorrelationProperties correlationProperties,
                                           GlossaryTermProperties glossaryTermProperties,
                                           GlossaryTermStatus initialStatus,
                                           String methodName)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException

Create a new metadata element to represent a glossary term whose lifecycle is managed through a controlled workflow.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryGUID - unique identifier of the glossary where the term is located; glossaryTermProperties - properties for the glossary term; initialStatus - glossary term status to use when the object is created; methodName - calling method
Returns:: unique identifier of the new metadata element for the glossary term
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

createGlossaryTermFromTemplate

public String createGlossaryTermFromTemplate(String userId,
                                             MetadataCorrelationProperties correlationProperties,
                                             String templateGUID,
                                             TemplateProperties templateProperties,
                                             String methodName)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException

Create a new metadata element to represent a glossary term using an existing metadata element as a template.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; templateGUID - unique identifier of the metadata element to copy; templateProperties - properties that override the template; methodName - calling method
Returns:: unique identifier of the new metadata element for the glossary term
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

updateGlossaryTerm

public void updateGlossaryTerm(String userId,
                               MetadataCorrelationProperties correlationProperties,
                               String glossaryTermGUID,
                               GlossaryTermProperties glossaryTermProperties,
                               boolean forLineage,
                               boolean forDuplicateProcessing,
                               Date effectiveTime,
                               String methodName)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException

Update the properties of the metadata element representing a glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryTermGUID - unique identifier of the glossary term to update; glossaryTermProperties - new properties for the glossary term; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

updateGlossaryTermStatus

public void updateGlossaryTermStatus(String userId,
                                     MetadataCorrelationProperties correlationProperties,
                                     String glossaryTermGUID,
                                     GlossaryTermStatus glossaryTermStatus,
                                     boolean forLineage,
                                     boolean forDuplicateProcessing,
                                     Date effectiveTime,
                                     String methodName)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException

Update the status of the metadata element representing a glossary term. This is only valid on a controlled glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryTermGUID - unique identifier of the glossary term to update; glossaryTermStatus - new properties for the glossary term; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setupTermCategory

public void setupTermCategory(String userId,
                              String assetManagerGUID,
                              String assetManagerName,
                              String glossaryCategoryGUID,
                              String glossaryTermGUID,
                              GlossaryTermCategorization categorizationProperties,
                              boolean forLineage,
                              boolean forDuplicateProcessing,
                              Date effectiveTime,
                              String methodName)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException

Link a term to a category.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryCategoryGUID - unique identifier of the glossary category; glossaryTermGUID - unique identifier of the glossary term; categorizationProperties - properties for the categorization relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermCategory

public void clearTermCategory(String userId,
                              String assetManagerGUID,
                              String assetManagerName,
                              String glossaryCategoryGUID,
                              String glossaryTermGUID,
                              boolean forLineage,
                              boolean forDuplicateProcessing,
                              Date effectiveTime,
                              String methodName)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException

Unlink a term from a category.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setupTermRelationship

public void setupTermRelationship(String userId,
                                  String assetManagerGUID,
                                  String assetManagerName,
                                  String glossaryTermOneGUID,
                                  String relationshipTypeName,
                                  String glossaryTermTwoGUID,
                                  GlossaryTermRelationship relationshipsProperties,
                                  boolean forLineage,
                                  boolean forDuplicateProcessing,
                                  Date effectiveTime,
                                  String methodName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException

Link two terms together using a specialist relationship. If there are no relationship properties then the status is set to ACTIVE and other properties are null.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryTermOneGUID - unique identifier of the glossary term at end 1; relationshipTypeName - name of the type of relationship to create; glossaryTermTwoGUID - unique identifier of the glossary term at end 2; relationshipsProperties - properties for the categorization relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

updateTermRelationship

public void updateTermRelationship(String userId,
                                   String glossaryTermOneGUID,
                                   String relationshipTypeName,
                                   String glossaryTermTwoGUID,
                                   GlossaryTermRelationship relationshipsProperties,
                                   boolean forLineage,
                                   boolean forDuplicateProcessing,
                                   Date effectiveTime,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException

Update the relationship properties for the two terms.

Parameters:: userId - calling user; glossaryTermOneGUID - unique identifier of the glossary term at end 1; relationshipTypeName - name of the type of relationship to create; glossaryTermTwoGUID - unique identifier of the glossary term at end 2; relationshipsProperties - properties for the categorization relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermRelationship

public void clearTermRelationship(String userId,
                                  String assetManagerGUID,
                                  String assetManagerName,
                                  String glossaryTermOneGUID,
                                  String relationshipTypeName,
                                  String glossaryTermTwoGUID,
                                  boolean forLineage,
                                  boolean forDuplicateProcessing,
                                  Date effectiveTime,
                                  String methodName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException

Remove the relationship between two terms.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryTermOneGUID - unique identifier of the glossary term at end 1; relationshipTypeName - name of the type of relationship to create; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsAbstractConcept

public void setTermAsAbstractConcept(String userId,
                                     MetadataCorrelationProperties correlationProperties,
                                     String glossaryTermGUID,
                                     boolean forLineage,
                                     boolean forDuplicateProcessing,
                                     Date effectiveTime,
                                     String methodName)
                              throws InvalidParameterException,
                                     UserNotAuthorizedException,
                                     PropertyServerException

Classify the glossary term to indicate that it describes an abstract concept.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsAbstractConcept

public void clearTermAsAbstractConcept(String userId,
                                       MetadataCorrelationProperties correlationProperties,
                                       String glossaryTermGUID,
                                       boolean forLineage,
                                       boolean forDuplicateProcessing,
                                       Date effectiveTime,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Remove the abstract concept designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsDataValue

public void setTermAsDataValue(String userId,
                               MetadataCorrelationProperties correlationProperties,
                               String glossaryTermGUID,
                               boolean forLineage,
                               boolean forDuplicateProcessing,
                               Date effectiveTime,
                               String methodName)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException

Classify the glossary term to indicate that it describes a data value.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsDataValue

public void clearTermAsDataValue(String userId,
                                 MetadataCorrelationProperties correlationProperties,
                                 String glossaryTermGUID,
                                 boolean forLineage,
                                 boolean forDuplicateProcessing,
                                 Date effectiveTime,
                                 String methodName)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException

Remove the data value designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsActivity

public void setTermAsActivity(String userId,
                              MetadataCorrelationProperties correlationProperties,
                              String glossaryTermGUID,
                              GlossaryTermActivityType activityType,
                              boolean forLineage,
                              boolean forDuplicateProcessing,
                              Date effectiveTime,
                              String methodName)
                       throws InvalidParameterException,
                              UserNotAuthorizedException,
                              PropertyServerException

Classify the glossary term to indicate that it describes a data value.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryTermGUID - unique identifier of the metadata element to update; activityType - type of activity; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsActivity

public void clearTermAsActivity(String userId,
                                MetadataCorrelationProperties correlationProperties,
                                String glossaryTermGUID,
                                boolean forLineage,
                                boolean forDuplicateProcessing,
                                Date effectiveTime,
                                String methodName)
                         throws InvalidParameterException,
                                UserNotAuthorizedException,
                                PropertyServerException

Remove the activity designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsContext

public void setTermAsContext(String userId,
                             MetadataCorrelationProperties correlationProperties,
                             String glossaryTermGUID,
                             GlossaryTermContextDefinition contextDefinition,
                             boolean forLineage,
                             boolean forDuplicateProcessing,
                             Date effectiveTime,
                             String methodName)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException

Classify the glossary term to indicate that it describes a context.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; glossaryTermGUID - unique identifier of the metadata element to update; contextDefinition - more details of the context; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsContext

public void clearTermAsContext(String userId,
                               MetadataCorrelationProperties correlationProperties,
                               String glossaryTermGUID,
                               boolean forLineage,
                               boolean forDuplicateProcessing,
                               Date effectiveTime,
                               String methodName)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException

Remove the context definition designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsSpineObject

public void setTermAsSpineObject(String userId,
                                 MetadataCorrelationProperties correlationProperties,
                                 String glossaryTermGUID,
                                 boolean forLineage,
                                 boolean forDuplicateProcessing,
                                 Date effectiveTime,
                                 String methodName)
                          throws InvalidParameterException,
                                 UserNotAuthorizedException,
                                 PropertyServerException

Classify the glossary term to indicate that it describes a spine object.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsSpineObject

public void clearTermAsSpineObject(String userId,
                                   MetadataCorrelationProperties correlationProperties,
                                   String glossaryTermGUID,
                                   boolean forLineage,
                                   boolean forDuplicateProcessing,
                                   Date effectiveTime,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException

Remove the spine object designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsSpineAttribute

public void setTermAsSpineAttribute(String userId,
                                    MetadataCorrelationProperties correlationProperties,
                                    String glossaryTermGUID,
                                    boolean forLineage,
                                    boolean forDuplicateProcessing,
                                    Date effectiveTime,
                                    String methodName)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException

Classify the glossary term to indicate that it describes a spine attribute.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsSpineAttribute

public void clearTermAsSpineAttribute(String userId,
                                      MetadataCorrelationProperties correlationProperties,
                                      String glossaryTermGUID,
                                      boolean forLineage,
                                      boolean forDuplicateProcessing,
                                      Date effectiveTime,
                                      String methodName)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException

Remove the spine attribute designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

setTermAsObjectIdentifier

public void setTermAsObjectIdentifier(String userId,
                                      MetadataCorrelationProperties correlationProperties,
                                      String glossaryTermGUID,
                                      boolean forLineage,
                                      boolean forDuplicateProcessing,
                                      Date effectiveTime,
                                      String methodName)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException

Classify the glossary term to indicate that it describes an object identifier.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

clearTermAsObjectIdentifier

public void clearTermAsObjectIdentifier(String userId,
                                        MetadataCorrelationProperties correlationProperties,
                                        String glossaryTermGUID,
                                        boolean forLineage,
                                        boolean forDuplicateProcessing,
                                        Date effectiveTime,
                                        String methodName)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException

Remove the object identifier designation from the glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

removeGlossaryTerm

public void removeGlossaryTerm(String userId,
                               MetadataCorrelationProperties correlationProperties,
                               String glossaryTermGUID,
                               boolean forLineage,
                               boolean forDuplicateProcessing,
                               Date effectiveTime,
                               String methodName)
                        throws InvalidParameterException,
                               UserNotAuthorizedException,
                               PropertyServerException

Remove the metadata element representing a glossary term.

Parameters:: userId - calling user; correlationProperties - properties to help with the mapping of the elements in the external asset manager and open metadata; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

findGlossaryTerms

public List<GlossaryTermElement> findGlossaryTerms(String userId,
                                                   String assetManagerGUID,
                                                   String assetManagerName,
                                                   String searchString,
                                                   String searchStringParameterName,
                                                   int startFrom,
                                                   int pageSize,
                                                   boolean forLineage,
                                                   boolean forDuplicateProcessing,
                                                   Date effectiveTime,
                                                   String methodName)
                                            throws InvalidParameterException,
                                                   UserNotAuthorizedException,
                                                   PropertyServerException

Retrieve the list of glossary term metadata elements that contain the search string. The search string is treated as a regular expression.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; searchString - string to find in the properties; searchStringParameterName - parameter supplying search string; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getTermsForGlossary

public List<GlossaryTermElement> getTermsForGlossary(String userId,
                                                     String assetManagerGUID,
                                                     String assetManagerName,
                                                     String glossaryGUID,
                                                     int startFrom,
                                                     int pageSize,
                                                     boolean forLineage,
                                                     boolean forDuplicateProcessing,
                                                     Date effectiveTime,
                                                     String methodName)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException

Retrieve the list of glossary terms associated with a glossary.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryGUID - unique identifier of the glossary of interest; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of associated metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getTermsForGlossaryCategory

public List<GlossaryTermElement> getTermsForGlossaryCategory(String userId,
                                                             String assetManagerGUID,
                                                             String assetManagerName,
                                                             String glossaryCategoryGUID,
                                                             int startFrom,
                                                             int pageSize,
                                                             boolean forLineage,
                                                             boolean forDuplicateProcessing,
                                                             Date effectiveTime,
                                                             String methodName)
                                                      throws InvalidParameterException,
                                                             UserNotAuthorizedException,
                                                             PropertyServerException

Retrieve the list of glossary terms associated with a glossary category.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; glossaryCategoryGUID - unique identifier of the glossary category of interest; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of associated metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossaryTermsByName

public List<GlossaryTermElement> getGlossaryTermsByName(String userId,
                                                        String assetManagerGUID,
                                                        String assetManagerName,
                                                        String name,
                                                        String nameParameterName,
                                                        int startFrom,
                                                        int pageSize,
                                                        boolean forLineage,
                                                        boolean forDuplicateProcessing,
                                                        Date effectiveTime,
                                                        String methodName)
                                                 throws InvalidParameterException,
                                                        UserNotAuthorizedException,
                                                        PropertyServerException

Retrieve the list of glossary term metadata elements with a matching qualified or display name. There are no wildcards supported on this request.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; name - name to search for; nameParameterName - parameter supplying the name property; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of matching metadata elements
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossaryTermByGUID

public GlossaryTermElement getGlossaryTermByGUID(String userId,
                                                 String assetManagerGUID,
                                                 String assetManagerName,
                                                 String guid,
                                                 boolean forLineage,
                                                 boolean forDuplicateProcessing,
                                                 Date effectiveTime,
                                                 String methodName)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException

Retrieve the glossary term metadata element with the supplied unique identifier.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; guid - unique identifier of the requested metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: matching metadata element
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

createExternalGlossaryLink

public String createExternalGlossaryLink(String userId,
                                         String assetManagerGUID,
                                         String assetManagerName,
                                         ExternalGlossaryLinkProperties linkProperties,
                                         String methodName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException

Create a link to an external glossary resource. This is associated with a glossary to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; linkProperties - properties of the link; methodName - calling method
Returns:: unique identifier of the external reference
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

updateExternalGlossaryLink

public void updateExternalGlossaryLink(String userId,
                                       String assetManagerGUID,
                                       String assetManagerName,
                                       String externalLinkGUID,
                                       ExternalGlossaryLinkProperties linkProperties,
                                       boolean forLineage,
                                       boolean forDuplicateProcessing,
                                       Date effectiveTime,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Update the properties of a reference to an external glossary resource.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; linkProperties - properties of the link; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

removeExternalGlossaryLink

public void removeExternalGlossaryLink(String userId,
                                       String assetManagerGUID,
                                       String assetManagerName,
                                       String externalLinkGUID,
                                       boolean forLineage,
                                       boolean forDuplicateProcessing,
                                       Date effectiveTime,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Remove information about a link to an external glossary resource (and the relationships that attached it to the glossaries).

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

attachExternalLinkToGlossary

public void attachExternalLinkToGlossary(String userId,
                                         String assetManagerGUID,
                                         String assetManagerName,
                                         String glossaryGUID,
                                         String externalLinkGUID,
                                         boolean forLineage,
                                         boolean forDuplicateProcessing,
                                         Date effectiveTime,
                                         String methodName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException

Connect a glossary to a reference to an external glossary resource.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; glossaryGUID - unique identifier of the metadata element to attach; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

detachExternalLinkFromGlossary

public void detachExternalLinkFromGlossary(String userId,
                                           String assetManagerGUID,
                                           String assetManagerName,
                                           String glossaryGUID,
                                           String externalLinkGUID,
                                           boolean forLineage,
                                           boolean forDuplicateProcessing,
                                           Date effectiveTime,
                                           String methodName)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException

Disconnect a glossary from a reference to an external glossary resource.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; 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?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getExternalLinksForGlossary

public List<ExternalGlossaryLinkElement> getExternalLinksForGlossary(String userId,
                                                                     String glossaryGUID,
                                                                     int startFrom,
                                                                     int pageSize,
                                                                     boolean forLineage,
                                                                     boolean forDuplicateProcessing,
                                                                     Date effectiveTime,
                                                                     String methodName)
                                                              throws InvalidParameterException,
                                                                     UserNotAuthorizedException,
                                                                     PropertyServerException

Retrieve the list of links to external glossary resources attached to a glossary.

Parameters:: userId - calling user; glossaryGUID - unique identifier of the metadata element for the glossary of interest; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of attached links to external glossary resources
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

getGlossariesForExternalLink

public List<GlossaryElement> getGlossariesForExternalLink(String userId,
                                                          String assetManagerGUID,
                                                          String assetManagerName,
                                                          String externalLinkGUID,
                                                          int startFrom,
                                                          int pageSize,
                                                          boolean forLineage,
                                                          boolean forDuplicateProcessing,
                                                          Date effectiveTime,
                                                          String methodName)
                                                   throws InvalidParameterException,
                                                          UserNotAuthorizedException,
                                                          PropertyServerException

Return the glossaries connected to an external glossary source.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the metadata element for the external glossary link of interest; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Returns:: list of glossaries
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

attachExternalCategoryLink

public void attachExternalCategoryLink(String userId,
                                       String assetManagerGUID,
                                       String assetManagerName,
                                       String glossaryCategoryGUID,
                                       String externalLinkGUID,
                                       ExternalGlossaryElementLinkProperties linkProperties,
                                       boolean forLineage,
                                       boolean forDuplicateProcessing,
                                       Date effectiveTime,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Create a link to an external glossary category resource. This is associated with a category to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; glossaryCategoryGUID - unique identifier for the glossary category; linkProperties - properties of the link; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

detachExternalCategoryLink

public void detachExternalCategoryLink(String userId,
                                       String assetManagerGUID,
                                       String assetManagerName,
                                       String glossaryCategoryGUID,
                                       String externalLinkGUID,
                                       boolean forLineage,
                                       boolean forDuplicateProcessing,
                                       Date effectiveTime,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Remove the link to an external glossary category resource.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; glossaryCategoryGUID - unique identifier for the glossary category; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

attachExternalTermLink

public void attachExternalTermLink(String userId,
                                   String assetManagerGUID,
                                   String assetManagerName,
                                   String glossaryTermGUID,
                                   String externalLinkGUID,
                                   ExternalGlossaryElementLinkProperties linkProperties,
                                   boolean forLineage,
                                   boolean forDuplicateProcessing,
                                   Date effectiveTime,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException

Create a link to an external glossary term resource. This is associated with a term to show that they have equivalent content. It is possible that this resource was generated from the glossary content or was the source for it.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; glossaryTermGUID - unique identifier for the glossary category; linkProperties - properties of the link; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

detachExternalTermLink

public void detachExternalTermLink(String userId,
                                   String assetManagerGUID,
                                   String assetManagerName,
                                   String glossaryTermGUID,
                                   String externalLinkGUID,
                                   boolean forLineage,
                                   boolean forDuplicateProcessing,
                                   Date effectiveTime,
                                   String methodName)
                            throws InvalidParameterException,
                                   UserNotAuthorizedException,
                                   PropertyServerException

Remove the link to an external glossary term resource.

Parameters:: userId - calling user; assetManagerGUID - unique identifier of software server capability representing the caller; assetManagerName - unique name of software server capability representing the caller; externalLinkGUID - unique identifier of the external reference; glossaryTermGUID - unique identifier for the glossary category; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; effectiveTime - optional date for effective time of the query. Null means any effective time; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid; UserNotAuthorizedException - the user is not authorized to issue this request; PropertyServerException - there is a problem reported in the open metadata server(s)

Class GlossaryExchangeHandler

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GlossaryExchangeHandler

Method Detail

createGlossary

createGlossaryFromTemplate

updateGlossary

removeGlossary

setGlossaryAsTaxonomy

clearGlossaryAsTaxonomy

setGlossaryAsCanonical

clearGlossaryAsCanonical

findGlossaries

getGlossariesByName

getGlossariesForAssetManager

getGlossaryByGUID

createGlossaryCategory

createGlossaryCategoryFromTemplate

updateGlossaryCategory

setupCategoryParent

clearCategoryParent

removeGlossaryCategory

findGlossaryCategories

getCategoriesForGlossary

getGlossaryCategoriesByName

getGlossaryCategoryParent

getGlossarySubCategories

getGlossaryCategoryByGUID

createGlossaryTerm

createControlledGlossaryTerm

createGlossaryTermFromTemplate

updateGlossaryTerm

updateGlossaryTermStatus

setupTermCategory

clearTermCategory

setupTermRelationship

updateTermRelationship

clearTermRelationship

setTermAsAbstractConcept

clearTermAsAbstractConcept

setTermAsDataValue

clearTermAsDataValue

setTermAsActivity

clearTermAsActivity

setTermAsContext

clearTermAsContext

setTermAsSpineObject

clearTermAsSpineObject

setTermAsSpineAttribute

clearTermAsSpineAttribute

setTermAsObjectIdentifier

clearTermAsObjectIdentifier

removeGlossaryTerm

findGlossaryTerms

getTermsForGlossary

getTermsForGlossaryCategory

getGlossaryTermsByName

getGlossaryTermByGUID

createExternalGlossaryLink

updateExternalGlossaryLink

removeExternalGlossaryLink

attachExternalLinkToGlossary

detachExternalLinkFromGlossary

getExternalLinksForGlossary

getGlossariesForExternalLink

attachExternalCategoryLink

detachExternalCategoryLink

attachExternalTermLink

detachExternalTermLink