[add]字典管理

framework-clouds/common/src/main/java/org/arch/common/modules/base/dto/DictDetailListDTO.java

+package org.arch.common.modules.base.dto;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@Data
+@ApiModel("数据字典详情")
+public class DictDetailListDTO {
+    @ApiModelProperty(value = "字典标识")
+    private String label;
+
+    @ApiModelProperty(value = "数据字典Id")
+    private Long dictId;
+
+    @ApiModelProperty(value = "启用状态 0 是 1 否")
+    private Integer flag;
+}

framework-clouds/common/src/main/java/org/arch/common/modules/base/dto/DictListDTO.java

+package org.arch.common.modules.base.dto;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+
+@Data
+@ApiModel("字典列表请求实体类")
+public class DictListDTO {
+    @ApiModelProperty(value = "字典名称")
+    private String name;
+
+    @ApiModelProperty(value = "字典标识")
+    private String typeValue;
+
+    @ApiModelProperty(value = "启用状态 0 是 1 否")
+    private String delFlag;
+
+    @ApiModelProperty(value = "当前页")
+    private Integer current;
+
+    @ApiModelProperty(value = "每页显示条数")
+    private Integer pageSize;
+}

framework-system-manage/src/main/java/org/arch/manage/conterller/DictController.java

+package org.arch.manage.conterller;
+
+
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.AllArgsConstructor;
+import org.arch.base.Result;
+import org.arch.common.modules.base.dto.DictDTO;
+import org.arch.common.modules.base.dto.DictListDTO;
+import org.arch.common.modules.base.entity.Dict;
+import org.arch.common.modules.base.entity.DictDetail;
+import org.arch.log.annotation.OperLog;
+import org.arch.log.logenum.LogOperTypeEnum;
+import org.arch.log.logenum.LogTypeEnum;
+import org.arch.manage.service.DictDetailService;
+import org.arch.manage.service.DictService;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 数据字典 前端控制器
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+@Api(value = "/dict", tags = {"数据模型字典管理 前端控制器"})
+@RestController
+@RequestMapping("/dict")
+@AllArgsConstructor
+public class DictController {
+
+    private final DictService dictService;
+
+    private final DictDetailService dictDetailService;
+
+    @ApiOperation(value = "根据字典标识取字典")
+    @PostMapping(value = "/gDictByKey")
+    //@AutoLog(value = LogEventTypeEnum.SEARCH, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.LOW, description = "根据标示获取字典")
+    @OperLog(value = LogOperTypeEnum.QUERY, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "根据标示获取字典", moduleName = "数据模型字典管理")
+    public Result<Object> getDictByKey(@RequestBody DictDTO model) {
+        String key = model.getKey();
+        return Result.success(dictService.getDictDetails(key));
+    }
+
+    @ApiOperation(value = "获取字典所有key")
+    @PostMapping(value = "/gAllDictKey")
+    //@AutoLog(value = LogEventTypeEnum.SEARCH, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.LOW, description = "获取所有字典的KEY")
+    @OperLog(value = LogOperTypeEnum.QUERY, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "获取所有字典的KEY", moduleName = "数据模型字典管理")
+    public Result<Object> getDictByKey() {
+        return Result.success(dictService.getAllDict());
+    }
+
+    @GetMapping(value = "/getDictLabels")
+    @ApiOperation(value = "根据字典标识查询字典下拉列表", notes = "根据字典标识查询字典下拉列表")
+    //@AutoLog(value = LogEventTypeEnum.SEARCH, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.LOW, description = "根据字典标识查询字典下拉列表")
+    @OperLog(value = LogOperTypeEnum.QUERY, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "根据字典标识查询字典下拉列表", moduleName = "数据模型字典管理")
+    public Result<List<DictDetail>> getDictLabels(String typeValue) {
+        QueryWrapper<Dict> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("type_value", typeValue);
+        Dict one = dictService.getOne(queryWrapper);
+        QueryWrapper<DictDetail> detailQueryWrapper = new QueryWrapper<>();
+        detailQueryWrapper.eq("dict_id", one.getId());
+        detailQueryWrapper.eq("flag", 0);
+        detailQueryWrapper.orderByAsc("sort", "grade");
+        List<DictDetail> list = dictDetailService.list(detailQueryWrapper);
+        return Result.success(list);
+    }
+
+
+    @PostMapping(value = "/")
+    @ApiOperation(value = "数据字段列表管理", notes = "数据字段列表管理")
+    //@AutoLog(value = LogEventTypeEnum.SEARCH, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.LOW, description = "数据字段列表管理")
+    @OperLog(value = LogOperTypeEnum.QUERY, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "数据字段列表管理", moduleName = "数据模型字典管理")
+    public Result<Page<Dict>> list(@RequestBody DictListDTO dictListDTO) {
+        Integer current = dictListDTO.getCurrent();
+        Integer pageSize = dictListDTO.getPageSize();
+        if (current == null) {
+            current = 1;
+        }
+        if (pageSize == null) {
+            pageSize = 10;
+        }
+        QueryWrapper<Dict> queryWrapper = Wrappers.query();
+        queryWrapper.like(StrUtil.isNotBlank(dictListDTO.getName()), "a.name", dictListDTO.getName());
+        queryWrapper.like(StrUtil.isNotBlank(dictListDTO.getTypeValue()), "a.type_value", dictListDTO.getTypeValue());
+        queryWrapper.eq(StrUtil.isNotBlank(dictListDTO.getDelFlag()), "a.del_flag", dictListDTO.getDelFlag());
+        queryWrapper.orderByDesc("create_time");
+        Page<Dict> aPage = dictService.page(new Page<>(current, pageSize), queryWrapper);
+        return Result.success(aPage);
+    }
+
+
+    @PostMapping(value = "/update")
+    @ApiOperation(value = "修改数据字典值", notes = "修改数据字典值")
+    //@AutoLog(value = LogEventTypeEnum.UPDATE, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.MIDDLE, description = "修改数据字典值")
+    @OperLog(value = LogOperTypeEnum.UPDATE, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "修改数据字典值", moduleName = "数据模型字典管理")
+    public Result<Object> update(@RequestBody Dict params) {
+        dictService.updateById(params);
+        return Result.success();
+    }
+
+
+    @PostMapping(value = "/create")
+    @ApiOperation(value = "新增数据字典值", notes = "新增数据字典值")
+    //@AutoLog(value = LogEventTypeEnum.INSERT, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.MIDDLE, description = "新增数据字典值")
+    @OperLog(value = LogOperTypeEnum.ADD, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "新增数据字典值", moduleName = "数据模型字典管理")
+    public Result<Object> create(@RequestBody Dict params) {
+        params.setCreateTime(DateTime.now());
+//        params.setCreateMan(getUserId());  // 从登录信息中拿当前登录人，暂时业务功能未实现
+        dictService.save(params);
+        return Result.success();
+    }
+
+
+    @PostMapping(value = "/delete")
+    @ApiOperation(value = "是否禁用-数据字典值", notes = "是否禁用-数据字典值")
+    //@AutoLog(value = LogEventTypeEnum.UPDATE, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.MIDDLE, description = "是否禁用-数据字典值")
+    @OperLog(value = LogOperTypeEnum.UPDATE, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "是否禁用", moduleName = "数据模型字典管理")
+    public Result<Object> delete(@RequestBody String id) {
+        JSONObject jsonObject = JSONObject.parseObject(id);
+        id = jsonObject.getString("id");
+        QueryWrapper<Dict> qwrapper = Wrappers.query();
+        qwrapper.eq("id", id);
+        Dict d = dictService.getOne(qwrapper);
+        UpdateWrapper<Dict> wrapper = Wrappers.update();
+        wrapper.eq("id", id);
+        if (d.getDelFlag() == null || d.getDelFlag() == 0) {
+            wrapper.set("del_flag", 1);
+        } else {
+            wrapper.set("del_flag", 0);
+        }
+        dictService.update(wrapper);
+        return Result.success();
+    }
+
+
+    @PostMapping(value = "/phyDel")
+    @ApiOperation(value = "物理删除-数据字典值", notes = "物理删除-数据字典值")
+    //@AutoLog(value = LogEventTypeEnum.DELETE, LogTypeValue = LogTypeEnum.BUSI_LOG, LogLevValue = LogLevEnum.HIGH, description = "物理删除-数据字典值")
+    @OperLog(value = LogOperTypeEnum.DELETE, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "物理删除", moduleName = "数据模型字典管理")
+    public Result<Object> phyDel(@RequestBody String id) {
+        JSONObject jsonObject = JSONObject.parseObject(id);
+        id = jsonObject.getString("id");
+        QueryWrapper<Dict> qwrapper = Wrappers.query();
+        qwrapper.eq("id", id);
+        Dict dict = dictService.getOne(qwrapper);
+        Assert.notNull(dict,"删除的字典不存在！");
+        // 判断该字典是否有字典详情清单，若存在一并删除
+        QueryWrapper<DictDetail> dDQueryWrapper = Wrappers.query();
+        dDQueryWrapper.eq("dict_id",dict.getId());
+        List<DictDetail> list = dictDetailService.list(dDQueryWrapper);
+        if(!CollectionUtils.isEmpty(list)){
+            List<Long> ids = list.stream().map(item -> item.getId()).collect(Collectors.toList());
+            dictDetailService.delByIds(ids);
+        }
+        dictService.removeById(dict.getId());
+        return Result.success();
+    }
+}

framework-system-manage/src/main/java/org/arch/manage/conterller/DictDetailController.java

+package org.arch.manage.conterller;
+
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.AllArgsConstructor;
+import org.arch.base.Result;
+import org.arch.common.modules.base.dto.DictDetailListDTO;
+import org.arch.common.modules.base.entity.DictDetail;
+import org.arch.log.annotation.OperLog;
+import org.arch.log.logenum.LogOperTypeEnum;
+import org.arch.log.logenum.LogTypeEnum;
+import org.arch.manage.service.DictDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@Api(value = "/dictDetail", tags = {"数据字典详情 前端控制器"})
+@RestController
+@RequestMapping("/dictDetail")
+@AllArgsConstructor
+public class DictDetailController {
+
+    @Autowired
+    private DictDetailService dictDetailService;
+
+
+    @ApiOperation(value = "维护-数据详情字典值列表查询")
+    @PostMapping(value = "/")
+    @OperLog(value = LogOperTypeEnum.ADD, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "维护-数据详情字典值列表查询", moduleName = "数据字典详情")
+    public Result<Page<DictDetail>> list(@RequestBody DictDetailListDTO dictDetailListDTO) {
+        QueryWrapper<DictDetail> queryWrapper = Wrappers.query();
+        queryWrapper.like(StrUtil.isNotBlank(dictDetailListDTO.getLabel()), "label", dictDetailListDTO.getLabel());
+        queryWrapper.eq("dict_id", dictDetailListDTO.getDictId());
+
+        if (dictDetailListDTO.getFlag() != null) {
+            queryWrapper.eq("flag", dictDetailListDTO.getFlag());
+        }
+        List<DictDetail> list = dictDetailService.list(queryWrapper);
+        return Result.success(list);
+    }
+
+    @PostMapping(value = "/details")
+    @ApiOperation(value = "查询-数据详情字典值")
+    @OperLog(value = LogOperTypeEnum.QUERY, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "查询-数据详情字典值", moduleName = "数据字典详情")
+    public Result<DictDetail> getById(String id) {
+        return Result.success(dictDetailService.getById(id));
+    }
+
+    @PostMapping(value = "/create")
+    @ApiOperation(value = "新建-数据详情字典值")
+    @OperLog(value = LogOperTypeEnum.ADD, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "新建-数据详情字典值", moduleName = "数据字典详情")
+    public Result<Object> create(@RequestBody DictDetail params) {
+        dictDetailService.save(params);
+        return Result.success();
+    }
+
+    @PostMapping(value = "/update")
+    @ApiOperation(value = "修改-数据详情字典值")
+    @OperLog(value = LogOperTypeEnum.UPDATE, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "修改-数据详情字典值", moduleName = "数据字典详情")
+    public Result<Object> updateById(@RequestBody DictDetail params) {
+        dictDetailService.updateById(params);
+        return Result.success();
+    }
+
+
+    @PostMapping(value = "/delete")
+    @ApiOperation(value = "是否禁用-数据详情字典值")
+    @OperLog(value = LogOperTypeEnum.DELETE, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "是否禁用-数据详情字典值", moduleName = "数据字典详情")
+    public Result<Object> delete(@RequestBody String id) {
+        JSONObject jsonObject = JSONObject.parseObject(id);
+        id = jsonObject.getString("id");
+        // dictDetailService.removeById(id);
+        QueryWrapper<DictDetail> qwrapper = Wrappers.query();
+        qwrapper.eq("id", id);
+        DictDetail d = dictDetailService.getOne(qwrapper);
+        UpdateWrapper<DictDetail> wrapper = Wrappers.update();
+        wrapper.eq("id", id);
+        if (d.getFlag() == null || d.getFlag() == 0) {
+            wrapper.set("flag", 1);
+        } else {
+            wrapper.set("flag", 0);
+        }
+        dictDetailService.update(wrapper);
+        return Result.success();
+    }
+
+    @PostMapping(value = "/phyDel")
+    @ApiOperation(value = "物理删除-数据详情字典值")
+    @OperLog(value = LogOperTypeEnum.DELETE, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "物理删除-数据详情字典值", moduleName = "数据字典详情")
+    public Result<Object> phyDel(@RequestBody String id) {
+        JSONObject jsonObject = JSONObject.parseObject(id);
+        id = jsonObject.getString("id");
+        // dictDetailService.removeById(id);
+        QueryWrapper<DictDetail> qwrapper = Wrappers.query();
+        qwrapper.eq("id", id);
+        DictDetail dictDetail = dictDetailService.getOne(qwrapper);
+        Assert.notNull(dictDetail,"查询的数据字典详情项不存在!");
+
+        // 删除数据
+        dictDetailService.removeById(id);
+
+        return Result.success();
+    }
+
+
+
+    @PostMapping(value = "/logCount")
+    @ApiOperation(value = "数据字典-日志总数")
+    @OperLog(value = LogOperTypeEnum.QUERY, logTypeValue = LogTypeEnum.BUSI_LOG, operDes = "数据字典-日志总数", moduleName = "数据字典详情")
+    public Result<DictDetail> getById() {
+        QueryWrapper<DictDetail> dictDetailQueryWrapper = Wrappers.query();
+        dictDetailQueryWrapper.eq("label","日志总数");
+        return Result.success(dictDetailService.getOne(dictDetailQueryWrapper));
+    }
+
+
+}

framework-system-manage/src/main/java/org/arch/manage/mapper/DictDetailMapper.java

+package org.arch.manage.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import org.arch.common.modules.base.entity.DictDetail;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 数据字典详情 Mapper 接口
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+@Repository
+@Mapper
+public interface DictDetailMapper extends MPJBaseMapper<DictDetail> {
+    @Select("select * from sys_dict_detail dd\n" +
+            "left join sys_dict d on dd.dict_id = d.id\n" +
+            "where d.type_value = #{value} and dd.label = #{label}")
+    DictDetail getDictDetail(String value, String label);
+
+    List<DictDetail> getDictByTypeValues(@Param("value") String value, @Param("values") String... values);
+    List<DictDetail> getDictByTypeValuesList(@Param("value") String value, @Param("values") String[] values);
+}

framework-system-manage/src/main/java/org/arch/manage/mapper/DictMapper.java

+package org.arch.manage.mapper;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Constants;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+import org.arch.common.modules.base.entity.Dict;
+import org.springframework.stereotype.Repository;
+
+/**
+ * <p>
+ * 数据字典 Mapper 接口
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+@Repository
+@Mapper
+public interface DictMapper extends BaseMapper<Dict> {
+
+	  @Select("<script>" +
+	            "SELECT a.*, b.label AS delFlagN " +
+	            "FROM sys_dict a " +
+	            "LEFT JOIN sys_dict_detail b ON a.del_flag = b.`value` AND b.dict_id = (SELECT id FROM sys_dict WHERE type_value = 'del_flag') " +
+	           
+	            "${ew.customSqlSegment}" +
+	            "</script>")
+	    @Override
+	    <E extends IPage<Dict>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<Dict> queryWrapper);
+}

framework-system-manage/src/main/java/org/arch/manage/service/DictDetailService.java

+package org.arch.manage.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.arch.common.modules.base.entity.DictDetail;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>
+ * 数据字典详情 服务类
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+public interface DictDetailService extends IService<DictDetail> {
+
+
+    DictDetail getDictDetail(String value, String label);
+
+    List<DictDetail> getGroupDictDetails(Long dictId);
+
+    Map<String, String> getGroupDictDetailsMap(Long dictId);
+
+    List<DictDetail> getDictByTypeValues(String type, String... values);
+    List<DictDetail> getDictByTypeValuesList(String type, String[] values);
+
+    void delByIds(List<Long> ids);
+}

framework-system-manage/src/main/java/org/arch/manage/service/DictService.java

+package org.arch.manage.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import org.arch.common.modules.base.entity.Dict;
+import org.arch.common.modules.base.entity.DictDetail;
+
+
+import java.util.List;
+
+/**
+ * <p>
+ * 数据字典 服务类
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+public interface DictService extends IService<Dict> {
+    /**
+     * 根据层级和类型获取字典id
+     *
+     * @param type  架构类型
+     * @param grade 层级
+     * @return 字典id
+     */
+    public Long getDictId(String type, Integer grade);
+
+    /**
+     * 根据key获取字典值
+     */
+    public List<DictDetail> getDictDetailsByKey(String key);
+
+    /**
+     * 获取 Dict 详细信息
+     * <p>
+     * 此方法使用mybatis left join 方法可以提高性能
+     * </>
+     *
+     * @param key 字典类型
+     * @return {@link List}<{@link DictDetail}>
+     */
+    List<DictDetail> getDictDetails(String key);
+
+    /**
+     * 获取所有字典
+     *
+     * @return {@link List}<{@link Dict}>
+     */
+    List<Dict> getAllDict();
+}

framework-system-manage/src/main/java/org/arch/manage/service/impl/DictDetailServiceImpl.java

+package org.arch.manage.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+import org.arch.base.enums.DelFlagEnum;
+import org.arch.common.modules.base.entity.DictDetail;
+import org.arch.manage.mapper.DictDetailMapper;
+import org.arch.manage.service.DictDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 数据字典详情 服务实现类
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+@Service
+public class DictDetailServiceImpl extends ServiceImpl<DictDetailMapper, DictDetail> implements DictDetailService {
+
+    @Autowired
+    DictDetailMapper dictDetailMapper;
+
+    @Override
+    public DictDetail getDictDetail(String value, String label) {
+        return dictDetailMapper.getDictDetail(value, label);
+    }
+
+    @Override
+    public List<DictDetail> getGroupDictDetails(Long dictId) {
+        QueryWrapper<DictDetail> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("dict_id", dictId);
+        queryWrapper.eq("flag", DelFlagEnum.SHOW.ordinal());
+        queryWrapper.orderByAsc("sort");
+        return list(queryWrapper);
+    }
+
+    @Override
+    public Map<String, String> getGroupDictDetailsMap(Long dictId) {
+        List<DictDetail> groupDictDetails = getGroupDictDetails(dictId);
+        Map<String, String> groupMap = groupDictDetails.stream()
+                .collect(Collectors.toMap(dictDetail -> dictDetail.getValue(), dictDetail -> dictDetail.getLabel()));
+        if (groupMap == null || groupMap.isEmpty()) {
+            return new LinkedHashMap<>();
+        }
+        return groupMap;
+    }
+
+    @Override
+    public List<DictDetail> getDictByTypeValues(String type, String... values) {
+        List<DictDetail> dictByTypeValues = dictDetailMapper.getDictByTypeValues(type, values);
+        return dictByTypeValues;
+    }
+    @Override
+    public List<DictDetail> getDictByTypeValuesList(String type, String[] values) {
+        List<DictDetail> dictByTypeValues = dictDetailMapper.getDictByTypeValuesList(type, values);
+        return dictByTypeValues;
+    }
+
+    @Override
+    public void delByIds(List<Long> ids) {
+        dictDetailMapper.deleteBatchIds(ids);
+    }
+}

framework-system-manage/src/main/java/org/arch/manage/service/impl/DictServiceImpl.java

+package org.arch.manage.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+import com.github.yulichang.wrapper.MPJLambdaWrapper;
+import org.arch.base.enums.DelFlagEnum;
+import org.arch.base.exception.BDException;
+import org.arch.base.utils.StringUtils;
+import org.arch.common.modules.base.entity.Dict;
+import org.arch.common.modules.base.entity.DictDetail;
+import org.arch.manage.mapper.DictDetailMapper;
+import org.arch.manage.mapper.DictMapper;
+import org.arch.manage.service.DictDetailService;
+import org.arch.manage.service.DictService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>
+ * 数据字典 服务实现类
+ * </p>
+ *
+ * @author audit
+ * @since 2020-08-27
+ */
+@Service
+public class DictServiceImpl extends ServiceImpl<DictMapper, Dict> implements DictService {
+
+    private static final Logger logger = LoggerFactory.getLogger(DictService.class);
+
+    @Autowired
+    private DictDetailService dictDetailService;
+
+    @Autowired
+    private DictDetailMapper dictDetailMapper;
+
+    @Override
+    public <E extends IPage<Dict>> E page(E page, Wrapper<Dict> queryWrapper) {
+        return getBaseMapper().selectPage(page, queryWrapper);
+    }
+
+    /**
+     * 根据层级和类型获取字典id
+     *
+     * @param type  架构类型
+     * @param grade 层级
+     * @return 字典id
+     */
+    @Override
+    public Long getDictId(String type, Integer grade) {
+        if (StringUtils.isBlank(type)) {
+            logger.info("getDictId-->架构类型为空");
+            throw new BDException("系统错误，请稍后再试！");
+        }
+        if (grade == null) {
+            logger.info("getDictId-->架构层级为空");
+            throw new BDException("系统错误，请稍后再试！");
+        }
+        QueryWrapper<Dict> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("type_value", type);
+        queryWrapper.eq("del_flag", DelFlagEnum.SHOW.getCode());
+        queryWrapper.orderByAsc("sort");
+        Dict dict = this.getOne(queryWrapper);
+        if (dict == null) {
+            logger.info("getDictId-->根据类型{}未查到对应字典数据", type);
+            throw new BDException("系统错误，请稍后再试！");
+        }
+        QueryWrapper<DictDetail> detailQueryWrapper = new QueryWrapper<>();
+        detailQueryWrapper.eq("dict_id", dict.getId());
+        detailQueryWrapper.eq("grade", grade);
+        detailQueryWrapper.eq("flag", DelFlagEnum.SHOW.getCode());
+        detailQueryWrapper.orderByAsc("sort");
+        DictDetail dictDetail = dictDetailService.getOne(detailQueryWrapper);
+        return dictDetail == null ? null : dictDetail.getId();
+    }
+
+    @Override
+    public List<DictDetail> getDictDetailsByKey(String key) {
+        QueryWrapper<Dict> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("type_value", key);
+        Dict one = getOne(queryWrapper);
+        List<DictDetail> details = new ArrayList<>();
+        if (one != null) {
+            Long id = one.getId();
+            details = dictDetailService.getGroupDictDetails(id);
+        }
+        return details;
+    }
+
+    @Override
+    public List<DictDetail> getDictDetails(String key) {
+        return dictDetailMapper.selectJoinList(DictDetail.class, new MPJLambdaWrapper<DictDetail>()
+                .selectAll(DictDetail.class)
+                .leftJoin(Dict.class, Dict::getId, DictDetail::getDictId)
+                .eq(Dict::getTypeValue, key)
+                .eq(DictDetail::getFlag, DelFlagEnum.SHOW.getCode())
+                .orderByAsc("sort", "grade"));
+    }
+
+    @Override
+    public List<Dict> getAllDict() {
+        return baseMapper.selectList(Wrappers.emptyWrapper());
+    }
+}