/** 
 | 
 * Copyright (c) 2018 人人开源 All rights reserved. 
 | 
 * <p> 
 | 
 * https://www.renren.io 
 | 
 * <p> 
 | 
 * 版权所有,侵权必究! 
 | 
 */ 
 | 
  
 | 
package com.zt.modules.sys.service; 
 | 
  
 | 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; 
 | 
import com.zt.common.constant.Constant; 
 | 
import com.zt.common.db.query.QueryFilter; 
 | 
import com.zt.common.exception.ErrorCode; 
 | 
import com.zt.common.exception.RenException; 
 | 
import com.zt.common.service.BaseService; 
 | 
import com.zt.core.context.UserContext; 
 | 
import com.zt.core.sys.model.SysDept; 
 | 
import com.zt.core.sys.model.SysUser; 
 | 
import com.zt.modules.sys.dao.SysRoleDao; 
 | 
import com.zt.modules.sys.dto.UserDto; 
 | 
import com.zt.modules.sys.model.SysMenu; 
 | 
import com.zt.modules.sys.model.SysRole; 
 | 
import com.zt.modules.sys.model.SysRoleMenu; 
 | 
import org.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.stereotype.Service; 
 | 
import org.springframework.transaction.annotation.Transactional; 
 | 
import com.zt.modules.sys.service.SysMenuService; 
 | 
  
 | 
import java.util.List; 
 | 
import java.util.stream.Collectors; 
 | 
  
 | 
/** 
 | 
 * 角色 
 | 
 * 
 | 
 * @author hehz 
 | 
 */ 
 | 
@Service 
 | 
public class SysRoleService extends BaseService<SysRoleDao, SysRole> { 
 | 
    @Autowired 
 | 
    private SysRoleMenuService sysRoleMenuService; 
 | 
    @Autowired 
 | 
    private SysRoleUserService sysRoleUserService; 
 | 
    @Autowired 
 | 
    private SysRoleDataScopeService sysRoleDataScopeService; 
 | 
    @Autowired 
 | 
    private SysDeptService sysDeptService; 
 | 
    @Autowired 
 | 
    private SysMenuService sysMenuService; 
 | 
  
 | 
  
 | 
    public List<SysRole> page(QueryFilter queryFilter) { 
 | 
        // 只查自己所属租户下的 
 | 
        QueryWrapper queryWrapper = queryFilter.getWrapper(); 
 | 
        queryWrapper.eq("tenant_id", UserContext.getUser().getTenantId()); 
 | 
        queryWrapper.eq("type", Constant.RoleType.NORMAL); 
 | 
        return super.query(queryFilter); 
 | 
    } 
 | 
  
 | 
    public List<SysRole> list(Long companyId) { 
 | 
        QueryFilter queryFilter = new QueryFilter(); 
 | 
        QueryWrapper queryWrapper = queryFilter.getWrapper(); 
 | 
        queryWrapper.eq("company_id", companyId); 
 | 
        queryWrapper.eq("type", Constant.RoleType.NORMAL); 
 | 
        return super.query(queryFilter); 
 | 
    } 
 | 
    /** 
 | 
     * 查询sysRole,条件是companyId下的role和其父级部门里面的全部roles 
 | 
     * @param companyId 
 | 
     * @return 
 | 
     */ 
 | 
    public List<SysRole> listWithParents(final Long companyId) { 
 | 
        QueryFilter queryFilter = new QueryFilter(); 
 | 
        QueryWrapper queryWrapper = queryFilter.getWrapper(); 
 | 
        queryWrapper.eq(Constant.TableColumn.IS_DELETE, Constant.Bool.NO); 
 | 
        queryWrapper.ne("type","1"); 
 | 
  
 | 
        List<SysRole> allList=baseDao.selectList(queryWrapper); 
 | 
/* 
 | 
        SysDept company=sysDeptService.get(companyId); 
 | 
  
 | 
        List<SysRole> sysRoles=allList.stream().filter(sysRole -> { 
 | 
            if(sysRole.getCompanyId().equals(companyId)){ 
 | 
                return true; 
 | 
            }else{ 
 | 
                if(company.getPids()!=null){ 
 | 
                    String[] pids=company.getPids().split(","); 
 | 
                    for(String pid:pids){ 
 | 
                        if(sysRole.getCompanyId().equals(new Long(pid))){ 
 | 
                            return true; 
 | 
                        } 
 | 
                    } 
 | 
                } 
 | 
            } 
 | 
            return false; 
 | 
        }).collect(Collectors.toList()); 
 | 
*/ 
 | 
  
 | 
        return allList; 
 | 
    } 
 | 
  
 | 
    public  List<SysUser> getRoleUsers(Long roleID){ 
 | 
        return  sysRoleUserService.getRoleUsers(roleID); 
 | 
    } 
 | 
  
 | 
    @Transactional(rollbackFor = Exception.class) 
 | 
    public void insert(SysRole entity) { 
 | 
        if (entity.getType() == 0) { 
 | 
            entity.setType(Constant.RoleType.NORMAL); 
 | 
        } 
 | 
        if (entity.getCompanyId() == null || entity.getCompanyId() == 0) { 
 | 
            throw new RenException(ErrorCode.PARAMS_GET_ERROR); 
 | 
        } 
 | 
        // 保存角色 
 | 
        super.insert(entity); 
 | 
/*        List<SysMenu> allList = sysMenuService.getAllList(); 
 | 
        for(SysMenu sysMenu:allList){ 
 | 
            SysRoleMenu sysRoleMenu = new SysRoleMenu(); 
 | 
            sysRoleMenu.setMenuId(sysMenu.getId()); 
 | 
            sysRoleMenu.setRoleId(entity.getId()); 
 | 
            sysRoleMenu.setDelete(true); 
 | 
            sysRoleMenuService.insert(sysRoleMenu); 
 | 
        }*/ 
 | 
    } 
 | 
  
 | 
    @Transactional(rollbackFor = Exception.class) 
 | 
    public void update(SysRole entity) { 
 | 
        // 更新角色 
 | 
        super.update(entity); 
 | 
  
 | 
        // 更新角色数据权限关系 
 | 
        // sysRoleDataScopeService.saveOrUpdate(entity.getId(), 
 | 
        // entity.getDeptIdList()); 
 | 
    } 
 | 
  
 | 
    @Transactional(rollbackFor = Exception.class) 
 | 
    public void delete(Long[] ids) { 
 | 
        // 删除角色 
 | 
        this.deleteLogic(ids); 
 | 
  
 | 
        // 删除角色用户关系 
 | 
        sysRoleUserService.deleteByRoleIds(ids); 
 | 
  
 | 
        // 删除角色菜单关系 
 | 
        sysRoleMenuService.deleteByRoleIds(ids); 
 | 
  
 | 
        // 删除角色数据权限关系 
 | 
        sysRoleDataScopeService.deleteByRoleIds(ids); 
 | 
    } 
 | 
  
 | 
    public List<SysRole> getByIds(List<Long> roleIds) { 
 | 
        return baseDao.selectList(new QueryWrapper<SysRole>().lambda().in(SysRole::getId, roleIds)); 
 | 
    } 
 | 
  
 | 
    public List<SysRole> getAllList() { 
 | 
        List<SysRole> roleList = baseDao.selectList(new QueryWrapper<SysRole>().eq(Constant.TableColumn.IS_DELETE, 
 | 
                Constant.Bool.NO).orderByAsc(Constant.TableColumn.SORT)); 
 | 
        return roleList; 
 | 
    } 
 | 
  
 | 
} 
 |