Package africa.absa.inception.security

Interface UserRepository

  • All Superinterfaces:
    org.springframework.data.repository.CrudRepository<User,​UUID>, org.springframework.data.jpa.repository.JpaRepository<User,​UUID>, org.springframework.data.repository.PagingAndSortingRepository<User,​UUID>, org.springframework.data.repository.query.QueryByExampleExecutor<User>, org.springframework.data.repository.Repository<User,​UUID>
    public interface UserRepository
extends org.springframework.data.jpa.repository.JpaRepository<User,​UUID>, org.springframework.data.repository.query.QueryByExampleExecutor<User>
    The UserRepository interface declares the repository for the User domain type.
    Author:
    Marcus Portmann

    • Method Detail

      • changePassword

        @Modifying
@Query("update User u set u.password = :password, u.passwordAttempts = :passwordAttempts, u.passwordExpiry = :passwordExpiry where u.id = :userId")
void changePassword​(@Param("userId")
                    UUID userId,
                    @Param("password")
                    String password,
                    @Param("passwordAttempts")
                    int passwordAttempts,
                    @Param("passwordExpiry")
                    Optional<LocalDateTime> passwordExpiry)

      • countByUserDirectoryId

        long countByUserDirectoryId​(UUID userDirectoryId)

      • countFiltered

        @Query("select count(u.id) from User u where ((lower(u.username) like lower(:filter)) or (lower(u.name) like lower(:filter))) and u.userDirectoryId = :userDirectoryId")
long countFiltered​(@Param("userDirectoryId")
                   UUID userDirectoryId,
                   @Param("filter")
                   String filter)

      • deleteById

        @Modifying
@Query("delete from User u where u.id = :userId")
void deleteById​(@Param("userId")
                UUID userId)
        Specified by:
        deleteById in interface org.springframework.data.repository.CrudRepository<User,​UUID>

      • existsByUserDirectoryIdAndUsernameIgnoreCase

        boolean existsByUserDirectoryIdAndUsernameIgnoreCase​(UUID userDirectoryId,
                                                     String username)

      • findByUserDirectoryId

        List<User> findByUserDirectoryId​(UUID userDirectoryId)

      • findByUserDirectoryId

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

      • findByUserDirectoryIdAndUsernameIgnoreCase

        Optional<User> findByUserDirectoryIdAndUsernameIgnoreCase​(UUID userDirectoryId,
                                                          String username)

      • findFiltered

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

      • getFunctionCodesByUserId

        @Query("select f.code from User u join u.groups as g join g.roles as r join r.functions as f where u.id = :userId")
List<String> getFunctionCodesByUserId​(@Param("userId")
                                      UUID userId)

      • getGroupNamesByUserId

        @Query("select g.name from User u join u.groups as g where u.id = :userId")
List<String> getGroupNamesByUserId​(@Param("userId")
                                   UUID userId)

      • getGroupsByUserId

        @Query("select g from User u join u.groups as g where u.id = :userId")
List<Group> getGroupsByUserId​(@Param("userId")
                              UUID userId)

      • getIdByUserDirectoryIdAndUsernameIgnoreCase

        @Query("select u.id from User u where u.userDirectoryId = :userDirectoryId and lower(u.username) like lower(:username)")
Optional<UUID> getIdByUserDirectoryIdAndUsernameIgnoreCase​(@Param("userDirectoryId")
                                                           UUID userDirectoryId,
                                                           @Param("username")
                                                           String username)

      • getNameByUserDirectoryIdAndUsernameIgnoreCase

        @Query("select u.name from User u where ((lower(u.username) = lower(:username)) and u.userDirectoryId = :userDirectoryId)")
Optional<String> getNameByUserDirectoryIdAndUsernameIgnoreCase​(UUID userDirectoryId,
                                                               String username)

      • getPasswordHistory

        @Query(value="select password from security.users_password_history where user_id = :userId and changed > :after",
       nativeQuery=true)
List<String> getPasswordHistory​(@Param("userId")
                                UUID userId,
                                @Param("after")
                                LocalDateTime after)

      • getRoleCodesByUserId

        @Query("select r.code from User u join u.groups as g join g.roles as r where u.id = :userId")
List<String> getRoleCodesByUserId​(@Param("userId")
                                  UUID userId)

      • getUserDirectoryIdByUsernameIgnoreCase

        @Query("select u.userDirectoryId from User u where lower(u.username) = lower(:username)")
Optional<UUID> getUserDirectoryIdByUsernameIgnoreCase​(@Param("username")
                                                      String username)

      • incrementPasswordAttempts

        @Modifying
@Query("update User u set u.passwordAttempts = u.passwordAttempts + 1 where u.id = :userId")
void incrementPasswordAttempts​(@Param("userId")
                               UUID userId)

      • isUserInGroup

        @Query("select case when (count(u.id) > 0) then true else false end from User u join u.groups as g where u.id = :userId and g.id = :groupId")
boolean isUserInGroup​(@Param("userId")
                      UUID userId,
                      @Param("groupId")
                      UUID groupId)

      • resetPassword

        @Modifying
@Query("update User u set u.password = :password, u.passwordAttempts = 0, u.passwordExpiry = :passwordExpiry where u.id = :userId")
void resetPassword​(@Param("userId")
                   UUID userId,
                   @Param("password")
                   String password,
                   @Param("passwordExpiry")
                   LocalDateTime passwordExpiry)

      • resetPasswordHistory

        @Modifying
@Query(value="delete from security.users_password_history where user_id = :userId",
       nativeQuery=true)
void resetPasswordHistory​(@Param("userId")
                          UUID userId)

      • savePasswordInPasswordHistory

        @Modifying
@Query(value="insert into security.users_password_history(user_id, changed, password) values (:userId, current_timestamp, :password)",
       nativeQuery=true)
void savePasswordInPasswordHistory​(@Param("userId")
                                   UUID userId,
                                   @Param("password")
                                   String password)