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

Interface StewardshipExchangeInterface

All Known Implementing Classes:
StewardshipExchangeClient
public interface StewardshipExchangeInterface
The StewardshipExchangeInterface supports the exchange of relationships (such as SemanticAssignment) and classifications that are added by stewards (or automated stewardship processes) such as Confidentiality.

  • Method Details

    • setElementAsDataField

      void setElementAsDataField(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, DataFieldValuesProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the element to indicate that it describes a data field and supply properties that describe the characteristics of the data values found within.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to update
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - descriptive properties for the data field
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearElementAsDataField

      void clearElementAsDataField(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the data field designation from the element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to update
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getDataFieldClassifiedElements

      List<ElementStub> getDataFieldClassifiedElements(String userId, String assetManagerGUID, String assetManagerName, DataFieldQueryProperties properties, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the elements classified with the DataField classification.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      properties - values to match on
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • setConfidenceClassification

      void setConfidenceClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, GovernanceClassificationProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization has that the data is complete, accurate and up-to-date. The level of confidence is expressed by the levelIdentifier property.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to classify
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the classification
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearConfidenceClassification

      void clearConfidenceClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the confidence classification from the element. This normally occurs when the organization has lost track of the level of confidence to assign to the element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to unclassify
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getConfidenceClassifiedElements

      List<MetadataElementSummary> getConfidenceClassifiedElements(String userId, String assetManagerGUID, String assetManagerName, boolean returnSpecificLevel, int levelIdentifier, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the elements classified with the confidence classification.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      returnSpecificLevel - should the results be filtered by levelIdentifier?
      levelIdentifier - the identifier to filter by (if returnSpecificLevel=true)
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • setCriticalityClassification

      void setCriticalityClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, GovernanceClassificationProperties properties, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify/reclassify the element (typically an asset) to indicate how critical the element (or associated resource) is to the organization. The level of criticality is expressed by the levelIdentifier property.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to classify
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the classification
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearCriticalityClassification

      void clearCriticalityClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the criticality classification from the element. This normally occurs when the organization has lost track of the level of criticality to assign to the element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to unclassify
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getCriticalityClassifiedElements

      List<MetadataElementSummary> getCriticalityClassifiedElements(String userId, String assetManagerGUID, String assetManagerName, boolean returnSpecificLevel, int levelIdentifier, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the elements classified with the criticality classification.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      returnSpecificLevel - should the results be filtered by levelIdentifier?
      levelIdentifier - the identifier to filter by (if returnSpecificLevel=true)
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • setConfidentialityClassification

      void setConfidentialityClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, GovernanceClassificationProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the level of confidentiality that any data associated with the element should be given. If the classification is attached to a glossary term, the level of confidentiality is a suggestion for any element linked to the glossary term via the SemanticAssignment classification. The level of confidence is expressed by the levelIdentifier property.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to classify
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the classification
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearConfidentialityClassification

      void clearConfidentialityClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the confidence classification from the element. This normally occurs when the organization has lost track of the level of confidentiality to assign to the element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to unclassify
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getConfidentialityClassifiedElements

      List<MetadataElementSummary> getConfidentialityClassifiedElements(String userId, String assetManagerGUID, String assetManagerName, boolean returnSpecificLevel, int levelIdentifier, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the elements classified with the confidentiality classification.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      returnSpecificLevel - should the results be filtered by levelIdentifier?
      levelIdentifier - the identifier to filter by (if returnSpecificLevel=true)
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • setRetentionClassification

      void setRetentionClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, RetentionClassificationProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource) is to be retained by the organization. The policy to apply to the element/resource is captured by the retentionBasis property. The dates after which the element/resource is archived and then deleted are specified in the archiveAfter and deleteAfter properties respectively.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to classify
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the classification
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearRetentionClassification

      void clearRetentionClassification(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the retention classification from the element. This normally occurs when the organization has lost track of, or no longer needs to track the retention period to assign to the element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the metadata element to unclassify
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getRetentionClassifiedElements

      List<MetadataElementSummary> getRetentionClassifiedElements(String userId, String assetManagerGUID, String assetManagerName, boolean returnSpecificBasisIdentifier, int basisIdentifier, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the elements classified with the retention classification.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      returnSpecificBasisIdentifier - should the results be filtered by basisIdentifier?
      basisIdentifier - the identifier to filter by (if returnSpecificBasisIdentifier=true)
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • addSecurityTags

      void addSecurityTags(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, SecurityTagsProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Add or replace the security tags for an element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - element to link it to - its type must inherit from Referenceable.
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the security tags
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - element not known, null userId or guid
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • clearSecurityTags

      void clearSecurityTags(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the security tags classification from an element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - element where the security tags need to be removed.
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - asset or element not known, null userId or guid
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • getSecurityTaggedElements

      List<MetadataElementSummary> getSecurityTaggedElements(String userId, String assetManagerGUID, String assetManagerName, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the contents of a subject area such as the glossaries, reference data sets and quality definitions.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • addOwnership

      void addOwnership(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, OwnerProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Add or replace the ownership classification for an element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - element to link it to - its type must inherit from Referenceable.
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the ownership
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - element not known, null userId or guid
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • clearOwnership

      void clearOwnership(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the ownership classification from an element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - element where the classification needs to be removed.
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - asset or element not known, null userId or guid
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • getOwnersElements

      List<MetadataElementSummary> getOwnersElements(String userId, String assetManagerGUID, String assetManagerName, String owner, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the contents of a subject area such as the glossaries, reference data sets and quality definitions.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      owner - unique identifier for the owner
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • addAssetOrigin

      void addAssetOrigin(String userId, String assetManagerGUID, String assetManagerName, String assetGUID, String externalIdentifier, AssetOriginProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Add or replace the origin classification for an asset.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      assetGUID - element to link it to - its type must inherit from Asset.
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - details of the origin
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - element not known, null userId or guid
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • clearAssetOrigin

      void clearAssetOrigin(String userId, String assetManagerGUID, String assetManagerName, String assetGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the origin classification from an asset.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      assetGUID - element where the classification needs to be removed.
      externalIdentifier - unique identifier of the element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - asset or element not known, null userId or guid
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • getAssetsByOrigin

      List<AssetElement> getAssetsByOrigin(String userId, String assetManagerGUID, String assetManagerName, FindAssetOriginProperties properties, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the assets from a specific origin.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      properties - values to search on - null means any value
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of the assets
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • addElementToSubjectArea

      void addElementToSubjectArea(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, SubjectAreaClassificationProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Classify the element to assert that the definitions it represents are part of a subject area definition.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software server capability representing the caller
      assetManagerName - unique name of software server capability representing the caller
      elementGUID - unique identifier of the metadata element to update
      externalIdentifier - unique identifier of the element in the external asset manager
      properties - qualified name of subject area
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • removeElementFromSubjectArea

      void removeElementFromSubjectArea(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String externalIdentifier, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the subject area designation from the identified element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software server capability representing the caller
      assetManagerName - unique name of software server capability representing the caller
      elementGUID - unique identifier of the metadata element to update
      externalIdentifier - unique identifier of the equivalent element in the external asset manager
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getMembersOfSubjectArea

      List<MetadataElementSummary> getMembersOfSubjectArea(String userId, String assetManagerGUID, String assetManagerName, String subjectAreaName, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Return information about the contents of a subject area such as the glossaries, reference data sets and quality definitions.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      subjectAreaName - unique identifier for the subject area
      startFrom - paging start point
      pageSize - maximum results that can be returned
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of element stubs
      Throws:
      InvalidParameterException - qualifiedName or userId is null
      PropertyServerException - problem accessing property server
      UserNotAuthorizedException - security access problem

    • setupSemanticAssignment

      void setupSemanticAssignment(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String glossaryTermGUID, SemanticAssignmentProperties properties, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute, data field or asset). This relationship indicates that the data associated with the element meaning matches the description in the glossary term.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the element that is being assigned to the glossary term
      glossaryTermGUID - unique identifier of the glossary term that provides the meaning
      properties - properties for the relationship
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • clearSemanticAssignment

      void clearSemanticAssignment(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, String glossaryTermGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove a semantic assignment relationship between an element and its glossary term.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the element that is being assigned to the glossary term
      glossaryTermGUID - unique identifier of the glossary term that provides the meaning
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getMeanings

      List<GlossaryTermElement> getMeanings(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the glossary terms linked via a "SemanticAssignment" relationship to the requested element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the element
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getSemanticAssignees

      List<RelatedMetadataElementSummary> getSemanticAssignees(String userId, String assetManagerGUID, String assetManagerName, String glossaryTermGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the elements linked via a "SemanticAssignment" relationship to the requested glossary term.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      glossaryTermGUID - unique identifier of the glossary term that the returned elements are linked to
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • addGovernanceDefinitionToElement

      void addGovernanceDefinitionToElement(String userId, String assetManagerGUID, String assetManagerName, String definitionGUID, String elementGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Link a governance definition to an element using the GovernedBy relationship.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software server capability representing the caller
      assetManagerName - unique name of software server capability representing the caller
      definitionGUID - identifier of the governance definition to link
      elementGUID - unique identifier of the metadata element to link
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • removeGovernanceDefinitionFromElement

      void removeGovernanceDefinitionFromElement(String userId, String assetManagerGUID, String assetManagerName, String definitionGUID, String elementGUID, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Remove the GovernedBy relationship between a governance definition and an element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software server capability representing the caller
      assetManagerName - unique name of software server capability representing the caller
      definitionGUID - identifier of the governance definition to link
      elementGUID - unique identifier of the metadata element to update
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Throws:
      InvalidParameterException - one of the parameters is invalid
      UserNotAuthorizedException - the user is not authorized to issue this request
      PropertyServerException - there is a problem reported in the open metadata server(s)

    • getGovernedByDefinitions

      List<GovernanceDefinitionElement> getGovernedByDefinitions(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the governance definitions linked via a "GovernedBy" relationship to the requested element.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the element
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getGovernedElements

      List<RelatedMetadataElementSummary> getGovernedElements(String userId, String assetManagerGUID, String assetManagerName, String governanceDefinitionGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the elements linked via a "GovernedBy" relationship to the requested governance definition.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      governanceDefinitionGUID - unique identifier of the glossary term that the returned elements are linked to
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getSourceElements

      List<RelatedMetadataElementSummary> getSourceElements(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the elements linked via a "SourceFrom" relationship to the requested element. The elements returned were used to create the requested element. Typically only one element is returned.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the glossary term that the returned elements are linked to
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getElementsSourceFrom

      List<RelatedMetadataElementSummary> getElementsSourceFrom(String userId, String assetManagerGUID, String assetManagerName, String elementGUID, int startFrom, int pageSize, Date effectiveTime, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the elements linked via a "SourceFrom" relationship to the requested element. The elements returned were created using the requested element as a template.
      Parameters:
      userId - calling user
      assetManagerGUID - unique identifier of software capability representing the caller
      assetManagerName - unique name of software capability representing the caller
      elementGUID - unique identifier of the glossary term that the returned elements are linked to
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      effectiveTime - the time that the retrieved elements must be effective for
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getMetadataElementByGUID

      MetadataElementSummary getMetadataElementByGUID(String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the metadata element using its unique identifier.
      Parameters:
      userId - calling user
      elementGUID - unique identifier for the metadata element
      forLineage - the retrieved element is for lineage processing so include archived elements
      forDuplicateProcessing - the retrieved element is for duplicate processing so do not combine results from known duplicates.
      effectiveTime - only return the element if it is effective at this time. Null means anytime. Use "new Date()" for now.
      Returns:
      metadata element properties
      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)

    • getMetadataElementByUniqueName

      MetadataElementSummary getMetadataElementByUniqueName(String userId, String uniqueName, String uniquePropertyName, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the metadata element using its unique name (typically the qualified name).
      Parameters:
      userId - calling user
      uniqueName - unique name for the metadata element
      uniquePropertyName - name of property name to test in the open metadata element - if null "qualifiedName" is used
      forLineage - the retrieved element is for lineage processing so include archived elements
      forDuplicateProcessing - the retrieved element is for duplicate processing so do not combine results from known duplicates.
      effectiveTime - only return the element if it is effective at this time. Null means anytime. Use "new Date()" for now.
      Returns:
      metadata element properties
      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)

    • getMetadataElementGUIDByUniqueName

      String getMetadataElementGUIDByUniqueName(String userId, String uniqueName, String uniquePropertyName, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the unique identifier of a metadata element using its unique name (typically the qualified name).
      Parameters:
      userId - calling user
      uniqueName - unique name for the metadata element
      uniquePropertyName - name of property name to test in the open metadata element - if null "qualifiedName" is used
      forLineage - the retrieved element is for lineage processing so include archived elements
      forDuplicateProcessing - the retrieved element is for duplicate processing so do not combine results from known duplicates.
      effectiveTime - only return the element if it is effective at this time. Null means anytime. Use "new Date()" for now.
      Returns:
      metadata element unique identifier (guid)
      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)

    • getElements

      List<MetadataElementSummary> getElements(String userId, FindProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements of the requested type name and/or name.
      Parameters:
      userId - calling user
      findProperties - open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getElementsByPropertyValue

      List<MetadataElementSummary> getElementsByPropertyValue(String userId, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements by a value found in one of the properties specified. The value must match exactly. An open metadata type name may be supplied to restrict the results.
      Parameters:
      userId - calling user
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • findElementsByPropertyValue

      List<MetadataElementSummary> findElementsByPropertyValue(String userId, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements by a value found in one of the properties specified. The value must be contained in the properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict the results.
      Parameters:
      userId - calling user
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getElementsByClassification

      List<MetadataElementSummary> getElementsByClassification(String userId, String classificationName, FindProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements with the requested classification name. It is also possible to limit the results by specifying a type name for the elements that should be returned. If no type name is specified then any type of element may be returned.
      Parameters:
      userId - calling user
      classificationName - name of classification
      findProperties - open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getElementsByClassificationWithPropertyValue

      List<MetadataElementSummary> getElementsByClassificationWithPropertyValue(String userId, String classificationName, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements with the requested classification name and with the requested a value found in one of the classification's properties specified. The value must match exactly. An open metadata type name may be supplied to restrict the types of elements returned.
      Parameters:
      userId - calling user
      classificationName - name of classification
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • findElementsByClassificationWithPropertyValue

      List<MetadataElementSummary> findElementsByClassificationWithPropertyValue(String userId, String classificationName, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements with the requested classification name and with the requested a value found in one of the classification's properties specified. The value must be contained in the properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict the results.
      Parameters:
      userId - calling user
      classificationName - name of classification
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getRelatedElements

      List<RelatedMetadataElementSummary> getRelatedElements(String userId, String elementGUID, String relationshipTypeName, int startingAtEnd, FindProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve related elements of the requested type name.
      Parameters:
      userId - calling user
      elementGUID - unique identifier of the starting end
      startingAtEnd - indicates which end to retrieve from (0 is "either end"; 1 is end1; 2 is end 2)
      relationshipTypeName - name of relationship
      findProperties - open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getRelatedElementsWithPropertyValue

      List<RelatedMetadataElementSummary> getRelatedElementsWithPropertyValue(String userId, String elementGUID, String relationshipTypeName, int startingAtEnd, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements linked via the requested relationship type name and with the requested a value found in one of the classification's properties specified. The value must match exactly. An open metadata type name may be supplied to restrict the types of elements returned.
      Parameters:
      userId - calling user
      elementGUID - unique identifier of the starting element
      relationshipTypeName - name of relationship
      startingAtEnd - indicates which end to retrieve from (0 is "either end"; 1 is end1; 2 is end 2)
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • findRelatedElementsWithPropertyValue

      List<RelatedMetadataElementSummary> findRelatedElementsWithPropertyValue(String userId, String elementGUID, String relationshipTypeName, int startingAtEnd, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve elements linked via the requested relationship type name and with the relationship's properties specified. The value must be contained in the by a value found in one of the properties specified. The value must be contained in the properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict the results.
      Parameters:
      userId - calling user
      elementGUID - unique identifier of the starting element
      relationshipTypeName - name of relationship
      startingAtEnd - indicates which end to retrieve from (0 is "either end"; 1 is end1; 2 is end 2)
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getRelationships

      List<MetadataRelationshipSummary> getRelationships(String userId, String relationshipTypeName, FindProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve relationships of the requested relationship type name.
      Parameters:
      userId - calling user
      relationshipTypeName - name of relationship
      findProperties - properties for the search
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • getRelationshipsWithPropertyValue

      List<MetadataRelationshipSummary> getRelationshipsWithPropertyValue(String userId, String relationshipTypeName, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve relationships of the requested relationship type name and with the requested a value found in one of the relationship's properties specified. The value must match exactly.
      Parameters:
      userId - calling user
      relationshipTypeName - name of relationship
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • findRelationshipsWithPropertyValue

      List<MetadataRelationshipSummary> findRelationshipsWithPropertyValue(String userId, String relationshipTypeName, FindPropertyNamesProperties findProperties, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve relationships of the requested relationship type name and with the requested a value found in one of the relationship's properties specified. The value must only be contained in the properties rather than needing to be an exact match.
      Parameters:
      userId - calling user
      relationshipTypeName - name of relationship
      findProperties - properties and optional open metadata type to search on
      startFrom - index of the list to start from (0 for start)
      pageSize - maximum number of elements to return.
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      Returns:
      list of related 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)

    • retrieveInstanceForGUID

      ElementHeader retrieveInstanceForGUID(String userId, String guid, boolean forLineage, boolean forDuplicateProcessing, Date effectiveTime) throws InvalidParameterException, UserNotAuthorizedException, PropertyServerException
      Retrieve the header for the instance identified by the supplied unique identifier. It may be an element (entity) or a relationship between elements.
      Parameters:
      userId - name of the server instance to connect to
      guid - identifier to use in the lookup
      forLineage - return elements marked with the Memento classification?
      forDuplicateProcessing - do not merge elements marked as duplicates?
      effectiveTime - effective time
      Returns:
      list of matching elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)
      Throws:
      InvalidParameterException
      UserNotAuthorizedException
      PropertyServerException