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>
