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

Class DataAssetExchangeResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/asset-manager/users/{userId}")
public class DataAssetExchangeResource
extends Object
    DataAssetExchangeResource is the server-side implementation of the Asset Manager OMAS's support for data asset such as data sets. It matches the DataAssetExchangeClient.

    • Constructor Detail

      • DataAssetExchangeResource

        public DataAssetExchangeResource()
        Default constructor

    • Method Detail

      • createDataAsset

        @PostMapping(path="/data-assets")
public GUIDResponse createDataAsset​(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @RequestParam
                                    boolean assetManagerIsHome,
                                    @RequestBody
                                    DataAssetRequestBody 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)

      • createDataAssetFromTemplate

        @PostMapping(path="/data-assets/from-template/{templateGUID}")
public GUIDResponse createDataAssetFromTemplate​(@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
        assetManagerIsHome - ensure that only the asset manager can update this asset
        templateGUID - unique identifier of the metadata element to copy
        requestBody - properties that override the template and correlate to external identifiers
        Returns:
        unique identifier of the new metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • updateDataAsset

        @PostMapping(path="/data-assets/{assetGUID}")
public VoidResponse updateDataAsset​(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String assetGUID,
                                    @RequestParam
                                    boolean isMergeUpdate,
                                    @RequestParam(required=false,defaultValue="false")
                                    boolean forLineage,
                                    @RequestParam(required=false,defaultValue="false")
                                    boolean forDuplicateProcessing,
                                    @RequestBody
                                    DataAssetRequestBody 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 - should the new properties be merged with existing properties (true) or completely replace them (false)?
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - new properties for 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)

      • publishDataAsset

        @PostMapping(path="/data-assets/{assetGUID}/publish")
public VoidResponse publishDataAsset​(@PathVariable
                                     String serverName,
                                     @PathVariable
                                     String userId,
                                     @PathVariable
                                     String assetGUID,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forLineage,
                                     @RequestParam(required=false,defaultValue="false")
                                     boolean forDuplicateProcessing,
                                     @RequestBody(required=false)
                                     EffectiveTimeQueryRequestBody 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 Asset Manager OMAS).
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetGUID - unique identifier of the metadata element to publish
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - correlation properties
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • withdrawDataAsset

        @PostMapping(path="/data-assets/{assetGUID}/withdraw")
public VoidResponse withdrawDataAsset​(@PathVariable
                                      String serverName,
                                      @PathVariable
                                      String userId,
                                      @PathVariable
                                      String assetGUID,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forLineage,
                                      @RequestParam(required=false,defaultValue="false")
                                      boolean forDuplicateProcessing,
                                      @RequestBody(required=false)
                                      EffectiveTimeQueryRequestBody 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 Asset Manager OMAS. This is the setting when the database 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
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - correlation 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)

      • removeDataAsset

        @PostMapping(path="/data-assets/{assetGUID}/remove")
public VoidResponse removeDataAsset​(@PathVariable
                                    String serverName,
                                    @PathVariable
                                    String userId,
                                    @PathVariable
                                    String assetGUID,
                                    @RequestParam(required=false,defaultValue="false")
                                    boolean forLineage,
                                    @RequestParam(required=false,defaultValue="false")
                                    boolean forDuplicateProcessing,
                                    @RequestBody(required=false)
                                    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
        assetGUID - 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 - correlation properties
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • setDataAssetAsReferenceData

        @PostMapping(path="/data-assets/{assetGUID}/is-reference-data")
public VoidResponse setDataAssetAsReferenceData​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @PathVariable
                                                String assetGUID,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forLineage,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forDuplicateProcessing,
                                                @RequestBody(required=false)
                                                UpdateRequestBody requestBody)
        Classify the asset to indicate that it can be used as reference data.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetGUID - unique identifier of the metadata element to update
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - correlation properties
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • clearDataAssetAsReferenceData

        @PostMapping(path="/data-assets/{assetGUID}/is-reference-data/remove")
public VoidResponse clearDataAssetAsReferenceData​(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String assetGUID,
                                                  @RequestParam(required=false,defaultValue="false")
                                                  boolean forLineage,
                                                  @RequestParam(required=false,defaultValue="false")
                                                  boolean forDuplicateProcessing,
                                                  @RequestBody(required=false)
                                                  UpdateRequestBody requestBody)
        Remove the reference data designation from the asset.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetGUID - unique identifier of the metadata element to update
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - correlation properties
        Returns:
        void or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • setupRelatedDataAsset

        @PostMapping(path="/data-assets/relationships/{relationshipTypeName}/from-asset/{fromAssetGUID}/to-asset/{toAssetGUID}")
public GUIDResponse setupRelatedDataAsset​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @RequestParam
                                          boolean assetManagerIsHome,
                                          @PathVariable
                                          String relationshipTypeName,
                                          @PathVariable
                                          String fromAssetGUID,
                                          @PathVariable
                                          String toAssetGUID,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forLineage,
                                          @RequestParam(required=false,defaultValue="false")
                                          boolean forDuplicateProcessing,
                                          @RequestBody
                                          RelationshipRequestBody requestBody)
        Link two asset together. Use information from the relationship type definition to ensure the fromAssetGUID and toAssetGUID are the right way around.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        assetManagerIsHome - ensure that only the process manager can update this process
        relationshipTypeName - type name of relationship to create
        fromAssetGUID - unique identifier of the asset at end 1 of the relationship
        toAssetGUID - unique identifier of the asset at end 2 of the relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - unique identifier for this relationship
        Returns:
        unique identifier 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)

      • getAssetRelationship

        @PostMapping(path="/data-assets/relationships/{relationshipTypeName}/from-asset/{fromAssetGUID}/to-asset/{toAssetGUID}/retrieve")
public RelationshipElementResponse getAssetRelationship​(@PathVariable
                                                        String serverName,
                                                        @PathVariable
                                                        String userId,
                                                        @PathVariable
                                                        String relationshipTypeName,
                                                        @PathVariable
                                                        String fromAssetGUID,
                                                        @PathVariable
                                                        String toAssetGUID,
                                                        @RequestParam(required=false,defaultValue="false")
                                                        boolean forLineage,
                                                        @RequestParam(required=false,defaultValue="false")
                                                        boolean forDuplicateProcessing,
                                                        @RequestBody
                                                        EffectiveTimeQueryRequestBody requestBody)
        Retrieve the relationship between two elements.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        relationshipTypeName - type name of relationship to create
        fromAssetGUID - unique identifier of the asset at end 1 of the relationship
        toAssetGUID - unique identifier of the asset at end 2 of the relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - optional date for effective time of the query. Null means any effective time
        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)

      • updateAssetRelationship

        @PostMapping(path="/data-assets/relationships/{relationshipTypeName}/{relationshipGUID}/update")
public VoidResponse updateAssetRelationship​(@PathVariable
                                            String serverName,
                                            @PathVariable
                                            String userId,
                                            @PathVariable
                                            String relationshipTypeName,
                                            @PathVariable
                                            String relationshipGUID,
                                            @RequestParam
                                            boolean isMergeUpdate,
                                            @RequestParam(required=false,defaultValue="false")
                                            boolean forLineage,
                                            @RequestParam(required=false,defaultValue="false")
                                            boolean forDuplicateProcessing,
                                            @RequestBody
                                            RelationshipRequestBody requestBody)
        Update relationship between two elements.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        relationshipTypeName - type name of relationship to update
        relationshipGUID - unique identifier of the relationship
        isMergeUpdate - should the new properties be merged with the existing properties, or replace them entirely
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - description and/or purpose 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)

      • clearAssetRelationship

        @PostMapping(path="/data-assets/relationships/{relationshipTypeName}/{relationshipGUID}/remove")
public VoidResponse clearAssetRelationship​(@PathVariable
                                           String serverName,
                                           @PathVariable
                                           String userId,
                                           @PathVariable
                                           String relationshipTypeName,
                                           @PathVariable
                                           String relationshipGUID,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forLineage,
                                           @RequestParam(required=false,defaultValue="false")
                                           boolean forDuplicateProcessing,
                                           @RequestBody
                                           EffectiveTimeQueryRequestBody requestBody)
        Remove the relationship between two elements.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        relationshipTypeName - type name of relationship to delete
        relationshipGUID - unique identifier of the relationship
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - external source ids
        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)

      • getRelatedAssetsAtEnd2

        @PostMapping(path="/data-assets/relationships/{relationshipTypeName}/from-asset/{fromAssetGUID}/retrieve/end2")
public RelationshipElementsResponse getRelatedAssetsAtEnd2​(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String relationshipTypeName,
                                                           @PathVariable
                                                           String fromAssetGUID,
                                                           @RequestParam
                                                           int startingFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forLineage,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forDuplicateProcessing,
                                                           @RequestBody
                                                           EffectiveTimeQueryRequestBody requestBody)
        Retrieve the requested relationships linked from a specific element at end 2.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        relationshipTypeName - type name of relationship to delete
        fromAssetGUID - unique identifier of the asset at end 1 of the relationship
        startingFrom - start position for results
        pageSize - maximum number of results
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - the time that the retrieved elements must be effective for (null for any time, new Date() for now)
        Returns:
        unique identifier and properties of the relationships 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)

      • getRelatedAssetsAtEnd1

        @PostMapping(path="/data-assets/data-assets/relationships/{relationshipTypeName}/to-asset/{toAssetGUID}/retrieve/end1")
public RelationshipElementsResponse getRelatedAssetsAtEnd1​(@PathVariable
                                                           String serverName,
                                                           @PathVariable
                                                           String userId,
                                                           @PathVariable
                                                           String relationshipTypeName,
                                                           @PathVariable
                                                           String toAssetGUID,
                                                           @RequestParam
                                                           int startingFrom,
                                                           @RequestParam
                                                           int pageSize,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forLineage,
                                                           @RequestParam(required=false,defaultValue="false")
                                                           boolean forDuplicateProcessing,
                                                           @RequestBody
                                                           EffectiveTimeQueryRequestBody requestBody)
        Retrieve the relationships linked from a specific element at end 2 of the relationship.
        Parameters:
        serverName - name of the server to route the request to
        userId - calling user
        relationshipTypeName - type name of relationship to delete
        toAssetGUID - unique identifier of the asset at end 2 of the relationship
        startingFrom - start position for results
        pageSize - maximum number of results
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - the time that the retrieved elements must be effective for (null for any time, new Date() for now)
        Returns:
        unique identifier and properties of the relationships 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)

      • findDataAssets

        @PostMapping(path="/data-assets/by-search-string")
public DataAssetElementsResponse findDataAssets​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @RequestParam
                                                int startFrom,
                                                @RequestParam
                                                int pageSize,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forLineage,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forDuplicateProcessing,
                                                @RequestBody
                                                SearchStringRequestBody requestBody)
        Retrieve the list of 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
        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 - search parameter and correlation properties
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • scanDataAssets

        @PostMapping(path="/data-assets/scan")
public DataAssetElementsResponse scanDataAssets​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @RequestParam
                                                int startFrom,
                                                @RequestParam
                                                int pageSize,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forLineage,
                                                @RequestParam(required=false,defaultValue="false")
                                                boolean forDuplicateProcessing,
                                                @RequestBody
                                                EffectiveTimeQueryRequestBody requestBody)
        Step through the assets visible to this caller.
        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 - search parameter and correlation properties
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getDataAssetsByName

        @PostMapping(path="/data-assets/by-name")
public DataAssetElementsResponse getDataAssetsByName​(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forLineage,
                                                     @RequestParam(required=false,defaultValue="false")
                                                     boolean forDuplicateProcessing,
                                                     @RequestBody
                                                     NameRequestBody requestBody)
        Retrieve the list of 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
        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 - search parameter and correlation properties
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getDataAssetsForAssetManager

        @PostMapping(path="/data-assets/by-asset-manager")
public DataAssetElementsResponse getDataAssetsForAssetManager​(@PathVariable
                                                              String serverName,
                                                              @PathVariable
                                                              String userId,
                                                              @RequestParam
                                                              int startFrom,
                                                              @RequestParam
                                                              int pageSize,
                                                              @RequestParam(required=false,defaultValue="false")
                                                              boolean forLineage,
                                                              @RequestParam(required=false,defaultValue="false")
                                                              boolean forDuplicateProcessing,
                                                              @RequestBody
                                                              EffectiveTimeQueryRequestBody requestBody)
        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 - search parameters and correlation properties
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)

      • getDataAssetByGUID

        @PostMapping(path="/data-assets/{assetGUID}/retrieve")
public DataAssetElementResponse getDataAssetByGUID​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @PathVariable
                                                   String assetGUID,
                                                   @RequestParam(required=false,defaultValue="false")
                                                   boolean forLineage,
                                                   @RequestParam(required=false,defaultValue="false")
                                                   boolean forDuplicateProcessing,
                                                   @RequestBody(required=false)
                                                   EffectiveTimeQueryRequestBody 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
        assetGUID - unique identifier of the requested metadata element
        forLineage - return elements marked with the Memento classification?
        forDuplicateProcessing - do not merge elements marked as duplicates?
        requestBody - correlation properties
        Returns:
        matching metadata element or InvalidParameterException one of the parameters is invalid or UserNotAuthorizedException the user is not authorized to issue this request or PropertyServerException there is a problem reported in the open metadata server(s)