java.lang.Object
- org.odpi.openmetadata.accessservices.governanceprogram.server.spring.GovernanceProgramResource

```
@RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/governance-program/users/{userId}")
public class GovernanceProgramResource
extends Object
```
The GovernanceProgramResource provides a Spring based server-side REST API that supports the RelatedElementsManagementInterface. It delegates each request to the RelatedElementRESTServices. 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

GovernanceProgramResource()
Default constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`VoidResponse`	`clearAssignmentScope(String serverName, String userId, String elementGUID, String scopeGUID, ExternalSourceRequestBody requestBody)`	Remove an "AssignmentScope" relationship between two referenceables.
`VoidResponse`	`clearGovernanceDefinitionScope(String serverName, String userId, String governanceDefinitionGUID, String scopeGUID, ExternalSourceRequestBody requestBody)`	Remove an "GovernanceDefinitionScope" relationship between two referenceables.
`VoidResponse`	`clearGovernanceResponsibilityAssignment(String serverName, String userId, String governanceResponsibilityGUID, String personRoleGUID, ExternalSourceRequestBody requestBody)`	Remove a "GovernanceResponsibilityAssignment" relationship between a governance responsibility and a person role.
`VoidResponse`	`clearGovernedBy(String serverName, String userId, String elementGUID, String governanceDefinitionGUID, ExternalSourceRequestBody requestBody)`	Remove a "GovernedBy" relationship between two elements.
`VoidResponse`	`clearMoreInformation(String serverName, String userId, String elementGUID, String detailGUID, ExternalSourceRequestBody requestBody)`	Remove a "MoreInformation" relationship between two referenceables.
`VoidResponse`	`clearResource(String serverName, String userId, String elementGUID, String resourceGUID, ExternalSourceRequestBody requestBody)`	Remove a "ResourceList" relationship between two referenceables.
`VoidResponse`	`clearStakeholder(String serverName, String userId, String elementGUID, String stakeholderGUID, ExternalSourceRequestBody requestBody)`	Remove a "Stakeholder" relationship between two referenceables.
`RelatedElementListResponse`	`getAssignedActors(String serverName, String userId, String scopeGUID, int startFrom, int pageSize)`	Retrieve the assigned actors linked by the "AssignmentScope" relationship between two referenceables.
`RelatedElementListResponse`	`getAssignedScopes(String serverName, String userId, String elementGUID, int startFrom, int pageSize)`	Retrieve the assigned scopes linked by the "AssignmentScope" relationship between two referenceables.
`RelatedElementListResponse`	`getDescriptiveElements(String serverName, String userId, String detailGUID, int startFrom, int pageSize)`	Retrieve the descriptive elements linked via a "MoreInformation" relationship between two referenceables.
`RelatedElementListResponse`	`getGovernanceDefinitionScopes(String serverName, String userId, String governanceDefinitionGUID, int startFrom, int pageSize)`	Retrieve the assigned scopes linked by the "GovernanceDefinitionScope" relationship between two referenceables.
`GovernanceDefinitionListResponse`	`getGovernanceDefinitionsForElement(String serverName, String userId, String elementGUID, int startFrom, int pageSize)`	Retrieve the governance definitions linked via a "GovernedBy" relationship to an element.
`RelatedElementListResponse`	`getGovernedElements(String serverName, String userId, String governanceDefinitionGUID, int startFrom, int pageSize)`	Retrieve the governed elements linked via a "GovernedBy" relationship to a governance definition.
`RelatedElementListResponse`	`getMoreInformation(String serverName, String userId, String elementGUID, int startFrom, int pageSize)`	Retrieve the detail elements linked via a "MoreInformation" relationship between two referenceables.
`RelatedElementListResponse`	`getResourceList(String serverName, String userId, String elementGUID, int startFrom, int pageSize)`	Retrieve the list of resources assigned to an element via the "ResourceList" relationship between two referenceables.
`GovernanceRoleListResponse`	`getResponsibleRoles(String serverName, String userId, String governanceResponsibilityGUID, int startFrom, int pageSize)`	Retrieve the person roles linked via a "GovernanceResponsibilityAssignment" relationship to a governance responsibility.
`GovernanceDefinitionListResponse`	`getRoleResponsibilities(String serverName, String userId, String personRoleGUID, int startFrom, int pageSize)`	Retrieve the governance responsibilities linked via a "GovernanceResponsibilityAssignment" relationship to a person role.
`GovernanceDefinitionListResponse`	`getScopedGovernanceDefinitions(String serverName, String userId, String scopeGUID, int startFrom, int pageSize)`	Retrieve the governance definitions linked by the "GovernanceDefinitionScope" relationship to a scope element.
`RelatedElementListResponse`	`getStakeholderCommissionedElements(String serverName, String userId, String stakeholderGUID, int startFrom, int pageSize)`	Retrieve the elements commissioned by a stakeholder, linked via the "Stakeholder" relationship between two referenceables.
`RelatedElementListResponse`	`getStakeholders(String serverName, String userId, String elementGUID, int startFrom, int pageSize)`	Retrieve the stakeholder elements linked via the "Stakeholder" relationship between two referenceables.
`RelatedElementListResponse`	`getSupportedByResource(String serverName, String userId, String resourceGUID, int startFrom, int pageSize)`	Retrieve the list of elements assigned to a resource via the "ResourceList" relationship between two referenceables.
`VoidResponse`	`setupAssignmentScope(String serverName, String userId, String elementGUID, String scopeGUID, RelationshipRequestBody requestBody)`	Create an "AssignmentScope" relationship between an element and its scope.
`VoidResponse`	`setupGovernanceDefinitionScope(String serverName, String userId, String governanceDefinitionGUID, String scopeGUID, RelationshipRequestBody requestBody)`	Create an "GovernanceDefinitionScope" relationship between a governance definition and its scope element.
`VoidResponse`	`setupGovernanceResponsibilityAssignment(String serverName, String userId, String governanceResponsibilityGUID, String personRoleGUID, RelationshipRequestBody requestBody)`	Create a "GovernanceResponsibilityAssignment" relationship between a governance responsibility and a person role.
`VoidResponse`	`setupGovernedBy(String serverName, String userId, String elementGUID, String governanceDefinitionGUID, RelationshipRequestBody requestBody)`	Create a "GovernedBy" relationship between an element and a governance definition.
`VoidResponse`	`setupMoreInformation(String serverName, String userId, String elementGUID, String detailGUID, RelationshipRequestBody requestBody)`	Create a "MoreInformation" relationship between an element that is descriptive and one that is providing the detail.
`VoidResponse`	`setupResource(String serverName, String userId, String elementGUID, String resourceGUID, RelationshipRequestBody requestBody)`	Create a "ResourceList" relationship between a consuming element and an element that represents resources.
`VoidResponse`	`setupStakeholder(String serverName, String userId, String elementGUID, String stakeholderGUID, RelationshipRequestBody requestBody)`	Create a "Stakeholder" relationship between an element and its stakeholder.

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

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

Method Detail

setupMoreInformation

@PostMapping(path="/related-elements/{elementGUID}/more-information/{detailGUID}")
public VoidResponse setupMoreInformation(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String elementGUID,
                                         @PathVariable
                                         String detailGUID,
                                         @RequestBody
                                         RelationshipRequestBody requestBody)

Create a "MoreInformation" relationship between an element that is descriptive and one that is providing the detail.

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

clearMoreInformation

@PostMapping(path="/related-elements/{elementGUID}/more-information/{detailGUID}/delete")
public VoidResponse clearMoreInformation(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String elementGUID,
                                         @PathVariable
                                         String detailGUID,
                                         @RequestBody
                                         ExternalSourceRequestBody requestBody)

Remove a "MoreInformation" relationship between two referenceables.

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

getMoreInformation

@GetMapping(path="/related-elements/more-information/by-descriptive-element/{elementGUID}")
public RelatedElementListResponse getMoreInformation(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String elementGUID,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize)

Retrieve the detail elements linked via a "MoreInformation" relationship between two referenceables.

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

getDescriptiveElements

@GetMapping(path="/related-elements/more-information/by-detail-element/{detailGUID}")
public RelatedElementListResponse getDescriptiveElements(@PathVariable
                                                         String serverName,
                                                         @PathVariable
                                                         String userId,
                                                         @PathVariable
                                                         String detailGUID,
                                                         @RequestParam
                                                         int startFrom,
                                                         @RequestParam
                                                         int pageSize)

Retrieve the descriptive elements linked via a "MoreInformation" relationship between two referenceables.

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

setupGovernedBy

@PostMapping(path="/related-elements/{elementGUID}/governed-by/{governanceDefinitionGUID}")
public VoidResponse setupGovernedBy(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String elementGUID,
                                    @PathVariable
                                    String governanceDefinitionGUID,
                                    @RequestBody
                                    RelationshipRequestBody requestBody)

Create a "GovernedBy" relationship between an element and a governance definition.

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

clearGovernedBy

@PostMapping(path="/related-elements/{elementGUID}/governed-by/{governanceDefinitionGUID}/delete")
public VoidResponse clearGovernedBy(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String elementGUID,
                                    @PathVariable
                                    String governanceDefinitionGUID,
                                    @RequestBody
                                    ExternalSourceRequestBody requestBody)

Remove a "GovernedBy" relationship between two elements.

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

getGovernanceDefinitionsForElement

@GetMapping(path="/related-elements/governed-by/by-element/{elementGUID}")
public GovernanceDefinitionListResponse getGovernanceDefinitionsForElement(@PathVariable
                                                                           String serverName,
                                                                           @PathVariable
                                                                           String userId,
                                                                           @PathVariable
                                                                           String elementGUID,
                                                                           @RequestParam
                                                                           int startFrom,
                                                                           @RequestParam
                                                                           int pageSize)

Retrieve the governance definitions linked via a "GovernedBy" relationship to an element.

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

getGovernedElements

@GetMapping(path="/related-elements/governed-by/by-governance-definition/{governanceDefinitionGUID}")
public RelatedElementListResponse getGovernedElements(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String governanceDefinitionGUID,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize)

Retrieve the governed elements linked via a "GovernedBy" relationship to a governance definition.

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

setupGovernanceDefinitionScope

@PostMapping(path="/related-elements/{governanceDefinitionGUID}/governance-definition-scopes/{scopeGUID}")
public VoidResponse setupGovernanceDefinitionScope(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String governanceDefinitionGUID,
                                                   @PathVariable
                                                   String scopeGUID,
                                                   @RequestBody
                                                   RelationshipRequestBody requestBody)

Create an "GovernanceDefinitionScope" relationship between a governance definition and its scope element.

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

clearGovernanceDefinitionScope

@PostMapping(path="/related-elements/{governanceDefinitionGUID}/governance-definition-scopes/{scopeGUID}/delete")
public VoidResponse clearGovernanceDefinitionScope(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String governanceDefinitionGUID,
                                                   @PathVariable
                                                   String scopeGUID,
                                                   @RequestBody
                                                   ExternalSourceRequestBody requestBody)

Remove an "GovernanceDefinitionScope" relationship between two referenceables.

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

getGovernanceDefinitionScopes

@GetMapping(path="/related-elements/governance-definition-scopes/by-governance-definition/{governanceDefinitionGUID}")
public RelatedElementListResponse getGovernanceDefinitionScopes(@PathVariable
                                                                String serverName,
                                                                @PathVariable
                                                                String userId,
                                                                @PathVariable
                                                                String governanceDefinitionGUID,
                                                                @RequestParam
                                                                int startFrom,
                                                                @RequestParam
                                                                int pageSize)

Retrieve the assigned scopes linked by the "GovernanceDefinitionScope" relationship between two referenceables.

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

getScopedGovernanceDefinitions

@GetMapping(path="/related-elements/governance-definition-scopes/by-scope/{scopeGUID}")
public GovernanceDefinitionListResponse getScopedGovernanceDefinitions(@PathVariable
                                                                       String serverName,
                                                                       @PathVariable
                                                                       String userId,
                                                                       @PathVariable
                                                                       String scopeGUID,
                                                                       @RequestParam
                                                                       int startFrom,
                                                                       @RequestParam
                                                                       int pageSize)

Retrieve the governance definitions linked by the "GovernanceDefinitionScope" relationship to a scope element.

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

setupGovernanceResponsibilityAssignment

@PostMapping(path="/related-elements/{governanceResponsibilityGUID}/governance-responsibility-assignments/{personRoleGUID}")
public VoidResponse setupGovernanceResponsibilityAssignment(@PathVariable
                                                            String serverName,
                                                            @PathVariable
                                                            String userId,
                                                            @PathVariable
                                                            String governanceResponsibilityGUID,
                                                            @PathVariable
                                                            String personRoleGUID,
                                                            @RequestBody
                                                            RelationshipRequestBody requestBody)

Create a "GovernanceResponsibilityAssignment" relationship between a governance responsibility and a person role.

Parameters:: serverName - name of the service to route the request to.; userId - calling user; governanceResponsibilityGUID - unique identifier of the governance responsibility (type of governance definition); personRoleGUID - unique identifier of the person role element; requestBody - relationship properties
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

clearGovernanceResponsibilityAssignment

@PostMapping(path="/related-elements/{governanceResponsibilityGUID}/governance-responsibility-assignments/{personRoleGUID}/delete")
public VoidResponse clearGovernanceResponsibilityAssignment(@PathVariable
                                                            String serverName,
                                                            @PathVariable
                                                            String userId,
                                                            @PathVariable
                                                            String governanceResponsibilityGUID,
                                                            @PathVariable
                                                            String personRoleGUID,
                                                            @RequestBody
                                                            ExternalSourceRequestBody requestBody)

Remove a "GovernanceResponsibilityAssignment" relationship between a governance responsibility and a person role.

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

getResponsibleRoles

@GetMapping(path="/related-elements/governance-responsibility-assignments/by-responsibility/{governanceResponsibilityGUID}")
public GovernanceRoleListResponse getResponsibleRoles(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @PathVariable
                                                      String governanceResponsibilityGUID,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize)

Retrieve the person roles linked via a "GovernanceResponsibilityAssignment" relationship to a governance responsibility.

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

getRoleResponsibilities

@GetMapping(path="/related-elements/governance-responsibility-assignments/by-role/{personRoleGUID}")
public GovernanceDefinitionListResponse getRoleResponsibilities(@PathVariable
                                                                String serverName,
                                                                @PathVariable
                                                                String userId,
                                                                @PathVariable
                                                                String personRoleGUID,
                                                                @RequestParam
                                                                int startFrom,
                                                                @RequestParam
                                                                int pageSize)

Retrieve the governance responsibilities linked via a "GovernanceResponsibilityAssignment" relationship to a person role.

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

setupStakeholder

@PostMapping(path="/related-elements/{elementGUID}/stakeholders/{stakeholderGUID}")
public VoidResponse setupStakeholder(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String elementGUID,
                                     @PathVariable
                                     String stakeholderGUID,
                                     @RequestBody
                                     RelationshipRequestBody requestBody)

Create a "Stakeholder" relationship between an element and its stakeholder.

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

clearStakeholder

@PostMapping(path="/related-elements/{elementGUID}/stakeholders/{stakeholderGUID}/delete")
public VoidResponse clearStakeholder(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String elementGUID,
                                     @PathVariable
                                     String stakeholderGUID,
                                     @RequestBody
                                     ExternalSourceRequestBody requestBody)

Remove a "Stakeholder" relationship between two referenceables.

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

getStakeholders

@GetMapping(path="/related-elements/stakeholders/by-commissioned-element/{elementGUID}")
public RelatedElementListResponse getStakeholders(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String elementGUID,
                                                  @RequestParam
                                                  int startFrom,
                                                  @RequestParam
                                                  int pageSize)

Retrieve the stakeholder elements linked via the "Stakeholder" relationship between two referenceables.

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

getStakeholderCommissionedElements

@GetMapping(path="/related-elements/stakeholders/by-stakeholder/{stakeholderGUID}")
public RelatedElementListResponse getStakeholderCommissionedElements(@PathVariable
                                                                     String serverName,
                                                                     @PathVariable
                                                                     String userId,
                                                                     @PathVariable
                                                                     String stakeholderGUID,
                                                                     @RequestParam
                                                                     int startFrom,
                                                                     @RequestParam
                                                                     int pageSize)

Retrieve the elements commissioned by a stakeholder, linked via the "Stakeholder" relationship between two referenceables.

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

setupAssignmentScope

@PostMapping(path="/related-elements/{elementGUID}/assignment-scopes/{scopeGUID}")
public VoidResponse setupAssignmentScope(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String elementGUID,
                                         @PathVariable
                                         String scopeGUID,
                                         @RequestBody
                                         RelationshipRequestBody requestBody)

Create an "AssignmentScope" relationship between an element and its scope.

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

clearAssignmentScope

@PostMapping(path="/related-elements/{elementGUID}/assignment-scopes/{scopeGUID}/delete")
public VoidResponse clearAssignmentScope(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String elementGUID,
                                         @PathVariable
                                         String scopeGUID,
                                         @RequestBody
                                         ExternalSourceRequestBody requestBody)

Remove an "AssignmentScope" relationship between two referenceables.

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

getAssignedScopes

@GetMapping(path="/related-elements/assignment-scopes/by-assigned-actor/{elementGUID}")
public RelatedElementListResponse getAssignedScopes(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String elementGUID,
                                                    @RequestParam
                                                    int startFrom,
                                                    @RequestParam
                                                    int pageSize)

Retrieve the assigned scopes linked by the "AssignmentScope" relationship between two referenceables.

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

getAssignedActors

@GetMapping(path="/related-elements/assignment-scopes/by-assigned-scope/{scopeGUID}")
public RelatedElementListResponse getAssignedActors(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String scopeGUID,
                                                    @RequestParam
                                                    int startFrom,
                                                    @RequestParam
                                                    int pageSize)

Retrieve the assigned actors linked by the "AssignmentScope" relationship between two referenceables.

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

setupResource

@PostMapping(path="/related-elements/{elementGUID}/resource-list/{resourceGUID}")
public VoidResponse setupResource(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String elementGUID,
                                  @PathVariable
                                  String resourceGUID,
                                  @RequestBody
                                  RelationshipRequestBody requestBody)

Create a "ResourceList" relationship between a consuming element and an element that represents resources.

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

clearResource

@PostMapping(path="/related-elements/{elementGUID}/resource-list/{resourceGUID}/delete")
public VoidResponse clearResource(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String elementGUID,
                                  @PathVariable
                                  String resourceGUID,
                                  @RequestBody
                                  ExternalSourceRequestBody requestBody)

Remove a "ResourceList" relationship between two referenceables.

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

getResourceList

@GetMapping(path="/related-elements/resource-list/by-assignee/{elementGUID}")
public RelatedElementListResponse getResourceList(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String elementGUID,
                                                  @RequestParam
                                                  int startFrom,
                                                  @RequestParam
                                                  int pageSize)

Retrieve the list of resources assigned to an element via the "ResourceList" relationship between two referenceables.

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

getSupportedByResource

@GetMapping(path="/related-elements/resource-list/by-resource/{resourceGUID}")
public RelatedElementListResponse getSupportedByResource(@PathVariable
                                                         String serverName,
                                                         @PathVariable
                                                         String userId,
                                                         @PathVariable
                                                         String resourceGUID,
                                                         @RequestParam
                                                         int startFrom,
                                                         @RequestParam
                                                         int pageSize)

Retrieve the list of elements assigned to a resource via the "ResourceList" relationship between two referenceables.

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

Class GovernanceProgramResource

Constructor Summary