You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by da...@apache.org on 2018/02/16 09:52:28 UTC
[12/30] atlas git commit: ATLAS-2246: OMRS Connector API plus REST
and IGC Connector skeleton - 15th February 2018
http://git-wip-us.apache.org/repos/asf/atlas/blob/8a57e657/omrs/src/main/java/org/apache/atlas/omrs/localrepository/repositoryconnector/LocalOMRSMetadataCollection.java
----------------------------------------------------------------------
diff --git a/omrs/src/main/java/org/apache/atlas/omrs/localrepository/repositoryconnector/LocalOMRSMetadataCollection.java b/omrs/src/main/java/org/apache/atlas/omrs/localrepository/repositoryconnector/LocalOMRSMetadataCollection.java
new file mode 100644
index 0000000..a46c28e
--- /dev/null
+++ b/omrs/src/main/java/org/apache/atlas/omrs/localrepository/repositoryconnector/LocalOMRSMetadataCollection.java
@@ -0,0 +1,3157 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * <p/>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p/>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.atlas.omrs.localrepository.repositoryconnector;
+
+import org.apache.atlas.omrs.eventmanagement.OMRSRepositoryEventProcessor;
+import org.apache.atlas.omrs.ffdc.*;
+import org.apache.atlas.omrs.ffdc.exception.*;
+import org.apache.atlas.omrs.localrepository.repositorycontentmanager.OMRSRepositoryContentManager;
+import org.apache.atlas.omrs.metadatacollection.OMRSMetadataCollection;
+import org.apache.atlas.omrs.metadatacollection.properties.MatchCriteria;
+import org.apache.atlas.omrs.metadatacollection.properties.SequencingOrder;
+import org.apache.atlas.omrs.metadatacollection.properties.instances.*;
+import org.apache.atlas.omrs.metadatacollection.properties.typedefs.*;
+
+import java.util.ArrayList;
+import java.util.Date;
+
+/**
+ * LocalOMRSMetadataCollection provides a wrapper around the metadata collection for the real local repository.
+ * Its role is to manage outbound repository events and audit logging/debug for the real local repository.
+ */
+public class LocalOMRSMetadataCollection extends OMRSMetadataCollection
+{
+ private static final String sourceName = "Local Repository";
+
+ private OMRSMetadataCollection realMetadataCollection = null;
+ private String localServerName = null;
+ private String localServerType = null;
+ private String localOrganizationName = null;
+ private OMRSRepositoryEventProcessor outboundRepositoryEventProcessor = null;
+ private OMRSRepositoryContentManager localRepositoryContentManager = null;
+
+
+ /**
+ * Constructor used by LocalOMRSRepositoryConnector
+ *
+ * @param localMetadataConnectionId - unique identifier for the local metadata collection.
+ * @param localServerName - name of the local server.
+ * @param localServerType - type of the local server.
+ * @param localOrganizationName - name of the organization that owns the local server.
+ * @param realMetadataCollection - metadata collection of the rela local connector.
+ * @param outboundRepositoryEventProcessor - outbound event processor
+ * (may be null if a repository event mapper is deployed).
+ * @param repositoryContentManager - manager of in-memory cache of type definitions (TypeDefs).
+ */
+ LocalOMRSMetadataCollection(String localMetadataConnectionId,
+ String localServerName,
+ String localServerType,
+ String localOrganizationName,
+ OMRSMetadataCollection realMetadataCollection,
+ OMRSRepositoryEventProcessor outboundRepositoryEventProcessor,
+ OMRSRepositoryContentManager repositoryContentManager)
+ {
+ /*
+ * The super class manages the local metadata collection id. This is a locally managed value.
+ */
+ super(localMetadataConnectionId);
+
+ /*
+ * Save the metadata collection object for the real repository. This is the metadata that does all of the
+ * work. LocalOMRSMetadataCollection is just a wrapper for managing repository events and debug and
+ * audit logging.
+ */
+ if (realMetadataCollection == null)
+ {
+ String actionDescription = "Local OMRS Metadata Collection Constructor";
+
+ OMRSErrorCode errorCode = OMRSErrorCode.NULL_LOCAL_METADATA_COLLECTION;
+ String errorMessage = errorCode.getErrorMessageId()
+ + errorCode.getFormattedErrorMessage();
+
+ throw new OMRSLogicErrorException(errorCode.getHTTPErrorCode(),
+ this.getClass().getName(),
+ actionDescription,
+ errorMessage,
+ errorCode.getSystemAction(),
+ errorCode.getUserAction());
+ }
+ this.realMetadataCollection = realMetadataCollection;
+
+ /*
+ * Save the information needed to send repository events.
+ */
+ this.localServerName = localServerName;
+ this.localServerType = localServerType;
+ this.localOrganizationName = localOrganizationName;
+ this.outboundRepositoryEventProcessor = outboundRepositoryEventProcessor;
+ this.localRepositoryContentManager = repositoryContentManager;
+ }
+
+
+ /* ==============================
+ * Group 2: Working with typedefs
+ */
+
+
+ /**
+ * Returns the list of different types of metadata organized into two groups. The first are the
+ * attribute type definitions (AttributeTypeDefs). These provide types for properties in full
+ * type definitions. Full type definitions (TypeDefs) describe types for entities, relationships
+ * and classifications.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @return TypeDefs - Lists of different categories of TypeDefs.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDefGallery getAllTypes(String userId) throws RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getAllTypes(userId);
+ }
+
+
+ /**
+ * Returns a list of TypeDefs that have the specified name. TypeDef names should be unique. This
+ * method allows wildcard character to be included in the name. These are * (asterisk) for an arbitrary string of
+ * characters and ampersand for an arbitrary character.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param name - name of the TypeDefs to return (including wildcard characters).
+ * @return TypeDefs list.
+ * @throws InvalidParameterException - the name of the TypeDef is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDefGallery findTypesByName(String userId,
+ String name) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findTypesByName(userId, name);
+ }
+
+
+ /**
+ * Returns all of the TypeDefs for a specific category.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param category - enum value for the category of TypeDef to return.
+ * @return TypeDefs list.
+ * @throws InvalidParameterException - the TypeDefCategory is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<TypeDef> findTypeDefsByCategory(String userId,
+ TypeDefCategory category) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findTypeDefsByCategory(userId, category);
+ }
+
+
+ /**
+ * Returns all of the AttributeTypeDefs for a specific category.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param category - enum value for the category of an AttributeTypeDef to return.
+ * @return TypeDefs list.
+ * @throws InvalidParameterException - the TypeDefCategory is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<AttributeTypeDef> findAttributeTypeDefsByCategory(String userId,
+ AttributeTypeDefCategory category) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findAttributeTypeDefsByCategory(userId, category);
+ }
+
+
+
+ /**
+ * Return the TypeDefs that have the properties matching the supplied match criteria.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param matchCriteria - TypeDefProperties - a list of property names and values.
+ * @return TypeDefs list.
+ * @throws InvalidParameterException - the matchCriteria is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<TypeDef> findTypeDefsByProperty(String userId,
+ TypeDefProperties matchCriteria) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findTypeDefsByProperty(userId, matchCriteria);
+ }
+
+
+ /**
+ * Return the types that are linked to the elements from the specified standard.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param standard - name of the standard - null means any.
+ * @param organization - name of the organization - null means any.
+ * @param identifier - identifier of the element in the standard - null means any.
+ * @return TypeDefs list - each entry in the list contains a typedef. This is is a structure
+ * describing the TypeDef's category and properties.
+ * @throws InvalidParameterException - all attributes of the external id are null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDefGallery findTypesByExternalID(String userId,
+ String standard,
+ String organization,
+ String identifier) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findTypesByExternalID(userId, standard, organization, identifier);
+ }
+
+ /**
+ * Return the TypeDefs that match the search criteria.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param searchCriteria - String - search criteria.
+ * @return TypeDefs list - each entry in the list contains a typedef. This is is a structure
+ * describing the TypeDef's category and properties.
+ * @throws InvalidParameterException - the searchCriteria is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<TypeDef> searchForTypeDefs(String userId,
+ String searchCriteria) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.searchForTypeDefs(userId, searchCriteria);
+ }
+
+
+ /**
+ * Return the TypeDef identified by the GUID.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique id of the TypeDef
+ * @return TypeDef structure describing its category and properties.
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - The requested TypeDef is not known in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDef getTypeDefByGUID(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getTypeDefByGUID(userId, guid);
+ }
+
+
+ /**
+ * Return the AttributeTypeDef identified by the GUID.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique id of the TypeDef
+ * @return TypeDef structure describing its category and properties.
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - The requested TypeDef is not known in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public AttributeTypeDef getAttributeTypeDefByGUID(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getAttributeTypeDefByGUID(userId, guid);
+ }
+
+
+ /**
+ * Return the TypeDef identified by the unique name.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param name - String name of the TypeDef.
+ * @return TypeDef structure describing its category and properties.
+ * @throws InvalidParameterException - the name is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the requested TypeDef is not found in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDef getTypeDefByName(String userId,
+ String name) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getTypeDefByName(userId, name);
+ }
+
+
+ /**
+ * Return the AttributeTypeDef identified by the unique name.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param name - String name of the TypeDef.
+ * @return TypeDef structure describing its category and properties.
+ * @throws InvalidParameterException - the name is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the requested TypeDef is not found in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public AttributeTypeDef getAttributeTypeDefByName(String userId,
+ String name) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getAttributeTypeDefByName(userId, name);
+ }
+
+
+ /**
+ * Create a collection of related types.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param newTypes - TypeDefGallery structure describing the new AttributeTypeDefs and TypeDefs.
+ * @throws InvalidParameterException - the new TypeDef is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotSupportedException - the repository is not able to support this TypeDef.
+ * @throws TypeDefKnownException - the TypeDef is already stored in the repository.
+ * @throws TypeDefConflictException - the new TypeDef conflicts with an existing TypeDef.
+ * @throws InvalidTypeDefException - the new TypeDef has invalid contents.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public void addTypeDefGallery(String userId,
+ TypeDefGallery newTypes) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotSupportedException,
+ TypeDefKnownException,
+ TypeDefConflictException,
+ InvalidTypeDefException,
+ UserNotAuthorizedException
+ {
+
+ }
+
+
+ /**
+ * Create a definition of a new TypeDef.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param newTypeDef - TypeDef structure describing the new TypeDef.
+ * @throws InvalidParameterException - the new TypeDef is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotSupportedException - the repository is not able to support this TypeDef.
+ * @throws TypeDefKnownException - the TypeDef is already stored in the repository.
+ * @throws TypeDefConflictException - the new TypeDef conflicts with an existing TypeDef.
+ * @throws InvalidTypeDefException - the new TypeDef has invalid contents.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public void addTypeDef(String userId,
+ TypeDef newTypeDef) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotSupportedException,
+ TypeDefKnownException,
+ TypeDefConflictException,
+ InvalidTypeDefException,
+ UserNotAuthorizedException
+ {
+ realMetadataCollection.addTypeDef(userId, newTypeDef);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.addTypeDef(sourceName, newTypeDef);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processNewTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ newTypeDef);
+ }
+ }
+
+ /**
+ * Create a definition of a new AttributeTypeDef.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param newAttributeTypeDef - TypeDef structure describing the new TypeDef.
+ * @throws InvalidParameterException - the new TypeDef is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotSupportedException - the repository is not able to support this TypeDef.
+ * @throws TypeDefKnownException - the TypeDef is already stored in the repository.
+ * @throws TypeDefConflictException - the new TypeDef conflicts with an existing TypeDef.
+ * @throws InvalidTypeDefException - the new TypeDef has invalid contents.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public void addAttributeTypeDef(String userId,
+ AttributeTypeDef newAttributeTypeDef) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotSupportedException,
+ TypeDefKnownException,
+ TypeDefConflictException,
+ InvalidTypeDefException,
+ UserNotAuthorizedException
+ {
+ realMetadataCollection.addAttributeTypeDef(userId, newAttributeTypeDef);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.addAttributeTypeDef(sourceName, newAttributeTypeDef);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processNewAttributeTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ newAttributeTypeDef);
+ }
+ }
+
+
+ /**
+ * Verify that a definition of a TypeDef is either new - or matches the definition already stored.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param typeDef - TypeDef structure describing the TypeDef to test.
+ * @return boolean - true means the TypeDef matches the local definition - false means the TypeDef is not known.
+ * @throws InvalidParameterException - the TypeDef is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotSupportedException - the repository is not able to support this TypeDef.
+ * @throws TypeDefConflictException - the new TypeDef conflicts with an existing TypeDef.
+ * @throws InvalidTypeDefException - the new TypeDef has invalid contents.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public boolean verifyTypeDef(String userId,
+ TypeDef typeDef) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotSupportedException,
+ TypeDefConflictException,
+ InvalidTypeDefException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.verifyTypeDef(userId, typeDef);
+ }
+
+
+ /**
+ * Verify that a definition of an AttributeTypeDef is either new - or matches the definition already stored.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param attributeTypeDef - TypeDef structure describing the TypeDef to test.
+ * @return boolean - true means the TypeDef matches the local definition - false means the TypeDef is not known.
+ * @throws InvalidParameterException - the TypeDef is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotSupportedException - the repository is not able to support this TypeDef.
+ * @throws TypeDefConflictException - the new TypeDef conflicts with an existing TypeDef.
+ * @throws InvalidTypeDefException - the new TypeDef has invalid contents.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public boolean verifyAttributeTypeDef(String userId,
+ AttributeTypeDef attributeTypeDef) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotSupportedException,
+ TypeDefConflictException,
+ InvalidTypeDefException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.verifyAttributeTypeDef(userId, attributeTypeDef);
+ }
+
+
+ /**
+ * Update one or more properties of the TypeDef. The TypeDefPatch controls what types of updates
+ * are safe to make to the TypeDef.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param typeDefPatch - TypeDef patch describing change to TypeDef.
+ * @return updated TypeDef
+ * @throws InvalidParameterException - the TypeDefPatch is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the requested TypeDef is not found in the metadata collection.
+ * @throws PatchErrorException - the TypeDef can not be updated because the supplied patch is incompatible
+ * with the stored TypeDef.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDef updateTypeDef(String userId,
+ TypeDefPatch typeDefPatch) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ PatchErrorException,
+ UserNotAuthorizedException
+ {
+ TypeDef updatedTypeDef = realMetadataCollection.updateTypeDef(userId, typeDefPatch);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.updateTypeDef(sourceName, updatedTypeDef);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processUpdatedTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ typeDefPatch);
+ }
+
+ return updatedTypeDef;
+ }
+
+
+ /**
+ * Delete the TypeDef. This is only possible if the TypeDef has never been used to create instances or any
+ * instances of this TypeDef have been purged from the metadata collection.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param obsoleteTypeDefGUID - String unique identifier for the TypeDef.
+ * @param obsoleteTypeDefName - String unique name for the TypeDef.
+ * @throws InvalidParameterException - the one of TypeDef identifiers is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the requested TypeDef is not found in the metadata collection.
+ * @throws TypeDefInUseException - the TypeDef can not be deleted because there are instances of this type in the
+ * the metadata collection. These instances need to be purged before the
+ * TypeDef can be deleted.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public void deleteTypeDef(String userId,
+ String obsoleteTypeDefGUID,
+ String obsoleteTypeDefName) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ TypeDefInUseException,
+ UserNotAuthorizedException
+ {
+ if ((obsoleteTypeDefGUID == null) || (obsoleteTypeDefName == null))
+ {
+ // TODO Throw InvalidParameterException
+ }
+
+ realMetadataCollection.deleteTypeDef(userId,
+ obsoleteTypeDefGUID,
+ obsoleteTypeDefName);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.deleteTypeDef(sourceName,
+ obsoleteTypeDefGUID,
+ obsoleteTypeDefName);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processDeletedTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ obsoleteTypeDefGUID,
+ obsoleteTypeDefName);
+ }
+ }
+
+
+ /**
+ * Delete an AttributeTypeDef. This is only possible if the AttributeTypeDef has never been used to create
+ * instances or any instances of this AttributeTypeDef have been purged from the metadata collection.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param obsoleteTypeDefGUID - String unique identifier for the AttributeTypeDef.
+ * @param obsoleteTypeDefName - String unique name for the AttributeTypeDef.
+ * @throws InvalidParameterException - the one of AttributeTypeDef identifiers is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the requested AttributeTypeDef is not found in the metadata collection.
+ * @throws TypeDefInUseException - the AttributeTypeDef can not be deleted because there are instances of this type in the
+ * the metadata collection. These instances need to be purged before the
+ * AttributeTypeDef can be deleted.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public void deleteAttributeTypeDef(String userId,
+ String obsoleteTypeDefGUID,
+ String obsoleteTypeDefName) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ TypeDefInUseException,
+ UserNotAuthorizedException
+ {
+ if ((obsoleteTypeDefGUID == null) || (obsoleteTypeDefName == null))
+ {
+ // TODO Throw InvalidParameterException
+ }
+
+ realMetadataCollection.deleteAttributeTypeDef(userId,
+ obsoleteTypeDefGUID,
+ obsoleteTypeDefName);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.deleteAttributeTypeDef(sourceName,
+ obsoleteTypeDefGUID,
+ obsoleteTypeDefName);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processDeletedAttributeTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ obsoleteTypeDefGUID,
+ obsoleteTypeDefName);
+ }
+ }
+
+
+ /**
+ * Change the guid or name of an existing TypeDef to a new value. This is used if two different
+ * TypeDefs are discovered to have the same guid. This is extremely unlikely but not impossible so
+ * the open metadata protocol has provision for this.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param originalTypeDefGUID - the original guid of the TypeDef.
+ * @param originalTypeDefName - the original name of the TypeDef.
+ * @param newTypeDefGUID - the new identifier for the TypeDef.
+ * @param newTypeDefName - new name for this TypeDef.
+ * @return typeDef - new values for this TypeDef, including the new guid/name.
+ * @throws InvalidParameterException - one of the parameters is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the TypeDef identified by the original guid/name is not found
+ * in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public TypeDef reIdentifyTypeDef(String userId,
+ String originalTypeDefGUID,
+ String originalTypeDefName,
+ String newTypeDefGUID,
+ String newTypeDefName) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ UserNotAuthorizedException
+ {
+ if ((originalTypeDefGUID == null) || (originalTypeDefName == null) ||
+ (newTypeDefGUID == null) || (newTypeDefName == null))
+ {
+ // TODO Throw InvalidParameterException
+ }
+
+ TypeDef originalTypeDef = realMetadataCollection.getTypeDefByGUID(userId, originalTypeDefGUID);
+
+ TypeDef newTypeDef = realMetadataCollection.reIdentifyTypeDef(userId,
+ originalTypeDefGUID,
+ originalTypeDefName,
+ newTypeDefGUID,
+ newTypeDefName);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.reIdentifyTypeDef(sourceName,
+ originalTypeDefGUID,
+ originalTypeDefName,
+ newTypeDef);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processReIdentifiedTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ originalTypeDef,
+ newTypeDef);
+ }
+
+ return newTypeDef;
+ }
+
+
+ /**
+ * Change the guid or name of an existing TypeDef to a new value. This is used if two different
+ * TypeDefs are discovered to have the same guid. This is extremely unlikely but not impossible so
+ * the open metadata protocol has provision for this.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param originalAttributeTypeDefGUID - the original guid of the AttributeTypeDef.
+ * @param originalAttributeTypeDefName - the original name of the AttributeTypeDef.
+ * @param newAttributeTypeDefGUID - the new identifier for the AttributeTypeDef.
+ * @param newAttributeTypeDefName - new name for this AttributeTypeDef.
+ * @return attributeTypeDef - new values for this AttributeTypeDef, including the new guid/name.
+ * @throws InvalidParameterException - one of the parameters is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeDefNotKnownException - the AttributeTypeDef identified by the original guid/name is not
+ * found in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public AttributeTypeDef reIdentifyAttributeTypeDef(String userId,
+ String originalAttributeTypeDefGUID,
+ String originalAttributeTypeDefName,
+ String newAttributeTypeDefGUID,
+ String newAttributeTypeDefName) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeDefNotKnownException,
+ UserNotAuthorizedException
+ {
+ if ((originalAttributeTypeDefGUID == null) || (originalAttributeTypeDefName == null) ||
+ (newAttributeTypeDefGUID == null) || (newAttributeTypeDefName == null))
+ {
+ // TODO Throw InvalidParameterException
+ }
+
+ AttributeTypeDef originalAttributeTypeDef = realMetadataCollection.getAttributeTypeDefByGUID(userId, originalAttributeTypeDefGUID);
+
+ AttributeTypeDef newAttributeTypeDef = realMetadataCollection.reIdentifyAttributeTypeDef(userId,
+ originalAttributeTypeDefGUID,
+ originalAttributeTypeDefName,
+ newAttributeTypeDefGUID,
+ newAttributeTypeDefName);
+
+ if (localRepositoryContentManager != null)
+ {
+ localRepositoryContentManager.reIdentifyAttributeTypeDef(sourceName,
+ originalAttributeTypeDefGUID,
+ originalAttributeTypeDefName,
+ newAttributeTypeDef);
+ }
+
+ if (outboundRepositoryEventProcessor != null)
+ {
+ outboundRepositoryEventProcessor.processReIdentifiedAttributeTypeDefEvent(sourceName,
+ metadataCollectionId,
+ localServerName,
+ localServerType,
+ localOrganizationName,
+ originalAttributeTypeDef,
+ newAttributeTypeDef);
+ }
+
+ return newAttributeTypeDef;
+ }
+
+
+
+ /* ===================================================
+ * Group 3: Locating entity and relationship instances
+ */
+
+
+ /**
+ * Returns a boolean indicating if the entity is stored in the metadata collection.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the entity
+ * @return entity details if the entity is found in the metadata collection; otherwise return null
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public EntityDetail isEntityKnown(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ EntityDetail entity = realMetadataCollection.isEntityKnown(userId, guid);
+
+ if (entity != null)
+ {
+ /*
+ * Ensure the provenance of the entity is correctly set. A repository may not support the storing of
+ * the metadata collection id in the repository (or uses null to mean "local"). When the entity
+ * detail is sent out, it must have its home metadata collection id set up. So LocalOMRSMetadataCollection
+ * fixes up the provenance.
+ */
+ if (entity.getMetadataCollectionId() == null)
+ {
+ entity.setMetadataCollectionId(metadataCollectionId);
+ entity.setInstanceProvenanceType(InstanceProvenanceType.LOCAL_COHORT);
+ }
+ }
+
+ return entity;
+ }
+
+
+ /**
+ * Return the header and classifications for a specific entity.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the entity
+ * @return EntitySummary structure
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws EntityNotKnownException - the requested entity instance is not known in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public EntitySummary getEntitySummary(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ EntityNotKnownException,
+ UserNotAuthorizedException
+ {
+ EntitySummary entity = realMetadataCollection.getEntitySummary(userId, guid);
+
+ if (entity != null)
+ {
+ /*
+ * Ensure the provenance of the entity is correctly set. A repository may not support the storing of
+ * the metadata collection id in the repository (or uses null to mean "local"). When the entity
+ * detail is sent out, it must have its home metadata collection id set up. So LocalOMRSMetadataCollection
+ * fixes up the provenance.
+ */
+ if (entity.getMetadataCollectionId() == null)
+ {
+ entity.setMetadataCollectionId(metadataCollectionId);
+ entity.setInstanceProvenanceType(InstanceProvenanceType.LOCAL_COHORT);
+ }
+ }
+
+ return entity;
+ }
+
+
+ /**
+ * Return the header, classifications and properties of a specific entity.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the entity.
+ * @return EntityDetail structure.
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws EntityNotKnownException - the requested entity instance is not known in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public EntityDetail getEntityDetail(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ EntityNotKnownException,
+ UserNotAuthorizedException
+ {
+ EntityDetail entity = realMetadataCollection.getEntityDetail(userId, guid);
+
+ if (entity != null)
+ {
+ /*
+ * Ensure the provenance of the entity is correctly set. A repository may not support the storing of
+ * the metadata collection id in the repository (or uses null to mean "local"). When the entity
+ * detail is sent out, it must have its home metadata collection id set up. So LocalOMRSMetadataCollection
+ * fixes up the provenance.
+ */
+ if (entity.getMetadataCollectionId() == null)
+ {
+ entity.setMetadataCollectionId(metadataCollectionId);
+ entity.setInstanceProvenanceType(InstanceProvenanceType.LOCAL_COHORT);
+ }
+ }
+
+ return entity;
+ }
+
+
+ /**
+ * Return a historical version of an entity - includes the header, classifications and properties of the entity.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the entity.
+ * @param asOfTime - the time used to determine which version of the entity that is desired.
+ * @return EntityDetail structure.
+ * @throws InvalidParameterException - the guid or date is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws EntityNotKnownException - the requested entity instance is not known in the metadata collection
+ * at the time requested.
+ * @throws PropertyErrorException - the asOfTime property is for a future time
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public EntityDetail getEntityDetail(String userId,
+ String guid,
+ Date asOfTime) throws InvalidParameterException,
+ RepositoryErrorException,
+ EntityNotKnownException,
+ PropertyErrorException,
+ UserNotAuthorizedException
+ {
+ EntityDetail entity = realMetadataCollection.getEntityDetail(userId, guid, asOfTime);
+
+ if (entity != null)
+ {
+ /*
+ * Ensure the provenance of the entity is correctly set. A repository may not support the storing of
+ * the metadata collection id in the repository (or uses null to mean "local"). When the entity
+ * detail is sent out, it must have its home metadata collection id set up. So LocalOMRSMetadataCollection
+ * fixes up the provenance.
+ */
+ if (entity.getMetadataCollectionId() == null)
+ {
+ entity.setMetadataCollectionId(metadataCollectionId);
+ entity.setInstanceProvenanceType(InstanceProvenanceType.LOCAL_COHORT);
+ }
+ }
+
+ return entity;
+ }
+
+
+ /**
+ * Return the header, classifications, properties and relationships for a specific entity.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the entity.
+ * @return EntityUniverse structure.
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws EntityNotKnownException - the requested entity instance is not known in the metadata collection.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public EntityUniverse getEntityUniverse(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ EntityNotKnownException,
+ UserNotAuthorizedException
+ {
+ EntityUniverse entity = realMetadataCollection.getEntityUniverse(userId, guid);
+
+ if (entity != null)
+ {
+ /*
+ * Ensure the provenance of the entity is correctly set. A repository may not support the storing of
+ * the metadata collection id in the repository (or uses null to mean "local"). When the entity
+ * detail is sent out, it must have its home metadata collection id set up. So LocalOMRSMetadataCollection
+ * fixes up the provenance.
+ */
+ if (entity.getMetadataCollectionId() == null)
+ {
+ entity.setMetadataCollectionId(metadataCollectionId);
+ entity.setInstanceProvenanceType(InstanceProvenanceType.LOCAL_COHORT);
+ }
+ }
+
+ return entity;
+ }
+
+
+ /**
+ * Return the relationships for a specific entity.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param entityGUID - String unique identifier for the entity.
+ * @param fromRelationshipElement - the starting element number of the relationships to return.
+ * This is used when retrieving elements
+ * beyond the first page of results. Zero means start from the first element.
+ * @param limitResultsByStatus - By default, relationships in all statuses are returned. However, it is possible
+ * to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all
+ * status values.
+ * @param asOfTime - Requests a historical query of the relationships for the entity. Null means return the
+ * present values.
+ * @param sequencingProperty - String name of the property that is to be used to sequence the results.
+ * Null means do not sequence on a property name (see SequencingOrder).
+ * @param sequencingOrder - Enum defining how the results should be ordered.
+ * @param pageSize -- the maximum number of result classifications that can be returned on this request. Zero means
+ * unrestricted return results size.
+ * @return Relationships list. Null means no relationships associated with the entity.
+ * @throws InvalidParameterException - a parameter is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws EntityNotKnownException - the requested entity instance is not known in the metadata collection.
+ * @throws PropertyErrorException - the sequencing property is not valid for the attached classifications.
+ * @throws PagingErrorException - the paging/sequencing parameters are set up incorrectly.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<Relationship> getRelationshipsForEntity(String userId,
+ String entityGUID,
+ int fromRelationshipElement,
+ ArrayList<InstanceStatus> limitResultsByStatus,
+ Date asOfTime,
+ String sequencingProperty,
+ SequencingOrder sequencingOrder,
+ int pageSize) throws InvalidParameterException,
+ RepositoryErrorException,
+ EntityNotKnownException,
+ PropertyErrorException,
+ PagingErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getRelationshipsForEntity(userId,
+ entityGUID,
+ fromRelationshipElement,
+ limitResultsByStatus,
+ asOfTime,
+ sequencingProperty,
+ sequencingOrder,
+ pageSize);
+ }
+
+
+ /**
+ * Return a list of entities that match the supplied properties according to the match criteria. The results
+ * can be returned over many pages.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param entityTypeGUID - String unique identifier for the entity type of interest (null means any entity type).
+ * @param matchProperties - List of entity properties to match to (null means match on entityTypeGUID only).
+ * @param matchCriteria - Enum defining how the properties should be matched to the entities in the repository.
+ * @param fromEntityDetailElement - the starting element number of the entities to return.
+ * This is used when retrieving elements
+ * beyond the first page of results. Zero means start from the first element.
+ * @param limitResultsByStatus - By default, entities in all statuses are returned. However, it is possible
+ * to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all
+ * status values.
+ * @param limitResultsByClassification - List of classifications that must be present on all returned entities.
+ * @param asOfTime - Requests a historical query of the entity. Null means return the present values.
+ * @param sequencingProperty - String name of the entity property that is to be used to sequence the results.
+ * Null means do not sequence on a property name (see SequencingOrder).
+ * @param sequencingOrder - Enum defining how the results should be ordered.
+ * @param pageSize - the maximum number of result entities that can be returned on this request. Zero means
+ * unrestricted return results size.
+ * @return a list of entities matching the supplied criteria - null means no matching entities in the metadata
+ * collection.
+ * @throws InvalidParameterException - a parameter is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeErrorException - the type guid passed on the request is not known by the
+ * metadata collection.
+ * @throws PropertyErrorException - the properties specified are not valid for any of the requested types of
+ * entity.
+ * @throws PagingErrorException - the paging/sequencing parameters are set up incorrectly.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<EntityDetail> findEntitiesByProperty(String userId,
+ String entityTypeGUID,
+ InstanceProperties matchProperties,
+ MatchCriteria matchCriteria,
+ int fromEntityDetailElement,
+ ArrayList<InstanceStatus> limitResultsByStatus,
+ ArrayList<String> limitResultsByClassification,
+ Date asOfTime,
+ String sequencingProperty,
+ SequencingOrder sequencingOrder,
+ int pageSize) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeErrorException,
+ PropertyErrorException,
+ PagingErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findEntitiesByProperty(userId,
+ entityTypeGUID,
+ matchProperties,
+ matchCriteria,
+ fromEntityDetailElement,
+ limitResultsByStatus,
+ limitResultsByClassification,
+ asOfTime,
+ sequencingProperty,
+ sequencingOrder,
+ pageSize);
+ }
+
+
+ /**
+ * Return a list of entities that have the requested type of classification attached.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param entityTypeGUID - unique identifier for the type of entity requested. Null mans any type of entity.
+ * @param classificationName - name of the classification - a null is not valid.
+ * @param matchClassificationProperties - list of classification properties used to narrow the search.
+ * @param matchCriteria - Enum defining how the properties should be matched to the classifications in the repository.
+ * @param fromEntityDetailElement - the starting element number of the entities to return.
+ * This is used when retrieving elements
+ * beyond the first page of results. Zero means start from the first element.
+ * @param limitResultsByStatus - By default, entities in all statuses are returned. However, it is possible
+ * to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all
+ * status values.
+ * @param asOfTime - Requests a historical query of the entity. Null means return the present values.
+ * @param sequencingProperty - String name of the entity property that is to be used to sequence the results.
+ * Null means do not sequence on a property name (see SequencingOrder).
+ * @param sequencingOrder - Enum defining how the results should be ordered.
+ * @param pageSize - the maximum number of result entities that can be returned on this request. Zero means
+ * unrestricted return results size.
+ * @return a list of entities matching the supplied criteria - null means no matching entities in the metadata
+ * collection.
+ * @throws InvalidParameterException - a parameter is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeErrorException - the type guid passed on the request is not known by the
+ * metadata collection.
+ * @throws ClassificationErrorException - the classification request is not known to the metadata collection.
+ * @throws PropertyErrorException - the properties specified are not valid for the requested type of
+ * classification.
+ * @throws PagingErrorException - the paging/sequencing parameters are set up incorrectly.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<EntityDetail> findEntitiesByClassification(String userId,
+ String entityTypeGUID,
+ String classificationName,
+ InstanceProperties matchClassificationProperties,
+ MatchCriteria matchCriteria,
+ ArrayList<InstanceStatus> limitResultsByStatus,
+ Date asOfTime,
+ String sequencingProperty,
+ SequencingOrder sequencingOrder,
+ int fromEntityDetailElement,
+ int pageSize) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeErrorException,
+ ClassificationErrorException,
+ PropertyErrorException,
+ PagingErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findEntitiesByClassification(userId,
+ entityTypeGUID,
+ classificationName,
+ matchClassificationProperties,
+ matchCriteria,
+ limitResultsByStatus,
+ asOfTime,
+ sequencingProperty,
+ sequencingOrder,
+ fromEntityDetailElement,
+ pageSize);
+ }
+
+
+ /**
+ * Return a list of entities matching the search criteria.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param searchCriteria - String expression of the characteristics of the required relationships.
+ * @param fromEntityDetailElement - the starting element number of the entities to return.
+ * This is used when retrieving elements
+ * beyond the first page of results. Zero means start from the first element.
+ * @param limitResultsByStatus - By default, entities in all statuses are returned. However, it is possible
+ * to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all
+ * status values.
+ * @param limitResultsByClassification - List of classifications that must be present on all returned entities.
+ * @param asOfTime - Requests a historical query of the entity. Null means return the present values.
+ * @param sequencingProperty - String name of the property that is to be used to sequence the results.
+ * Null means do not sequence on a property name (see SequencingOrder).
+ * @param sequencingOrder - Enum defining how the results should be ordered.
+ * @param pageSize - the maximum number of result entities that can be returned on this request. Zero means
+ * unrestricted return results size.
+ * @return a list of entities matching the supplied criteria - null means no matching entities in the metadata
+ * collection.
+ * @throws InvalidParameterException - a parameter is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws PropertyErrorException - the sequencing property specified is not valid for any of the requested types of
+ * entity.
+ * @throws PagingErrorException - the paging/sequencing parameters are set up incorrectly.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<EntityDetail> searchForEntities(String userId,
+ String searchCriteria,
+ int fromEntityDetailElement,
+ ArrayList<InstanceStatus> limitResultsByStatus,
+ ArrayList<String> limitResultsByClassification,
+ Date asOfTime,
+ String sequencingProperty,
+ SequencingOrder sequencingOrder,
+ int pageSize) throws InvalidParameterException,
+ RepositoryErrorException,
+ PropertyErrorException,
+ PagingErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.searchForEntities(userId,
+ searchCriteria,
+ fromEntityDetailElement,
+ limitResultsByStatus,
+ limitResultsByClassification,
+ asOfTime,
+ sequencingProperty,
+ sequencingOrder,
+ pageSize);
+ }
+
+
+ /**
+ * Returns a boolean indicating if the relationship is stored in the metadata collection.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the relationship.
+ * @return relationship details if the relationship is found in the metadata collection; otherwise return null.
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public Relationship isRelationshipKnown(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.isRelationshipKnown(userId, guid);
+ }
+
+
+ /**
+ * Return a requested relationship.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the relationship.
+ * @return a relationship structure.
+ * @throws InvalidParameterException - the guid is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws RelationshipNotKnownException - the metadata collection does not have a relationship with
+ * the requested GUID stored.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public Relationship getRelationship(String userId,
+ String guid) throws InvalidParameterException,
+ RepositoryErrorException,
+ RelationshipNotKnownException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getRelationship(userId, guid);
+ }
+
+
+ /**
+ * Return a historical version of a relationship.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param guid - String unique identifier for the relationship.
+ * @param asOfTime - the time used to determine which version of the entity that is desired.
+ * @return EntityDetail structure.
+ * @throws InvalidParameterException - the guid or date is null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws RelationshipNotKnownException - the requested entity instance is not known in the metadata collection
+ * at the time requested.
+ * @throws PropertyErrorException - the asOfTime property is for a future time.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public Relationship getRelationship(String userId,
+ String guid,
+ Date asOfTime) throws InvalidParameterException,
+ RepositoryErrorException,
+ RelationshipNotKnownException,
+ PropertyErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.getRelationship(userId, guid, asOfTime);
+ }
+
+
+ /**
+ * Return a list of relationships that match the requested properties by hte matching criteria. The results
+ * can be broken into pages.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param relationshipTypeGUID - unique identifier (guid) for the new relationship's type.
+ * @param matchProperties - list of properties used to narrow the search.
+ * @param matchCriteria - Enum defining how the properties should be matched to the relationships in the repository.
+ * @param fromEntityDetailElement - the starting element number of the entities to return.
+ * This is used when retrieving elements
+ * beyond the first page of results. Zero means start from the first element.
+ * @param limitResultsByStatus - By default, relationships in all statuses are returned. However, it is possible
+ * to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all
+ * status values.
+ * @param asOfTime - Requests a historical query of the relationships for the entity. Null means return the
+ * present values.
+ * @param sequencingProperty - String name of the property that is to be used to sequence the results.
+ * Null means do not sequence on a property name (see SequencingOrder).
+ * @param sequencingOrder - Enum defining how the results should be ordered.
+ * @param pageSize - the maximum number of result relationships that can be returned on this request. Zero means
+ * unrestricted return results size.
+ * @return a list of relationships. Null means no matching relationships.
+ * @throws InvalidParameterException - one of the parameters is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws TypeErrorException - the type guid passed on the request is not known by the
+ * metadata collection.
+ * @throws PropertyErrorException - the properties specified are not valid for any of the requested types of
+ * relationships.
+ * @throws PagingErrorException - the paging/sequencing parameters are set up incorrectly.
+ * @throws UserNotAuthorizedException - the userId is not permitted to perform this operation.
+ */
+ public ArrayList<Relationship> findRelationshipsByProperty(String userId,
+ String relationshipTypeGUID,
+ InstanceProperties matchProperties,
+ MatchCriteria matchCriteria,
+ int fromEntityDetailElement,
+ ArrayList<InstanceStatus> limitResultsByStatus,
+ Date asOfTime,
+ String sequencingProperty,
+ SequencingOrder sequencingOrder,
+ int pageSize) throws InvalidParameterException,
+ RepositoryErrorException,
+ TypeErrorException,
+ PropertyErrorException,
+ PagingErrorException,
+ UserNotAuthorizedException
+ {
+ return realMetadataCollection.findRelationshipsByProperty(userId,
+ relationshipTypeGUID,
+ matchProperties,
+ matchCriteria,
+ fromEntityDetailElement,
+ limitResultsByStatus,
+ asOfTime,
+ sequencingProperty,
+ sequencingOrder,
+ pageSize);
+ }
+
+
+ /**
+ * Return a list of relationships that match the search criteria. The results can be paged.
+ *
+ * @param userId - unique identifier for requesting user.
+ * @param searchCriteria - String expression of the characteristics of the required relationships.
+ * @param fromRelationshipElement - Element number of the results to skip to when building the results list
+ * to return. Zero means begin at the start of the results. This is used
+ * to retrieve the results over a number of pages.
+ * @param limitResultsByStatus - By default, relationships in all statuses are returned. However, it is possible
+ * to specify a list of statuses (eg ACTIVE) to restrict the results to. Null means all
+ * status values.
+ * @param asOfTime - Requests a historical query of the relationships for the entity. Null means return the
+ * present values.
+ * @param sequencingProperty - String name of the property that is to be used to sequence the results.
+ * Null means do not sequence on a property name (see SequencingOrder).
+ * @param sequencingOrder - Enum defining how the results should be ordered.
+ * @param pageSize - the maximum number of result relationships that can be returned on this request. Zero means
+ * unrestricted return results size.
+ * @return a list of relationships. Null means no matching relationships.
+ * @throws InvalidParameterException - one of the parameters is invalid or null.
+ * @throws RepositoryErrorException - there is a problem communicating with the metadata repository where
+ * the metadata collection is stored.
+ * @throws PropertyErrorException - there is a problem with one
<TRUNCATED>