com.xforceplus.dao

接口 RoleDao

所有超级接口:

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

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

方法概要

限定符和类型	方法和说明
void	batchUpdateTenant(java.util.List<java.lang.Long> roleIds, java.lang.Long tenantId)
long	countDifferentByTenantIdAndCode(long tenantId, long currentId, java.lang.String roleCode)
long	countDifferentByTenantIdAndName(long tenantId, long currentId, java.lang.String roleName)
long	countRoleByTenantIdAndIdAndType(long tenantId, long roleId, int type)
void	deleteById(java.lang.Long id)
void	deleteByTenantIdAndIds(long tenantId, java.util.List<java.lang.Long> roleIds)
void	disableOrgRolesByGradingRoleId(java.lang.Long roleId)
java.util.List<Role>	findByListTenantIdAndCode(long tenantId, java.lang.String roleCode)
java.util.List<Role>	findByListTenantIdAndName(java.lang.Long tenantId, java.lang.String roleName)
java.util.List<Role>	findByName(java.lang.String name) 根据角色名称列表
java.util.List<Role>	findByNameAndId(java.lang.String name, java.lang.Long roleId) 根据ID查询角色名称，不等于当前ID
java.util.List<Role>	findByTenantId(java.lang.Long oldTenantId)
Role	findByTenantIdAndCode(long tenantId, java.lang.String roleCode)
java.util.List<Role>	findByTenantIdAndFromRoleId(long tenantId, long fromRoleId)
java.util.List<Role>	findByTenantIdAndRoleCodes(long tenantId, java.util.Collection<java.lang.String> roleCodes)
java.util.Set<java.lang.Long>	findFromIdByOrgRoleIds(java.util.Set<java.lang.Long> roleIds)
java.lang.Long	findIdByTenantIdAndCode(long tenantId, java.lang.String roleCode)
java.util.List<com.xforceplus.domain.tenant.OrgRoleCntDTO>	getOrgRoleCntByGradingRoleIds(java.lang.Long tenantId, java.util.Set<java.lang.Long> roleIds)
java.util.List<com.xforceplus.domain.tenant.RoleUserCntDTO>	getRoleUserCntByRoleIds(java.lang.Long tenantId, java.util.Set<java.lang.Long> roleIds)
int	updateStatus(long roleId, int status)
int	updateStatus(long tenantId, long roleId, int status)

从接口继承的方法 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

从接口继承的方法 com.xforceplus.dao.RoleCustomizedDao

findResourceSetByRoleId, findRolesRelAccount, findRolesResourcesetRel

方法详细资料

deleteById

@Transactional
 @Modifying(clearAutomatically=true)
 @Query(value="delete from Role r where r.id = :id")
void deleteById(@Param(value="id")
                                                                                                                         java.lang.Long id)

指定者:

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

findByName

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.name = :name")
java.util.List<Role> findByName(@Param(value="name")
                                                                                                                         java.lang.String name)

根据角色名称列表

参数:

name - 角色

返回:

List

findByNameAndId

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.name = :name and r.id<>:roleId")
java.util.List<Role> findByNameAndId(@Param(value="name")
                                                                                                                                                java.lang.String name,
                                                                                                                                                @Param(value="roleId")
                                                                                                                                                java.lang.Long roleId)

根据ID查询角色名称，不等于当前ID

参数:

name - 角色

roleId - 角色

返回:

List

findByTenantIdAndRoleCodes

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.tenantId = :tenantId and r.code in (:roleCodes)")
java.util.List<Role> findByTenantIdAndRoleCodes(@Param(value="tenantId")
                                                                                                                                                                            long tenantId,
                                                                                                                                                                            @Param(value="roleCodes")
                                                                                                                                                                            java.util.Collection<java.lang.String> roleCodes)

updateStatus

@Transactional
 @Modifying(flushAutomatically=true)
 @Query(value="update Role r set r.status = :status where r.id = :roleId and r.tenantId = :tenantId")
int updateStatus(@Param(value="tenantId")
                                                                                                                                                                           long tenantId,
                                                                                                                                                                           @Param(value="roleId")
                                                                                                                                                                           long roleId,
                                                                                                                                                                           @Param(value="status")
                                                                                                                                                                           int status)

updateStatus

@Transactional
 @Modifying(flushAutomatically=true)
 @Query(value="update Role r set r.status = :status where r.id = :roleId")
int updateStatus(@Param(value="roleId")
                                                                                                                                                long roleId,
                                                                                                                                                @Param(value="status")
                                                                                                                                                int status)

findByTenantIdAndFromRoleId

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.tenantId = :tenantId and r.fromRoleId =:fromRoleId")
java.util.List<Role> findByTenantIdAndFromRoleId(@Param(value="tenantId")
                                                                                                                                                                                long tenantId,
                                                                                                                                                                                @Param(value="fromRoleId")
                                                                                                                                                                                long fromRoleId)

findIdByTenantIdAndCode

@Transactional(readOnly=true)
 @Query(value="select r.id from Role r where r.tenantId = :tenantId and r.code =:roleCode")
java.lang.Long findIdByTenantIdAndCode(@Param(value="tenantId")
                                                                                                                                                                 long tenantId,
                                                                                                                                                                 @Param(value="roleCode")
                                                                                                                                                                 java.lang.String roleCode)

findByTenantIdAndCode

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.tenantId = :tenantId and r.code =:roleCode")
Role findByTenantIdAndCode(@Param(value="tenantId")
                                                                                                                                                  long tenantId,
                                                                                                                                                  @Param(value="roleCode")
                                                                                                                                                  java.lang.String roleCode)

findByListTenantIdAndCode

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.tenantId = :tenantId and r.code =:roleCode")
java.util.List<Role> findByListTenantIdAndCode(@Param(value="tenantId")
                                                                                                                                                                      long tenantId,
                                                                                                                                                                      @Param(value="roleCode")
                                                                                                                                                                      java.lang.String roleCode)

countDifferentByTenantIdAndCode

@Transactional(readOnly=true)
 @Query(value="select count(*) from sys_role where tenant_id = :tenantId and role_code =:roleCode and role_id <> :currentId",
       nativeQuery=true)
long countDifferentByTenantIdAndCode(@Param(value="tenantId")
                                                                                                                                                                                                                          long tenantId,
                                                                                                                                                                                                                          @Param(value="currentId")
                                                                                                                                                                                                                          long currentId,
                                                                                                                                                                                                                          @Param(value="roleCode")
                                                                                                                                                                                                                          java.lang.String roleCode)

countDifferentByTenantIdAndName

@Transactional(readOnly=true)
 @Query(value="select count(*) from sys_role where tenant_id = :tenantId and role_name =:roleName and role_id <> :currentId",
       nativeQuery=true)
long countDifferentByTenantIdAndName(@Param(value="tenantId")
                                                                                                                                                                                                                          long tenantId,
                                                                                                                                                                                                                          @Param(value="currentId")
                                                                                                                                                                                                                          long currentId,
                                                                                                                                                                                                                          @Param(value="roleName")
                                                                                                                                                                                                                          java.lang.String roleName)

findByTenantId

@Transactional(readOnly=true)
java.util.List<Role> findByTenantId(java.lang.Long oldTenantId)

batchUpdateTenant

@Transactional
 @Modifying(flushAutomatically=true)
 @Query(value="update Role r set r.tenantId = :tenantId where r.id in (:roleIds)")
void batchUpdateTenant(@Param(value="roleIds")
                                                                                                                                                              java.util.List<java.lang.Long> roleIds,
                                                                                                                                                              @Param(value="tenantId")
                                                                                                                                                              java.lang.Long tenantId)

getOrgRoleCntByGradingRoleIds

@Transactional(readOnly=true)
 @Query(value="select new com.xforceplus.domain.tenant.OrgRoleCntDTO(r.fromRoleId, count(r.id)) from Role r where r.tenantId = :tenantId and r.fromRoleId in :roleIds and r.status =1 and r.type = 2 and (r.expiredDate is null or r.expiredDate >= current_date) group by r.fromRoleId")
java.util.List<com.xforceplus.domain.tenant.OrgRoleCntDTO> getOrgRoleCntByGradingRoleIds(@Param(value="tenantId")
                                                                                                                                                                                                                                                                                                                                                                                                                 java.lang.Long tenantId,
                                                                                                                                                                                                                                                                                                                                                                                                                 @Param(value="roleIds")
                                                                                                                                                                                                                                                                                                                                                                                                                 java.util.Set<java.lang.Long> roleIds)

getRoleUserCntByRoleIds

@Transactional(readOnly=true)
 @Query(value="select new com.xforceplus.domain.tenant.RoleUserCntDTO(r.id, count(rel.id)) from Role r left join com.xforceplus.entity.RoleUserRel rel on rel.roleId = r.id where r.tenantId = :tenantId and r.id in :roleIds group by r.id")
java.util.List<com.xforceplus.domain.tenant.RoleUserCntDTO> getRoleUserCntByRoleIds(@Param(value="tenantId")
                                                                                                                                                                                                                                                                                                                                                                java.lang.Long tenantId,
                                                                                                                                                                                                                                                                                                                                                                @Param(value="roleIds")
                                                                                                                                                                                                                                                                                                                                                                java.util.Set<java.lang.Long> roleIds)

disableOrgRolesByGradingRoleId

@Transactional
 @Modifying(flushAutomatically=true)
 @Query(value="update Role r set r.status = 0 where r.fromRoleId = :roleId")
void disableOrgRolesByGradingRoleId(@Param(value="roleId")
                                                                                                                                                                     java.lang.Long roleId)

findByListTenantIdAndName

@Transactional(readOnly=true)
 @Query(value="select r from Role r where r.tenantId = :tenantId and r.name =:roleName")
java.util.List<Role> findByListTenantIdAndName(@Param(value="tenantId")
                                                                                                                                                                      java.lang.Long tenantId,
                                                                                                                                                                      @Param(value="roleName")
                                                                                                                                                                      java.lang.String roleName)

deleteByTenantIdAndIds

@Transactional
 @Modifying(clearAutomatically=true)
 @Query(value="delete from Role r where r.tenantId = :tenantId and r.id in :roleIds")
void deleteByTenantIdAndIds(@Param(value="tenantId")
                                                                                                                                                                      long tenantId,
                                                                                                                                                                      @Param(value="roleIds")
                                                                                                                                                                      java.util.List<java.lang.Long> roleIds)

findFromIdByOrgRoleIds

@Transactional(readOnly=true)
 @Query(value="select r.fromRoleId from Role r where r.id in :roleIds and r.type = 2 and r.status = 1 and (r.expiredDate is null or r.expiredDate >= current_date)")
java.util.Set<java.lang.Long> findFromIdByOrgRoleIds(@Param(value="roleIds")
                                                                                                                                                                                                                                                        java.util.Set<java.lang.Long> roleIds)

countRoleByTenantIdAndIdAndType

@Transactional(readOnly=true)
 @Query(value="select count(r.id) from Role r where r.tenantId = :tenantId and r.id = :roleId and r.type = :type and r.status = 1 and (r.expiredDate is null or r.expiredDate >= current_date)")
long countRoleByTenantIdAndIdAndType(@Param(value="tenantId")
                                                                                                                                                                                                                                                                    long tenantId,
                                                                                                                                                                                                                                                                    @Param(value="roleId")
                                                                                                                                                                                                                                                                    long roleId,
                                                                                                                                                                                                                                                                    @Param(value="type")
                                                                                                                                                                                                                                                                    int type)