java.lang.Object
- org.odpi.openmetadata.accessservices.assetmanager.server.spring.LineageExchangeResource

```
@RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/asset-manager/users/{userId}")
public class LineageExchangeResource
extends Object
```
LineageExchangeResource is the server-side implementation of the Asset Manager OMAS's support for processes, ports and lineage mapping. It matches the LineageExchangeClient.

Constructor Summary

Constructors
Constructor Description

LineageExchangeResource()
Default constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`VoidResponse`	`clearBusinessSignificant(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, UpdateRequestBody requestBody)`	Remove the "BusinessSignificant" designation from the element.
`VoidResponse`	`clearControlFlow(String serverName, String userId, String controlFlowGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove the control flow relationship between two elements.
`VoidResponse`	`clearDataFlow(String serverName, String userId, String dataFlowGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove the data flow relationship between two elements.
`VoidResponse`	`clearLineageMapping(String serverName, String userId, String lineageMappingGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove the lineage mapping between two elements.
`VoidResponse`	`clearPortDelegation(String serverName, String userId, String portOneGUID, String portTwoGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove the port delegation relationship between two ports.
`VoidResponse`	`clearPortSchemaType(String serverName, String userId, String portGUID, String schemaTypeGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove the schema type from a port.
`VoidResponse`	`clearProcessCall(String serverName, String userId, String processCallGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove the process call relationship.
`VoidResponse`	`clearProcessParent(String serverName, String userId, String parentProcessGUID, String childProcessGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Remove a parent-child relationship between two processes.
`VoidResponse`	`clearProcessPort(String serverName, String userId, String processGUID, String portGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Unlink a port from a process.
`GUIDResponse`	`createPort(String serverName, String userId, String processGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, PortRequestBody requestBody)`	Create a new metadata element to represent a port.
`GUIDResponse`	`createProcess(String serverName, String userId, boolean assetManagerIsHome, ProcessRequestBody requestBody)`	Create a new metadata element to represent a process.
`GUIDResponse`	`createProcessFromTemplate(String serverName, String userId, String templateGUID, boolean assetManagerIsHome, TemplateRequestBody requestBody)`	Create a new metadata element to represent a process using an existing metadata element as a template.
`PortElementsResponse`	`findPorts(String serverName, String userId, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, SearchStringRequestBody requestBody)`	Retrieve the list of port metadata elements that contain the search string.
`ProcessElementsResponse`	`findProcesses(String serverName, String userId, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, SearchStringRequestBody requestBody)`	Retrieve the list of process metadata elements that contain the search string.
`ControlFlowElementResponse`	`getControlFlow(String serverName, String userId, String currentStepGUID, String nextStepGUID, boolean forLineage, boolean forDuplicateProcessing, NameRequestBody requestBody)`	Retrieve the control flow relationship between two elements.
`ControlFlowElementsResponse`	`getControlFlowNextSteps(String serverName, String userId, String currentStepGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the control relationships linked from a specific element to the possible next elements in the process.
`ControlFlowElementsResponse`	`getControlFlowPreviousSteps(String serverName, String userId, String currentStepGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the control relationships linked from a specific element to the possible previous elements in the process.
`DataFlowElementResponse`	`getDataFlow(String serverName, String userId, String dataSupplierGUID, String dataConsumerGUID, boolean forLineage, boolean forDuplicateProcessing, NameRequestBody requestBody)`	Retrieve the data flow relationship between two elements.
`DataFlowElementsResponse`	`getDataFlowConsumers(String serverName, String userId, String dataSupplierGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the data flow relationships linked from a specific element to the downstream consumers.
`DataFlowElementsResponse`	`getDataFlowSuppliers(String serverName, String userId, String dataConsumerGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the data flow relationships linked from a specific element to the upstream suppliers.
`LineageMappingElementsResponse`	`getDestinationLineageMappings(String serverName, String userId, String sourceElementGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the lineage mapping relationships linked from a specific source element to its destinations.
`LineageMappingElementResponse`	`getLineageMapping(String serverName, String userId, String sourceElementGUID, String destinationElementGUID, boolean forLineage, boolean forDuplicateProcessing, NameRequestBody requestBody)`	Retrieve the process call relationship between two elements.
`PortElementResponse`	`getPortByGUID(String serverName, String userId, String portGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the port metadata element with the supplied unique identifier.
`PortElementResponse`	`getPortDelegation(String serverName, String userId, String portGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the port that this port delegates to.
`PortElementsResponse`	`getPortsByName(String serverName, String userId, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, NameRequestBody requestBody)`	Retrieve the list of port metadata elements with a matching qualified or display name.
`PortElementsResponse`	`getPortsForProcess(String serverName, String userId, String processGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the list of ports associated with a process.
`PortElementsResponse`	`getPortUse(String serverName, String userId, String portGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the list of ports that delegate to this port.
`ProcessElementResponse`	`getProcessByGUID(String serverName, String userId, String processGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the process metadata element with the supplied unique identifier.
`ProcessCallElementResponse`	`getProcessCall(String serverName, String userId, String callerGUID, String calledGUID, boolean forLineage, boolean forDuplicateProcessing, NameRequestBody requestBody)`	Retrieve the process call relationship between two elements.
`ProcessCallElementsResponse`	`getProcessCalled(String serverName, String userId, String callerGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the process call relationships linked from a specific element to the elements it calls.
`ProcessCallElementsResponse`	`getProcessCallers(String serverName, String userId, String calledGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the process call relationships linked from a specific element to its callers.
`ProcessElementsResponse`	`getProcessesByName(String serverName, String userId, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, NameRequestBody requestBody)`	Retrieve the list of process metadata elements with a matching qualified or display name.
`ProcessElementsResponse`	`getProcessesForAssetManager(String serverName, String userId, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Return the list of processes associated with the process manager.
`ProcessElementResponse`	`getProcessParent(String serverName, String userId, String processGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the process metadata element with the supplied unique identifier.
`LineageMappingElementsResponse`	`getSourceLineageMappings(String serverName, String userId, String destinationElementGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the lineage mapping relationships linked from a specific destination element to its sources.
`ProcessElementsResponse`	`getSubProcesses(String serverName, String userId, String processGUID, int startFrom, int pageSize, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Retrieve the process metadata element with the supplied unique identifier.
`VoidResponse`	`publishProcess(String serverName, String userId, String processGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Update the zones for the process so that it becomes visible to consumers.
`VoidResponse`	`removePort(String serverName, String userId, String portGUID, boolean forLineage, boolean forDuplicateProcessing, UpdateRequestBody requestBody)`	Remove the metadata element representing a port.
`VoidResponse`	`removeProcess(String serverName, String userId, String processGUID, boolean forLineage, boolean forDuplicateProcessing, UpdateRequestBody requestBody)`	Remove the metadata element representing a process.
`VoidResponse`	`setBusinessSignificant(String serverName, String userId, String elementGUID, boolean forLineage, boolean forDuplicateProcessing, UpdateRequestBody requestBody)`	Classify a port, process or process as "BusinessSignificant" (this may affect the way that lineage is displayed).
`GUIDResponse`	`setupControlFlow(String serverName, String userId, String currentStepGUID, String nextStepGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link two elements to show that when one completes the next is started.
`GUIDResponse`	`setupDataFlow(String serverName, String userId, String dataSupplierGUID, String dataConsumerGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link two elements together to show that data flows from one to the other.
`VoidResponse`	`setupLineageMapping(String serverName, String userId, String sourceElementGUID, String destinationElementGUID, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link to elements together to show that they are part of the lineage of the data that is moving between the processes.
`VoidResponse`	`setupPortDelegation(String serverName, String userId, String portOneGUID, String portTwoGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link two ports together to show that portTwo is an implementation of portOne.
`VoidResponse`	`setupPortSchemaType(String serverName, String userId, boolean assetManagerIsHome, String portGUID, String schemaTypeGUID, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link a schema type to a port to show the structure of data it accepts.
`GUIDResponse`	`setupProcessCall(String serverName, String userId, String callerGUID, String calledGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link two elements together to show a request-response call between them.
`VoidResponse`	`setupProcessParent(String serverName, String userId, String parentProcessGUID, String childProcessGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Create a parent-child relationship between two processes.
`VoidResponse`	`setupProcessPort(String serverName, String userId, String processGUID, String portGUID, boolean assetManagerIsHome, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Link a port to a process.
`VoidResponse`	`updateControlFlow(String serverName, String userId, String controlFlowGUID, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Update the relationship between two elements that shows that when one completes the next is started.
`VoidResponse`	`updateDataFlow(String serverName, String userId, String dataFlowGUID, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Update relationship between two elements that shows that data flows from one to the other.
`VoidResponse`	`updateLineageMapping(String serverName, String userId, String lineageMappingGUID, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Remove the lineage mapping between two elements.
`VoidResponse`	`updatePort(String serverName, String userId, String portGUID, boolean forLineage, boolean forDuplicateProcessing, PortRequestBody requestBody)`	Update the properties of the metadata element representing a port.
`VoidResponse`	`updateProcess(String serverName, String userId, String processGUID, boolean isMergeUpdate, boolean forLineage, boolean forDuplicateProcessing, ProcessRequestBody requestBody)`	Update the metadata element representing a process.
`VoidResponse`	`updateProcessCall(String serverName, String userId, String processCallGUID, boolean forLineage, boolean forDuplicateProcessing, RelationshipRequestBody requestBody)`	Update the relationship between two elements that shows a request-response call between them.
`VoidResponse`	`updateProcessStatus(String serverName, String userId, String processGUID, boolean forLineage, boolean forDuplicateProcessing, ProcessStatusRequestBody requestBody)`	Update the status of the metadata element representing a process.
`VoidResponse`	`withdrawProcess(String serverName, String userId, String processGUID, boolean forLineage, boolean forDuplicateProcessing, EffectiveTimeQueryRequestBody requestBody)`	Update the zones for the process so that it is no longer visible to consumers.

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

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

Method Detail

createProcess

@PostMapping(path="/processes")
public GUIDResponse createProcess(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @RequestParam
                                  boolean assetManagerIsHome,
                                  @RequestBody
                                  ProcessRequestBody requestBody)

Create a new metadata element to represent a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetManagerIsHome - ensure that only the process manager can update this process; requestBody - properties about the process to store
Returns:: unique identifier of the new process 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)

createProcessFromTemplate

@PostMapping(path="/processes/from-template/{templateGUID}")
public GUIDResponse createProcessFromTemplate(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String templateGUID,
                                              @RequestParam
                                              boolean assetManagerIsHome,
                                              @RequestBody
                                              TemplateRequestBody requestBody)

Create a new metadata element to represent a process using an existing metadata element as a template.

Parameters:: serverName - name of the server to route the request to; userId - calling user; templateGUID - unique identifier of the metadata element to copy; assetManagerIsHome - ensure that only the process manager can update this process; requestBody - properties that override the template
Returns:: unique identifier of the new process 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)

updateProcess

@PostMapping(path="/processes/{processGUID}")
public VoidResponse updateProcess(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String processGUID,
                                  @RequestParam
                                  boolean isMergeUpdate,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forLineage,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forDuplicateProcessing,
                                  @RequestBody
                                  ProcessRequestBody requestBody)

Update the metadata element representing a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the metadata element to update; isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - new properties for the metadata element
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)

updateProcessStatus

@PostMapping(path="/processes/{processGUID}/status")
public VoidResponse updateProcessStatus(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String processGUID,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        ProcessStatusRequestBody requestBody)

Update the status of the metadata element representing a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the process to update; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - new status for the process
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)

setupProcessParent

@PostMapping(path="/processes/parent/{parentProcessGUID}/child/{childProcessGUID}")
public VoidResponse setupProcessParent(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String parentProcessGUID,
                                       @PathVariable
                                       String childProcessGUID,
                                       @RequestParam
                                       boolean assetManagerIsHome,
                                       @RequestParam(required=false,defaultValue="false")
                                       boolean forLineage,
                                       @RequestParam(required=false,defaultValue="false")
                                       boolean forDuplicateProcessing,
                                       @RequestBody
                                       RelationshipRequestBody requestBody)

Create a parent-child relationship between two processes.

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetManagerIsHome - ensure that only the process manager can update this process; parentProcessGUID - unique identifier of the process in the external process manager that is to be the parent process; childProcessGUID - unique identifier of the process in the external process manager that is to be the nested sub-process; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

clearProcessParent

@PostMapping(path="/processes/parent/{parentProcessGUID}/child/{childProcessGUID}/remove")
public VoidResponse clearProcessParent(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String parentProcessGUID,
                                       @PathVariable
                                       String childProcessGUID,
                                       @RequestParam(required=false,defaultValue="false")
                                       boolean forLineage,
                                       @RequestParam(required=false,defaultValue="false")
                                       boolean forDuplicateProcessing,
                                       @RequestBody
                                       EffectiveTimeQueryRequestBody requestBody)

Remove a parent-child relationship between two processes.

Parameters:: serverName - name of the server to route the request to; userId - calling user; parentProcessGUID - unique identifier of the process in the external process manager that is to be the parent process; childProcessGUID - unique identifier of the process in the external process manager that is to be the nested sub-process; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

publishProcess

@PostMapping(path="/processes/{processGUID}/publish")
public VoidResponse publishProcess(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String processGUID,
                                   @RequestParam(required=false,defaultValue="false")
                                   boolean forLineage,
                                   @RequestParam(required=false,defaultValue="false")
                                   boolean forDuplicateProcessing,
                                   @RequestBody
                                   EffectiveTimeQueryRequestBody requestBody)

Update the zones for the process so that it becomes visible to consumers. (The zones are set to the list of zones in the publishedZones option configured for each instance of the Asset Manager OMAS).

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the metadata element to publish; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

withdrawProcess

@PostMapping(path="/processes/{processGUID}/withdraw")
public VoidResponse withdrawProcess(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String processGUID,
                                    @RequestParam(required=false,defaultValue="false")
                                    boolean forLineage,
                                    @RequestParam(required=false,defaultValue="false")
                                    boolean forDuplicateProcessing,
                                    @RequestBody
                                    EffectiveTimeQueryRequestBody requestBody)

Update the zones for the process so that it is no longer visible to consumers. (The zones are set to the list of zones in the defaultZones option configured for each instance of the Asset Manager OMAS. This is the setting when the process is first created).

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the metadata element to withdraw; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - effective time
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)

removeProcess

@PostMapping(path="/processes/{processGUID}/remove")
public VoidResponse removeProcess(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String processGUID,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forLineage,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forDuplicateProcessing,
                                  @RequestBody
                                  UpdateRequestBody requestBody)

Remove the metadata element representing a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the metadata element to remove; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
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)

findProcesses

@PostMapping(path="/processes/by-search-string")
public ProcessElementsResponse findProcesses(@PathVariable
                                             String serverName,
                                             @PathVariable
                                             String userId,
                                             @RequestParam
                                             int startFrom,
                                             @RequestParam
                                             int pageSize,
                                             @RequestParam(required=false,defaultValue="false")
                                             boolean forLineage,
                                             @RequestParam(required=false,defaultValue="false")
                                             boolean forDuplicateProcessing,
                                             @RequestBody
                                             SearchStringRequestBody requestBody)

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

Parameters:: serverName - name of the server to route the request to; userId - calling user; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - string to find in the properties
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)

getProcessesForAssetManager

@PostMapping(path="/processes/by-asset-manager")
public ProcessElementsResponse getProcessesForAssetManager(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @RequestParam
                                                           int startFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forLineage,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forDuplicateProcessing,
                                                           @RequestBody
                                                           EffectiveTimeQueryRequestBody requestBody)

Return the list of processes associated with the process manager.

Parameters:: serverName - name of the server to route the request to; userId - calling user; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: list of metadata elements describing the processes associated with the requested asset manager 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)

getProcessesByName

@PostMapping(path="/processes/by-name")
public ProcessElementsResponse getProcessesByName(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @RequestParam
                                                  int startFrom,
                                                  @RequestParam
                                                  int pageSize,
                                                  @RequestParam(required=false,defaultValue="false")
                                                  boolean forLineage,
                                                  @RequestParam(required=false,defaultValue="false")
                                                  boolean forDuplicateProcessing,
                                                  @RequestBody
                                                  NameRequestBody requestBody)

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

Parameters:: serverName - name of the server to route the request to; userId - calling user; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - name to search for
Returns:: list of matching metadata elements 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)

getProcessByGUID

@PostMapping(path="/processes/{processGUID}/retrieve")
public ProcessElementResponse getProcessByGUID(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String processGUID,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forLineage,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forDuplicateProcessing,
                                               @RequestBody
                                               EffectiveTimeQueryRequestBody requestBody)

Retrieve the process metadata element with the supplied unique identifier.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the requested metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: requested metadata element 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)

getProcessParent

@PostMapping(path="/processes/{processGUID}/parent/retrieve")
public ProcessElementResponse getProcessParent(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String processGUID,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forLineage,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forDuplicateProcessing,
                                               @RequestBody
                                               EffectiveTimeQueryRequestBody requestBody)

Retrieve the process metadata element with the supplied unique identifier.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the requested metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: parent process element 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)

getSubProcesses

@PostMapping(path="/processes/{processGUID}/children/retrieve")
public ProcessElementsResponse getSubProcesses(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String processGUID,
                                               @RequestParam
                                               int startFrom,
                                               @RequestParam
                                               int pageSize,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forLineage,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forDuplicateProcessing,
                                               @RequestBody
                                               EffectiveTimeQueryRequestBody requestBody)

Retrieve the process metadata element with the supplied unique identifier.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the requested metadata element; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: list of process elements 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)

createPort

@PostMapping(path="/processes/{processGUID}/ports")
public GUIDResponse createPort(@PathVariable
                               String serverName,
                               @PathVariable
                               String userId,
                               @PathVariable
                               String processGUID,
                               @RequestParam
                               boolean assetManagerIsHome,
                               @RequestParam(required=false,defaultValue="false")
                               boolean forLineage,
                               @RequestParam(required=false,defaultValue="false")
                               boolean forDuplicateProcessing,
                               @RequestBody
                               PortRequestBody requestBody)

Create a new metadata element to represent a port.

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetManagerIsHome - ensure that only the process manager can update this port; processGUID - unique identifier of the process where the port is located; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties for the port
Returns:: unique identifier of the new metadata element for the port 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)

updatePort

@PostMapping(path="/ports/{portGUID}/update")
public VoidResponse updatePort(@PathVariable
                               String serverName,
                               @PathVariable
                               String userId,
                               @PathVariable
                               String portGUID,
                               @RequestParam(required=false,defaultValue="false")
                               boolean forLineage,
                               @RequestParam(required=false,defaultValue="false")
                               boolean forDuplicateProcessing,
                               @RequestBody
                               PortRequestBody requestBody)

Update the properties of the metadata element representing a port. This call replaces all existing properties with the supplied properties.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portGUID - unique identifier of the port to update; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - new properties for the port
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)

setupProcessPort

@PostMapping(path="/processes/{processGUID}/ports/{portGUID}")
public VoidResponse setupProcessPort(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String processGUID,
                                     @PathVariable
                                     String portGUID,
                                     @RequestParam
                                     boolean assetManagerIsHome,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     RelationshipRequestBody requestBody)

Link a port to a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetManagerIsHome - ensure that only the process manager can update this process; processGUID - unique identifier of the process; portGUID - unique identifier of the port; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

clearProcessPort

@PostMapping(path="/processes/{processGUID}/ports/{portGUID}/remove")
public VoidResponse clearProcessPort(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String processGUID,
                                     @PathVariable
                                     String portGUID,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     EffectiveTimeQueryRequestBody requestBody)

Unlink a port from a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the process; portGUID - unique identifier of the port; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

setupPortDelegation

@PostMapping(path="/ports/{portOneGUID}/port-delegations/{portTwoGUID}")
public VoidResponse setupPortDelegation(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String portOneGUID,
                                        @PathVariable
                                        String portTwoGUID,
                                        @RequestParam
                                        boolean assetManagerIsHome,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        RelationshipRequestBody requestBody)

Link two ports together to show that portTwo is an implementation of portOne. (That is, portOne delegates to portTwo.)

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetManagerIsHome - ensure that only the process manager can update this process; portOneGUID - unique identifier of the port at end 1; portTwoGUID - unique identifier of the port at end 2; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

clearPortDelegation

@PostMapping(path="/ports/{portOneGUID}/port-delegations/{portTwoGUID}/remove")
public VoidResponse clearPortDelegation(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String portOneGUID,
                                        @PathVariable
                                        String portTwoGUID,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        EffectiveTimeQueryRequestBody requestBody)

Remove the port delegation relationship between two ports.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portOneGUID - unique identifier of the port at end 1; portTwoGUID - unique identifier of the port at end 2; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

setupPortSchemaType

@PostMapping(path="/ports/{portGUID}/schema-type/{schemaTypeGUID}")
public VoidResponse setupPortSchemaType(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @RequestParam
                                        boolean assetManagerIsHome,
                                        @PathVariable
                                        String portGUID,
                                        @PathVariable
                                        String schemaTypeGUID,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        RelationshipRequestBody requestBody)

Link a schema type to a port to show the structure of data it accepts.

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetManagerIsHome - ensure that only the process manager can update this process; portGUID - unique identifier of the port; schemaTypeGUID - unique identifier of the schemaType; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

clearPortSchemaType

@PostMapping(path="/ports/{portGUID}/schema-type/{schemaTypeGUID}/remove")
public VoidResponse clearPortSchemaType(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String portGUID,
                                        @PathVariable
                                        String schemaTypeGUID,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        EffectiveTimeQueryRequestBody requestBody)

Remove the schema type from a port.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portGUID - unique identifier of the port; schemaTypeGUID - unique identifier of the schemaType; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

removePort

@PostMapping(path="/ports/{portGUID}/remove")
public VoidResponse removePort(@PathVariable
                               String serverName,
                               @PathVariable
                               String userId,
                               @PathVariable
                               String portGUID,
                               @RequestParam(required=false,defaultValue="false")
                               boolean forLineage,
                               @RequestParam(required=false,defaultValue="false")
                               boolean forDuplicateProcessing,
                               @RequestBody
                               UpdateRequestBody requestBody)

Remove the metadata element representing a port.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portGUID - unique identifier of the metadata element to remove; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
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)

findPorts

@PostMapping(path="/ports/by-search-string")
public PortElementsResponse findPorts(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @RequestParam
                                      int startFrom,
                                      @RequestParam
                                      int pageSize,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forLineage,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forDuplicateProcessing,
                                      @RequestBody
                                      SearchStringRequestBody requestBody)

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

Parameters:: serverName - name of the server to route the request to; userId - calling user; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - string to find in the properties
Returns:: list of matching metadata elements 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)

getPortsForProcess

@PostMapping(path="/processes/{processGUID}/ports/retrieve")
public PortElementsResponse getPortsForProcess(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String processGUID,
                                               @RequestParam
                                               int startFrom,
                                               @RequestParam
                                               int pageSize,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forLineage,
                                               @RequestParam(required=false,defaultValue="false")
                                               boolean forDuplicateProcessing,
                                               @RequestBody
                                               EffectiveTimeQueryRequestBody requestBody)

Retrieve the list of ports associated with a process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processGUID - unique identifier of the process of interest; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: list of associated metadata elements 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)

getPortUse

@PostMapping(path="/ports/{portGUID}/used-by/retrieve")
public PortElementsResponse getPortUse(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String portGUID,
                                       @RequestParam
                                       int startFrom,
                                       @RequestParam
                                       int pageSize,
                                       @RequestParam(required=false,defaultValue="false")
                                       boolean forLineage,
                                       @RequestParam(required=false,defaultValue="false")
                                       boolean forDuplicateProcessing,
                                       @RequestBody
                                       EffectiveTimeQueryRequestBody requestBody)

Retrieve the list of ports that delegate to this port.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portGUID - unique identifier of the starting port; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: list of associated metadata elements 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)

getPortDelegation

@PostMapping(path="/ports/{portGUID}/port-delegations/retrieve")
public PortElementResponse getPortDelegation(@PathVariable
                                             String serverName,
                                             @PathVariable
                                             String userId,
                                             @PathVariable
                                             String portGUID,
                                             @RequestParam(required=false,defaultValue="false")
                                             boolean forLineage,
                                             @RequestParam(required=false,defaultValue="false")
                                             boolean forDuplicateProcessing,
                                             @RequestBody
                                             EffectiveTimeQueryRequestBody requestBody)

Retrieve the port that this port delegates to.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portGUID - unique identifier of the starting port alias; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: matching metadata element 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)

getPortsByName

@PostMapping(path="/ports/by-name")
public PortElementsResponse getPortsByName(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @RequestParam
                                           int startFrom,
                                           @RequestParam
                                           int pageSize,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forLineage,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forDuplicateProcessing,
                                           @RequestBody
                                           NameRequestBody requestBody)

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

Parameters:: serverName - name of the server to route the request to; userId - calling user; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - name to search for
Returns:: list of matching metadata elements 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)

getPortByGUID

@PostMapping(path="/ports/{portGUID}/retrieve")
public PortElementResponse getPortByGUID(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String portGUID,
                                         @RequestParam(required=false,defaultValue="false")
                                         boolean forLineage,
                                         @RequestParam(required=false,defaultValue="false")
                                         boolean forDuplicateProcessing,
                                         @RequestBody
                                         EffectiveTimeQueryRequestBody requestBody)

Retrieve the port metadata element with the supplied unique identifier.

Parameters:: serverName - name of the server to route the request to; userId - calling user; portGUID - unique identifier of the requested metadata element; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: matching metadata element 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)

setBusinessSignificant

@PostMapping(path="/elements/{elementGUID}/is-business-significant")
public VoidResponse setBusinessSignificant(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @PathVariable
                                           String elementGUID,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forLineage,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forDuplicateProcessing,
                                           @RequestBody
                                           UpdateRequestBody requestBody)

Classify a port, process or process as "BusinessSignificant" (this may affect the way that lineage is displayed).

Parameters:: serverName - name of the server to route the request to; userId - calling user; elementGUID - unique identifier of the metadata element to update; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
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)

clearBusinessSignificant

@PostMapping(path="/elements/{elementGUID}/is-business-significant/remove")
public VoidResponse clearBusinessSignificant(@PathVariable
                                             String serverName,
                                             @PathVariable
                                             String userId,
                                             @PathVariable
                                             String elementGUID,
                                             @RequestParam(required=false,defaultValue="false")
                                             boolean forLineage,
                                             @RequestParam(required=false,defaultValue="false")
                                             boolean forDuplicateProcessing,
                                             @RequestBody
                                             UpdateRequestBody requestBody)

Remove the "BusinessSignificant" designation from the element.

Parameters:: serverName - name of the server to route the request to; userId - calling user; elementGUID - unique identifier of the metadata element to update; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties to help with the mapping of the elements in the external asset manager and open metadata
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)

setupDataFlow

@PostMapping(path="/data-flows/suppliers/{dataSupplierGUID}/consumers/{dataConsumerGUID}")
public GUIDResponse setupDataFlow(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String dataSupplierGUID,
                                  @PathVariable
                                  String dataConsumerGUID,
                                  @RequestParam
                                  boolean assetManagerIsHome,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forLineage,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forDuplicateProcessing,
                                  @RequestBody
                                  RelationshipRequestBody requestBody)

Link two elements together to show that data flows from one to the other.

Parameters:: serverName - name of the server to route the request to; userId - calling user; dataSupplierGUID - unique identifier of the data supplier; dataConsumerGUID - unique identifier of the data consumer; assetManagerIsHome - ensure that only the process manager can update this process; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties of the relationship
Returns:: unique identifier of the relationship 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)

getDataFlow

@PostMapping(path="/data-flows/suppliers/{dataSupplierGUID}/consumers/{dataConsumerGUID}/retrieve")
public DataFlowElementResponse getDataFlow(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @PathVariable
                                           String dataSupplierGUID,
                                           @PathVariable
                                           String dataConsumerGUID,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forLineage,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forDuplicateProcessing,
                                           @RequestBody
                                           NameRequestBody requestBody)

Retrieve the data flow relationship between two elements. The qualifiedName is optional unless there is more than one data flow relationships between these two elements since it is used to disambiguate the request.

Parameters:: serverName - name of the server to route the request to; userId - calling user; dataSupplierGUID - unique identifier of the data supplier; dataConsumerGUID - unique identifier of the data consumer; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - optional name to search for
Returns:: unique identifier and properties of the relationship 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)

updateDataFlow

@PostMapping(path="/data-flows/{dataFlowGUID}/update")
public VoidResponse updateDataFlow(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String dataFlowGUID,
                                   @RequestParam(required=false,defaultValue="false")
                                   boolean forLineage,
                                   @RequestParam(required=false,defaultValue="false")
                                   boolean forDuplicateProcessing,
                                   @RequestBody
                                   RelationshipRequestBody requestBody)

Update relationship between two elements that shows that data flows from one to the other.

Parameters:: serverName - name of the server to route the request to; userId - calling user; dataFlowGUID - unique identifier of the data flow relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties of the relationship
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)

clearDataFlow

@PostMapping(path="/data-flows/{dataFlowGUID}/remove")
public VoidResponse clearDataFlow(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String dataFlowGUID,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forLineage,
                                  @RequestParam(required=false,defaultValue="false")
                                  boolean forDuplicateProcessing,
                                  @RequestBody
                                  EffectiveTimeQueryRequestBody requestBody)

Remove the data flow relationship between two elements.

Parameters:: serverName - name of the server to route the request to; userId - calling user; dataFlowGUID - unique identifier of the data flow relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

getDataFlowConsumers

@PostMapping(path="/data-flows/suppliers/{dataSupplierGUID}/consumers/retrieve")
public DataFlowElementsResponse getDataFlowConsumers(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String dataSupplierGUID,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forLineage,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forDuplicateProcessing,
                                                     @RequestBody
                                                     EffectiveTimeQueryRequestBody requestBody)

Retrieve the data flow relationships linked from a specific element to the downstream consumers.

Parameters:: serverName - name of the server to route the request to; userId - calling user; dataSupplierGUID - unique identifier of the data supplier; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: unique identifier and properties of the relationship 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)

getDataFlowSuppliers

@PostMapping(path="/data-flows/consumers/{dataConsumerGUID}/suppliers/retrieve")
public DataFlowElementsResponse getDataFlowSuppliers(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String dataConsumerGUID,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forLineage,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forDuplicateProcessing,
                                                     @RequestBody
                                                     EffectiveTimeQueryRequestBody requestBody)

Retrieve the data flow relationships linked from a specific element to the upstream suppliers.

Parameters:: serverName - name of the server to route the request to; userId - calling user; dataConsumerGUID - unique identifier of the data consumer; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: unique identifier and properties of the relationship 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)

setupControlFlow

@PostMapping(path="/control-flows/current-steps/{currentStepGUID}/next-steps/{nextStepGUID}")
public GUIDResponse setupControlFlow(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String currentStepGUID,
                                     @PathVariable
                                     String nextStepGUID,
                                     @RequestParam
                                     boolean assetManagerIsHome,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     RelationshipRequestBody requestBody)

Link two elements to show that when one completes the next is started.

Parameters:: serverName - name of the server to route the request to; userId - calling user; currentStepGUID - unique identifier of the previous step; nextStepGUID - unique identifier of the next step; assetManagerIsHome - ensure that only the process manager can update this process; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties of the relationship
Returns:: unique identifier for the control flow relationship 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)

getControlFlow

@PostMapping(path="/control-flows/current-steps/{currentStepGUID}/next-steps/{nextStepGUID}/retrieve")
public ControlFlowElementResponse getControlFlow(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String currentStepGUID,
                                                 @PathVariable
                                                 String nextStepGUID,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forLineage,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forDuplicateProcessing,
                                                 @RequestBody
                                                 NameRequestBody requestBody)

Retrieve the control flow relationship between two elements. The qualifiedName is optional unless there is more than one control flow relationships between these two elements since it is used to disambiguate the request.

Parameters:: serverName - name of the server to route the request to; userId - calling user; currentStepGUID - unique identifier of the previous step; nextStepGUID - unique identifier of the next step; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifier for this relationship
Returns:: unique identifier and properties of the relationship 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)

updateControlFlow

@PostMapping(path="/control-flows/{controlFlowGUID}/update")
public VoidResponse updateControlFlow(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String controlFlowGUID,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forLineage,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forDuplicateProcessing,
                                      @RequestBody
                                      RelationshipRequestBody requestBody)

Update the relationship between two elements that shows that when one completes the next is started.

Parameters:: serverName - name of the server to route the request to; userId - calling user; controlFlowGUID - unique identifier of the control flow relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties of the relationship
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)

clearControlFlow

@PostMapping(path="/control-flows/{controlFlowGUID}/remove")
public VoidResponse clearControlFlow(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String controlFlowGUID,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     EffectiveTimeQueryRequestBody requestBody)

Remove the control flow relationship between two elements.

Parameters:: serverName - name of the server to route the request to; userId - calling user; controlFlowGUID - unique identifier of the control flow relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

getControlFlowNextSteps

@PostMapping(path="/control-flows/current-steps/{currentStepGUID}/next-steps/retrieve")
public ControlFlowElementsResponse getControlFlowNextSteps(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String currentStepGUID,
                                                           @RequestParam
                                                           int startFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forLineage,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forDuplicateProcessing,
                                                           @RequestBody
                                                           EffectiveTimeQueryRequestBody requestBody)

Retrieve the control relationships linked from a specific element to the possible next elements in the process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; currentStepGUID - unique identifier of the current step; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: unique identifier and properties of the relationship 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)

getControlFlowPreviousSteps

@PostMapping(path="/control-flows/current-steps/{currentStepGUID}/previous-steps/retrieve")
public ControlFlowElementsResponse getControlFlowPreviousSteps(@PathVariable
                                                               String serverName,
                                                               @PathVariable
                                                               String userId,
                                                               @PathVariable
                                                               String currentStepGUID,
                                                               @RequestParam
                                                               int startFrom,
                                                               @RequestParam
                                                               int pageSize,
                                                               @RequestParam(required=false,defaultValue="false")
                                                               boolean forLineage,
                                                               @RequestParam(required=false,defaultValue="false")
                                                               boolean forDuplicateProcessing,
                                                               @RequestBody
                                                               EffectiveTimeQueryRequestBody requestBody)

Retrieve the control relationships linked from a specific element to the possible previous elements in the process.

Parameters:: serverName - name of the server to route the request to; userId - calling user; currentStepGUID - unique identifier of the previous step; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: unique identifier and properties of the relationship 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)

setupProcessCall

@PostMapping(path="/process-calls/callers/{callerGUID}/called/{calledGUID}")
public GUIDResponse setupProcessCall(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String callerGUID,
                                     @PathVariable
                                     String calledGUID,
                                     @RequestParam
                                     boolean assetManagerIsHome,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     RelationshipRequestBody requestBody)

Link two elements together to show a request-response call between them.

Parameters:: serverName - name of the server to route the request to; userId - calling user; callerGUID - unique identifier of the element that is making the call; calledGUID - unique identifier of the element that is processing the call; assetManagerIsHome - ensure that only the process manager can update this process; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties of the relationship
Returns:: unique identifier of the new relationship 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)

getProcessCall

@PostMapping(path="/process-calls/callers/{callerGUID}/called/{calledGUID}/retrieve")
public ProcessCallElementResponse getProcessCall(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String callerGUID,
                                                 @PathVariable
                                                 String calledGUID,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forLineage,
                                                 @RequestParam(required=false,defaultValue="false")
                                                 boolean forDuplicateProcessing,
                                                 @RequestBody
                                                 NameRequestBody requestBody)

Retrieve the process call relationship between two elements. The qualifiedName is optional unless there is more than one process call relationships between these two elements since it is used to disambiguate the request. This is often used in conjunction with update.

Parameters:: serverName - name of the server to route the request to; userId - calling user; callerGUID - unique identifier of the element that is making the call; calledGUID - unique identifier of the element that is processing the call; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifier for this relationship
Returns:: unique identifier and properties of the relationship 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)

updateProcessCall

@PostMapping(path="/process-calls/{processCallGUID}/update")
public VoidResponse updateProcessCall(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String processCallGUID,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forLineage,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forDuplicateProcessing,
                                      @RequestBody
                                      RelationshipRequestBody requestBody)

Update the relationship between two elements that shows a request-response call between them.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processCallGUID - unique identifier of the process call relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - properties of the relationship
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)

clearProcessCall

@PostMapping(path="/process-calls/{processCallGUID}/remove")
public VoidResponse clearProcessCall(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String processCallGUID,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     EffectiveTimeQueryRequestBody requestBody)

Remove the process call relationship.

Parameters:: serverName - name of the server to route the request to; userId - calling user; processCallGUID - unique identifier of the process call relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

getProcessCalled

@PostMapping(path="/process-calls/callers/{callerGUID}/called/retrieve")
public ProcessCallElementsResponse getProcessCalled(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String callerGUID,
                                                    @RequestParam
                                                    int startFrom,
                                                    @RequestParam
                                                    int pageSize,
                                                    @RequestParam(required=false,defaultValue="false")
                                                    boolean forLineage,
                                                    @RequestParam(required=false,defaultValue="false")
                                                    boolean forDuplicateProcessing,
                                                    @RequestBody
                                                    EffectiveTimeQueryRequestBody requestBody)

Retrieve the process call relationships linked from a specific element to the elements it calls.

Parameters:: serverName - name of the server to route the request to; userId - calling user; callerGUID - unique identifier of the element that is making the call; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: unique identifier and properties of the relationship 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)

getProcessCallers

@PostMapping(path="/process-calls/called/{calledGUID}/callers/retrieve")
public ProcessCallElementsResponse getProcessCallers(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String calledGUID,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forLineage,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forDuplicateProcessing,
                                                     @RequestBody
                                                     EffectiveTimeQueryRequestBody requestBody)

Retrieve the process call relationships linked from a specific element to its callers.

Parameters:: serverName - name of the server to route the request to; userId - calling user; calledGUID - unique identifier of the element that is processing the call; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
Returns:: unique identifier and properties of the relationship 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)

setupLineageMapping

@PostMapping(path="/lineage-mappings/sources/{sourceElementGUID}/destinations/{destinationElementGUID}")
public VoidResponse setupLineageMapping(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String sourceElementGUID,
                                        @PathVariable
                                        String destinationElementGUID,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        RelationshipRequestBody requestBody)

Link to elements together to show that they are part of the lineage of the data that is moving between the processes. Typically, the lineage relationships stitch together processes and data assets supported by different technologies.

Parameters:: serverName - name of the server to route the request to; userId - calling user; sourceElementGUID - unique identifier of the source; destinationElementGUID - unique identifier of the destination; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

getLineageMapping

@PostMapping(path="/lineage-mappings/sources/{sourceElementGUID}/destinations/{destinationElementGUID}/retrieve")
public LineageMappingElementResponse getLineageMapping(@PathVariable
                                                       String serverName,
                                                       @PathVariable
                                                       String userId,
                                                       @PathVariable
                                                       String sourceElementGUID,
                                                       @PathVariable
                                                       String destinationElementGUID,
                                                       @RequestParam(required=false,defaultValue="false")
                                                       boolean forLineage,
                                                       @RequestParam(required=false,defaultValue="false")
                                                       boolean forDuplicateProcessing,
                                                       @RequestBody
                                                       NameRequestBody requestBody)

Retrieve the process call relationship between two elements. The qualifiedName is optional unless there is more than one process call relationships between these two elements since it is used to disambiguate the request. This is often used in conjunction with update.

Parameters:: serverName - name of the server to route the request to; userId - calling user; sourceElementGUID - unique identifier of the source; destinationElementGUID - unique identifier of the destination; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifier for this relationship
Returns:: unique identifier and properties of the relationship 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)

updateLineageMapping

@PostMapping(path="/lineage-mappings/{lineageMappingGUID}/update")
public VoidResponse updateLineageMapping(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String lineageMappingGUID,
                                         @RequestParam(required=false,defaultValue="false")
                                         boolean forLineage,
                                         @RequestParam(required=false,defaultValue="false")
                                         boolean forDuplicateProcessing,
                                         @RequestBody
                                         RelationshipRequestBody requestBody)

Remove the lineage mapping between two elements.

Parameters:: serverName - name of the server to route the request to; userId - calling user; lineageMappingGUID - unique identifier of the relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

clearLineageMapping

@PostMapping(path="/lineage-mappings/{lineageMappingGUID}/remove")
public VoidResponse clearLineageMapping(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String lineageMappingGUID,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forLineage,
                                        @RequestParam(required=false,defaultValue="false")
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        EffectiveTimeQueryRequestBody requestBody)

Remove the lineage mapping between two elements.

Parameters:: serverName - name of the server to route the request to; userId - calling user; lineageMappingGUID - unique identifier of the relationship; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

getDestinationLineageMappings

@PostMapping(path="/lineage-mappings/sources/{sourceElementGUID}/destinations/retrieve")
public LineageMappingElementsResponse getDestinationLineageMappings(@PathVariable
                                                                    String serverName,
                                                                    @PathVariable
                                                                    String userId,
                                                                    @PathVariable
                                                                    String sourceElementGUID,
                                                                    @RequestParam
                                                                    int startFrom,
                                                                    @RequestParam
                                                                    int pageSize,
                                                                    @RequestParam(required=false,defaultValue="false")
                                                                    boolean forLineage,
                                                                    @RequestParam(required=false,defaultValue="false")
                                                                    boolean forDuplicateProcessing,
                                                                    @RequestBody
                                                                    EffectiveTimeQueryRequestBody requestBody)

Retrieve the lineage mapping relationships linked from a specific source element to its destinations.

Parameters:: serverName - name of the server to route the request to; userId - calling user; sourceElementGUID - unique identifier of the source; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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)

getSourceLineageMappings

@PostMapping(path="/lineage-mappings/destinations/{destinationElementGUID}/sources/retrieve")
public LineageMappingElementsResponse getSourceLineageMappings(@PathVariable
                                                               String serverName,
                                                               @PathVariable
                                                               String userId,
                                                               @PathVariable
                                                               String destinationElementGUID,
                                                               @RequestParam
                                                               int startFrom,
                                                               @RequestParam
                                                               int pageSize,
                                                               @RequestParam(required=false,defaultValue="false")
                                                               boolean forLineage,
                                                               @RequestParam(required=false,defaultValue="false")
                                                               boolean forDuplicateProcessing,
                                                               @RequestBody
                                                               EffectiveTimeQueryRequestBody requestBody)

Retrieve the lineage mapping relationships linked from a specific destination element to its sources.

Parameters:: serverName - name of the server to route the request to; userId - calling user; destinationElementGUID - unique identifier of the destination; startFrom - paging start point; pageSize - maximum results that can be returned; forLineage - return elements marked with the Memento classification?; forDuplicateProcessing - do not merge elements marked as duplicates?; requestBody - unique identifiers of software server capability representing the caller (optional)
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 LineageExchangeResource

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LineageExchangeResource

Method Detail

createProcess

createProcessFromTemplate

updateProcess

updateProcessStatus

setupProcessParent

clearProcessParent

publishProcess

withdrawProcess

removeProcess

findProcesses

getProcessesForAssetManager

getProcessesByName

getProcessByGUID

getProcessParent

getSubProcesses

createPort

updatePort

setupProcessPort

clearProcessPort

setupPortDelegation

clearPortDelegation

setupPortSchemaType

clearPortSchemaType

removePort

findPorts

getPortsForProcess

getPortUse

getPortDelegation

getPortsByName

getPortByGUID

setBusinessSignificant

clearBusinessSignificant

setupDataFlow

getDataFlow

updateDataFlow

clearDataFlow

getDataFlowConsumers

getDataFlowSuppliers

setupControlFlow

getControlFlow

updateControlFlow

clearControlFlow

getControlFlowNextSteps

getControlFlowPreviousSteps

setupProcessCall

getProcessCall

updateProcessCall

clearProcessCall

getProcessCalled

getProcessCallers

setupLineageMapping

getLineageMapping

updateLineageMapping

clearLineageMapping

getDestinationLineageMappings

getSourceLineageMappings