java.lang.Object
- org.odpi.openmetadata.accessservices.communityprofile.server.spring.CommunityProfileValidValuesResource

```
@RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/community-profile/users/{userId}")
public class CommunityProfileValidValuesResource
extends Object
```
The CommunityProfileValidValuesResource provides a Spring based server-side REST API that supports the ValidValueManagementInterface. It delegates each request to the ValidValueRESTServices. This provides the server-side implementation of the Community Profile Open Metadata Assess Service (OMAS) which is used to manage information about people, roles and organizations.

Constructor Summary

Constructors
Constructor Description

CommunityProfileValidValuesResource()
Default constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`VoidResponse`	`clearReferenceValueTag(String serverName, String userId, String elementGUID, String validValueGUID, ExternalSourceRequestBody requestBody)`	Remove a reference value assignment relationship between an element and a valid value.
`VoidResponse`	`clearValidValueMember(String serverName, String userId, String validValueSetGUID, String validValueMemberGUID, ExternalSourceRequestBody requestBody)`	Remove a membership relationship between a validValue and a validValueSet that it belongs to.
`VoidResponse`	`clearValidValues(String serverName, String userId, String elementGUID, String validValueGUID, ExternalSourceRequestBody requestBody)`	Remove a valid value assignment relationship between an element and a valid value.
`GUIDResponse`	`createValidValue(String serverName, String userId, ReferenceableRequestBody requestBody)`	Create a new metadata element to represent a validValues.
`ValidValueListResponse`	`findValidValues(String serverName, String userId, int startFrom, int pageSize, SearchStringRequestBody requestBody)`	Retrieve the list of validValue metadata elements that contain the search string.
`ValidValueListResponse`	`getAllValidValues(String serverName, String userId, int startFrom, int pageSize)`	Retrieve the list of validValue metadata elements with a matching qualified or display name.
`RelatedElementListResponse`	`getAssigneesOfReferenceValue(String serverName, String userId, String validValueGUID, int startFrom, int pageSize)`	Return information about the consumers linked to a valid value.
`RelatedElementListResponse`	`getConsumersOfValidValue(String serverName, String userId, String validValueGUID, int startFrom, int pageSize)`	Return information about the consumers linked to a valid value.
`ValidValueListResponse`	`getReferenceValues(String serverName, String userId, String elementGUID, int startFrom, int pageSize)`	Return information about the valid values linked as reference value tags to an element.
`ValidValueListResponse`	`getSetsForValidValue(String serverName, String userId, String validValueGUID, int startFrom, int pageSize)`	Page through the list of valid value sets that a valid value definition/set belongs to.
`ValidValueResponse`	`getValidValueByGUID(String serverName, String userId, String guid)`	Retrieve the validValue metadata element with the supplied unique identifier.
`ValidValueListResponse`	`getValidValuesByName(String serverName, String userId, int startFrom, int pageSize, NameRequestBody requestBody)`	Retrieve the list of validValue metadata elements with a matching qualified or display name.
`ValidValueListResponse`	`getValidValueSetMembers(String serverName, String userId, String validValueSetGUID, int startFrom, int pageSize)`	Page through the members of a valid value set.
`ValidValueResponse`	`getValidValuesForConsumer(String serverName, String userId, String elementGUID)`	Return information about the valid value set linked to an element as its set of valid values.
`VoidResponse`	`removeValidValue(String serverName, String userId, String validValueGUID, ExternalSourceRequestBody requestBody)`	Remove the metadata element representing a validValue.
`VoidResponse`	`setupReferenceValueTag(String serverName, String userId, String elementGUID, String validValueGUID, RelationshipRequestBody requestBody)`	Create a reference value assignment relationship between an element and a valid value to show that the valid value is a semiformal tag/classification.
`VoidResponse`	`setupValidValueMember(String serverName, String userId, String validValueSetGUID, String validValueMemberGUID, RelationshipRequestBody requestBody)`	Create a membership relationship between a validValue and a validValueSet that it belongs to.
`VoidResponse`	`setupValidValues(String serverName, String userId, String elementGUID, String validValueGUID, RelationshipRequestBody requestBody)`	Create a valid value assignment relationship between an element and a valid value (typically, a valid value set) to show that the valid value defines the values that can be stored in the data item that the element represents.
`VoidResponse`	`updateValidValue(String serverName, String userId, String validValueGUID, boolean isMergeUpdate, ReferenceableRequestBody requestBody)`	Update the metadata element representing a validValues.

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

Constructor Detail
- CommunityProfileValidValuesResource
```
public CommunityProfileValidValuesResource()
```
  Default constructor

Method Detail

createValidValue

@PostMapping(path="/valid-values")
public GUIDResponse createValidValue(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @RequestBody
                                     ReferenceableRequestBody requestBody)

Create a new metadata element to represent a validValues.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; requestBody - properties to store
Returns:: unique identifier of the new metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

updateValidValue

@PostMapping(path="/valid-values/{validValueGUID}")
public VoidResponse updateValidValue(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String validValueGUID,
                                     @RequestParam
                                     boolean isMergeUpdate,
                                     @RequestBody
                                     ReferenceableRequestBody requestBody)

Update the metadata element representing a validValues.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; validValueGUID - unique identifier of the metadata element to update; isMergeUpdate - should the new properties be merged with the existing properties of overlay them?; requestBody - new properties for this element
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

setupValidValueMember

@PostMapping(path="/valid-values/{validValueSetGUID}/valid-value-members/{validValueMemberGUID}")
public VoidResponse setupValidValueMember(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String validValueSetGUID,
                                          @PathVariable
                                          String validValueMemberGUID,
                                          @RequestBody
                                          RelationshipRequestBody requestBody)

Create a membership relationship between a validValue and a validValueSet that it belongs to.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; validValueSetGUID - unique identifier of the valid value set; validValueMemberGUID - unique identifier of the member; requestBody - relationship properties
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

clearValidValueMember

@PostMapping(path="/valid-values/{validValueSetGUID}/valid-value-members/{validValueMemberGUID}/delete")
public VoidResponse clearValidValueMember(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String validValueSetGUID,
                                          @PathVariable
                                          String validValueMemberGUID,
                                          @RequestBody
                                          ExternalSourceRequestBody requestBody)

Remove a membership relationship between a validValue and a validValueSet that it belongs to.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; validValueSetGUID - unique identifier of the valid value set; validValueMemberGUID - unique identifier of the member; requestBody - external source identifiers
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

setupValidValues

@PostMapping(path="/valid-values/{elementGUID}/valid-values/{validValueGUID}")
public VoidResponse setupValidValues(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String elementGUID,
                                     @PathVariable
                                     String validValueGUID,
                                     @RequestBody
                                     RelationshipRequestBody requestBody)

Create a valid value assignment relationship between an element and a valid value (typically, a valid value set) to show that the valid value defines the values that can be stored in the data item that the element represents.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; elementGUID - unique identifier of the element; validValueGUID - unique identifier of the valid value; requestBody - relationship properties
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

clearValidValues

@PostMapping(path="/valid-values/{elementGUID}/valid-values/{validValueGUID}/delete")
public VoidResponse clearValidValues(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String elementGUID,
                                     @PathVariable
                                     String validValueGUID,
                                     @RequestBody
                                     ExternalSourceRequestBody requestBody)

Remove a valid value assignment relationship between an element and a valid value.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; elementGUID - unique identifier of the element; validValueGUID - unique identifier of the valid value; requestBody - external source identifiers
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

setupReferenceValueTag

@PostMapping(path="/valid-values/{elementGUID}/reference-value-tags/{validValueGUID}")
public VoidResponse setupReferenceValueTag(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @PathVariable
                                           String elementGUID,
                                           @PathVariable
                                           String validValueGUID,
                                           @RequestBody
                                           RelationshipRequestBody requestBody)

Create a reference value assignment relationship between an element and a valid value to show that the valid value is a semiformal tag/classification.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; elementGUID - unique identifier of the element; validValueGUID - unique identifier of the valid value; requestBody - relationship properties
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

clearReferenceValueTag

@PostMapping(path="/valid-values/{elementGUID}/reference-value-tags/{validValueGUID}/delete")
public VoidResponse clearReferenceValueTag(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @PathVariable
                                           String elementGUID,
                                           @PathVariable
                                           String validValueGUID,
                                           @RequestBody
                                           ExternalSourceRequestBody requestBody)

Remove a reference value assignment relationship between an element and a valid value.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; elementGUID - unique identifier of the element; validValueGUID - unique identifier of the valid value; requestBody - external source identifiers
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

removeValidValue

@PostMapping(path="/valid-values/{validValueGUID}/delete")
public VoidResponse removeValidValue(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String validValueGUID,
                                     @RequestBody
                                     ExternalSourceRequestBody requestBody)

Remove the metadata element representing a validValue.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; validValueGUID - unique identifier of the metadata element to remove; requestBody - external source identifiers
Returns:: void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

findValidValues

@PostMapping(path="/valid-values/by-search-string")
public ValidValueListResponse findValidValues(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @RequestParam
                                              int startFrom,
                                              @RequestParam
                                              int pageSize,
                                              @RequestBody
                                              SearchStringRequestBody requestBody)

Retrieve the list of validValue metadata elements that contain the search string. The search string is treated as a regular expression.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; requestBody - string to find in the properties; startFrom - paging start point; pageSize - maximum results that can be returned
Returns:: list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getValidValuesByName

@PostMapping(path="/valid-values/by-name")
public ValidValueListResponse getValidValuesByName(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @RequestParam
                                                   int startFrom,
                                                   @RequestParam
                                                   int pageSize,
                                                   @RequestBody
                                                   NameRequestBody requestBody)

Retrieve the list of validValue metadata elements with a matching qualified or display name. There are no wildcards supported on this request.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; requestBody - name to search for; startFrom - paging start point; pageSize - maximum results that can be returned
Returns:: list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getValidValueSetMembers

@GetMapping(path="/valid-values/members/{validValueSetGUID}")
public ValidValueListResponse getValidValueSetMembers(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String validValueSetGUID,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize)

Page through the members of a valid value set.

Parameters:: serverName - called server; userId - calling user; validValueSetGUID - unique identifier of the valid value set; startFrom - index of the list to start from (0 for start); pageSize - maximum number of elements to return.
Returns:: list of valid value beans
InvalidParameterException name or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

getSetsForValidValue

@GetMapping(path="/valid-values/sets/{validValueGUID}")
public ValidValueListResponse getSetsForValidValue(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String validValueGUID,
                                                   @RequestParam
                                                   int startFrom,
                                                   @RequestParam
                                                   int pageSize)

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

Parameters:: serverName - called server; userId - calling user; validValueGUID - unique identifier of the valid value; startFrom - index of the list to start from (0 for start); pageSize - maximum number of elements to return.
Returns:: list of valid value beans
InvalidParameterException name or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

getValidValuesForConsumer

@GetMapping(path="/valid-values/by-consumer/{elementGUID}")
public ValidValueResponse getValidValuesForConsumer(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String elementGUID)

Return information about the valid value set linked to an element as its set of valid values.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; elementGUID - unique identifier for the element using the valid value set
Returns:: matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getConsumersOfValidValue

@GetMapping(path="/valid-values/{validValueGUID}/consumers")
public RelatedElementListResponse getConsumersOfValidValue(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String validValueGUID,
                                                           @RequestParam
                                                           int startFrom,
                                                           @RequestParam
                                                           int pageSize)

Return information about the consumers linked to a valid value.

Parameters:: serverName - called server; userId - calling user; validValueGUID - unique identifier for the validValue; startFrom - index of the list to start from (0 for start); pageSize - maximum number of elements to return.
Returns:: list of matching person roles
InvalidParameterException name or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

getReferenceValues

@GetMapping(path="/valid-values/by-reference-value-tags/{elementGUID}")
public ValidValueListResponse getReferenceValues(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String elementGUID,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize)

Return information about the valid values linked as reference value tags to an element.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; elementGUID - unique identifier for the element using the valid value set; startFrom - index of the list to start from (0 for start); pageSize - maximum number of elements to return.
Returns:: matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

getAssigneesOfReferenceValue

@GetMapping(path="/valid-values/{validValueGUID}/by-reference-value-tag-assignees")
public RelatedElementListResponse getAssigneesOfReferenceValue(@PathVariable
                                                               String serverName,
                                                               @PathVariable
                                                               String userId,
                                                               @PathVariable
                                                               String validValueGUID,
                                                               @RequestParam
                                                               int startFrom,
                                                               @RequestParam
                                                               int pageSize)