Package org.openiam.esb.repository

Interface UserRepository

All Superinterfaces:

AbstractEntityRepository<UserEntity,String>, AbstractKeyEntityCustomRepository<UserEntity,String>, AbstractKeyEntityRepository<UserEntity,String>, org.springframework.data.repository.CrudRepository<UserEntity,String>, FindBeansRepositoryCustom<UserEntity,UserSearchBean>, org.springframework.data.jpa.repository.JpaRepository<UserEntity,String>, org.springframework.data.jpa.repository.JpaSpecificationExecutor<UserEntity>, org.springframework.data.repository.PagingAndSortingRepository<UserEntity,String>, org.springframework.data.repository.query.QueryByExampleExecutor<UserEntity>, org.springframework.data.repository.Repository<UserEntity,String>, UserRepositoryCustom

@Repository
public interface UserRepository
extends AbstractKeyEntityRepository<UserEntity,String>, UserRepositoryCustom

This is repository for working with User

Method Summary

Modifier and Type	Method	Description
List<UserEntity>	findByEmail(String email, org.springframework.data.domain.Pageable page)
List<UserEntity>	findByLastDateLessThan(Date lastDate)
UserEntity	findPrimarySupervisor(String employeeId)
List<String>	getAllAttachedSupSubIds(Collection<String> userIds)
org.springframework.data.domain.Page<UserEntity>	getAllSuperiors(org.springframework.data.domain.Pageable page)
List<String>	getAllUserIds()	Get all user ids from DB.
org.springframework.data.domain.Page<UserEntity>	getFilteredSubordinates(String userId, List<String> filteredIds, org.springframework.data.domain.Pageable page)
org.springframework.data.domain.Page<UserEntity>	getSubordinates(String userId, org.springframework.data.domain.Pageable page)
int	getSubordinatesCount(String userId)
org.springframework.data.domain.Page<UserEntity>	getSuperiors(String userId, org.springframework.data.domain.Pageable page)
List<UserEntity>	getUserBySecondaryStatus(UserStatusEnum secStatus, org.springframework.data.domain.Pageable page)
List<EntitlementsDBWrapper>	getUserGroupToDeProvisionInEndDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUserGroupToProvisionInStartDateRange(Date from, Date to)
List<String>	getUserIdsForGroups(Collection<String> entityIds, org.springframework.data.domain.Pageable page)
List<String>	getUserIdsForOrganizations(Collection<String> entityIds, org.springframework.data.domain.Pageable page)
List<String>	getUserIdsForResources(Collection<String> entityIds, org.springframework.data.domain.Pageable page)
List<String>	getUserIdsForRoles(Collection<String> entityIds, org.springframework.data.domain.Pageable page)
String	getUserMetadataTypeId(String userId)
List<EntitlementsDBWrapper>	getUserOrgToDeProvisionInEndDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUserOrgToProvisionInStartDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUserResToDeProvisionInEndDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUserResToProvisionInStartDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUserRoleToDeProvisionInEndDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUserRoleToProvisionInStartDateRange(Date from, Date to)
List<EntitlementsDBWrapper>	getUsersForGroupsByAccessRights(List<String> groupIds, List<String> accessRightIds)
List<EntitlementsDBWrapper>	getUsersForGroupsXrefs(List<String> groupIds, String userId)
List<EntitlementsDBWrapper>	getUsersForOrganizationsXrefs(List<String> orgIds, String userId)
List<EntitlementsDBWrapper>	getUsersForRolesByAccessRights(List<String> roleIds, List<String> accessRightIds)
List<EntitlementsDBWrapper>	getUsersForRolesXrefs(List<String> roleIds, String userId)
boolean	isUserEntitledToResource(String userId, String resourceId)
boolean	isUserInGroup(String userId, String groupId)
boolean	isUserInOrg(String userId, String orgId)
boolean	isUserInRole(String userId, String roleId)

Methods inherited from interface org.openiam.esb.repository.AbstractEntityRepository

getPageable

Methods inherited from interface org.openiam.esb.repository.custom.AbstractKeyEntityCustomRepository

findByIdIn

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

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

Methods inherited from interface org.openiam.esb.repository.custom.FindBeansRepositoryCustom

count, find, find, find, getByExample, getByExample, isValidSearchBean

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

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

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

count, exists, findAll, findAll, findAll, findOne

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

findAll

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

count, exists, findAll, findBy, findOne

Methods inherited from interface org.openiam.esb.repository.custom.UserRepositoryCustom

findByIds, findForSynchronizationRequest, findSubordinatesWithFilter, getUserBetweenCreateDate, getUserBetweenLastDate, getUserBetweenStartDate

Method Detail

isUserInGroup

@Query("SELECT case when (count(u.id) > 0) then true else false end FROM UserEntity u JOIN u.groups g WHERE g.entity.id=:entityId AND u.id=:userId")
boolean isUserInGroup(@Param("userId")
                      String userId,
                      @Param("entityId")
                      String groupId)

isUserInRole

@Query("SELECT case when (count(u.id) > 0) then true else false end FROM UserEntity u JOIN u.roles r WHERE r.entity.id=:entityId AND u.id=:userId")
boolean isUserInRole(@Param("userId")
                     String userId,
                     @Param("entityId")
                     String roleId)

isUserInOrg

@Query("SELECT case when (count(u.id) > 0) then true else false end FROM UserEntity u JOIN u.affiliations r WHERE r.entity.id=:entityId AND u.id=:userId")
boolean isUserInOrg(@Param("userId")
                    String userId,
                    @Param("entityId")
                    String orgId)

getSuperiors

@Query("SELECT s.id.supervisor FROM SupervisorEntity s WHERE s.id.employee.id=:userId")
org.springframework.data.domain.Page<UserEntity> getSuperiors(@Param("userId")
                                                              String userId,
                                                              org.springframework.data.domain.Pageable page)

getAllSuperiors

@Query("SELECT s.id.supervisor FROM SupervisorEntity s")
org.springframework.data.domain.Page<UserEntity> getAllSuperiors(org.springframework.data.domain.Pageable page)

getSubordinatesCount

@Query("SELECT COUNT(DISTINCT s.id.employee.id) FROM SupervisorEntity s WHERE s.id.supervisor.id=:userId")
int getSubordinatesCount(@Param("userId")
                         String userId)

getSubordinates

@Query("SELECT s.id.employee FROM SupervisorEntity s WHERE s.id.supervisor.id=:userId")
org.springframework.data.domain.Page<UserEntity> getSubordinates(@Param("userId")
                                                                 String userId,
                                                                 org.springframework.data.domain.Pageable page)

getFilteredSubordinates

@Query("SELECT s.id.employee FROM SupervisorEntity s WHERE s.id.supervisor.id=:userId and s.id.employee.id IN (:filteredIds)")
org.springframework.data.domain.Page<UserEntity> getFilteredSubordinates(@Param("userId")
                                                                         String userId,
                                                                         @Param("filteredIds")
                                                                         List<String> filteredIds,
                                                                         org.springframework.data.domain.Pageable page)

getAllUserIds

@Query("SELECT u.id FROM UserEntity u")
List<String> getAllUserIds()

Get all user ids from DB.

Returns:

getUserIdsForRoles

@Query("SELECT u.id FROM UserEntity u JOIN u.roles r WHERE r.entity.id IN (:entityIds)")
List<String> getUserIdsForRoles(@Param("entityIds")
                                Collection<String> entityIds,
                                org.springframework.data.domain.Pageable page)

getUserIdsForGroups

@Query("SELECT u.id FROM UserEntity u JOIN u.groups r WHERE r.entity.id IN (:entityIds)")
List<String> getUserIdsForGroups(@Param("entityIds")
                                 Collection<String> entityIds,
                                 org.springframework.data.domain.Pageable page)

getUserIdsForOrganizations

@Query("SELECT u.id FROM UserEntity u JOIN u.affiliations r WHERE r.entity.id IN (:entityIds)")
List<String> getUserIdsForOrganizations(@Param("entityIds")
                                        Collection<String> entityIds,
                                        org.springframework.data.domain.Pageable page)

getUserIdsForResources

@Query("SELECT u.id FROM UserEntity u JOIN u.resources r WHERE r.entity.id IN (:entityIds)")
List<String> getUserIdsForResources(@Param("entityIds")
                                    Collection<String> entityIds,
                                    org.springframework.data.domain.Pageable page)

isUserEntitledToResource

@Query("SELECT case when (count(u.id) > 0) then true else false end FROM UserEntity u JOIN u.resources r WHERE r.entity.id=:entityId AND u.id=:userId")
boolean isUserEntitledToResource(@Param("userId")
                                 String userId,
                                 @Param("entityId")
                                 String resourceId)

findPrimarySupervisor

@Query("SELECT s.id.supervisor FROM SupervisorEntity s WHERE s.id.employee.id=:userId AND s.primarySuper=true")
UserEntity findPrimarySupervisor(@Param("userId")
                                 String employeeId)

getAllAttachedSupSubIds

@Query(value="SELECT STAFF_ID as ID FROM ORG_STRUCTURE WHERE SUPERVISOR_ID IN (:userIds)UNION SELECT SUPERVISOR_ID as ID FROM ORG_STRUCTURE WHERE STAFF_ID IN (:userIds) ",
       nativeQuery=true)
List<String> getAllAttachedSupSubIds(@Param("userIds")
                                     Collection<String> userIds)

getUserBySecondaryStatus

@Query("SELECT u FROM UserEntity u WHERE u.secondaryStatus=:secStatus")
List<UserEntity> getUserBySecondaryStatus(@Param("secStatus")
                                          UserStatusEnum secStatus,
                                          org.springframework.data.domain.Pageable page)

findByEmail

@Query("SELECT u FROM UserEntity u JOIN u.emailAddresses e WHERE u.status != \'DEACTIVATED\' AND e.emailAddress=:email")
List<UserEntity> findByEmail(@Param("email")
                             String email,
                             org.springframework.data.domain.Pageable page)

findByLastDateLessThan

List<UserEntity> findByLastDateLessThan(Date lastDate)

getUsersForGroupsByAccessRights

@Query("SELECT NEW EntitlementsDBWrapper(user.id, r.id, CONCAT(user.firstName, user.lastName), ug.entity.id,ug.startDate,ug.endDate, ug.description ) FROM UserToGroupMembershipXrefEntity ug JOIN ug.rights as r  JOIN ug.memberEntity as user WHERE ug.entity.id IN (:groupIds) and r.id IN (:accessRightIds)")
List<EntitlementsDBWrapper> getUsersForGroupsByAccessRights(@Param("groupIds")
                                                            List<String> groupIds,
                                                            @Param("accessRightIds")
                                                            List<String> accessRightIds)

getUsersForRolesByAccessRights

@Query("SELECT NEW EntitlementsDBWrapper(user.id, r.id, CONCAT(user.firstName, user.lastName), ug.entity.id,ug.startDate,ug.endDate, ug.description ) FROM UserToRoleMembershipXrefEntity ug JOIN ug.rights as r  JOIN ug.memberEntity as user WHERE ug.entity.id IN (:roleIds) and r.id IN (:accessRightIds)")
List<EntitlementsDBWrapper> getUsersForRolesByAccessRights(@Param("roleIds")
                                                           List<String> roleIds,
                                                           @Param("accessRightIds")
                                                           List<String> accessRightIds)

getUsersForRolesXrefs

@Query("SELECT NEW EntitlementsDBWrapper(user.id, r.id, CONCAT(user.firstName, user.lastName), ug.entity.id,ug.startDate,ug.endDate, ug.description ) FROM UserToRoleMembershipXrefEntity ug LEFT JOIN ug.rights as r  JOIN ug.memberEntity as user WHERE ug.entity.id IN (:roleIds) and user.id=:userId")
List<EntitlementsDBWrapper> getUsersForRolesXrefs(@Param("roleIds")
                                                  List<String> roleIds,
                                                  @Param("userId")
                                                  String userId)

getUsersForGroupsXrefs

@Query("SELECT NEW EntitlementsDBWrapper(user.id, r.id, CONCAT(user.firstName, user.lastName), ug.entity.id,ug.startDate,ug.endDate, ug.description ) FROM UserToGroupMembershipXrefEntity ug LEFT JOIN ug.rights as r  JOIN ug.memberEntity as user WHERE ug.entity.id IN (:groupIds) and user.id=:userId")
List<EntitlementsDBWrapper> getUsersForGroupsXrefs(@Param("groupIds")
                                                   List<String> groupIds,
                                                   @Param("userId")
                                                   String userId)

getUserMetadataTypeId

@Query("SELECT user.type.id FROM UserEntity user WHERE user.id = :userId")
String getUserMetadataTypeId(@Param("userId")
                             String userId)

getUsersForOrganizationsXrefs

@Query("SELECT NEW EntitlementsDBWrapper(user.id, r.id, CONCAT(user.firstName, user.lastName), uo.entity.id, uo.startDate, uo.endDate, uo.description) FROM UserToOrganizationMembershipXrefEntity uo LEFT JOIN uo.rights as r  JOIN uo.memberEntity as user WHERE uo.entity.id IN (:orgIds) and user.id=:userId")
List<EntitlementsDBWrapper> getUsersForOrganizationsXrefs(@Param("orgIds")
                                                          List<String> orgIds,
                                                          @Param("userId")
                                                          String userId)

getUserRoleToProvisionInStartDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ur.memberEntity.id, ur.entity.id) FROM UserToRoleMembershipXrefEntity ur WHERE ur.startDate >= :from AND ur.startDate <= :to")
List<EntitlementsDBWrapper> getUserRoleToProvisionInStartDateRange(@Param("from")
                                                                   Date from,
                                                                   @Param("to")
                                                                   Date to)

getUserGroupToProvisionInStartDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToGroupMembershipXrefEntity ug WHERE ug.startDate >= :from AND ug.startDate <= :to")
List<EntitlementsDBWrapper> getUserGroupToProvisionInStartDateRange(@Param("from")
                                                                    Date from,
                                                                    @Param("to")
                                                                    Date to)

getUserOrgToProvisionInStartDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToOrganizationMembershipXrefEntity  ug WHERE ug.startDate >= :from AND ug.startDate <= :to")
List<EntitlementsDBWrapper> getUserOrgToProvisionInStartDateRange(@Param("from")
                                                                  Date from,
                                                                  @Param("to")
                                                                  Date to)

getUserResToProvisionInStartDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToResourceMembershipXrefEntity ug WHERE ug.startDate >= :from AND ug.startDate <= :to")
List<EntitlementsDBWrapper> getUserResToProvisionInStartDateRange(@Param("from")
                                                                  Date from,
                                                                  @Param("to")
                                                                  Date to)

getUserRoleToDeProvisionInEndDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToRoleMembershipXrefEntity ug WHERE ug.endDate >= :from AND ug.endDate <= :to")
List<EntitlementsDBWrapper> getUserRoleToDeProvisionInEndDateRange(@Param("from")
                                                                   Date from,
                                                                   @Param("to")
                                                                   Date to)

getUserGroupToDeProvisionInEndDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToGroupMembershipXrefEntity ug WHERE ug.endDate >= :from AND ug.endDate <= :to")
List<EntitlementsDBWrapper> getUserGroupToDeProvisionInEndDateRange(@Param("from")
                                                                    Date from,
                                                                    @Param("to")
                                                                    Date to)

getUserOrgToDeProvisionInEndDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToOrganizationMembershipXrefEntity ug WHERE ug.endDate >= :from AND ug.endDate <= :to")
List<EntitlementsDBWrapper> getUserOrgToDeProvisionInEndDateRange(@Param("from")
                                                                  Date from,
                                                                  @Param("to")
                                                                  Date to)

getUserResToDeProvisionInEndDateRange

@Query("SELECT NEW EntitlementsDBWrapper(ug.memberEntity.id, ug.entity.id) FROM UserToResourceMembershipXrefEntity ug WHERE ug.endDate >= :from AND ug.endDate <= :to")
List<EntitlementsDBWrapper> getUserResToDeProvisionInEndDateRange(@Param("from")
                                                                  Date from,
                                                                  @Param("to")
                                                                  Date to)