Package org.odpi.openmetadata.accessservices.itinfrastructure.server.spring

Class ITAssetResource

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 Details

    • ITAssetResource

      public ITAssetResource()
      Default constructor

  • Method Details

    • 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 EffectiveTimeQueryRequestBody 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 EffectiveTimeQueryRequestBody 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 ExternalSourceRequestBody 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 AssetElementsResponse 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 AssetElementsResponse 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)

    • getAssetsByDeployedImplementationType

      @PostMapping(path="/assets/{assetTypeName}/by-deployed-implementation-type") public AssetElementsResponse getAssetsByDeployedImplementationType(@PathVariable String serverName, @PathVariable String userId, @PathVariable String assetTypeName, @RequestParam int startFrom, @RequestParam int pageSize, @RequestBody(required=false) NameRequestBody requestBody)
      Retrieve the list of asset metadata elements with a matching deployed implementation type. 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 AssetElementsResponse getAssetsForInfrastructureManager(@PathVariable String serverName, @PathVariable String userId, @PathVariable String infrastructureManagerGUID, @PathVariable String infrastructureManagerName, @PathVariable String assetTypeName, @RequestParam int startFrom, @RequestParam int pageSize, @RequestBody ResultsRequestBody 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 AssetElementResponse getAssetByGUID(@PathVariable String serverName, @PathVariable String userId, @PathVariable String assetTypeName, @PathVariable String assetGUID, @RequestBody ResultsRequestBody 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 AssetRelationshipsResponse 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 ResultsRequestBody 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 RelatedAssetsResponse 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 ResultsRequestBody 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 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
      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 ResultsRequestBody 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 ResultsRequestBody 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 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
      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 ResultsRequestBody 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 ResultsRequestBody 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 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
      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 ResultsRequestBody 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 ResultsRequestBody 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)
      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
      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)

    • clearLineageMapping

      @PostMapping(path="/lineage-mappings/{lineageMappingGUID}/remove") public VoidResponse clearLineageMapping(@PathVariable String serverName, @PathVariable String userId, @PathVariable String lineageMappingGUID, @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
      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, @RequestBody ResultsRequestBody 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
      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, @RequestBody ResultsRequestBody 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
      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)