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

Class ConnectionExchangeResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/asset-manager/users/{userId}")
public class ConnectionExchangeResource
extends Object
    ConnectionExchangeResource is the server-side implementation of the Asset Manager OMAS's support for connections, endpoints and connector types. It matches the ConnectionExchangeClient.

    • Constructor Detail

      • ConnectionExchangeResource

        public ConnectionExchangeResource()
        Default constructor

    • Method Detail

      • createConnection

        @PostMapping(path="/connections")
public GUIDResponse createConnection​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @RequestParam
                                     boolean assetManagerIsHome,
                                     @RequestBody
                                     ConnectionRequestBody requestBody)
        Create a new metadata element to represent the root of a connection.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this connection
        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)

      • createConnectionFromTemplate

        @PostMapping(path="/connections/from-template/{templateGUID}")
public GUIDResponse createConnectionFromTemplate​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @PathVariable
                                                 String templateGUID,
                                                 @RequestParam
                                                 boolean assetManagerIsHome,
                                                 @RequestBody
                                                 TemplateRequestBody requestBody)
        Create a new metadata element to represent a connection using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new connection.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        templateGUID - unique identifier of the metadata element to copy
        assetManagerIsHome - ensure that only the asset manager can update this connection
        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)

      • updateConnection

        @PostMapping(path="/connections/{connectionGUID}")
public VoidResponse updateConnection​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String connectionGUID,
                                     @RequestParam
                                     boolean isMergeUpdate,
                                     @RequestParam
                                     boolean forLineage,
                                     @RequestParam
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     ConnectionRequestBody requestBody)
        Update the metadata element representing an asset.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the metadata element to update
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • setupConnectorType

        @PostMapping(path="/connections/{connectionGUID}/connector-types/{connectorTypeGUID}")
public VoidResponse setupConnectorType​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String connectionGUID,
                                       @PathVariable
                                       String connectorTypeGUID,
                                       @RequestParam
                                       boolean assetManagerIsHome,
                                       @RequestParam
                                       boolean forLineage,
                                       @RequestParam
                                       boolean forDuplicateProcessing,
                                       @RequestBody
                                       RelationshipRequestBody requestBody)
        Create a relationship between a connection and a connector type.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the connection in the external asset manager
        connectorTypeGUID - unique identifier of the connector type in the external asset manager
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • clearConnectorType

        @PostMapping(path="/connections/{connectionGUID}/connector-types/{connectorTypeGUID}/remove")
public VoidResponse clearConnectorType​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String connectionGUID,
                                       @PathVariable
                                       String connectorTypeGUID,
                                       @RequestParam
                                       boolean forLineage,
                                       @RequestParam
                                       boolean forDuplicateProcessing,
                                       @RequestBody
                                       EffectiveTimeQueryRequestBody requestBody)
        Remove a relationship between a connection and a connector type.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the connection in the external asset manager
        connectorTypeGUID - unique identifier of the connector type in the external asset manager
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • setupEndpoint

        @PostMapping(path="/connections/{connectionGUID}/endpoints/{endpointGUID}")
public VoidResponse setupEndpoint​(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String connectionGUID,
                                  @PathVariable
                                  String endpointGUID,
                                  @RequestParam
                                  boolean assetManagerIsHome,
                                  @RequestParam
                                  boolean forLineage,
                                  @RequestParam
                                  boolean forDuplicateProcessing,
                                  @RequestBody
                                  RelationshipRequestBody requestBody)
        Create a relationship between a connection and an endpoint.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the connection in the external asset manager
        endpointGUID - unique identifier of the endpoint in the external asset manager
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • clearEndpoint

        @PostMapping(path="/connections/{connectionGUID}/endpoints/{endpointGUID}/remove")
public VoidResponse clearEndpoint​(@PathVariable
                                  String serverName,
                                  @PathVariable
                                  String userId,
                                  @PathVariable
                                  String connectionGUID,
                                  @PathVariable
                                  String endpointGUID,
                                  @RequestParam
                                  boolean forLineage,
                                  @RequestParam
                                  boolean forDuplicateProcessing,
                                  @RequestBody
                                  EffectiveTimeQueryRequestBody requestBody)
        Remove a relationship between a connection and an endpoint.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the connection in the external asset manager
        endpointGUID - unique identifier of the endpoint in the external asset manager
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • setupEmbeddedConnection

        @PostMapping(path="/connections/{connectionGUID}/embedded-connections/{embeddedConnectionGUID}")
public VoidResponse setupEmbeddedConnection​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String connectionGUID,
                                            @PathVariable
                                            String embeddedConnectionGUID,
                                            @RequestParam
                                            boolean assetManagerIsHome,
                                            @RequestParam
                                            boolean forLineage,
                                            @RequestParam
                                            boolean forDuplicateProcessing,
                                            @RequestBody
                                            RelationshipRequestBody requestBody)
        Create a relationship between a virtual connection and an embedded connection.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the virtual connection in the external asset manager
        embeddedConnectionGUID - unique identifier of the embedded connection in the external asset manager
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • clearEmbeddedConnection

        @PostMapping(path="/connections/{connectionGUID}/embedded-connections/{embeddedConnectionGUID}/remove")
public VoidResponse clearEmbeddedConnection​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String connectionGUID,
                                            @PathVariable
                                            String embeddedConnectionGUID,
                                            @RequestParam
                                            boolean forLineage,
                                            @RequestParam
                                            boolean forDuplicateProcessing,
                                            @RequestBody
                                            EffectiveTimeQueryRequestBody requestBody)
        Remove a relationship between a virtual connection and an embedded connection.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the virtual connection in the external asset manager
        embeddedConnectionGUID - unique identifier of the embedded connection in the external asset manager
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • setupAssetConnection

        @PostMapping(path="/data-assets/{assetGUID}/connections/{connectionGUID}")
public VoidResponse setupAssetConnection​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String assetGUID,
                                         @PathVariable
                                         String connectionGUID,
                                         @RequestParam
                                         boolean assetManagerIsHome,
                                         @RequestParam
                                         boolean forLineage,
                                         @RequestParam
                                         boolean forDuplicateProcessing,
                                         @RequestBody
                                         RelationshipRequestBody requestBody)
        Create a relationship between an asset and its connection.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this relationship
        assetGUID - unique identifier of the asset
        connectionGUID - unique identifier of the connection
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • clearAssetConnection

        @PostMapping(path="/data-assets/{assetGUID}/connections/{connectionGUID}/remove")
public VoidResponse clearAssetConnection​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String assetGUID,
                                         @PathVariable
                                         String connectionGUID,
                                         @RequestParam
                                         boolean forLineage,
                                         @RequestParam
                                         boolean forDuplicateProcessing,
                                         @RequestBody
                                         EffectiveTimeQueryRequestBody requestBody)
        Remove a relationship between an asset and its connection.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetGUID - unique identifier of the asset
        connectionGUID - unique identifier of the connection
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • removeConnection

        @PostMapping(path="/connections/{connectionGUID}/remove")
public VoidResponse removeConnection​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String connectionGUID,
                                     @RequestParam
                                     boolean forLineage,
                                     @RequestParam
                                     boolean forDuplicateProcessing,
                                     @RequestBody
                                     UpdateRequestBody requestBody)
        Remove the metadata element representing a connection. This will delete the connection and all anchored elements such as schema and comments.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the metadata element to remove
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for query
        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)

      • findConnections

        @PostMapping(path="/connections/by-search-string")
public ConnectionsResponse findConnections​(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @RequestParam
                                           int startFrom,
                                           @RequestParam
                                           int pageSize,
                                           @RequestParam
                                           boolean forLineage,
                                           @RequestParam
                                           boolean forDuplicateProcessing,
                                           @RequestBody
                                           SearchStringRequestBody requestBody)
        Retrieve the list of connection metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getConnectionsByName

        @PostMapping(path="/connections/by-name")
public ConnectionsResponse getConnectionsByName​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @RequestParam
                                                int startFrom,
                                                @RequestParam
                                                int pageSize,
                                                @RequestParam
                                                boolean forLineage,
                                                @RequestParam
                                                boolean forDuplicateProcessing,
                                                @RequestBody
                                                NameRequestBody requestBody)
        Retrieve the list of connection metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getConnectionsForAssetManager

        @PostMapping(path="/connections/by-asset-manager")
public ConnectionsResponse getConnectionsForAssetManager​(@PathVariable
                                                         String serverName,
                                                         @PathVariable
                                                         String userId,
                                                         @RequestParam
                                                         int startFrom,
                                                         @RequestParam
                                                         int pageSize,
                                                         @RequestParam
                                                         boolean forLineage,
                                                         @RequestParam
                                                         boolean forDuplicateProcessing,
                                                         @RequestBody
                                                         EffectiveTimeQueryRequestBody requestBody)
        Retrieve the list of connections created on behalf of the named asset manager.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getConnectionByGUID

        @PostMapping(path="/connections/{connectionGUID}/retrieve")
public ConnectionResponse getConnectionByGUID​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String connectionGUID,
                                              @RequestParam
                                              boolean forLineage,
                                              @RequestParam
                                              boolean forDuplicateProcessing,
                                              @RequestBody
                                              EffectiveTimeQueryRequestBody requestBody)
        Retrieve the connection metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectionGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • createEndpoint

        @PostMapping(path="/endpoints")
public GUIDResponse createEndpoint​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @RequestParam
                                   boolean assetManagerIsHome,
                                   @RequestBody
                                   EndpointRequestBody requestBody)
        Create a new metadata element to represent a network endpoint.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this endpoint
        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)

      • createEndpointFromTemplate

        @PostMapping(path="/endpoints/from-template/{templateGUID}")
public GUIDResponse createEndpointFromTemplate​(@PathVariable
                                               String serverName,
                                               @PathVariable
                                               String userId,
                                               @PathVariable
                                               String templateGUID,
                                               @RequestParam
                                               boolean assetManagerIsHome,
                                               @RequestBody
                                               TemplateRequestBody requestBody)
        Create a new metadata element to represent a network endpoint using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new endpoint.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this endpoint
        templateGUID - unique identifier of the metadata element to copy
        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)

      • updateEndpoint

        @PostMapping(path="/endpoints/{endpointGUID}")
public VoidResponse updateEndpoint​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String endpointGUID,
                                   @RequestParam
                                   boolean isMergeUpdate,
                                   @RequestParam
                                   boolean forLineage,
                                   @RequestParam
                                   boolean forDuplicateProcessing,
                                   @RequestBody
                                   EndpointRequestBody requestBody)
        Update the metadata element representing an asset.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        endpointGUID - unique identifier of the metadata element to update
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • removeEndpoint

        @PostMapping(path="/endpoints/{endpointGUID}/remove")
public VoidResponse removeEndpoint​(@PathVariable
                                   String serverName,
                                   @PathVariable
                                   String userId,
                                   @PathVariable
                                   String endpointGUID,
                                   @RequestParam
                                   boolean forLineage,
                                   @RequestParam
                                   boolean forDuplicateProcessing,
                                   @RequestBody
                                   UpdateRequestBody requestBody)
        Remove the metadata element representing a network endpoint. This will delete the endpoint and all anchored elements such as schema and comments.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        endpointGUID - unique identifier of the metadata element to remove
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for query
        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)

      • findEndpoints

        @PostMapping(path="/endpoints/by-search-string")
public EndpointsResponse findEndpoints​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @RequestParam
                                       int startFrom,
                                       @RequestParam
                                       int pageSize,
                                       @RequestParam
                                       boolean forLineage,
                                       @RequestParam
                                       boolean forDuplicateProcessing,
                                       @RequestBody
                                       SearchStringRequestBody requestBody)
        Retrieve the list of network endpoint metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getEndpointsByName

        @PostMapping(path="/endpoints/by-name")
public EndpointsResponse getEndpointsByName​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @RequestParam
                                            int startFrom,
                                            @RequestParam
                                            int pageSize,
                                            @RequestParam
                                            boolean forLineage,
                                            @RequestParam
                                            boolean forDuplicateProcessing,
                                            @RequestBody
                                            NameRequestBody requestBody)
        Retrieve the list of network endpoint metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getEndpointsForAssetManager

        @PostMapping(path="/endpoints/by-asset-manager")
public EndpointsResponse getEndpointsForAssetManager​(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize,
                                                     @RequestParam
                                                     boolean forLineage,
                                                     @RequestParam
                                                     boolean forDuplicateProcessing,
                                                     @RequestBody
                                                     EffectiveTimeQueryRequestBody requestBody)
        Retrieve the list of endpoints created on behalf of the named asset manager.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • getEndpointByGUID

        @PostMapping(path="/endpoints/{endpointGUID}/retrieve")
public EndpointResponse getEndpointByGUID​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String endpointGUID,
                                          @RequestParam
                                          boolean forLineage,
                                          @RequestParam
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          EffectiveTimeQueryRequestBody requestBody)
        Retrieve the network endpoint metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        endpointGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • createConnectorType

        @PostMapping(path="/connector-types")
public GUIDResponse createConnectorType​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @RequestParam
                                        boolean assetManagerIsHome,
                                        @RequestBody
                                        ConnectorTypeRequestBody requestBody)
        Create a new metadata element to represent the root of an asset.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the asset manager can update this asset
        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)

      • createConnectorTypeFromTemplate

        @PostMapping(path="/connector-types/from-template/{templateGUID}")
public GUIDResponse createConnectorTypeFromTemplate​(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String templateGUID,
                                                    @RequestParam
                                                    boolean assetManagerIsHome,
                                                    @RequestBody
                                                    TemplateRequestBody requestBody)
        Create a new metadata element to represent an asset using an existing metadata element as a template. The template defines additional classifications and relationships that should be added to the new asset.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        templateGUID - unique identifier of the metadata element to copy
        assetManagerIsHome - ensure that only the asset manager can update this asset
        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)

      • updateConnectorType

        @PostMapping(path="/connector-types/{connectorTypeGUID}")
public VoidResponse updateConnectorType​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String connectorTypeGUID,
                                        @RequestParam
                                        boolean isMergeUpdate,
                                        @RequestParam
                                        boolean forLineage,
                                        @RequestParam
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        ConnectorTypeRequestBody requestBody)
        Update the metadata element representing an asset.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectorTypeGUID - unique identifier of the metadata element to update
        isMergeUpdate - should the new properties be merged with existing properties (true) or completely replace them (false)?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • removeConnectorType

        @PostMapping(path="/connector-types/{connectorTypeGUID}/remove")
public VoidResponse removeConnectorType​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String connectorTypeGUID,
                                        @RequestParam
                                        boolean forLineage,
                                        @RequestParam
                                        boolean forDuplicateProcessing,
                                        @RequestBody
                                        UpdateRequestBody requestBody)
        Remove the metadata element representing an asset. This will delete the asset and all anchored elements such as schema and comments.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectorTypeGUID - unique identifier of the metadata element to remove
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • findConnectorTypes

        @PostMapping(path="/connector-types/by-search-string")
public ConnectorTypesResponse findConnectorTypes​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize,
                                                 @RequestParam
                                                 boolean forLineage,
                                                 @RequestParam
                                                 boolean forDuplicateProcessing,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody)
        Retrieve the list of connector type metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getConnectorTypesByName

        @PostMapping(path="/connector-types/by-name")
public ConnectorTypesResponse getConnectorTypesByName​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize,
                                                      @RequestParam
                                                      boolean forLineage,
                                                      @RequestParam
                                                      boolean forDuplicateProcessing,
                                                      @RequestBody
                                                      NameRequestBody requestBody)
        Retrieve the list of connector type metadata elements with a matching qualified or display name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties to store
        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)

      • getConnectorTypesForAssetManager

        @PostMapping(path="/connector-types/by-asset-manager")
public ConnectorTypesResponse getConnectorTypesForAssetManager​(@PathVariable
                                                               String serverName,
                                                               @PathVariable
                                                               String userId,
                                                               @RequestParam
                                                               int startFrom,
                                                               @RequestParam
                                                               int pageSize,
                                                               @RequestParam
                                                               boolean forLineage,
                                                               @RequestParam
                                                               boolean forDuplicateProcessing,
                                                               @RequestBody
                                                               EffectiveTimeQueryRequestBody requestBody)
        Retrieve the list of assets created on behalf of the named asset manager.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)

      • getConnectorTypeByGUID

        @PostMapping(path="/connector-types/{connectorTypeGUID}/retrieve")
public ConnectorTypeResponse getConnectorTypeByGUID​(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String connectorTypeGUID,
                                                    @RequestParam
                                                    boolean forLineage,
                                                    @RequestParam
                                                    boolean forDuplicateProcessing,
                                                    @RequestBody
                                                    EffectiveTimeQueryRequestBody requestBody)
        Retrieve the connector type metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        connectorTypeGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - properties for 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)