provider-service/src/main/java/cn/aiyangniu/api/service/impl/system/SysModServiceImpl.java

package cn.aiyangniu.api.service.impl.system;

import cn.aiyangniu.api.service.system.SysModService;
import cn.aiyangniu.api.common.entity.system.SysBtnEntity;
import cn.aiyangniu.api.common.entity.system.SysModEntity;
import cn.aiyangniu.api.common.entity.system.SysModVo;
import cn.aiyangniu.api.mapper.system.SysBtnMapper;
import cn.aiyangniu.api.mapper.system.SysModMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

/**
 * 系统模块服务实现类
 *
 * @author Henry Hall
 * @since 2020-08-08
 */
@Service
public class SysModServiceImpl implements SysModService {

    @Resource
    private SysModMapper modMapper;

    @Resource
    private SysBtnMapper btnMapper;

    /**
     * addMod 添加模块
     *
     * @param modEntity 模块实体对象
     * @return 返回保存结果
     */
    @Override
    public int addMod(SysModEntity modEntity) {
        return modMapper.addMod(modEntity);
    }

    /**
     * delMods 删除模块
     *
     * @param userId 操作人员编号
     * @param modIds 模块编号数组
     * @return 返回删除结果
     */
    @Transactional
    @Override
    public int delMods(String userId, List<String> modIds) {
        List<String> idList = new ArrayList<>();
        List<SysModEntity> modEntities = modMapper.selMods("");
        for(String s : modIds) {
            getModIds(modEntities, s, idList);
        }
        SysModVo sysModVo = new SysModVo();
        sysModVo.setOptUser(userId);
        sysModVo.setModIds(idList);
        btnMapper.delBtnsByModId(sysModVo);
        return modMapper.delMods(sysModVo);
    }

    /**
     * getMod 获取单一模块
     *
     * @param modId 模块编号
     * @return 返回模块对象
     */
    @Override
    public SysModEntity getMod(String modId) {
        return modMapper.getMod(modId);
    }

    /**
     * edtMod 修改模块
     *
     * @param modEntity 模块实体对象
     * @return 返回修改结果
     */
    @Override
    public int edtMod(SysModEntity modEntity) {
        return modMapper.edtMod(modEntity);
    }

    /**
     * listMods 列表显示模块
     *
     * @param parentId 父级编号
     * @return 返回模块列表
     */
    @Override
    public List<SysModEntity> listMods(String parentId) {
        List<SysModEntity> modEntityList = modMapper.listMods();
        // 用于重新排序展示
        if(modEntityList!=null && modEntityList.size()>0) {
            modEntityList = buildTrees(modEntityList, parentId);
        }
        return modEntityList;
    }

    /**
     * selMods 列表显示模块
     *
     * @param kind 查询种类，1为查询全部，2为查询当前用户所拥有的
     * @param userMods 当前用户所拥有的模块
     * @return 返回模块列表
     */
    @Override
    public List<SysModEntity> selMods(String kind, String parentId, String schName, String userMods) {
        List<SysModEntity> modEntityList = modMapper.selMods(schName);
        if(modEntityList!=null && modEntityList.size()>0) {
            if("2".equals(kind)) {
                modEntityList.removeIf(modEntity -> !userMods.contains(modEntity.getModCode()));
            }
            modEntityList = buildTrees(modEntityList, parentId);
        }
        return modEntityList;
    }

    /**
     * sortMods 统计子级模块数量，用于排序
     *
     * @param parentId 父级编号
     * @return 返回新增结果
     */
    @Override
    public int sortMods(String parentId) {
        return modMapper.sortMods(parentId);
    }

    /**
     * getModBtns 获取模块及按钮信息
     *
     * @return 返回模块列表
     */
    @Override
    public List<SysModEntity> getModBtns() {
        List<SysModEntity> newList = null;
        List<SysModEntity> moduleEntities = modMapper.selMods("");
        List<SysBtnEntity> buttonEntities = btnMapper.selBtns();
        if(moduleEntities != null && moduleEntities.size() > 0) {
            List<SysBtnEntity> btnEntities;
            for(SysModEntity sysModEntity : moduleEntities) {
                btnEntities = new ArrayList<>();
                for(SysBtnEntity sysBtnEntity : buttonEntities) {
                    if(sysModEntity.getModId().equals(sysBtnEntity.getModId())) {
                        btnEntities.add(sysBtnEntity);
                    }
                }
                sysModEntity.setButtonList(btnEntities);
            }
            String parentId = "00000000-0000-0000-0000-000000000000";
            newList = new ArrayList<>();
            int modLevel = 0;
            for(SysModEntity curEnt: moduleEntities) {
                if(parentId.equals(curEnt.getParentId())) {
                    curEnt.setModLevel(modLevel);
                    newList.add(curEnt);
                    getChildMod(moduleEntities, curEnt.getModId(), newList, modLevel);
                }
            }
        }
        return newList;
    }

    /**
     * 获取树型的节点下所有子节点编号
     *
     * @param ents 模块的List
     * @param cid  当前模块编号
     */
    private void getModIds(List<SysModEntity> ents, String cid, List<String> idList) {
        if(ents != null && ents.size() > 0 && !"".equals(cid)) {
            idList.add(cid);
            List<SysModEntity> list = getModules(ents, cid);
            if(list.size() > 0) {
                for(SysModEntity cEntity : list) {
                    getModIds(ents, cEntity.getModId(), idList);
                }
            }
        }
    }

    /**
     * 获取树型的节点下所有子节点对象List
     *
     * @param ents 模块的List
     * @param cid  当前模块编号
     */
    private List<SysModEntity> getModules(List<SysModEntity> ents, String cid) {
        List<SysModEntity> list = new ArrayList<>();
        if(ents != null && ents.size() > 0) {
            for(SysModEntity cEntity : ents) {
                if(cid.equals(cEntity.getParentId())) {
                    list.add(cEntity);
                }
            }
        }
        return list;
    }

    /**
     * 从已有List中找出与父级编号一致的，放到新的List中, 用于递归排序
     *
     * @param lists 已有List数组
     * @param parentId 父级编号
     * @param newList 新的List数组
     * @param modLevel 模块级别
     */
    private static void getChildMod(List<SysModEntity> lists, String parentId, List<SysModEntity> newList, int modLevel) {
        if(lists != null && lists.size() > 0) {
            modLevel++;
            for(SysModEntity entity : lists) {
                if(entity.getParentId().equals(parentId)) {
                    entity.setModLevel(modLevel);
                    newList.add(entity);
                    getChildMod(lists, entity.getModId(), newList, modLevel);
                }
            }
        }
    }

    /**
     * 递归筛选组织前端所需要的数据格式
     *
     * @param lists    组织对象数组List
     * @param parentId 父级编号
     * @return 返回要求的数据格式
     */
    private List<SysModEntity> buildTrees(List<SysModEntity> lists, String parentId) {
        List<SysModEntity> entities = new ArrayList<>();
        if(lists != null && lists.size() > 0) {
            for(SysModEntity cEntity : lists) {
                if(cEntity.getParentId().equals(parentId)) {
                    entities.add(findChildren(cEntity, lists));
                }
            }
        }
        return entities;
    }

    private static SysModEntity findChildren(SysModEntity typeEntity, List<SysModEntity> lists) {
        if(lists != null && lists.size() > 0) {
            for(SysModEntity entity : lists) {
                if(entity.getParentId().equals(typeEntity.getModId())) {
                    if(typeEntity.getChildren() == null) {
                        typeEntity.setChildren(new ArrayList<>());
                    }
                    typeEntity.getChildren().add(findChildren(entity, lists));
                }
            }
        }
        return typeEntity;
    }
}