http://git-wip-us.apache.org/repos/asf/atlas/blob/a1fd4068/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataCollection.java ---------------------------------------------------------------------- diff --git a/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataCollection.java b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataCollection.java new file mode 100644 index 0000000..f796d48 --- /dev/null +++ b/omrs/src/main/java/org/apache/atlas/omrs/adapters/inmemory/repositoryconnector/InMemoryOMRSMetadataCollection.java @@ -0,0 +1,4523 @@ +/* + * 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.adapters.inmemory.repositoryconnector; + +import org.apache.atlas.omrs.ffdc.OMRSErrorCode; +import org.apache.atlas.omrs.ffdc.exception.*; +import org.apache.atlas.omrs.localrepository.repositorycontentmanager.OMRSRepositoryHelper; +import org.apache.atlas.omrs.localrepository.repositorycontentmanager.OMRSRepositoryValidator; +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.*; + +/** + * The InMemoryOMRSMetadataCollection represents a metadata repository that supports an in-memory repository. + * Requests to this metadata collection work with the hashmaps used to manage metadata types and instances. + */ +public class InMemoryOMRSMetadataCollection extends OMRSMetadataCollection +{ + private String repositoryName; /* Initialized in constructor */ + + private InMemoryOMRSMetadataStore repositoryStore = new InMemoryOMRSMetadataStore(); + + + /** + * Constructor ensures the metadata collection is linked to its connector and knows its metadata collection Id. + * + * @param parentConnector - connector that this metadata collection supports. The connector has the information + * to call the metadata repository. + * @param metadataCollectionId - unique Identifier of the metadata collection Id. + */ + public InMemoryOMRSMetadataCollection(InMemoryOMRSRepositoryConnector parentConnector, + String repositoryName, + OMRSRepositoryHelper repositoryHelper, + OMRSRepositoryValidator repositoryValidator, + String metadataCollectionId) + { + /* + * The metadata collection Id is the unique Id for the metadata collection. It is managed by the super class. + */ + super(parentConnector, repositoryName, metadataCollectionId, repositoryHelper, repositoryValidator); + + /* + * Save parentConnector since this has the connection information and access to the metadata about the + * connector. + */ + this.parentConnector = parentConnector; + this.repositoryName = repositoryName; + this.repositoryStore.setRepositoryName(repositoryName); + } + + + /* ====================================================================== + * Group 1: Confirm the identity of the metadata repository being called. + */ + + /** + * Returns the identifier of the metadata repository. This is the identifier used to register the + * metadata repository with the metadata repository cohort. It is also the identifier used to + * identify the home repository of a metadata instance. + * + * @return String - metadata collection id. + * @throws RepositoryErrorException - there is a problem communicating with the metadata repository. + */ + public String getMetadataCollectionId() throws RepositoryErrorException + { + final String methodName = "getMetadataCollectionId"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + return super.metadataCollectionId; + } + + + /* ============================== + * 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 TypeDefGalleryResponse - List of different categories of type definitions. + * @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 + { + final String methodName = "getAllTypes"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + + TypeDefGallery typeDefGallery = new TypeDefGallery(); + List<AttributeTypeDef> attributeTypeDefs = repositoryStore.getAttributeTypeDefs(); + List<TypeDef> typeDefs = repositoryStore.getTypeDefs(); + + typeDefGallery.setAttributeTypeDefs(attributeTypeDefs); + typeDefGallery.setTypeDefs(typeDefs); + + return repositoryHelper.getActiveTypeDefGallery(); + } + + + /** + * Returns a list of type definitions that have the specified name. Type 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 + { + final String methodName = "findTypesByName"; + final String nameParameterName = "name"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeName(repositoryName, nameParameterName, name, methodName); + + return repositoryHelper.getActiveTypesByWildCardName(repositoryName, 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 List<TypeDef> findTypeDefsByCategory(String userId, + TypeDefCategory category) throws InvalidParameterException, + RepositoryErrorException, + UserNotAuthorizedException + { + final String methodName = "findTypeDefsByCategory"; + final String categoryParameterName = "category"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDefCategory(repositoryName, categoryParameterName, category, methodName); + + List<TypeDef> allTypes = repositoryStore.getTypeDefs(); + List<TypeDef> typesForCategory = new ArrayList<>(); + + if (! allTypes.isEmpty()) + { + for (TypeDef typeDef : allTypes) + { + if (typeDef != null) + { + if (typeDef.getCategory() == category) + { + typesForCategory.add(typeDef); + } + } + } + } + + if (typesForCategory.isEmpty()) + { + typesForCategory = null; + } + + return typesForCategory; + } + + + /** + * 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 List<AttributeTypeDef> findAttributeTypeDefsByCategory(String userId, + AttributeTypeDefCategory category) throws InvalidParameterException, + RepositoryErrorException, + UserNotAuthorizedException + { + final String methodName = "findAttributeTypeDefsByCategory"; + final String categoryParameterName = "category"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateAttributeTypeDefCategory(repositoryName, categoryParameterName, category, methodName); + + List<AttributeTypeDef> allTypes = repositoryStore.getAttributeTypeDefs(); + List<AttributeTypeDef> typesForCategory = new ArrayList<>(); + + if (! allTypes.isEmpty()) + { + for (AttributeTypeDef attributeTypeDef : allTypes) + { + if (attributeTypeDef != null) + { + if (attributeTypeDef.getCategory() == category) + { + typesForCategory.add(attributeTypeDef); + } + } + } + } + + if (typesForCategory.isEmpty()) + { + typesForCategory = null; + } + + return typesForCategory; + } + + + /** + * 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 List<TypeDef> findTypeDefsByProperty(String userId, + TypeDefProperties matchCriteria) throws InvalidParameterException, + RepositoryErrorException, + UserNotAuthorizedException + { + final String methodName = "findTypeDefsByProperty"; + final String matchCriteriaParameterName = "matchCriteria"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateMatchCriteria(repositoryName, matchCriteriaParameterName, matchCriteria, methodName); + + List<TypeDef> allTypes = repositoryStore.getTypeDefs(); + List<TypeDef> typesMatchProperties = new ArrayList<>(); + List<String> propertyNames = matchCriteria.getTypeDefProperties(); + + if (! allTypes.isEmpty()) + { + for (TypeDef typeDef : allTypes) + { + if (typeDef != null) + { + List<TypeDefAttribute> typeDefAttributes = typeDef.getPropertiesDefinition(); + boolean allPropertiesMatch = true; + + for (String propertyName : propertyNames) + { + boolean thisPropertyMatches = false; + + if (propertyName != null) + { + for (TypeDefAttribute attribute : typeDefAttributes) + { + if (attribute != null) + { + if (propertyName.equals(attribute.getAttributeName())) + { + thisPropertyMatches = true; + break; + } + } + } + + if (! thisPropertyMatches) + { + allPropertiesMatch = false; + break; + } + } + } + + if (allPropertiesMatch) + { + typesMatchProperties.add(typeDef); + } + } + } + } + + if (typesMatchProperties.isEmpty()) + { + typesMatchProperties = null; + } + + return typesMatchProperties; + } + + + /** + * 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 List<TypeDef> findTypesByExternalID(String userId, + String standard, + String organization, + String identifier) throws InvalidParameterException, + RepositoryErrorException, + UserNotAuthorizedException + { + final String methodName = "findTypesByExternalID"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateExternalId(repositoryName, standard, organization, identifier, methodName); + + List<AttributeTypeDef> attributeTypeDefs = repositoryStore.getAttributeTypeDefs(); + List<TypeDef> typeDefs = repositoryStore.getTypeDefs(); + + List<AttributeTypeDef> matchedAttributeTypeDefs = new ArrayList<>(); + List<TypeDef> matchedTypeDefs = new ArrayList<>(); + + + + // TODO Loop through the AttributeTypeDefs and TypeDefs looking for matching external IDs + + OMRSErrorCode errorCode = OMRSErrorCode.METHOD_NOT_IMPLEMENTED; + + String errorMessage = errorCode.getErrorMessageId() + errorCode.getFormattedErrorMessage(methodName, this.getClass().getName(), repositoryName); + + throw new RepositoryErrorException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + + /** + * 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 List<TypeDef> searchForTypeDefs(String userId, + String searchCriteria) throws InvalidParameterException, + RepositoryErrorException, + UserNotAuthorizedException + { + final String methodName = "searchForTypeDefs"; + final String searchCriteriaParameterName = "searchCriteria"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateSearchCriteria(repositoryName, searchCriteriaParameterName, searchCriteria, methodName); + + List<TypeDef> matchedTypeDefs = new ArrayList<>(); + + for (TypeDef typeDef : repositoryStore.getTypeDefs()) + { + if (typeDef != null) + { + if (typeDef.getName().matches(searchCriteria)) + { + matchedTypeDefs.add(typeDef); + } + } + } + + if (matchedTypeDefs.isEmpty()) + { + matchedTypeDefs = null; + } + + return matchedTypeDefs; + } + + + /** + * 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 + { + final String methodName = "getTypeDefByGUID"; + final String guidParameterName = "guid"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeGUID(repositoryName, guidParameterName, guid, methodName); + + TypeDef matchedTypeDef = repositoryStore.getTypeDef(guid); + + if (matchedTypeDef != null) + { + return matchedTypeDef; + } + + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ID_NOT_KNOWN; + + String errorMessage = errorCode.getErrorMessageId() + errorCode.getFormattedErrorMessage(guid, methodName, repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + + } + + + /** + * 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 + { + final String methodName = "getAttributeTypeDefByGUID"; + final String guidParameterName = "guid"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeGUID(repositoryName, guidParameterName, guid, methodName); + + AttributeTypeDef matchedAttributeTypeDef = repositoryStore.getAttributeTypeDef(guid); + + if (matchedAttributeTypeDef != null) + { + return matchedAttributeTypeDef; + } + + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ID_NOT_KNOWN; + + String errorMessage = errorCode.getErrorMessageId() + errorCode.getFormattedErrorMessage(guid, methodName, repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + + /** + * 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 + { + final String methodName = "getTypeDefByName"; + final String nameParameterName = "name"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeName(repositoryName, nameParameterName, name, methodName); + + for (TypeDef typeDef : repositoryStore.getTypeDefs()) + { + if (name.equals(typeDef.getName())) + { + return typeDef; + } + } + + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_NAME_NOT_KNOWN; + + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(name, methodName, repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + + /** + * 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 + { + final String methodName = "getAttributeTypeDefByName"; + final String nameParameterName = "name"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeName(repositoryName, nameParameterName, name, methodName); + + for (AttributeTypeDef attributeTypeDef : repositoryStore.getAttributeTypeDefs()) + { + if (name.equals(attributeTypeDef.getName())) + { + return attributeTypeDef; + } + } + + OMRSErrorCode errorCode = OMRSErrorCode.ATTRIBUTE_TYPEDEF_NAME_NOT_KNOWN; + + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(name, methodName, repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + + /** + * Create a collection of related types. + * + * @param userId - unique identifier for requesting user. + * @param newTypes - TypeDefGalleryResponse 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 FunctionNotSupportedException - the repository does not support this call. + * @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 + { + final String methodName = "addTypeDefGallery"; + final String galleryParameterName = "newTypes"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDefGallery(repositoryName, galleryParameterName, newTypes, methodName); + + List<AttributeTypeDef> attributeTypeDefs = newTypes.getAttributeTypeDefs(); + List<TypeDef> typeDefs = newTypes.getTypeDefs(); + + if (attributeTypeDefs != null) + { + for (AttributeTypeDef attributeTypeDef : attributeTypeDefs) + { + this.addAttributeTypeDef(userId, attributeTypeDef); + } + } + + if (typeDefs != null) + { + for (TypeDef typeDef : typeDefs) + { + this.addTypeDef(userId, typeDef); + } + } + } + + + /** + * 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 + { + final String methodName = "addTypeDef"; + final String typeDefParameterName = "newTypeDef"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDef(repositoryName, typeDefParameterName, newTypeDef, methodName); + repositoryValidator.validateUnknownTypeDef(repositoryName, typeDefParameterName, newTypeDef, methodName); + + TypeDef existingTypeDef = repositoryStore.getTypeDef(newTypeDef.getGUID()); + + if (existingTypeDef != null) + { + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ALREADY_DEFINED; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(newTypeDef.getName(), + newTypeDef.getGUID(), + repositoryName); + + throw new TypeDefKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + repositoryStore.putTypeDef(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 + { + final String methodName = "addAttributeTypeDef"; + final String typeDefParameterName = "newAttributeTypeDef"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateAttributeTypeDef(repositoryName, typeDefParameterName, newAttributeTypeDef, methodName); + repositoryValidator.validateUnknownAttributeTypeDef(repositoryName, typeDefParameterName, newAttributeTypeDef, methodName); + + AttributeTypeDef existingTypeDef = repositoryStore.getAttributeTypeDef(newAttributeTypeDef.getGUID()); + + if (existingTypeDef != null) + { + OMRSErrorCode errorCode = OMRSErrorCode.ATTRIBUTE_TYPEDEF_ALREADY_DEFINED; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(newAttributeTypeDef.getName(), + newAttributeTypeDef.getGUID(), + repositoryName); + + throw new TypeDefKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + repositoryStore.putAttributeTypeDef(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 + { + final String methodName = "verifyTypeDef"; + final String typeDefParameterName = "typeDef"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDef(repositoryName, typeDefParameterName, typeDef, methodName); + + TypeDef existingTypeDef = repositoryStore.getTypeDef(typeDef.getGUID()); + + // todo need to validate that the supplied type def matches the stored one + + if (existingTypeDef == null) + { + return false; + } + else + { + return true; + } + } + + + /** + * 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 + { + final String methodName = "verifyAttributeTypeDef"; + final String typeDefParameterName = "attributeTypeDef"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateAttributeTypeDef(repositoryName, typeDefParameterName, attributeTypeDef, methodName); + + AttributeTypeDef existingAttributeTypeDef = repositoryStore.getAttributeTypeDef(attributeTypeDef.getGUID()); + + // todo need to validate that the supplied attribute type def matches the stored one + + if (existingAttributeTypeDef == null) + { + return false; + } + else + { + return true; + } + } + + + /** + * 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 + { + final String methodName = "updateTypeDef"; + final String typeDefParameterName = "typeDefPatch"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDefPatch(repositoryName, typeDefPatch, methodName); + + TypeDef existingTypeDef = repositoryStore.getTypeDef(typeDefPatch.getTypeDefGUID()); + + if (existingTypeDef == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ID_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(typeDefPatch.getTypeDefGUID(), + typeDefParameterName, + repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + TypeDef updatedTypeDef = repositoryHelper.applyPatch(repositoryName, existingTypeDef, typeDefPatch); + + repositoryStore.putTypeDef(updatedTypeDef); + + 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 + { + final String methodName = "deleteTypeDef"; + final String guidParameterName = "obsoleteTypeDefGUID"; + final String nameParameterName = "obsoleteTypeDefName"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDefIds(repositoryName, + guidParameterName, + nameParameterName, + obsoleteTypeDefGUID, + obsoleteTypeDefName, + methodName); + + TypeDef typeDef = repositoryStore.getTypeDef(obsoleteTypeDefGUID); + if (typeDef == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ID_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(typeDef.getGUID(), + guidParameterName, + repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_IN_USE; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(obsoleteTypeDefName, + obsoleteTypeDefGUID, + repositoryName); + + throw new TypeDefInUseException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + + /** + * 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 + { + final String methodName = "deleteAttributeTypeDef"; + final String guidParameterName = "obsoleteTypeDefGUID"; + final String nameParameterName = "obsoleteTypeDefName"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateAttributeTypeDefIds(repositoryName, + guidParameterName, + nameParameterName, + obsoleteTypeDefGUID, + obsoleteTypeDefName, + methodName); + + AttributeTypeDef attributeTypeDef = repositoryStore.getAttributeTypeDef(obsoleteTypeDefGUID); + if (attributeTypeDef == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ID_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(obsoleteTypeDefGUID, + guidParameterName, + repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + OMRSErrorCode errorCode = OMRSErrorCode.ATTRIBUTE_TYPEDEF_IN_USE; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(obsoleteTypeDefName, + obsoleteTypeDefGUID, + repositoryName); + + throw new TypeDefInUseException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + + /** + * 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 + { + final String methodName = "reIdentifyTypeDef"; + final String originalGUIDParameterName = "originalTypeDefGUID"; + final String originalNameParameterName = "originalTypeDefName"; + final String newGUIDParameterName = "newTypeDefGUID"; + final String newNameParameterName = "newTypeDefName"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDefIds(repositoryName, + originalGUIDParameterName, + originalNameParameterName, + originalTypeDefGUID, + originalTypeDefName, + methodName); + repositoryValidator.validateTypeDefIds(repositoryName, + newGUIDParameterName, + newNameParameterName, + newTypeDefGUID, + newTypeDefName, + methodName); + + TypeDef existingTypeDef = repositoryStore.getTypeDef(originalTypeDefGUID); + + if (existingTypeDef == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.TYPEDEF_ID_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(originalTypeDefName, + originalTypeDefGUID, + repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + existingTypeDef.setGUID(newTypeDefGUID); + existingTypeDef.setName(newTypeDefName); + + existingTypeDef.setVersion(existingTypeDef.getVersion() + 1); + + repositoryStore.putTypeDef(existingTypeDef); + + return existingTypeDef; + } + + + /** + * 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 + { + final String methodName = "reIdentifyAttributeTypeDef"; + final String originalGUIDParameterName = "originalAttributeTypeDefGUID"; + final String originalNameParameterName = "originalAttributeTypeDefName"; + final String newGUIDParameterName = "newAttributeTypeDefGUID"; + final String newNameParameterName = "newAttributeTypeDefName"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeDefIds(repositoryName, + originalGUIDParameterName, + originalNameParameterName, + originalAttributeTypeDefGUID, + originalAttributeTypeDefName, + methodName); + repositoryValidator.validateTypeDefIds(repositoryName, + newGUIDParameterName, + newNameParameterName, + newAttributeTypeDefGUID, + newAttributeTypeDefName, + methodName); + + AttributeTypeDef existingAttributeTypeDef = repositoryStore.getAttributeTypeDef(originalAttributeTypeDefGUID); + + if (existingAttributeTypeDef == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.ATTRIBUTE_TYPEDEF_ID_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + + errorCode.getFormattedErrorMessage(originalAttributeTypeDefName, + originalAttributeTypeDefGUID, + repositoryName); + + throw new TypeDefNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + existingAttributeTypeDef.setGUID(newAttributeTypeDefGUID); + existingAttributeTypeDef.setName(newAttributeTypeDefName); + + existingAttributeTypeDef.setVersion(existingAttributeTypeDef.getVersion() + 1); + + repositoryStore.putAttributeTypeDef(existingAttributeTypeDef); + + return existingAttributeTypeDef; + } + + + /* =================================================== + * 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 + { + final String methodName = "isEntityKnown"; + final String guidParameterName = "guid"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateGUID(repositoryName, guidParameterName, guid, methodName); + + return repositoryStore.getEntity(guid); + } + + + /** + * 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 + { + final String methodName = "getEntitySummary"; + final String guidParameterName = "guid"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateGUID(repositoryName, guidParameterName, guid, methodName); + + EntitySummary entity = repositoryStore.getEntity(guid); + if (entity == null) + { + entity = repositoryStore.getEntityProxy(guid); + } + + if (entity == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.ENTITY_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + errorCode.getFormattedErrorMessage(guid, + methodName, + repositoryName); + + throw new EntityNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + 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 + { + final String methodName = "getEntityDetail"; + final String guidParameterName = "guid"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateGUID(repositoryName, guidParameterName, guid, methodName); + + EntityDetail entity = this.isEntityKnown(userId, guid); + + if (entity == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.ENTITY_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + errorCode.getFormattedErrorMessage(guid, + methodName, + repositoryName); + + throw new EntityNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + return entity; + } + + + /** + * Return a historical versionName 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 versionName of the entity that is desired. + * @return EntityDetail structure. + * @throws InvalidParameterException - the guid or date is null or date is for a future time. + * @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 UserNotAuthorizedException - the userId is not permitted to perform this operation. + */ + public EntityDetail getEntityDetail(String userId, + String guid, + Date asOfTime) throws InvalidParameterException, + RepositoryErrorException, + EntityNotKnownException, + UserNotAuthorizedException + { + final String methodName = "getEntityDetail"; + final String guidParameterName = "guid"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateGUID(repositoryName, guidParameterName, guid, methodName); + + EntityDetail entity = repositoryStore.timeWarpEntityStore(methodName, asOfTime).get(guid); + + if (entity == null) + { + OMRSErrorCode errorCode = OMRSErrorCode.ENTITY_NOT_KNOWN; + String errorMessage = errorCode.getErrorMessageId() + errorCode.getFormattedErrorMessage(guid, + repositoryName); + + throw new EntityNotKnownException(errorCode.getHTTPErrorCode(), + this.getClass().getName(), + methodName, + errorMessage, + errorCode.getSystemAction(), + errorCode.getUserAction()); + } + + 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 relationshipTypeGUID - String GUID of the the type of relationship required (null for all). + * @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 List<Relationship> getRelationshipsForEntity(String userId, + String entityGUID, + String relationshipTypeGUID, + int fromRelationshipElement, + List<InstanceStatus> limitResultsByStatus, + Date asOfTime, + String sequencingProperty, + SequencingOrder sequencingOrder, + int pageSize) throws InvalidParameterException, + RepositoryErrorException, + EntityNotKnownException, + PropertyErrorException, + PagingErrorException, + UserNotAuthorizedException + { + final String methodName = "getRelationshipsForEntity"; + final String guidParameterName = "entityGUID"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateGUID(repositoryName, guidParameterName, entityGUID, methodName); + + // TODO validate entity guid and take notice of relationshipTypeGUID + + List<Relationship> entityRelationships = new ArrayList<>(); + + HashMap<String, Relationship> relationshipStore = repositoryStore.timeWarpRelationshipStore(methodName, asOfTime); + + for (Relationship storedRelationship : relationshipStore.values()) + { + if (storedRelationship != null) + { + EntityProxy entityOneProxy = storedRelationship.getEntityOneProxy(); + EntityProxy entityTwoProxy = storedRelationship.getEntityTwoProxy(); + + if (entityOneProxy != null) + { + if (entityGUID.equals(entityOneProxy.getGUID())) + { + entityRelationships.add(storedRelationship); + } + } + + if (entityTwoProxy != null) + { + if (entityGUID.equals(entityTwoProxy.getGUID())) + { + entityRelationships.add(storedRelationship); + } + } + } + } + + if (entityRelationships.isEmpty()) + { + return null; + } + + return formatRelationshipResults(entityRelationships, + fromRelationshipElement, + 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 fromEntityElement - 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 List<EntityDetail> findEntitiesByProperty(String userId, + String entityTypeGUID, + InstanceProperties matchProperties, + MatchCriteria matchCriteria, + int fromEntityElement, + List<InstanceStatus> limitResultsByStatus, + List<String> limitResultsByClassification, + Date asOfTime, + String sequencingProperty, + SequencingOrder sequencingOrder, + int pageSize) throws InvalidParameterException, + RepositoryErrorException, + TypeErrorException, + PropertyErrorException, + PagingErrorException, + UserNotAuthorizedException + { + final String methodName = "findEntitiesByProperty"; + final String matchCriteriaParameterName = "matchCriteria"; + final String matchPropertiesParameterName = "matchProperties"; + final String guidParameterName = "entityTypeGUID"; + + this.validateRepositoryConnector(methodName); + parentConnector.validateRepositoryIsActive(methodName); + + repositoryValidator.validateUserId(repositoryName, userId, methodName); + repositoryValidator.validateTypeGUID(repositoryName, guidParameterName, entityTypeGUID, methodName); + repositoryValidator.validateMatchCriteria(repositoryName, + matchCriteriaParameterName, + matchPropertiesParameterName, + matchCriteria, + matchProperties, + methodName); + + /* + * This is a brute force implementation of locating in entity since it iterates through all of + * the stored entities. + */ + List<EntityDetail> foundEntities = new ArrayList<>(); + HashMap<String, EntityDetail> entityStore = repositoryStore.timeWarpEntityStore(methodName, asOfTime); + + for (EntityDetail entity : entityStore.values()) + { + if (entity != null) + { + if ((repositoryValidator.verifyInstanceType(entityTypeGUID, entity)) && + (repositoryValidator.verifyInstanceHasRightStatus(limitResultsByStatus, entity)) && +
<TRUNCATED>