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

Class SecurityManagerOMASResource

  • @RestController
@RequestMapping("/servers/{serverName}/open-metadata/access-services/security-manager/users/{userId}")
public class SecurityManagerOMASResource
extends Object
    Server-side REST API support for security manager independent REST endpoints

    • Constructor Detail

      • SecurityManagerOMASResource

        public SecurityManagerOMASResource()
        Instantiates a new Security Manager OMAS resource.

    • Method Detail

      • getOutTopicConnection

        @GetMapping(path="/topics/out-topic-connection/{callerId}")
public ConnectionResponse getOutTopicConnection​(@PathVariable
                                                String serverName,
                                                @PathVariable
                                                String userId,
                                                @PathVariable
                                                String callerId)
        Return the connection object for the Security Manager OMAS's out topic.
        Parameters:
        serverName - name of the server to route the request to
        userId - identifier of calling user
        callerId - unique identifier of the caller
        Returns:
        connection object for the out topic or InvalidParameterException one of the parameters is null or invalid or UserNotAuthorizedException user not authorized to issue this request or PropertyServerException problem retrieving the discovery engine definition.

      • createSecurityManagerInCatalog

        @PostMapping(path="/metadata-sources/security-managers")
public GUIDResponse createSecurityManagerInCatalog​(@PathVariable
                                                   String serverName,
                                                   @PathVariable
                                                   String userId,
                                                   @RequestBody
                                                   SecurityManagerRequestBody requestBody)
        Create the security manager software server capability.
        Parameters:
        serverName - name of calling server
        userId - calling user
        requestBody - properties of the file system
        Returns:
        unique identifier for the file system or InvalidParameterException one of the parameters is null or invalid or PropertyServerException problem accessing property server or UserNotAuthorizedException security access problem

      • getMetadataSourceGUID

        @GetMapping(path="metadata-sources/by-name/{qualifiedName}")
public GUIDResponse getMetadataSourceGUID​(@PathVariable
                                          String serverName,
                                          @PathVariable
                                          String userId,
                                          @PathVariable
                                          String qualifiedName)
        Retrieve the unique identifier of the software server capability representing a metadata source.
        Parameters:
        serverName - name of the server to route the request to.
        userId - calling user
        qualifiedName - unique name of the integration daemon
        Returns:
        unique identifier of the integration daemon's software server capability or InvalidParameterException the bean properties are invalid or UserNotAuthorizedException user not authorized to issue this request or PropertyServerException problem accessing the property server

      • createSecurityGroup

        @PostMapping("/security-groups")
public GUIDResponse createSecurityGroup​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @RequestBody
                                        SecurityGroupProperties requestBody)
        Create a new security group. The type of the definition is located in the requestBody.
        Parameters:
        serverName - called server
        userId - calling user
        requestBody - requestBody of the definition
        Returns:
        unique identifier of the definition or InvalidParameterException typeName, documentIdentifier or userId is null; documentIdentifier is not unique; typeName is not valid PropertyServerException problem accessing the metadata service UserNotAuthorizedException security access problem

      • updateSecurityGroup

        @PostMapping("/security-groups/{securityGroupGUID}/update")
public VoidResponse updateSecurityGroup​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String securityGroupGUID,
                                        @RequestParam
                                        boolean isMergeUpdate,
                                        @RequestBody
                                        SecurityGroupProperties requestBody)
        Update an existing security group.
        Parameters:
        serverName - called server
        userId - calling user
        securityGroupGUID - unique identifier of the definition to update
        isMergeUpdate - are unspecified properties unchanged (true) or removed?
        requestBody - properties to update
        Returns:
        void or InvalidParameterException guid, documentIdentifier or userId is null; documentIdentifier is not unique; guid is not known PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • deleteSecurityGroup

        @PostMapping("/security-groups/{securityGroupGUID}/delete")
public VoidResponse deleteSecurityGroup​(@PathVariable
                                        String serverName,
                                        @PathVariable
                                        String userId,
                                        @PathVariable
                                        String securityGroupGUID,
                                        @RequestBody(required=false)
                                        NullRequestBody requestBody)
        Delete a specific security group.
        Parameters:
        serverName - called server
        userId - calling user
        securityGroupGUID - unique identifier of the definition to remove
        requestBody - null request body
        Returns:
        void or InvalidParameterException guid is null or not known PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • getSecurityGroupsForDistinguishedName

        @GetMapping("/security-groups/for-distinguished-name/{distinguishedName}")
public SecurityGroupsResponse getSecurityGroupsForDistinguishedName​(@PathVariable
                                                                    String serverName,
                                                                    @PathVariable
                                                                    String userId,
                                                                    @PathVariable
                                                                    String distinguishedName,
                                                                    @RequestParam
                                                                    int startFrom,
                                                                    @RequestParam
                                                                    int pageSize)
        Return the list of security groups associated with a unique distinguishedName. In an ideal world, the should be only one.
        Parameters:
        serverName - called server
        userId - calling user
        distinguishedName - unique name of the security group
        startFrom - where to start from in the list of definitions
        pageSize - max number of results to return in one call
        Returns:
        list of security groups or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the caller is not authorized to issue the request PropertyServerException the metadata service has problems

      • getElementsGovernedBySecurityGroup

        @GetMapping("/security-groups/{securityGroupGUID}/governed-by/elements")
public ElementStubsResponse getElementsGovernedBySecurityGroup​(@PathVariable
                                                               String serverName,
                                                               @PathVariable
                                                               String userId,
                                                               @PathVariable
                                                               String securityGroupGUID,
                                                               @RequestParam
                                                               int startFrom,
                                                               @RequestParam
                                                               int pageSize)
        Return the elements that are governed by the supplied security group.
        Parameters:
        serverName - called server
        userId - calling user
        securityGroupGUID - unique name of the security group
        startFrom - where to start from in the list of definitions
        pageSize - max number of results to return in one call
        Returns:
        list of headers for the associated elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the caller is not authorized to issue the request PropertyServerException the metadata service has problems

      • findSecurityGroups

        @PostMapping("/security-groups/by-search-string")
public SecurityGroupsResponse findSecurityGroups​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody)
        Return the list of security groups that match the search string - this can be a regular expression.
        Parameters:
        serverName - called server
        userId - calling user
        requestBody - value to search for
        startFrom - where to start from in the list of definition results
        pageSize - max number of results to return in one call
        Returns:
        list of security groups or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the caller is not authorized to issue the request PropertyServerException the metadata service has problems

      • getSecurityGroupByGUID

        @GetMapping("/security-groups/{securityGroupGUID}")
public SecurityGroupResponse getSecurityGroupByGUID​(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String securityGroupGUID)
        Return information about a specific actor profile.
        Parameters:
        serverName - called server
        userId - calling user
        securityGroupGUID - unique identifier for the actor profile
        Returns:
        properties of the actor profile InvalidParameterException securityGroupGUID or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • createUserIdentity

        @PostMapping(path="/user-identities")
public GUIDResponse createUserIdentity​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @RequestBody
                                       UserIdentityRequestBody requestBody)
        Create a UserIdentity. This is not connected to a profile.
        Parameters:
        serverName - name of target server
        userId - the name of the calling user.
        requestBody - userId for the new userIdentity.
        Returns:
        guid or InvalidParameterException - one of the parameters is invalid or PropertyServerException - there is a problem retrieving information from the property server(s) or UserNotAuthorizedException - the requesting user is not authorized to issue this request.

      • updateUserIdentity

        @PostMapping(path="/user-identities/{userIdentityGUID}")
public VoidResponse updateUserIdentity​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String userIdentityGUID,
                                       @RequestParam
                                       boolean isMergeUpdate,
                                       @RequestBody
                                       UserIdentityRequestBody requestBody)
        Update a UserIdentity.
        Parameters:
        serverName - name of target server
        userId - the name of the calling user
        userIdentityGUID - unique identifier of the UserIdentity
        isMergeUpdate - should the supplied properties be overlaid on the existing properties (true) or replace them (false
        requestBody - updated properties for the new userIdentity
        Returns:
        void or InvalidParameterException one of the parameters is invalid. PropertyServerException there is a problem retrieving information from the property server(s). UserNotAuthorizedException the requesting user is not authorized to issue this request.

      • deleteUserIdentity

        @PostMapping(path="/user-identities/{userIdentityGUID}/delete")
public VoidResponse deleteUserIdentity​(@PathVariable
                                       String serverName,
                                       @PathVariable
                                       String userId,
                                       @PathVariable
                                       String userIdentityGUID,
                                       @RequestBody
                                       MetadataSourceRequestBody requestBody)
        Remove a user identity object. This will fail if a profile would be left without an associated user identity.
        Parameters:
        serverName - name of target server
        userId - the name of the calling user.
        userIdentityGUID - unique identifier of the UserIdentity
        requestBody - external source identifiers
        Returns:
        void or InvalidParameterException - one of the parameters is invalid or PropertyServerException - there is a problem retrieving information from the property server(s) or UserNotAuthorizedException - the requesting user is not authorized to issue this request.

      • addIdentityToProfile

        @PostMapping(path="/user-identities/{userIdentityGUID}/personal-profiles/{profileGUID}/link")
public VoidResponse addIdentityToProfile​(@PathVariable
                                         String serverName,
                                         @PathVariable
                                         String userId,
                                         @PathVariable
                                         String userIdentityGUID,
                                         @PathVariable
                                         String profileGUID,
                                         @RequestBody
                                         MetadataSourceRequestBody requestBody)
        Link a user identity to a profile. This will fail if the user identity is already connected to a profile.
        Parameters:
        serverName - name of target server
        userId - the name of the calling user.
        userIdentityGUID - unique identifier of the UserIdentity
        profileGUID - the profile to add the identity to.
        requestBody - external source identifiers
        Returns:
        void or InvalidParameterException - one of the parameters is invalid or PropertyServerException - there is a problem retrieving information from the property server(s) or UserNotAuthorizedException - the requesting user is not authorized to issue this request.

      • removeIdentityFromProfile

        @PostMapping(path="/user-identities/{userIdentityGUID}/profiles/{profileGUID}/unlink")
public VoidResponse removeIdentityFromProfile​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String userIdentityGUID,
                                              @PathVariable
                                              String profileGUID,
                                              @RequestBody
                                              MetadataSourceRequestBody requestBody)
        Remove a user identity object. This will fail if the profile would be left without an associated user identity.
        Parameters:
        serverName - name of target server
        userId - the name of the calling user.
        userIdentityGUID - unique identifier of the UserIdentity
        profileGUID - the profile to add the identity to.
        requestBody - external source identifiers
        Returns:
        void or InvalidParameterException - one of the parameters is invalid or PropertyServerException - there is a problem retrieving information from the property server(s) or UserNotAuthorizedException - the requesting user is not authorized to issue this request.

      • findUserIdentities

        @PostMapping(path="/user-identities/by-search-string")
public UserIdentitiesResponse findUserIdentities​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody)
        Retrieve the list of user identity metadata elements that contain the search string. The search string is treated as a regular expression.
        Parameters:
        serverName - name of target server
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        requestBody - string to find in the properties
        Returns:
        list of matching metadata elements or InvalidParameterException one of the parameters is invalid UserNotAuthorizedException the user is not authorized to issue this request PropertyServerException there is a problem reported in the open metadata server(s)

      • getUserIdentitiesByName

        @PostMapping(path="/user-identities/by-name")
public UserIdentitiesResponse getUserIdentitiesByName​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize,
                                                      @RequestBody
                                                      NameRequestBody requestBody)
        Retrieve the list of user identity metadata elements with a matching qualified name. There are no wildcards supported on this request.
        Parameters:
        serverName - name of target server
        userId - calling user
        startFrom - paging start point
        pageSize - maximum results that can be returned
        requestBody - name to search for
        Returns:
        list of matching metadata elements 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)

      • getUserIdentityByGUID

        @GetMapping(path="/user-identities/{userIdentityGUID}")
public UserIdentityResponse getUserIdentityByGUID​(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String userIdentityGUID)
        Retrieve the userIdentity metadata element with the supplied unique identifier.
        Parameters:
        serverName - name of target server
        userId - calling user
        userIdentityGUID - unique identifier of the requested metadata element
        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)

      • getActorProfileByGUID

        @GetMapping(path="/profiles/{actorProfileGUID}")
public ActorProfileResponse getActorProfileByGUID​(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @PathVariable
                                                  String actorProfileGUID)
        Return information about a specific actor profile.
        Parameters:
        serverName - called server
        userId - calling user
        actorProfileGUID - unique identifier for the actor profile
        Returns:
        properties of the actor profile InvalidParameterException actorProfileGUID or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • getActorProfileByUserId

        @GetMapping(path="/profiles/user-ids/{actorProfileUserId}")
public ActorProfileResponse getActorProfileByUserId​(@PathVariable
                                                    String serverName,
                                                    @PathVariable
                                                    String userId,
                                                    @PathVariable
                                                    String actorProfileUserId)
        Return information about a specific actor profile.
        Parameters:
        serverName - called server
        userId - calling user
        actorProfileUserId - unique identifier for the actor profile
        Returns:
        properties of the actor profile InvalidParameterException actorProfileUserId or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • getActorProfileByName

        @PostMapping(path="/profiles/by-name")
public ActorProfileListResponse getActorProfileByName​(@PathVariable
                                                      String serverName,
                                                      @PathVariable
                                                      String userId,
                                                      @RequestParam
                                                      int startFrom,
                                                      @RequestParam
                                                      int pageSize,
                                                      @RequestBody
                                                      NameRequestBody requestBody)
        Return information about a named actor profile.
        Parameters:
        serverName - called server
        userId - calling user
        startFrom - index of the list to start from (0 for start)
        pageSize - maximum number of elements to return.
        requestBody - unique name for the actor profile
        Returns:
        list of matching actor profiles (hopefully only one) InvalidParameterException name or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • findActorProfile

        @PostMapping(path="/profiles/by-search-string")
public ActorProfileListResponse findActorProfile​(@PathVariable
                                                 String serverName,
                                                 @PathVariable
                                                 String userId,
                                                 @RequestParam
                                                 int startFrom,
                                                 @RequestParam
                                                 int pageSize,
                                                 @RequestBody
                                                 SearchStringRequestBody requestBody)
        Retrieve the list of matching profiles for the search string.
        Parameters:
        serverName - called server
        userId - the name of the calling user.
        requestBody - RegEx string to search for
        startFrom - index of the list to start from (0 for start)
        pageSize - maximum number of elements to return.
        Returns:
        list of matching actor profiles InvalidParameterException guid invalid or the external references are not correctly specified, or are null. PropertyServerException the server is not available. UserNotAuthorizedException the calling user is not authorized to issue the call.

      • getAppointees

        @PostMapping(path="/person-roles/{personRoleGUID}/appointees")
public PersonRoleAppointeeListResponse getAppointees​(@PathVariable
                                                     String serverName,
                                                     @PathVariable
                                                     String userId,
                                                     @PathVariable
                                                     String personRoleGUID,
                                                     @RequestParam
                                                     int startFrom,
                                                     @RequestParam
                                                     int pageSize,
                                                     @RequestBody
                                                     EffectiveTimeRequestBody requestBody)
        Return the list of people appointed to a particular role.
        Parameters:
        serverName - called server
        userId - calling user
        personRoleGUID - unique identifier of the person role
        startFrom - index of the list to start from (0 for start)
        pageSize - maximum number of elements to return
        requestBody - time for appointments, null for full appointment history
        Returns:
        list of appointees or InvalidParameterException one of the guids is null or not known PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • getPersonRoleByGUID

        @GetMapping(path="/person-roles/{personRoleGUID}")
public PersonRoleResponse getPersonRoleByGUID​(@PathVariable
                                              String serverName,
                                              @PathVariable
                                              String userId,
                                              @PathVariable
                                              String personRoleGUID)
        Return information about a specific person role.
        Parameters:
        serverName - called server
        userId - calling user
        personRoleGUID - unique identifier for the person role
        Returns:
        properties of the person role InvalidParameterException personRoleGUID or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • getPersonRoleByName

        @PostMapping(path="/person-roles/by-name")
public PersonRoleListResponse getPersonRoleByName​(@PathVariable
                                                  String serverName,
                                                  @PathVariable
                                                  String userId,
                                                  @RequestParam
                                                  int startFrom,
                                                  @RequestParam
                                                  int pageSize,
                                                  @RequestBody
                                                  NameRequestBody requestBody)
        Return information about a named person role.
        Parameters:
        serverName - called server
        userId - calling user
        startFrom - index of the list to start from (0 for start)
        pageSize - maximum number of elements to return.
        requestBody - unique name for the actor profile
        Returns:
        list of matching actor profiles (hopefully only one) InvalidParameterException name or userId is null PropertyServerException problem accessing property server UserNotAuthorizedException security access problem

      • findPersonRole

        @PostMapping(path="/person-roles/by-search-string")
public PersonRoleListResponse findPersonRole​(@PathVariable
                                             String serverName,
                                             @PathVariable
                                             String userId,
                                             @RequestParam
                                             int startFrom,
                                             @RequestParam
                                             int pageSize,
                                             @RequestBody
                                             SearchStringRequestBody requestBody)
        Retrieve the list of matching roles for the search string.
        Parameters:
        serverName - called server
        userId - the name of the calling user.
        startFrom - index of the list to start from (0 for start)
        pageSize - maximum number of elements to return.
        requestBody - RegEx string to search for
        Returns:
        list of matching actor profiles InvalidParameterException guid invalid or the external references are not correctly specified, or are null. PropertyServerException the server is not available. UserNotAuthorizedException the calling user is not authorized to issue the call.