Package africa.absa.inception.security

Interface GroupRepository

All Superinterfaces:

org.springframework.data.repository.CrudRepository<Group,UUID>, org.springframework.data.jpa.repository.JpaRepository<Group,UUID>, org.springframework.data.repository.PagingAndSortingRepository<Group,UUID>, org.springframework.data.repository.query.QueryByExampleExecutor<Group>, org.springframework.data.repository.Repository<Group,UUID>

public interface GroupRepository
extends org.springframework.data.jpa.repository.JpaRepository<Group,UUID>

The GroupRepository interface declares the repository for the Group domain type.

Author:

Marcus Portmann

Method Summary

Modifier and Type	Method	Description
void	addRoleToGroup(UUID groupId, String roleCode)
void	addUserToGroup(UUID groupId, UUID userId)
long	countByUserDirectoryId(UUID userDirectoryId)
long	countFiltered(UUID userDirectoryId, String filter)
long	countFilteredUsernamesForGroup(UUID userDirectoryId, UUID groupId, String filter)
long	countGroupRole(UUID groupId, String roleCode)
long	countUsernamesForGroup(UUID userDirectoryId, UUID groupId)
long	countUsersById(UUID groupId)
void	deleteById(UUID groupId)
boolean	existsByUserDirectoryIdAndNameIgnoreCase(UUID userDirectoryId, String name)
List<Group>	findByUserDirectoryId(UUID userDirectoryId)
org.springframework.data.domain.Page<Group>	findByUserDirectoryId(UUID userDirectoryId, org.springframework.data.domain.Pageable pageable)
Optional<Group>	findByUserDirectoryIdAndNameIgnoreCase(UUID userDirectoryId, String name)
org.springframework.data.domain.Page<Group>	findFiltered(UUID userDirectoryId, String filter, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Page<String>	getFilteredUsernamesForGroup(UUID userDirectoryId, UUID groupId, String filter, org.springframework.data.domain.Pageable pageable)
List<String>	getFunctionCodesByUserDirectoryIdAndGroupNames(UUID userDirectoryId, List<String> groupNames)
Optional<UUID>	getIdByUserDirectoryIdAndNameIgnoreCase(UUID userDirectoryId, String name)
List<String>	getNamesByUserDirectoryId(UUID userDirectoryId)
List<String>	getRoleCodesByGroupId(UUID groupId)
List<String>	getRoleCodesByUserDirectoryIdAndGroupNames(UUID userDirectoryId, List<String> groupNames)
List<Role>	getRolesByGroupId(UUID groupId)
List<String>	getUsernamesForGroup(UUID userDirectoryId, UUID groupId)
org.springframework.data.domain.Page<String>	getUsernamesForGroup(UUID userDirectoryId, UUID groupId, org.springframework.data.domain.Pageable pageable)
int	removeRoleFromGroup(UUID groupId, String roleCode)
void	removeUserFromGroup(UUID groupId, UUID userId)

Methods inherited from interface org.springframework.data.repository.CrudRepository

count, delete, deleteAll, deleteAll, deleteAllById, existsById, findById, save

Methods inherited from interface org.springframework.data.jpa.repository.JpaRepository

deleteAllByIdInBatch, deleteAllInBatch, deleteAllInBatch, deleteInBatch, findAll, findAll, findAll, findAll, findAllById, flush, getById, getOne, saveAll, saveAllAndFlush, saveAndFlush

Methods inherited from interface org.springframework.data.repository.PagingAndSortingRepository

findAll

Methods inherited from interface org.springframework.data.repository.query.QueryByExampleExecutor

count, exists, findAll, findOne

Method Detail

addRoleToGroup

@Modifying
@Query(value="insert into security.role_to_group_map(role_code, group_id) values (:roleCode, :groupId)",
       nativeQuery=true)
void addRoleToGroup(@Param("groupId")
                    UUID groupId,
                    @Param("roleCode")
                    String roleCode)

addUserToGroup

@Modifying
@Query(value="insert into security.user_to_group_map(user_id, group_id) values (:userId, :groupId)",
       nativeQuery=true)
void addUserToGroup(@Param("groupId")
                    UUID groupId,
                    @Param("userId")
                    UUID userId)

countByUserDirectoryId

long countByUserDirectoryId(UUID userDirectoryId)

countFiltered

@Query("select count(g.id) from Group g where (lower(g.name) like lower(:filter)) and g.userDirectoryId = :userDirectoryId")
long countFiltered(@Param("userDirectoryId")
                   UUID userDirectoryId,
                   @Param("filter")
                   String filter)

countFilteredUsernamesForGroup

@Query("select count(u.id) from Group g join g.users as u where g.userDirectoryId = :userDirectoryId and g.id = :groupId and (lower(u.username) like lower(:filter))")
long countFilteredUsernamesForGroup(@Param("userDirectoryId")
                                    UUID userDirectoryId,
                                    @Param("groupId")
                                    UUID groupId,
                                    @Param("filter")
                                    String filter)

countGroupRole

@Query(value="select count(role_code) from security.role_to_group_map where role_code = :roleCode and group_id = :groupId",
       nativeQuery=true)
long countGroupRole(@Param("groupId")
                    UUID groupId,
                    @Param("roleCode")
                    String roleCode)

countUsernamesForGroup

@Query("select count(u.id) from Group g join g.users as u where g.userDirectoryId = :userDirectoryId and g.id = :groupId")
long countUsernamesForGroup(@Param("userDirectoryId")
                            UUID userDirectoryId,
                            @Param("groupId")
                            UUID groupId)

countUsersById

@Query("select count(u.id) from Group g join g.users as u where g.id = :groupId")
long countUsersById(@Param("groupId")
                    UUID groupId)

deleteById

@Modifying
@Query("delete from Group g where g.id = :groupId")
void deleteById(@Param("groupId")
                UUID groupId)

Specified by:

deleteById in interface org.springframework.data.repository.CrudRepository<Group,UUID>

existsByUserDirectoryIdAndNameIgnoreCase

@Transactional
boolean existsByUserDirectoryIdAndNameIgnoreCase(UUID userDirectoryId,
                                                 String name)

findByUserDirectoryId

List<Group> findByUserDirectoryId(UUID userDirectoryId)

findByUserDirectoryId

org.springframework.data.domain.Page<Group> findByUserDirectoryId(UUID userDirectoryId,
                                                                  org.springframework.data.domain.Pageable pageable)

findByUserDirectoryIdAndNameIgnoreCase

Optional<Group> findByUserDirectoryIdAndNameIgnoreCase(UUID userDirectoryId,
                                                       String name)

findFiltered

@Query("select g from Group g where (lower(g.name) like lower(:filter)) and g.userDirectoryId = :userDirectoryId")
org.springframework.data.domain.Page<Group> findFiltered(@Param("userDirectoryId")
                                                         UUID userDirectoryId,
                                                         @Param("filter")
                                                         String filter,
                                                         org.springframework.data.domain.Pageable pageable)

getFilteredUsernamesForGroup

@Query("select u.username from Group g join g.users as u where g.userDirectoryId = :userDirectoryId and g.id = :groupId and (lower(u.username) like lower(:filter))")
org.springframework.data.domain.Page<String> getFilteredUsernamesForGroup(@Param("userDirectoryId")
                                                                          UUID userDirectoryId,
                                                                          @Param("groupId")
                                                                          UUID groupId,
                                                                          @Param("filter")
                                                                          String filter,
                                                                          org.springframework.data.domain.Pageable pageable)

getFunctionCodesByUserDirectoryIdAndGroupNames

@Query("select distinct f.code from Group g join g.roles as r join r.functions as f where g.userDirectoryId = :userDirectoryId and lower(g.name) in :groupNames")
List<String> getFunctionCodesByUserDirectoryIdAndGroupNames(@Param("userDirectoryId")
                                                            UUID userDirectoryId,
                                                            @Param("groupNames")
                                                            List<String> groupNames)

getIdByUserDirectoryIdAndNameIgnoreCase

@Query("select g.id from Group g where g.userDirectoryId = :userDirectoryId and lower(g.name) like lower(:name)")
Optional<UUID> getIdByUserDirectoryIdAndNameIgnoreCase(@Param("userDirectoryId")
                                                       UUID userDirectoryId,
                                                       @Param("name")
                                                       String name)

getNamesByUserDirectoryId

@Query("select g.name from Group g where g.userDirectoryId = :userDirectoryId")
List<String> getNamesByUserDirectoryId(@Param("userDirectoryId")
                                       UUID userDirectoryId)

getRoleCodesByGroupId

@Query("select r.code from Group g join g.roles as r where g.id = :groupId")
List<String> getRoleCodesByGroupId(@Param("groupId")
                                   UUID groupId)

getRoleCodesByUserDirectoryIdAndGroupNames

@Query("select distinct r.code from Group g join g.roles as r where g.userDirectoryId = :userDirectoryId and lower(g.name) in :groupNames")
List<String> getRoleCodesByUserDirectoryIdAndGroupNames(@Param("userDirectoryId")
                                                        UUID userDirectoryId,
                                                        @Param("groupNames")
                                                        List<String> groupNames)

getRolesByGroupId

@Query("select r from Group g join g.roles as r where g.id = :groupId")
List<Role> getRolesByGroupId(@Param("groupId")
                             UUID groupId)

getUsernamesForGroup

@Query("select u.username from Group g join g.users as u where g.userDirectoryId = :userDirectoryId and g.id = :groupId")
List<String> getUsernamesForGroup(@Param("userDirectoryId")
                                  UUID userDirectoryId,
                                  @Param("groupId")
                                  UUID groupId)

getUsernamesForGroup

@Query("select u.username from Group g join g.users as u where g.userDirectoryId = :userDirectoryId and g.id = :groupId")
org.springframework.data.domain.Page<String> getUsernamesForGroup(@Param("userDirectoryId")
                                                                  UUID userDirectoryId,
                                                                  @Param("groupId")
                                                                  UUID groupId,
                                                                  org.springframework.data.domain.Pageable pageable)

removeRoleFromGroup

@Modifying
@Query(value="delete from security.role_to_group_map where group_id=:groupId and role_code = :roleCode",
       nativeQuery=true)
int removeRoleFromGroup(@Param("groupId")
                        UUID groupId,
                        @Param("roleCode")
                        String roleCode)

removeUserFromGroup

@Modifying
@Query(value="delete from security.user_to_group_map where group_id=:groupId and user_id = :userId",
       nativeQuery=true)
void removeUserFromGroup(@Param("groupId")
                         UUID groupId,
                         @Param("userId")
                         UUID userId)