iden_server/src/main/java/com/care/demo/service/impl/SystemDictionariesServiceImpl.java

package com.care.demo.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.care.common.exception.BDException;
import com.care.common.vo.PageResVO;
import com.care.demo.entity.RimsDictionaries;
import com.care.demo.mapper.RimsDictionariesMapper;
import com.care.demo.service.SystemDictionariesService;
import com.care.common.util.PageUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

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


/**
 * @author nhc
 * @version 1.0
 * @description 系统设置-字典管理模块-业务逻辑层接口实现类
 * @date 2021/02/08/19:41
 */
@Service
public class SystemDictionariesServiceImpl implements SystemDictionariesService {

    @Resource
    private RimsDictionariesMapper rimsDictionariesMapper;


    /**
     * 无条件分页查询
     * 业务逻辑：
     * 1、先通过传递过来的页面大小与查询到的总记录数算出总页数；
     * 2、根据总页数限制当前页的范围不会越界
     * 3、先查询一级字典集合，通过遍历id映射二级字典PID查询出的集合填充进对象
     * 4、将补全完整的Page工具类携带所有搜索数据返回
     * @param page 分页参数对象
     * @return 返回携带数据的分页工具对象z
     */
    @Override
    public PageUtil<RimsDictionaries> getDictionaries(PageResVO page) {
        //1、创建一个分页工具对象（然后对分页数据进行整理）
        PageUtil<RimsDictionaries> pageUtil = new PageUtil<>();
        //2、更新当前页面大小
        pageUtil.setPageSize(page.getPageSize());
        //3、获取无条件查询总记录数
        //因为只对一级记录进行分页，所以要查询的是所有一级记录的总记录数
        QueryWrapper<RimsDictionaries> wrapper = new QueryWrapper<>();
        //查询条件为 PID = 0 为一级目录
        wrapper.lambda()
                .eq(RimsDictionaries::getPid, 0);
        pageUtil.setTotal(rimsDictionariesMapper.selectCount(wrapper));
        //4、更新当前页码（此时页码将不会再发生越界问题）
        pageUtil.setCurrent(page.getCurrent());
        //一级字典分页集合
        List<RimsDictionaries> dictionariesList1 = new ArrayList<>();
        //添加查询条件查询 所有未被删除的字典数据
        QueryWrapper<RimsDictionaries> dictionariesQueryWrapper = new QueryWrapper<>();
        dictionariesQueryWrapper.lambda()
                .eq(RimsDictionaries::getPid, 0)
                .orderByAsc(RimsDictionaries::getEnable);
        Page<RimsDictionaries> dictionariesPage = rimsDictionariesMapper.selectPage(
                new Page<>(
                        pageUtil.getCurrent(), pageUtil.getPageSize()),
                dictionariesQueryWrapper);
        List<RimsDictionaries> records = dictionariesPage.getRecords();
        for (RimsDictionaries rimsDictionaries : records) {
            //根据一级字典id获取所有二级字典对象集合
            QueryWrapper<RimsDictionaries> wrapper2 = new QueryWrapper<>();
            wrapper2.lambda()
                    .eq(RimsDictionaries::getPid, rimsDictionaries.getId())
                    .orderByAsc(RimsDictionaries::getEnable);
            List<RimsDictionaries> rimsDictionariesList2 =
                    rimsDictionariesMapper.selectList(wrapper2);
            //将二级字典对象set进属性
            rimsDictionaries.setRimsDictionariesList(rimsDictionariesList2);
            //将一级分页对象set进一级字典分页对象集合
            dictionariesList1.add(rimsDictionaries);
        }
        pageUtil.setListT(dictionariesList1);
        return pageUtil;
    }

    /**
     * 多条件分页查询
     * @param rimsDictionaries 字典对象用来承载搜索条件
     * @param page 分页对象
     * @return 符合搜索条件的字典集合
     */
    @Override
    public PageUtil<RimsDictionaries> getDictionariesByPage(RimsDictionaries rimsDictionaries, PageResVO page) {
        //1、创建一个分页工具对象（然后对分页数据进行整理）
        PageUtil<RimsDictionaries> pageUtil = new PageUtil<>();
        //2、更新当前页面大小
        pageUtil.setPageSize(page.getPageSize());
        //3、获取多条件查询总记录数
        pageUtil.setTotal(rimsDictionariesMapper.selectDictionariesByCount(rimsDictionaries));
        //4、更新当前页码（此时页码将不会再发生越界问题）
        pageUtil.setCurrent(page.getCurrent());
        List<RimsDictionaries> dictionariesList = rimsDictionariesMapper.selectDictionariesByPage(rimsDictionaries, pageUtil);
        pageUtil.setListT(dictionariesList);
        return pageUtil;
    }

    /**
     * 字段查重
     * @param rimsDictionaries 收集需要查重的字段参数
     * @return 返回0表示字段没有重复，非零表示有重复
     */
    @Override
    public Integer getDictionaRepetitionCount(RimsDictionaries rimsDictionaries) {
        return rimsDictionariesMapper.selectDictionaRepetitionCount(rimsDictionaries);
    }

    /**
     * 添加记录
     * @param rimsDictionaries 收集需要添加的字段参数
     * @return 添加成功返回 1
     */
    @Override
    public Integer addDictionaries(RimsDictionaries rimsDictionaries) {
        return rimsDictionariesMapper.insert(rimsDictionaries);
    }

    /**
     * 修改记录
     * @param rimsDictionaries 收集需要添加的字段参数
     * @return 修改成功返回 1
     */
    @Override
    public Integer updateDictionaries(RimsDictionaries rimsDictionaries) {
        return rimsDictionariesMapper.updateById(rimsDictionaries);
    }

    /**
     * 删除记录
     * @param id 删除记录的id（有可能是父级id）
     * @return 删除成功返回 1
     */
    @Override
    public Integer deleteDictionariesById(Long id) {
        //先判定是否为父级id
        RimsDictionaries rimsDictionaries = rimsDictionariesMapper.selectById(id);
        if(rimsDictionaries == null){
            return 0;
        }
        //若为父节点，则先删除所有子节点
        if(0 == rimsDictionaries.getPid()){
            QueryWrapper<RimsDictionaries> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(RimsDictionaries::getPid,id);
            rimsDictionariesMapper.delete(wrapper);
        }
        //最后删除当前节点
        return rimsDictionariesMapper.deleteById(id);
    }

    /**
     * 启用停用记录
     * @param rimsDictionaries 字典对象里面包含要修改数据的id和启停值
     * @return 修改成功返回 1
     */
    @Override
    public Integer updateDictionariesEnableById(RimsDictionaries rimsDictionaries) {
        //变更参数承载对象
        RimsDictionaries rd = new RimsDictionaries();
        //根据传入的启用停用值取反
        rd.setEnable(rimsDictionaries.getEnable() == 0 ? 1 : 0);
        //若修改的记录为一级目录，则先修改全部的子目录
        if(rimsDictionaries.getPid() == 0){
            //构建修改条件
            UpdateWrapper<RimsDictionaries> wrapper = new UpdateWrapper<>();
            wrapper.lambda().eq(RimsDictionaries::getPid,rimsDictionaries.getId());
            rimsDictionariesMapper.update(rd, wrapper);
        }
        //最后修改当前节点
        rd.setId(rimsDictionaries.getId());
        return rimsDictionariesMapper.updateById(rd);
    }
    /**
     * 根据编码表dicCode,查询子节点列表
     *
     * @param dicCode
     * @return
     */
    @Override
    public List<RimsDictionaries> listDictionariesByDicCode(String dicCode) {
        if (StringUtils.isEmpty(dicCode)) {
            throw new BDException("请指定要查询的父节点编码");
        }
        QueryWrapper<RimsDictionaries> queryWrapper = new QueryWrapper<>();
        //查询未删除、启用的字典
        queryWrapper.lambda().eq(RimsDictionaries::getDicCode, dicCode);
        RimsDictionaries rimsDictionaries = rimsDictionariesMapper.selectOne(queryWrapper);
        List<RimsDictionaries> rimsDictionariesList =null;
        if(rimsDictionaries!=null){
            QueryWrapper<RimsDictionaries> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(RimsDictionaries::getPid, rimsDictionaries.getId())
                    .eq(RimsDictionaries::getDeleted,0)
                    .eq(RimsDictionaries::getEnable,0)
                    .orderByAsc(RimsDictionaries::getDicSort);
            rimsDictionariesList = rimsDictionariesMapper.selectList(wrapper);
        }
        return rimsDictionariesList;
    }
    /**
     * 根据编码表父节点dicCode,节点dicCode查询节点名称
     * @param pDicCode
     * @param dicCode
     * @return
     */
    @Override
    public String getDictionariesNameByDicCode(String pDicCode,String dicCode) {
        if (StringUtils.isEmpty(pDicCode)&&StringUtils.isEmpty(dicCode)) {
            throw new BDException("请指定要查询的节点编码");
        }
        QueryWrapper<RimsDictionaries> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(RimsDictionaries::getDicCode, pDicCode);
        RimsDictionaries pRimsDictionaries = rimsDictionariesMapper.selectOne(queryWrapper);
        String dictionariesName = "";
        if(pRimsDictionaries!=null){
            QueryWrapper<RimsDictionaries> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(RimsDictionaries::getPid, pRimsDictionaries.getId());
            wrapper.lambda().eq(RimsDictionaries::getDicCode, dicCode);
            RimsDictionaries rimsDictionaries = rimsDictionariesMapper.selectOne(wrapper);
            if(rimsDictionaries!=null){
                dictionariesName = rimsDictionaries.getDictionariesName();
            }
        }
        return dictionariesName;
    }

    /**
     * 以名称为key ，code 为值返回map
     * @param pDicCode
     * @return
     */
    @Override
    public Map<String, String> getReverseDicMapByDicCode(String pDicCode) {
        if(StringUtils.isBlank(pDicCode)){
            return Collections.emptyMap();
        }
        List<RimsDictionaries> dics = listDictionariesByDicCode(pDicCode);
        if(CollUtil.isEmpty(dics)){
            return Collections.emptyMap();
        }
        Map<String,String> resultMap = new HashMap<>(16);
        dics.forEach(dic ->resultMap.put(dic.getDictionariesName(),dic.getDicCode()));
        return resultMap;
    }
}