ValidValuesHandler (OCF Metadata Management Server-side Handlers 2.2 API)

java.lang.Object
- org.odpi.openmetadata.commonservices.ocf.metadatamanagement.handlers.ValidValuesHandler

```
public class ValidValuesHandler
extends Object
```
ValidValuesHandler provides the methods to create and maintain lists of valid value definitions grouped into a valid value set. Both valid value definitions and valid value sets have the same attributes and so inherit from ValidValue where all of the attributes are defined. A set is just grouping of valid values. Valid value definitions and set can be nested many times in other valid value sets.

Constructor Summary

Constructors
Constructor and Description
`ValidValuesHandler(String serviceName, String serverName, InvalidParameterHandler invalidParameterHandler, RepositoryHandler repositoryHandler, OMRSRepositoryHelper repositoryHelper, LastAttachmentHandler lastAttachmentHandler)` Construct the handler information needed to interact with the repository services

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`assignReferenceValueToItem(String userId, String validValueGUID, String referenceableGUID, int confidence, String steward, String notes, String methodName)` Link a valid value as a reference value to a referencable to act as a tag/classification to help with locating and grouping the referenceable.
`void`	`assignValidValueToConsumer(String userId, String validValueGUID, String consumerGUID, boolean strictRequirement, String methodName)` Link a valid value typically to a schema element or glossary term to show that it uses the valid values.
`void`	`attachValidValueToSet(String userId, String setGUID, String validValueGUID, String methodName)` Create a link between a valid value set or definition and a set.
`String`	`createExternalValidValueDefinition(String userId, String externalSourceGUID, String externalSourceName, String setGUID, String qualifiedName, String displayName, String description, String usage, String scope, String preferredValue, boolean isDeprecated, Map<String,String> additionalProperties, Map<String,Object> extendedProperties, String methodName)` Create a new valid value definition that is owned/managed by an external tool.
`String`	`createExternalValidValueSet(String userId, String externalSourceGUID, String externalSourceName, String qualifiedName, String displayName, String description, String usage, String scope, boolean isDeprecated, Map<String,String> additionalProperties, Map<String,Object> extendedProperties, String methodName)` Create a new valid value set that is owned/managed by an external tool.
`String`	`createValidValueDefinition(String userId, String setGUID, String qualifiedName, String displayName, String description, String usage, String scope, String preferredValue, boolean isDeprecated, Map<String,String> additionalProperties, Map<String,Object> extendedProperties, String methodName)` Create a new valid value definition.
`String`	`createValidValueSet(String userId, String qualifiedName, String displayName, String description, String usage, String scope, boolean isDeprecated, Map<String,String> additionalProperties, Map<String,Object> extendedProperties, String methodName)` Create a new valid value set.
`void`	`deleteValidValue(String userId, String validValueGUID, String qualifiedName, String methodName)` Remove the valid value form the repository.
`void`	`detachValidValueFromSet(String userId, String setGUID, String validValueGUID, String methodName)` Remove the link between a valid value and a set it is a member of.
`List<ValidValue>`	`findValidValues(String userId, String searchString, int startFrom, int pageSize, String methodName)` Locate valid values that match the search string.
`List<ReferenceValueAssignedItem>`	`getReferenceValueAssignedItems(String userId, String validValueGUID, List<String> supportedZones, int startFrom, int pageSize, String methodName)` Page through the list of referenceables that have this valid value as a reference value.
`List<ReferenceValueAssignment>`	`getReferenceValueAssignments(String userId, String referenceableGUID, int startFrom, int pageSize, String methodName)` Page through the list of assigned reference values for a referenceable.
`List<ValidValue>`	`getSetsForValidValue(String userId, String validValueGUID, int startFrom, int pageSize, String methodName)` Page through the list of valid value sets that a valid value definition/set belongs to.
`ValidValue`	`getValidValueByGUID(String userId, String validValueGUID, String methodName)` Retrieve a specific valid value from the repository.
`List<ValidValue>`	`getValidValueByName(String userId, String validValueName, String methodName)` Retrieve a specific valid value from the repository.
`List<ValidValueMapping>`	`getValidValueMappings(String userId, String validValueGUID, int startFrom, int pageSize, String methodName)` Page through the list of mappings for a valid value.
`List<ValidValuesAssignmentConsumer>`	`getValidValuesAssignmentConsumers(String userId, String validValueGUID, List<String> supportedZones, int startFrom, int pageSize, String methodName)` Page through the list of consumers for a valid value.
`List<ValidValuesAssignmentDefinition>`	`getValidValuesAssignmentDefinition(String userId, String referenceableGUID, int startFrom, int pageSize, String methodName)` Page through the list of valid values assigned to referenceable element.
`List<ValidValue>`	`getValidValueSetMembers(String userId, String validValueSetGUID, int startFrom, int pageSize, String methodName)` Page through the members of a valid value set.
`List<ValidValueImplementationAsset>`	`getValidValuesImplementationAssets(String userId, String validValueGUID, List<String> supportedZones, int startFrom, int pageSize, String methodName)` Page through the list of implementations for a valid value.
`void`	`linkValidValueToImplementation(String userId, String validValueGUID, String assetGUID, String symbolicName, String implementationValue, Map<String,String> additionalValues, String methodName)` Link a valid value to an asset that provides the implementation.
`void`	`mapValidValues(String userId, String validValue1GUID, String validValue2GUID, String associationDescription, int confidence, String steward, String notes, String methodName)` Link together 2 valid values from different sets that have equivalent values/meanings.
`void`	`setAssetHandler(AssetHandler assetHandler)` Set up the asset handler.
`void`	`unassignReferenceValueFromItem(String userId, String validValueGUID, String referenceableGUID, String methodName)` Remove the reference value link between a valid value and a referenceable (item).
`void`	`unassignValidValueFromConsumer(String userId, String validValueGUID, String consumerGUID, String methodName)` Remove the link between a valid value and a consumer.
`void`	`unlinkValidValueFromImplementation(String userId, String validValueGUID, String assetGUID, String methodName)` Remove the link between a valid value and an implementing asset.
`void`	`unmapValidValues(String userId, String validValue1GUID, String validValue2GUID, String methodName)` Remove the reference value link between a valid value and a referenceable (item).
`void`	`updateValidValue(String userId, String validValueGUID, String qualifiedName, String displayName, String description, String usage, String scope, String preferredValue, boolean isDeprecated, Map<String,String> additionalProperties, Map<String,Object> extendedProperties, String methodName)` Update the properties of the valid value.

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

Constructor Detail

ValidValuesHandler

public ValidValuesHandler(String serviceName,
                          String serverName,
                          InvalidParameterHandler invalidParameterHandler,
                          RepositoryHandler repositoryHandler,
                          OMRSRepositoryHelper repositoryHelper,
                          LastAttachmentHandler lastAttachmentHandler)

Construct the handler information needed to interact with the repository services

Parameters:: serviceName - name of this service; serverName - name of the local server; invalidParameterHandler - handler for managing parameter errors; repositoryHandler - manages calls to the repository services; repositoryHelper - provides utilities for manipulating the repository services objects; lastAttachmentHandler - handler for recording last attachment

Method Detail

setAssetHandler
```
public void setAssetHandler(AssetHandler assetHandler)
```
Set up the asset handler. This cannot be passed on the constructor because the validValuesHandler is needed to create the assetHandler.

Parameters:

assetHandler - handler for retrieving assets

createValidValueSet

public String createValidValueSet(String userId,
                                  String qualifiedName,
                                  String displayName,
                                  String description,
                                  String usage,
                                  String scope,
                                  boolean isDeprecated,
                                  Map<String,String> additionalProperties,
                                  Map<String,Object> extendedProperties,
                                  String methodName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException

Create a new valid value set. This just creates the Set itself. Members are added either as they are created, or they can be attached to a set after they are created.

Parameters:: userId - calling user.; qualifiedName - unique name.; displayName - displayable descriptive name.; description - further information.; usage - how/when should this set be used.; scope - what is the scope of this set's values.; isDeprecated - is the valid value deprecated; additionalProperties - additional properties for this set.; extendedProperties - properties that need to be populated into a subtype.; methodName - calling method
Returns:: unique identifier for the new set
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

createValidValueDefinition

public String createValidValueDefinition(String userId,
                                         String setGUID,
                                         String qualifiedName,
                                         String displayName,
                                         String description,
                                         String usage,
                                         String scope,
                                         String preferredValue,
                                         boolean isDeprecated,
                                         Map<String,String> additionalProperties,
                                         Map<String,Object> extendedProperties,
                                         String methodName)
                                  throws InvalidParameterException,
                                         UserNotAuthorizedException,
                                         PropertyServerException

Create a new valid value definition.

Parameters:: userId - calling user.; setGUID - unique identifier of the set to attach this to.; qualifiedName - unique name.; displayName - displayable descriptive name.; description - further information.; usage - how/when should this value be used.; scope - what is the scope of the values.; preferredValue - the value that should be used in an implementation if possible.; isDeprecated - is the valid value deprecated; additionalProperties - additional properties for this definition.; extendedProperties - properties that need to be populated into a subtype.; methodName - calling method
Returns:: unique identifier for the new definition
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

createExternalValidValueSet

public String createExternalValidValueSet(String userId,
                                          String externalSourceGUID,
                                          String externalSourceName,
                                          String qualifiedName,
                                          String displayName,
                                          String description,
                                          String usage,
                                          String scope,
                                          boolean isDeprecated,
                                          Map<String,String> additionalProperties,
                                          Map<String,Object> extendedProperties,
                                          String methodName)
                                   throws InvalidParameterException,
                                          UserNotAuthorizedException,
                                          PropertyServerException

Create a new valid value set that is owned/managed by an external tool. This just creates the Set itself. Members are added either as they are created, or they can be attached to a set after they are created.

Parameters:: userId - calling user.; externalSourceGUID - guid of the software server capability entity that represented the external source; externalSourceName - name of the software server capability entity that represented the external source; qualifiedName - unique name.; displayName - displayable descriptive name.; description - further information.; usage - how/when should this set be used.; scope - what is the scope of this set's values.; isDeprecated - is the valid value deprecated; additionalProperties - additional properties for this set.; extendedProperties - properties that need to be populated into a subtype.; methodName - calling method
Returns:: unique identifier for the new set
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

createExternalValidValueDefinition

public String createExternalValidValueDefinition(String userId,
                                                 String externalSourceGUID,
                                                 String externalSourceName,
                                                 String setGUID,
                                                 String qualifiedName,
                                                 String displayName,
                                                 String description,
                                                 String usage,
                                                 String scope,
                                                 String preferredValue,
                                                 boolean isDeprecated,
                                                 Map<String,String> additionalProperties,
                                                 Map<String,Object> extendedProperties,
                                                 String methodName)
                                          throws InvalidParameterException,
                                                 UserNotAuthorizedException,
                                                 PropertyServerException

Create a new valid value definition that is owned/managed by an external tool.

Parameters:: userId - calling user.; externalSourceGUID - guid of the software server capability entity that represented the external source; externalSourceName - name of the software server capability entity that represented the external source; setGUID - unique identifier of the set to attach this to.; qualifiedName - unique name.; displayName - displayable descriptive name.; description - further information.; usage - how/when should this value be used.; scope - what is the scope of the values.; preferredValue - the value that should be used in an implementation if possible.; isDeprecated - is the valid value deprecated; additionalProperties - additional properties for this definition.; extendedProperties - properties that need to be populated into a subtype.; methodName - calling method
Returns:: unique identifier for the new definition
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

updateValidValue

public void updateValidValue(String userId,
                             String validValueGUID,
                             String qualifiedName,
                             String displayName,
                             String description,
                             String usage,
                             String scope,
                             String preferredValue,
                             boolean isDeprecated,
                             Map<String,String> additionalProperties,
                             Map<String,Object> extendedProperties,
                             String methodName)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException

Update the properties of the valid value. All properties are updated. If only changing some if the properties, retrieve the current values from the repository and pass existing values back on this call if they are not to change.

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; qualifiedName - unique name.; displayName - displayable descriptive name.; description - further information.; usage - how/when should this value be used.; scope - what is the scope of the values.; preferredValue - the value that should be used in an implementation if possible.; isDeprecated - is the valid value deprecated; additionalProperties - additional properties for this valid value.; extendedProperties - properties that need to be populated into a subtype.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

deleteValidValue
```
public void deleteValidValue(String userId,
                             String validValueGUID,
                             String qualifiedName,
                             String methodName)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException
```
Remove the valid value form the repository. All links to it are deleted too.

Parameters:

userId - calling user

validValueGUID - unique identifier of the value to delete

qualifiedName - unique name of the value to delete. This is used to verify that the correct valid value is being deleted.

methodName - calling method

Throws:

InvalidParameterException - one of the parameters is invalid.

UserNotAuthorizedException - the user is not authorized to make this request.

PropertyServerException - the repository is not available or not working properly.

attachValidValueToSet

public void attachValidValueToSet(String userId,
                                  String setGUID,
                                  String validValueGUID,
                                  String methodName)
                           throws InvalidParameterException,
                                  UserNotAuthorizedException,
                                  PropertyServerException

Create a link between a valid value set or definition and a set. This means the valid value is a member of the set.

Parameters:: userId - calling user.; setGUID - unique identifier of the set.; validValueGUID - unique identifier of the valid value to add to the set.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

detachValidValueFromSet

public void detachValidValueFromSet(String userId,
                                    String setGUID,
                                    String validValueGUID,
                                    String methodName)
                             throws InvalidParameterException,
                                    UserNotAuthorizedException,
                                    PropertyServerException

Remove the link between a valid value and a set it is a member of.

Parameters:: userId - calling user; setGUID - owning set; validValueGUID - unique identifier of the member to be removed.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

linkValidValueToImplementation

public void linkValidValueToImplementation(String userId,
                                           String validValueGUID,
                                           String assetGUID,
                                           String symbolicName,
                                           String implementationValue,
                                           Map<String,String> additionalValues,
                                           String methodName)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException

Link a valid value to an asset that provides the implementation. Typically this method is used to link a valid value set to a code table.

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; assetGUID - unique identifier of the asset that implements the valid value.; symbolicName - lookup name for valid value; implementationValue - value used in implementation; additionalValues - additional values stored under the symbolic name; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

unlinkValidValueFromImplementation

public void unlinkValidValueFromImplementation(String userId,
                                               String validValueGUID,
                                               String assetGUID,
                                               String methodName)
                                        throws InvalidParameterException,
                                               UserNotAuthorizedException,
                                               PropertyServerException

Remove the link between a valid value and an implementing asset.

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; assetGUID - unique identifier of the asset that used to implement the valid value.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

assignValidValueToConsumer

public void assignValidValueToConsumer(String userId,
                                       String validValueGUID,
                                       String consumerGUID,
                                       boolean strictRequirement,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Link a valid value typically to a schema element or glossary term to show that it uses the valid values.

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; consumerGUID - unique identifier of the element to link to.; strictRequirement - the valid values defines the only values that are permitted.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

unassignValidValueFromConsumer

public void unassignValidValueFromConsumer(String userId,
                                           String validValueGUID,
                                           String consumerGUID,
                                           String methodName)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException

Remove the link between a valid value and a consumer.

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; consumerGUID - unique identifier of the element to remove the link from.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

assignReferenceValueToItem

public void assignReferenceValueToItem(String userId,
                                       String validValueGUID,
                                       String referenceableGUID,
                                       int confidence,
                                       String steward,
                                       String notes,
                                       String methodName)
                                throws InvalidParameterException,
                                       UserNotAuthorizedException,
                                       PropertyServerException

Link a valid value as a reference value to a referencable to act as a tag/classification to help with locating and grouping the referenceable.

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; referenceableGUID - unique identifier of the element to link to.; confidence - how confident is the steward that this mapping is correct (0-100).; steward - identifier of steward; notes - additional notes from the steward; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

unassignReferenceValueFromItem

public void unassignReferenceValueFromItem(String userId,
                                           String validValueGUID,
                                           String referenceableGUID,
                                           String methodName)
                                    throws InvalidParameterException,
                                           UserNotAuthorizedException,
                                           PropertyServerException

Remove the reference value link between a valid value and a referenceable (item).

Parameters:: userId - calling user.; validValueGUID - unique identifier of the valid value.; referenceableGUID - unique identifier of the element to remove the link from.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

mapValidValues

public void mapValidValues(String userId,
                           String validValue1GUID,
                           String validValue2GUID,
                           String associationDescription,
                           int confidence,
                           String steward,
                           String notes,
                           String methodName)
                    throws InvalidParameterException,
                           UserNotAuthorizedException,
                           PropertyServerException

Link together 2 valid values from different sets that have equivalent values/meanings.

Parameters:: userId - calling user.; validValue1GUID - unique identifier of the valid value.; validValue2GUID - unique identifier of the other valid value to link to.; associationDescription - how are the valid values related?; confidence - how confident is the steward that this mapping is correct (0-100).; steward - identifier of steward; notes - additional notes from the steward; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

unmapValidValues

public void unmapValidValues(String userId,
                             String validValue1GUID,
                             String validValue2GUID,
                             String methodName)
                      throws InvalidParameterException,
                             UserNotAuthorizedException,
                             PropertyServerException

Remove the reference value link between a valid value and a referenceable (item).

Parameters:: userId - calling user.; validValue1GUID - unique identifier of the valid value.; validValue2GUID - unique identifier of the other valid value element to remove the link from.; methodName - calling method
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValueByGUID

public ValidValue getValidValueByGUID(String userId,
                                      String validValueGUID,
                                      String methodName)
                               throws InvalidParameterException,
                                      UserNotAuthorizedException,
                                      PropertyServerException

Retrieve a specific valid value from the repository.

Parameters:: userId - calling user; validValueGUID - unique identifier of the valid value.; methodName - calling method
Returns:: Valid value bean
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValueByName

public List<ValidValue> getValidValueByName(String userId,
                                            String validValueName,
                                            String methodName)
                                     throws InvalidParameterException,
                                            UserNotAuthorizedException,
                                            PropertyServerException

Retrieve a specific valid value from the repository. Duplicates may be returned if multiple valid values have been assigned the same qualified name.

Parameters:: userId - calling user; validValueName - qualified name of the valid value.; methodName - calling method
Returns:: Valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

findValidValues

public List<ValidValue> findValidValues(String userId,
                                        String searchString,
                                        int startFrom,
                                        int pageSize,
                                        String methodName)
                                 throws InvalidParameterException,
                                        UserNotAuthorizedException,
                                        PropertyServerException

Locate valid values that match the search string. It considers the names, description, scope, usage and preferred value.

Parameters:: userId - calling user; searchString - string value to look for - may contain RegEx characters.; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValueSetMembers

public List<ValidValue> getValidValueSetMembers(String userId,
                                                String validValueSetGUID,
                                                int startFrom,
                                                int pageSize,
                                                String methodName)
                                         throws InvalidParameterException,
                                                UserNotAuthorizedException,
                                                PropertyServerException

Page through the members of a valid value set.

Parameters:: userId - calling user; validValueSetGUID - unique identifier of the valid value set.; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getSetsForValidValue

public List<ValidValue> getSetsForValidValue(String userId,
                                             String validValueGUID,
                                             int startFrom,
                                             int pageSize,
                                             String methodName)
                                      throws InvalidParameterException,
                                             UserNotAuthorizedException,
                                             PropertyServerException

Page through the list of valid value sets that a valid value definition/set belongs to.

Parameters:: userId - calling user; validValueGUID - unique identifier of valid value to query; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValuesAssignmentConsumers

public List<ValidValuesAssignmentConsumer> getValidValuesAssignmentConsumers(String userId,
                                                                             String validValueGUID,
                                                                             List<String> supportedZones,
                                                                             int startFrom,
                                                                             int pageSize,
                                                                             String methodName)
                                                                      throws InvalidParameterException,
                                                                             UserNotAuthorizedException,
                                                                             PropertyServerException

Page through the list of consumers for a valid value.

Parameters:: userId - calling user; validValueGUID - unique identifier of valid value to query; supportedZones - list of zones that define which assets can be retrieved.; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value consumer beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValuesAssignmentDefinition

public List<ValidValuesAssignmentDefinition> getValidValuesAssignmentDefinition(String userId,
                                                                                String referenceableGUID,
                                                                                int startFrom,
                                                                                int pageSize,
                                                                                String methodName)
                                                                         throws InvalidParameterException,
                                                                                UserNotAuthorizedException,
                                                                                PropertyServerException

Page through the list of valid values assigned to referenceable element.

Parameters:: userId - calling user; referenceableGUID - unique identifier of anchoring referenceable; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value consumer beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValuesImplementationAssets

public List<ValidValueImplementationAsset> getValidValuesImplementationAssets(String userId,
                                                                              String validValueGUID,
                                                                              List<String> supportedZones,
                                                                              int startFrom,
                                                                              int pageSize,
                                                                              String methodName)
                                                                       throws InvalidParameterException,
                                                                              UserNotAuthorizedException,
                                                                              PropertyServerException

Page through the list of implementations for a valid value.

Parameters:: userId - calling user; validValueGUID - unique identifier of valid value to query; supportedZones - list of zones that define which assets can be retrieved.; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getValidValueMappings

public List<ValidValueMapping> getValidValueMappings(String userId,
                                                     String validValueGUID,
                                                     int startFrom,
                                                     int pageSize,
                                                     String methodName)
                                              throws InvalidParameterException,
                                                     UserNotAuthorizedException,
                                                     PropertyServerException

Page through the list of mappings for a valid value. These are other valid values from different valid value sets that are equivalent in some way. The association description covers the type of association.

Parameters:: userId - calling user; validValueGUID - unique identifier of valid value to query; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of mappings to other valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getReferenceValueAssignedItems

public List<ReferenceValueAssignedItem> getReferenceValueAssignedItems(String userId,
                                                                       String validValueGUID,
                                                                       List<String> supportedZones,
                                                                       int startFrom,
                                                                       int pageSize,
                                                                       String methodName)
                                                                throws InvalidParameterException,
                                                                       UserNotAuthorizedException,
                                                                       PropertyServerException

Page through the list of referenceables that have this valid value as a reference value.

Parameters:: userId - calling user; validValueGUID - unique identifier of valid value to query; supportedZones - list of zones that define which assets can be retrieved.; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of referenceable beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

getReferenceValueAssignments

public List<ReferenceValueAssignment> getReferenceValueAssignments(String userId,
                                                                   String referenceableGUID,
                                                                   int startFrom,
                                                                   int pageSize,
                                                                   String methodName)
                                                            throws InvalidParameterException,
                                                                   UserNotAuthorizedException,
                                                                   PropertyServerException

Page through the list of assigned reference values for a referenceable.

Parameters:: userId - calling user; referenceableGUID - unique identifier of assigned item; startFrom - paging starting point; pageSize - maximum number of return values.; methodName - calling method
Returns:: list of valid value beans
Throws:: InvalidParameterException - one of the parameters is invalid.; UserNotAuthorizedException - the user is not authorized to make this request.; PropertyServerException - the repository is not available or not working properly.

Class ValidValuesHandler