com.xforceplus.dao

接口 RoleUserRelDao

所有超级接口:

org.springframework.data.repository.CrudRepository<RoleUserRel,java.lang.Long>, io.geewit.data.jpa.essential.repository.JpaBatchExecutor<RoleUserRel>, org.springframework.data.jpa.repository.JpaRepository<RoleUserRel,java.lang.Long>, org.springframework.data.jpa.repository.JpaSpecificationExecutor<RoleUserRel>, org.springframework.data.repository.PagingAndSortingRepository<RoleUserRel,java.lang.Long>, org.springframework.data.repository.query.QueryByExampleExecutor<RoleUserRel>, org.springframework.data.repository.Repository<RoleUserRel,java.lang.Long>

public interface RoleUserRelDao
extends org.springframework.data.jpa.repository.JpaRepository<RoleUserRel,java.lang.Long>, org.springframework.data.jpa.repository.JpaSpecificationExecutor<RoleUserRel>, io.geewit.data.jpa.essential.repository.JpaBatchExecutor<RoleUserRel>

方法概要

限定符和类型	方法和说明
void	batchUpdateTenant(java.util.List<java.lang.Long> roleUserRelIds, java.lang.Long tenantId)
long	countByRoleId(long roleId)
void	deleteById(java.lang.Long id)
void	deleteByRoleId(long roleId)
void	deleteByRoleIdAndOrgId(java.lang.Long roleId, java.lang.Long orgId)
void	deleteByRoleIdAndOrgIdAndType(long roleId, long orgId, int type)
void	deleteByRoleIdAndUserIds(long roleId, java.util.Collection<java.lang.Long> userIds)
void	deleteByTenantIdAndRoleIdAndUserIds(long tenantId, long roleId, java.util.Collection<java.lang.Long> userIds)
void	deleteByTenantIdAndRoleIds(long tenantId, java.util.Collection<java.lang.Long> roleIds)
void	deleteByTenantIdAndUserIdAndRoleId(long tenantId, long userId, java.lang.Long roleId)
void	deleteByTenantIdAndUserIdAndRoleIds(long tenantId, long userId, java.util.Collection<java.lang.Long> roleIds)
void	deleteByUserId(long userId)
java.util.List<RoleUserRel>	findByRoleId(long roleId)
java.util.List<RoleUserRel>	findByRoleIdAndTenantId(long roleId, long tenantId)
java.util.List<RoleUserRel>	findByTenantId(long tenantId)
java.util.List<RoleUserRel>	findByUserId(long userId)
java.util.Set<java.lang.Long>	findGradingRoleIdsByUserId(java.lang.Long userId)
java.util.Set<java.lang.Long>	findOrgIdsByTenantIdAndRoleIdsAndType(long tenantId, java.util.Collection<java.lang.Long> roleIds)
java.util.List<java.lang.Long>	findUserIdsByRoleId(java.lang.Long roleId)
void	updateRoleId(long existRoleId, long newRoleId)

从接口继承的方法 org.springframework.data.jpa.repository.JpaRepository

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

从接口继承的方法 org.springframework.data.repository.PagingAndSortingRepository

findAll

从接口继承的方法 org.springframework.data.repository.CrudRepository

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

从接口继承的方法 org.springframework.data.repository.query.QueryByExampleExecutor

count, exists, findAll, findOne

从接口继承的方法 org.springframework.data.jpa.repository.JpaSpecificationExecutor

count, findAll, findAll, findAll, findOne

从接口继承的方法 io.geewit.data.jpa.essential.repository.JpaBatchExecutor

saveBatch

方法详细资料

deleteById

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.id = :id")
void deleteById(@Param(value="id")
                                                                                                                                                                                                                   java.lang.Long id)

指定者:

deleteById 在接口中 org.springframework.data.repository.CrudRepository<RoleUserRel,java.lang.Long>

findByRoleId

@Query(value="select rel from RoleUserRel rel where rel.roleId = :roleId")
java.util.List<RoleUserRel> findByRoleId(@Param(value="roleId")
                                                                                                                     long roleId)

findByUserId

@Query(value="select rel from RoleUserRel rel where rel.userId = :userId")
java.util.List<RoleUserRel> findByUserId(@Param(value="userId")
                                                                                                                     long userId)

deleteByTenantIdAndUserIdAndRoleId

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.tenantId = :tenantId and rel.userId = :userId and rel.roleId = :roleId")
void deleteByTenantIdAndUserIdAndRoleId(@Param(value="tenantId")
                                                                                                                                                                                                                                                                                                         long tenantId,
                                                                                                                                                                                                                                                                                                         @Param(value="userId")
                                                                                                                                                                                                                                                                                                         long userId,
                                                                                                                                                                                                                                                                                                         @Param(value="roleId")
                                                                                                                                                                                                                                                                                                         java.lang.Long roleId)

deleteByUserId

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.userId = :userId")
void deleteByUserId(@Param(value="userId")
                                                                                                                                                                                                                               long userId)

deleteByRoleId

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.roleId = :roleId")
void deleteByRoleId(@Param(value="roleId")
                                                                                                                                                                                                                               long roleId)

countByRoleId

@Query(value="select count(rel.id) from RoleUserRel rel where rel.roleId = :roleId")
long countByRoleId(@Param(value="roleId")
                                                                                                         long roleId)

findByTenantId

@Query(value="select rel from RoleUserRel rel where rel.tenantId = :tenantId")
java.util.List<RoleUserRel> findByTenantId(@Param(value="tenantId")
                                                                                                                           long tenantId)

batchUpdateTenant

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="update RoleUserRel rel set rel.tenantId = :tenantId where rel.id in :roleUserRelIds")
void batchUpdateTenant(@Param(value="roleUserRelIds")
                                                                                                                                                                                                                                                               java.util.List<java.lang.Long> roleUserRelIds,
                                                                                                                                                                                                                                                               @Param(value="tenantId")
                                                                                                                                                                                                                                                               java.lang.Long tenantId)

findByRoleIdAndTenantId

@Query(value="select rel from RoleUserRel rel where rel.roleId = :roleId and rel.tenantId = :tenantId")
java.util.List<RoleUserRel> findByRoleIdAndTenantId(@Param(value="roleId")
                                                                                                                                                             long roleId,
                                                                                                                                                             @Param(value="tenantId")
                                                                                                                                                             long tenantId)

findUserIdsByRoleId

@Query(value="select rel.userId from RoleUserRel rel where rel.roleId = :roleId")
java.util.List<java.lang.Long> findUserIdsByRoleId(@Param(value="roleId")
                                                                                                                                      java.lang.Long roleId)

findGradingRoleIdsByUserId

@Query(value="select rel.roleId from RoleUserRel rel inner join com.xforceplus.entity.Role r on rel.roleId = r.id where rel.userId = :userId and r.type = 1")
java.util.Set<java.lang.Long> findGradingRoleIdsByUserId(@Param(value="userId")
                                                                                                                                                                                                                        java.lang.Long userId)

deleteByRoleIdAndUserIds

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.roleId = :roleId and rel.userId in :userIds")
void deleteByRoleIdAndUserIds(@Param(value="roleId")
                                                                                                                                                                                                                                                                    long roleId,
                                                                                                                                                                                                                                                                    @Param(value="userIds")
                                                                                                                                                                                                                                                                    java.util.Collection<java.lang.Long> userIds)

deleteByTenantIdAndUserIdAndRoleIds

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.tenantId = :tenantId and rel.userId = :userId and rel.roleId in :roleIds")
void deleteByTenantIdAndUserIdAndRoleIds(@Param(value="tenantId")
                                                                                                                                                                                                                                                                                                            long tenantId,
                                                                                                                                                                                                                                                                                                            @Param(value="userId")
                                                                                                                                                                                                                                                                                                            long userId,
                                                                                                                                                                                                                                                                                                            @Param(value="roleIds")
                                                                                                                                                                                                                                                                                                            java.util.Collection<java.lang.Long> roleIds)

updateRoleId

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="update RoleUserRel rel set rel.roleId = :newRoleId where rel.roleId = :existRoleId")
void updateRoleId(@Param(value="existRoleId")
                                                                                                                                                                                                                                                         long existRoleId,
                                                                                                                                                                                                                                                         @Param(value="newRoleId")
                                                                                                                                                                                                                                                         long newRoleId)

deleteByTenantIdAndRoleIds

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.tenantId = :tenantId and rel.roleId in :roleIds")
void deleteByTenantIdAndRoleIds(@Param(value="tenantId")
                                                                                                                                                                                                                                                                          long tenantId,
                                                                                                                                                                                                                                                                          @Param(value="roleIds")
                                                                                                                                                                                                                                                                          java.util.Collection<java.lang.Long> roleIds)

deleteByRoleIdAndOrgId

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.roleId = :roleId and rel.orgId = :orgId")
void deleteByRoleIdAndOrgId(@Param(value="roleId")
                                                                                                                                                                                                                                                              java.lang.Long roleId,
                                                                                                                                                                                                                                                              @Param(value="orgId")
                                                                                                                                                                                                                                                              java.lang.Long orgId)

deleteByTenantIdAndRoleIdAndUserIds

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.tenantId = :tenantId and rel.roleId = :roleId and rel.userId in :userIds")
void deleteByTenantIdAndRoleIdAndUserIds(@Param(value="tenantId")
                                                                                                                                                                                                                                                                                                            long tenantId,
                                                                                                                                                                                                                                                                                                            @Param(value="roleId")
                                                                                                                                                                                                                                                                                                            long roleId,
                                                                                                                                                                                                                                                                                                            @Param(value="userIds")
                                                                                                                                                                                                                                                                                                            java.util.Collection<java.lang.Long> userIds)

findOrgIdsByTenantIdAndRoleIdsAndType

@Query(value="select rel.orgId from RoleUserRel rel where rel.tenantId = :tenantId and rel.roleId in :roleIds and rel.relType = 2")
java.util.Set<java.lang.Long> findOrgIdsByTenantIdAndRoleIdsAndType(@Param(value="tenantId")
                                                                                                                                                                                                         long tenantId,
                                                                                                                                                                                                         @Param(value="roleIds")
                                                                                                                                                                                                         java.util.Collection<java.lang.Long> roleIds)

deleteByRoleIdAndOrgIdAndType

@Transactional(rollbackFor=java.lang.Exception.class)
 @Modifying(flushAutomatically=true,
           clearAutomatically=true)
 @Query(value="delete from RoleUserRel rel where rel.roleId = :roleId and rel.orgId = :orgId and rel.relType = :type")
void deleteByRoleIdAndOrgIdAndType(@Param(value="roleId")
                                                                                                                                                                                                                                                                                             long roleId,
                                                                                                                                                                                                                                                                                             @Param(value="orgId")
                                                                                                                                                                                                                                                                                             long orgId,
                                                                                                                                                                                                                                                                                             @Param(value="type")
                                                                                                                                                                                                                                                                                             int type)