java.lang.Object
- org.odpi.openmetadata.accessservices.itinfrastructure.server.spring.ITAssetResource

@RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/it-infrastructure/users/{userId}")
public class ITAssetResource
extends Object

ITAssetResource is the server-side of AssetManagerClientBase. It is called from the specific clients that manage the specializations of IT Infrastructure assets.

Constructor Summary

Constructors
Constructor Description

ITAssetResource()
Default constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`VoidResponse`	`addClassification(String serverName, String userId, String assetTypeName, String assetGUID, String classificationName, boolean infrastructureManagerIsHome, AssetExtensionsRequestBody requestBody)`	Add a classification to an asset.
`VoidResponse`	`clearClassification(String serverName, String userId, String assetTypeName, String assetGUID, String classificationName, EffectiveTimeMetadataSourceRequestBody requestBody)`	Remove a classification from an asset.
`VoidResponse`	`clearControlFlow(String serverName, String userId, String controlFlowGUID, EffectiveTimeMetadataSourceRequestBody requestBody)`	Remove the control flow relationship between two elements.
`VoidResponse`	`clearDataFlow(String serverName, String userId, String dataFlowGUID, EffectiveTimeMetadataSourceRequestBody requestBody)`	Remove the data flow relationship between two elements.
`VoidResponse`	`clearLineageMapping(String serverName, String userId, String lineageMappingGUID, EffectiveTimeMetadataSourceRequestBody requestBody)`	Remove the lineage mapping between two elements.
`VoidResponse`	`clearProcessCall(String serverName, String userId, String processCallGUID, EffectiveTimeMetadataSourceRequestBody requestBody)`	Remove the process call relationship.
`VoidResponse`	`clearRelatedAsset(String serverName, String userId, String assetTypeName, String assetGUID, String relationshipTypeName, String relatedAssetTypeName, String relatedAssetGUID, EffectiveTimeMetadataSourceRequestBody requestBody)`	Remove a relationship between an asset and a related asset.
`GUIDResponse`	`createAsset(String serverName, String userId, boolean infrastructureManagerIsHome, AssetRequestBody requestBody)`	Create a new metadata element to represent an asset.
`GUIDResponse`	`createAssetFromTemplate(String serverName, String userId, String templateGUID, boolean infrastructureManagerIsHome, TemplateRequestBody requestBody)`	Create a new metadata element to represent an asset using an existing metadata element as a template.
`AssetListResponse`	`findAssets(String serverName, String userId, String assetTypeName, int startFrom, int pageSize, SearchStringRequestBody requestBody)`	Retrieve the list of asset metadata elements that contain the search string.
`AssetResponse`	`getAssetByGUID(String serverName, String userId, String assetTypeName, String assetGUID, EffectiveTimeRequestBody requestBody)`	Retrieve the asset metadata element with the supplied unique identifier.
`AssetRelationshipListResponse`	`getAssetRelationships(String serverName, String userId, String assetTypeName, String assetGUID, String relationshipTypeName, String relatedAssetTypeName, int startingEnd, int startFrom, int pageSize, EffectiveTimeRequestBody requestBody)`	Return the list of relationships between assets.
`AssetListResponse`	`getAssetsByName(String serverName, String userId, String assetTypeName, int startFrom, int pageSize, NameRequestBody requestBody)`	Retrieve the list of asset metadata elements with a matching qualified or display name.
`AssetListResponse`	`getAssetsForInfrastructureManager(String serverName, String userId, String infrastructureManagerGUID, String infrastructureManagerName, String assetTypeName, int startFrom, int pageSize, EffectiveTimeRequestBody requestBody)`	Retrieve the list of assets created by this caller.
`ControlFlowElementResponse`	`getControlFlow(String serverName, String userId, String currentStepGUID, String nextStepGUID, NameRequestBody requestBody)`	Retrieve the control flow relationship between two elements.
`ControlFlowElementsResponse`	`getControlFlowNextSteps(String serverName, String userId, String currentStepGUID, int startFrom, int pageSize, EffectiveTimeRequestBody 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, EffectiveTimeRequestBody 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, NameRequestBody requestBody)`	Retrieve the data flow relationship between two elements.
`DataFlowElementsResponse`	`getDataFlowConsumers(String serverName, String userId, String dataSupplierGUID, int startFrom, int pageSize, EffectiveTimeRequestBody 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, EffectiveTimeRequestBody 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, EffectiveTimeRequestBody 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, NameRequestBody requestBody)`	Retrieve the process call relationship between two elements.
`ProcessCallElementResponse`	`getProcessCall(String serverName, String userId, String callerGUID, String calledGUID, NameRequestBody requestBody)`	Retrieve the process call relationship between two elements.
`ProcessCallElementsResponse`	`getProcessCalled(String serverName, String userId, String callerGUID, int startFrom, int pageSize, EffectiveTimeRequestBody 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, EffectiveTimeRequestBody requestBody)`	Retrieve the process call relationships linked from a specific element to its callers.
`RelatedAssetListResponse`	`getRelatedAssets(String serverName, String userId, String assetTypeName, String assetGUID, String relationshipTypeName, String relatedAssetTypeName, int startingEnd, int startFrom, int pageSize, EffectiveTimeRequestBody requestBody)`	Return the list of assets linked by another asset.
`LineageMappingElementsResponse`	`getSourceLineageMappings(String serverName, String userId, String destinationElementGUID, int startFrom, int pageSize, EffectiveTimeRequestBody requestBody)`	Retrieve the lineage mapping relationships linked from a specific destination element to its sources.
`VoidResponse`	`publishAsset(String serverName, String userId, String assetGUID, NullRequestBody requestBody)`	Update the zones for the asset so that it becomes visible to consumers.
`VoidResponse`	`removeAsset(String serverName, String userId, String assetGUID, MetadataSourceRequestBody requestBody)`	Remove the metadata element representing an asset.
`GUIDResponse`	`setupControlFlow(String serverName, String userId, String currentStepGUID, String nextStepGUID, boolean infrastructureManagerIsHome, ControlFlowRequestBody 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 infrastructureManagerIsHome, DataFlowRequestBody 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, LineageMappingRequestBody requestBody)`	Link to elements together to show that they are part of the lineage of the data that is moving between the processes.
`GUIDResponse`	`setupProcessCall(String serverName, String userId, String callerGUID, String calledGUID, boolean infrastructureManagerIsHome, ProcessCallRequestBody requestBody)`	Link two elements together to show a request-response call between them.
`VoidResponse`	`setupRelatedAsset(String serverName, String userId, String assetTypeName, String assetGUID, String relationshipTypeName, String relatedAssetTypeName, String relatedAssetGUID, boolean infrastructureManagerIsHome, AssetExtensionsRequestBody requestBody)`	Create a relationship between an asset and a related asset.
`VoidResponse`	`updateAsset(String serverName, String userId, String assetGUID, boolean isMergeUpdate, AssetRequestBody requestBody)`	Update the metadata element representing an asset.
`VoidResponse`	`updateAssetRelationship(String serverName, String userId, String relationshipTypeName, String relationshipGUID, boolean isMergeUpdate, AssetExtensionsRequestBody requestBody)`	Update a relationship between an asset and a related asset.
`VoidResponse`	`updateAssetStatus(String serverName, String userId, String assetTypeName, String assetGUID, ElementStatusRequestBody requestBody)`	Update the status of the metadata element representing an asset.
`VoidResponse`	`updateClassification(String serverName, String userId, String assetTypeName, String assetGUID, String classificationName, boolean isMergeUpdate, AssetExtensionsRequestBody requestBody)`	Update the properties of a classification for an asset.
`VoidResponse`	`updateControlFlow(String serverName, String userId, String controlFlowGUID, ControlFlowRequestBody 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, DataFlowRequestBody requestBody)`	Update relationship between two elements that shows that data flows from one to the other.
`VoidResponse`	`updateProcessCall(String serverName, String userId, String processCallGUID, ProcessCallRequestBody requestBody)`	Update the relationship between two elements that shows a request-response call between them.
`VoidResponse`	`withdrawAsset(String serverName, String userId, String assetGUID, NullRequestBody requestBody)`	Update the zones for the asset 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
- ITAssetResource
```
public ITAssetResource()
```
  Default constructor

Method Detail

createAsset
```
@PostMapping(path="/assets")
public GUIDResponse createAsset(@PathVariable
                                String serverName,
                                @PathVariable
                                String userId,
                                @RequestParam
                                boolean infrastructureManagerIsHome,
                                @RequestBody
                                AssetRequestBody requestBody)
```
Create a new metadata element to represent an asset.

Parameters:

serverName - name of the server to route the request to.

userId - calling user

infrastructureManagerIsHome - should the asset be marked as owned by the infrastructure manager so others can not update?

requestBody - properties to store

Returns:

unique identifier of the new 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)

createAssetFromTemplate

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

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

Parameters:: serverName - name of the server to route the request to.; userId - calling user; infrastructureManagerIsHome - should the asset be marked as owned by the infrastructure manager so others can not update?; templateGUID - unique identifier of the metadata element to copy; requestBody - properties that override the template
Returns:: unique identifier of the new 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)

updateAsset

@PostMapping(path="/assets/{assetGUID}")
public VoidResponse updateAsset(@PathVariable
                                String serverName,
                                @PathVariable
                                String userId,
                                @PathVariable
                                String assetGUID,
                                @RequestParam
                                boolean isMergeUpdate,
                                @RequestBody
                                AssetRequestBody requestBody)

Update the metadata element representing an asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetGUID - unique identifier of the metadata element to update; isMergeUpdate - are unspecified properties unchanged (true) or removed?; requestBody - new properties for this 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)

updateAssetStatus

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/status")
public VoidResponse updateAssetStatus(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String assetTypeName,
                                      @PathVariable
                                      String assetGUID,
                                      @RequestBody
                                      ElementStatusRequestBody requestBody)

Update the status of the metadata element representing an asset.

Parameters:: serverName - name of the server to route the request to; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset to update; 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)

setupRelatedAsset

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/{relationshipTypeName}/{relatedAssetTypeName}/{relatedAssetGUID}")
public VoidResponse setupRelatedAsset(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String assetTypeName,
                                      @PathVariable
                                      String assetGUID,
                                      @PathVariable
                                      String relationshipTypeName,
                                      @PathVariable
                                      String relatedAssetTypeName,
                                      @PathVariable
                                      String relatedAssetGUID,
                                      @RequestParam
                                      boolean infrastructureManagerIsHome,
                                      @RequestBody
                                      AssetExtensionsRequestBody requestBody)

Create a relationship between an asset and a related asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset; relationshipTypeName - name of the relationship type; relatedAssetTypeName - name of type for the asset; relatedAssetGUID - unique identifier of the related asset; infrastructureManagerIsHome - ensure that only the infrastructure manager can update this asset; requestBody - properties
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

updateAssetRelationship

@PostMapping(path="/assets/relationships/{relationshipTypeName}/{relationshipGUID}/update")
public VoidResponse updateAssetRelationship(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String relationshipTypeName,
                                            @PathVariable
                                            String relationshipGUID,
                                            @RequestParam
                                            boolean isMergeUpdate,
                                            @RequestBody
                                            AssetExtensionsRequestBody requestBody)

Update a relationship between an asset and a related asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; relationshipTypeName - name of the relationship type; relationshipGUID - unique identifier of the asset; isMergeUpdate - should the supplied properties be merged with existing properties (true) by replacing just the properties with matching names, or should the entire properties of the instance be replaced?; requestBody - new properties
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

clearRelatedAsset

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/{relationshipTypeName}/{relatedAssetTypeName}/{relatedAssetGUID}/delete")
public VoidResponse clearRelatedAsset(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String assetTypeName,
                                      @PathVariable
                                      String assetGUID,
                                      @PathVariable
                                      String relationshipTypeName,
                                      @PathVariable
                                      String relatedAssetTypeName,
                                      @PathVariable
                                      String relatedAssetGUID,
                                      @RequestBody
                                      EffectiveTimeMetadataSourceRequestBody requestBody)

Remove a relationship between an asset and a related asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset; relationshipTypeName - name of the relationship type; relatedAssetTypeName - name of type for the asset; relatedAssetGUID - unique identifier of the related asset; requestBody - unique identifier/name of software server capability representing the infrastructure manager
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)

addClassification

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/classify/{classificationName}")
public VoidResponse addClassification(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String assetTypeName,
                                      @PathVariable
                                      String assetGUID,
                                      @PathVariable
                                      String classificationName,
                                      @RequestParam
                                      boolean infrastructureManagerIsHome,
                                      @RequestBody
                                      AssetExtensionsRequestBody requestBody)

Add a classification to an asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset; classificationName - name of the classification type; infrastructureManagerIsHome - ensure that only the infrastructure manager can update this asset; requestBody - properties
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

updateClassification

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/reclassify/{classificationName}")
public VoidResponse updateClassification(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String assetTypeName,
                                         @PathVariable
                                         String assetGUID,
                                         @PathVariable
                                         String classificationName,
                                         @RequestParam
                                         boolean isMergeUpdate,
                                         @RequestBody
                                         AssetExtensionsRequestBody requestBody)

Update the properties of a classification for an asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset; classificationName - name of the classification type; isMergeUpdate - should the supplied properties be merged with existing properties (true) by replacing just the properties with matching names, or should the entire properties of the instance be replaced?; requestBody - properties
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

clearClassification

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/declassify/{classificationName}")
public VoidResponse clearClassification(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String assetTypeName,
                                        @PathVariable
                                        String assetGUID,
                                        @PathVariable
                                        String classificationName,
                                        @RequestBody
                                        EffectiveTimeMetadataSourceRequestBody requestBody)

Remove a classification from an asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset; classificationName - name of the classification type; requestBody - properties
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

publishAsset
```
@PostMapping(path="/assets/{assetGUID}/publish")
public VoidResponse publishAsset(@PathVariable
                                 String serverName,
                                 @PathVariable
                                 String userId,
                                 @PathVariable
                                 String assetGUID,
                                 @RequestBody(required=false)
                                 NullRequestBody requestBody)
```
Update the zones for the asset 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 IT Infrastructure OMAS).

Parameters:

serverName - name of the server to route the request to.

userId - calling user

assetGUID - unique identifier of the metadata element to publish

requestBody - null request body

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)

withdrawAsset
```
@PostMapping(path="/assets/{assetGUID}/withdraw")
public VoidResponse withdrawAsset(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String assetGUID,
                                  @RequestBody(required=false)
                                  NullRequestBody requestBody)
```
Update the zones for the asset 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 IT Infrastructure OMAS. This is the setting when the asset is first created).

Parameters:

serverName - name of the server to route the request to.

userId - calling user

assetGUID - unique identifier of the metadata element to withdraw

requestBody - null request body

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)

removeAsset

@PostMapping(path="/assets/{assetGUID}/delete")
public VoidResponse removeAsset(@PathVariable
                                String serverName,
                                @PathVariable
                                String userId,
                                @PathVariable
                                String assetGUID,
                                @RequestBody
                                MetadataSourceRequestBody requestBody)

Remove the metadata element representing an asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetGUID - unique identifier of the metadata element to remove; requestBody - unique identifier/name of software server capability representing the infrastructure manager
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)

findAssets

@PostMapping(path="/assets/{assetTypeName}/by-search-string")
public AssetListResponse findAssets(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String assetTypeName,
                                    @RequestParam
                                    int startFrom,
                                    @RequestParam
                                    int pageSize,
                                    @RequestBody
                                    SearchStringRequestBody requestBody)

Retrieve the list of asset 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; assetTypeName - name of type for the asset; startFrom - paging start point; pageSize - maximum results that can be returned; 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)

getAssetsByName

@PostMapping(path="/assets/{assetTypeName}/by-name")
public AssetListResponse getAssetsByName(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String assetTypeName,
                                         @RequestParam
                                         int startFrom,
                                         @RequestParam
                                         int pageSize,
                                         @RequestBody
                                         NameRequestBody requestBody)

Retrieve the list of asset 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; assetTypeName - name of type for the asset; startFrom - paging start point; pageSize - maximum results that can be returned; 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)

getAssetsForInfrastructureManager

@PostMapping(path="/infrastructure-managers/{infrastructureManagerGUID}/{infrastructureManagerName}/assets/{assetTypeName}")
public AssetListResponse getAssetsForInfrastructureManager(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String infrastructureManagerGUID,
                                                           @PathVariable
                                                           String infrastructureManagerName,
                                                           @PathVariable
                                                           String assetTypeName,
                                                           @RequestParam
                                                           int startFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestBody
                                                           EffectiveTimeRequestBody requestBody)

Retrieve the list of assets created by this caller.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; infrastructureManagerGUID - unique identifier of software server capability representing the infrastructure manager; infrastructureManagerName - unique name of software server capability representing the infrastructure manager; assetTypeName - name of type for the asset; startFrom - paging start point; pageSize - maximum results that can be returned; requestBody - effective time for the query
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)

getAssetByGUID

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}")
public AssetResponse getAssetByGUID(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String assetTypeName,
                                    @PathVariable
                                    String assetGUID,
                                    @RequestBody
                                    EffectiveTimeRequestBody requestBody)

Retrieve the asset metadata element with the supplied unique identifier.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the requested metadata element; requestBody - effective time for the query
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)

getAssetRelationships

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/{relationshipTypeName}/{relatedAssetTypeName}/relationships")
public AssetRelationshipListResponse getAssetRelationships(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String assetTypeName,
                                                           @PathVariable
                                                           String assetGUID,
                                                           @PathVariable
                                                           String relationshipTypeName,
                                                           @PathVariable
                                                           String relatedAssetTypeName,
                                                           @RequestParam
                                                           int startingEnd,
                                                           @RequestParam
                                                           int startFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestBody
                                                           EffectiveTimeRequestBody requestBody)

Return the list of relationships between assets.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset to start with; startingEnd - which end of the relationship to start at 0=either end; 1=end1 and 2=end 2; relationshipTypeName - name of type for the relationship; relatedAssetTypeName - name of type of retrieved assets; startFrom - paging start point; pageSize - maximum results that can be returned; requestBody - effective time for the query
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)

getRelatedAssets

@PostMapping(path="/assets/{assetTypeName}/{assetGUID}/{relationshipTypeName}/{relatedAssetTypeName}")
public RelatedAssetListResponse getRelatedAssets(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String assetTypeName,
                                                 @PathVariable
                                                 String assetGUID,
                                                 @PathVariable
                                                 String relationshipTypeName,
                                                 @PathVariable
                                                 String relatedAssetTypeName,
                                                 @RequestParam
                                                 int startingEnd,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize,
                                                 @RequestBody
                                                 EffectiveTimeRequestBody requestBody)

Return the list of assets linked by another asset.

Parameters:: serverName - name of the server to route the request to.; userId - calling user; assetTypeName - name of type for the asset; assetGUID - unique identifier of the asset to start with; startingEnd - which end of the relationship to start at 0=either end; 1=end1 and 2=end 2; relationshipTypeName - name of type for the relationship; relatedAssetTypeName - name of type of retrieved assets; startFrom - paging start point; pageSize - maximum results that can be returned; requestBody - effective time for the query
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)

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 infrastructureManagerIsHome,
                                  @RequestBody
                                  DataFlowRequestBody 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; infrastructureManagerIsHome - ensure that only the process manager can update this process; 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,
                                           @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; 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,
                                   @RequestBody
                                   DataFlowRequestBody 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; 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,
                                  @RequestBody
                                  EffectiveTimeMetadataSourceRequestBody 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; 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,
                                                     @RequestBody
                                                     EffectiveTimeRequestBody 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; 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,
                                                     @RequestBody
                                                     EffectiveTimeRequestBody 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; 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 infrastructureManagerIsHome,
                                     @RequestBody
                                     ControlFlowRequestBody 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; infrastructureManagerIsHome - ensure that only the process manager can update this process; 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,
                                                 @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; 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,
                                      @RequestBody
                                      ControlFlowRequestBody 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; 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,
                                     @RequestBody
                                     EffectiveTimeMetadataSourceRequestBody 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; requestBody - effective time and external identifiers
Returns:: void or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

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,
                                                           @RequestBody
                                                           EffectiveTimeRequestBody 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; requestBody - null request body
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,
                                                               @RequestBody
                                                               EffectiveTimeRequestBody 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; requestBody - unique identifiers of software server capability representing the caller (optional); startFrom - paging start point; pageSize - maximum results that can be returned
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 infrastructureManagerIsHome,
                                     @RequestBody
                                     ProcessCallRequestBody 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; infrastructureManagerIsHome - ensure that only the process manager can update this process; 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,
                                                 @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; requestBody - qualified name to disambiguate request
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,
                                      @RequestBody
                                      ProcessCallRequestBody 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; 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,
                                     @RequestBody
                                     EffectiveTimeMetadataSourceRequestBody 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; 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,
                                                    @RequestBody
                                                    EffectiveTimeRequestBody 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; 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,
                                                     @RequestBody
                                                     EffectiveTimeRequestBody 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; 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,
                                        @RequestBody
                                        LineageMappingRequestBody 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; 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,
                                                       @RequestBody
                                                       NameRequestBody requestBody)