工作方法类型

huangzhen

2023-09-12 4c3795f6f131b942d4c48b8351baafee19296976

工作方法类型

 ruoyi-admin/src/main/java/com/ruoyi/RuoYiApplication.java

@@ -1,5 +1,6 @@
package com.ruoyi;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

 ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysDistrictController.java

@@ -8,6 +8,10 @@
import com.ruoyi.system.domain.SysDistrict;
import com.ruoyi.system.domain.resp.DistrictTreeRespDTO;
import com.ruoyi.system.service.SysDistrictService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.io.Serializable;
@@ -19,8 +23,9 @@
 * @author hz
 * @since 2023-09-07 13:13:47
 */
@Api(tags = "获取区划信息接口")
@RestController
@RequestMapping("/system/sysDistrict/")
@RequestMapping("/system/district/")
public class SysDistrictController {
    /**
     * 获取所有
@@ -29,6 +34,7 @@
    private SysDistrictService sysDistrictService;

    @GetMapping("/list")
    @ApiOperation(value = "区划信息", notes = "获取所有", httpMethod = "GET")
    public AjaxResult selectAll() {
        List<SysDistrict> sysDistricts = sysDistrictService.selectAll();
        return AjaxResult.success(sysDistricts);
@@ -38,6 +44,7 @@
     * 树状返回
     *
     */
    @ApiOperation(value = "区划信息", notes = "获取树形", httpMethod = "GET")
    @GetMapping("/tree")
    public AjaxResult selectAllByTree() {
        List<DistrictTreeRespDTO> sysDistricts = sysDistrictService.selectAllByTree();

 ruoyi-admin/src/main/java/com/ruoyi/web/controller/system/SysOperateTypeController.java

对比新文件
@@ -0,0 +1,132 @@
package com.ruoyi.web.controller.system;



import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.SysOperateType;
import com.ruoyi.system.domain.req.OperateTypeEditReqDTO;
import com.ruoyi.system.domain.req.OperateTypeListReqDTO;
import com.ruoyi.system.domain.req.OperateTypeAddReqDTO;
import com.ruoyi.system.service.SysOperateTypeService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

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

import static com.ruoyi.common.core.domain.AjaxResult.error;
import static com.ruoyi.common.core.domain.AjaxResult.success;

/**
 * @author hz
 * @since 2023-09-07 17:10:06
 */
@Api(tags = "获取作业类型与操作管理接口")
@RestController
@RequestMapping("/system/operateType")
public class SysOperateTypeController  extends BaseController {
    /**
     * 服务对象
     */
    @Resource
    private SysOperateTypeService sysOperateTypeService;

    /**
     * 获取作业类型列表
     */
    @ApiOperation(value = "获取作业类型列表",httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "name", dataTypeClass = String.class,value = "作业类型名称"),
    })
    @PostMapping("/list")
    public AjaxResult list(@RequestBody OperateTypeListReqDTO reqDTO) {
        List<SysOperateType> operateTypes = sysOperateTypeService.selectOperateTypeList(reqDTO);
        return success(operateTypes);
    }

    /**
     * 根据作业类型编号获取详细信息
     */
    @ApiOperation(value = "获取操作类型信息",httpMethod = "GET")
    @ApiImplicitParam(name = "operateTypeId",dataTypeClass = Long.class,value = "操作类型id",required = true)
    @GetMapping(value = "/getInfoById/{id}")
    public AjaxResult getInfo(@PathVariable Long id)
    {
        return success(sysOperateTypeService.selectOperateTypeById(id));
    }

    /**
     * 新增作业类型
     */
    @PostMapping("/add")
    @Log(title = "作业类型管理", businessType = BusinessType.INSERT)
    @ApiOperation(value = "新增作业类型",httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "parentId",dataTypeClass = Long.class, value = "父作业类型id",required = true),
            @ApiImplicitParam(name = "code", dataTypeClass = String.class,value = "作业类型代码",required = true),
            @ApiImplicitParam(name = "name", dataTypeClass = String.class,value = "作业类型名称",required = true),
    })
    public AjaxResult add(@Validated @RequestBody OperateTypeAddReqDTO type) {
        if (!sysOperateTypeService.checkOperateTypeNameUnique(type.getName(),type.getParentId())) {
            return error("新增作业类型'" + type.getName() + "'失败，作业类型名称已存在");
        }
        return toAjax(sysOperateTypeService.insertOperateType(type));
    }

    /**
     * 修改作业类型
     */
    @Log(title = "作业类型管理", businessType = BusinessType.UPDATE)
    @PostMapping("/edit")
    @ApiOperation(value = "修改作业类型",httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", dataTypeClass = Long.class,value = "作业类型id",required = true),
            @ApiImplicitParam(name = "parentId", dataTypeClass = Long.class,value = "父作业类型id",required = true),
            @ApiImplicitParam(name = "code", dataTypeClass = String.class,value = "作业类型代码",required = true),
            @ApiImplicitParam(name = "name", dataTypeClass = String.class,value = "作业类型名称",required = true),
    })
    public AjaxResult edit(@Validated @RequestBody OperateTypeEditReqDTO reqDTO)
    {
        Long id = reqDTO.getId();
        if (!sysOperateTypeService.checkOperateTypeNameUnique(reqDTO.getName(),reqDTO.getParentId()))
        {
            return error("修改作业类型'" + reqDTO.getName() + "'失败，作业类型名称已存在");
        }
        else if (reqDTO.getParentId().equals(id))
        {
            return error("修改作业类型'" + reqDTO.getName() + "'失败，上级作业类型不能是自己");
        }
        return toAjax(sysOperateTypeService.updateOperateType(reqDTO));
    }

    /**
     * 删除作业类型
     */
    @Log(title = "作业类型管理", businessType = BusinessType.DELETE)
    @GetMapping("/removeById/{id}")
    @ApiOperation(value = "删除操作类型信息",httpMethod = "GET")
    @ApiImplicitParam(name = "id",dataTypeClass = Long.class,value = "操作类型id",required = true)
    public AjaxResult remove(@PathVariable Long id)
    {
        if (sysOperateTypeService.hasChildByOperateTypeId(id))
        {
            return warn("存在下级作业类型,不允许删除");
        }
        // TODO (HZ,2023/9/11 9:31,后面完善 由于不知道和哪些表关联)
        //if (sysOperateTypeService.checkDeptExistUser(deptId))
        //{
        //    return warn("作业类型存在用户,不允许删除");
        //}
        return toAjax(sysOperateTypeService.deleteOperateTypeById(id));
    }
}


 ruoyi-common/src/main/java/com/ruoyi/common/constant/CacheConstants.java

@@ -30,8 +30,12 @@

    public static final String SYS_DISTRICT_LIST_KEY = "sys_district_list";


    public static final String SYS_DISTRICT_TREE_KEY = "sys_district_tree";


    public static final String SYS_OPERATE_TYPE_NAME_KEY = "sys_operate_type_name";

    /**
     * 防重提交 redis key
     */

 ruoyi-common/src/main/java/com/ruoyi/common/core/domain/entity/SysUser.java

@@ -29,6 +29,10 @@
    @Excel(name = "部门编号", type = Type.IMPORT)
    private Long deptId;

    private Long districtId;

    private String unit;

    /** 用户账号 */
    @Excel(name = "登录名称")
    private String userName;
@@ -297,11 +301,29 @@
        this.roleId = roleId;
    }

    public Long getDistrictId() {
        return districtId;
    }

    public void setDistrictId(Long districtId) {
        this.districtId = districtId;
    }

    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
            .append("userId", getUserId())
            .append("deptId", getDeptId())
            .append("unit", getUnit())
            .append("districtId", getDistrictId())
            .append("userName", getUserName())
            .append("nickName", getNickName())
            .append("email", getEmail())

 ruoyi-common/src/main/java/com/ruoyi/common/enums/coalmineEnums/DeleteStatusEnum.java

对比新文件
@@ -0,0 +1,32 @@
package com.ruoyi.common.enums.coalmineEnums;

public enum DeleteStatusEnum {

    NO((byte)0,"有效"),
    YES((byte)2,"删除"),
    ;

    private Byte status;
    private String desc;

    DeleteStatusEnum(Byte status, String desc) {
        this.status = status;
        this.desc = desc;
    }

    public Byte getStatus() {
        return status;
    }

    public void setStatus(Byte status) {
        this.status = status;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

 ruoyi-common/src/main/java/com/ruoyi/common/enums/coalmineEnums/EnableStatusEnum.java

对比新文件
@@ -0,0 +1,32 @@
package com.ruoyi.common.enums.coalmineEnums;

public enum EnableStatusEnum {

    NO((byte)0,"停用"),
    YES((byte)1,"启用"),
    ;

    private Byte status;
    private String desc;

    EnableStatusEnum(Byte status, String desc) {
        this.status = status;
        this.desc = desc;
    }

    public Byte getStatus() {
        return status;
    }

    public void setStatus(Byte status) {
        this.status = status;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

 ruoyi-framework/src/main/java/com/ruoyi/framework/web/exception/GlobalExceptionHandler.java

@@ -157,9 +157,10 @@
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Object handleMethodArgumentNotValidException(MethodArgumentNotValidException e)
    {
        log.error(e.getMessage(), e);
        //log.error(e.getMessage(), e);
        log.error(e.getBindingResult().getFieldError()+"");
        String message = e.getBindingResult().getFieldError().getDefaultMessage();
        return AjaxResult.error(message);
        return AjaxResult.error(ResultConstants.PARAM_ERROR.getCode(),message);
    }

    /**

 ruoyi-system/src/main/java/com/ruoyi/system/domain/SysOperateType.java

对比新文件
@@ -0,0 +1,55 @@
package com.ruoyi.system.domain;

import com.baomidou.mybatisplus.annotation.*;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.data.annotation.Id;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author hz
 * @since 2023-09-07 17:10:09
 */
@Data
public class SysOperateType implements Serializable {

    @Id
    @TableId(type = IdType.AUTO)
    private Long id;

    private Long parentId;
    /** 祖级列表 */
    private String ancestors;
    
    private String code;
    
    private String name;

    private Integer type;

    /** 删除标志（0代表存在 2代表删除） */
    private Byte delFlag;

    /** 创建者 */
    @TableField(fill = FieldFill.INSERT)
    private String createBy;

    /** 创建时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;

    /** 更新者 */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private String updateBy;

    /** 更新时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
}


 ruoyi-system/src/main/java/com/ruoyi/system/domain/bo/SysOperateTypeWholeNameBO.java

对比新文件
@@ -0,0 +1,22 @@
package com.ruoyi.system.domain.bo;

import lombok.Data;

import java.io.Serializable;

/**
 * @author Mr.huang
 * @decription
 * @date 2023/9/11 17:14
 */
@Data
public class SysOperateTypeWholeNameBO implements Serializable {

    private Integer type;

    private String qualificationType;

    private String jobCategory;

    private String operationItems;
}

 ruoyi-system/src/main/java/com/ruoyi/system/domain/req/OperateTypeAddReqDTO.java

对比新文件
@@ -0,0 +1,26 @@
package com.ruoyi.system.domain.req;

import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;

/**
 * @author Mr.huang
 * @decription
 * @date 2023/9/8 10:49
 */
@Data
public class OperateTypeAddReqDTO implements Serializable {

    @NotNull(message = "父id不能为空")
    private Long parentId;

    @NotBlank(message = "code不能为空")
    private String code;

    @NotBlank(message = "name不能为空")
    private String name;

}

 ruoyi-system/src/main/java/com/ruoyi/system/domain/req/OperateTypeEditReqDTO.java

对比新文件
@@ -0,0 +1,29 @@
package com.ruoyi.system.domain.req;

import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;

/**
 * @author Mr.huang
 * @decription
 * @date 2023/9/8 10:49
 */
@Data
public class OperateTypeEditReqDTO implements Serializable {

    @NotNull(message = "id不能为空")
    private Long id;

    @NotNull(message = "父id不能为空")
    private Long parentId;

    @NotBlank(message = "code不能为空")
    private String code;

    @NotBlank(message = "name不能为空")
    private String name;

}

 ruoyi-system/src/main/java/com/ruoyi/system/domain/req/OperateTypeListReqDTO.java

对比新文件
@@ -0,0 +1,16 @@
package com.ruoyi.system.domain.req;

import cn.hutool.bloomfilter.filter.SDBMFilter;
import lombok.Data;

/**
 * @author Mr.huang
 * @decription
 * @date 2023/9/8 10:07
 */
@Data
public class OperateTypeListReqDTO{

    private String name;

}

 ruoyi-system/src/main/java/com/ruoyi/system/mapper/SysOperateTypeMapper.java

对比新文件
@@ -0,0 +1,27 @@
package com.ruoyi.system.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.system.domain.SysOperateType;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * @author hz
 * @since 2023-09-07 17:10:08
 */
@Mapper
public interface SysOperateTypeMapper extends BaseMapper<SysOperateType> {

    SysOperateType selectOperateTypeById(Long id);

    List<SysOperateType> selectChildrenOperateTypeById(Long id);

    void updateOperateTypeChildren(List<SysOperateType> sysOperateTypes);

    int hasChildByOperateTypeId(Long id);

    List<SysOperateType> selectOperateTypeByIds(List<Long> list);
}


 ruoyi-system/src/main/java/com/ruoyi/system/service/SysOperateTypeService.java

对比新文件
@@ -0,0 +1,99 @@
package com.ruoyi.system.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.ruoyi.system.domain.SysOperateType;
import com.ruoyi.system.domain.bo.SysOperateTypeWholeNameBO;
import com.ruoyi.system.domain.req.OperateTypeEditReqDTO;
import com.ruoyi.system.domain.req.OperateTypeListReqDTO;
import com.ruoyi.system.domain.req.OperateTypeAddReqDTO;

import java.util.List;

/**
 * @author hz
 * @since 2023-09-07 17:10:09
 */
public interface  SysOperateTypeService extends IService<SysOperateType> {

    /**
     * 查询作业类型管理数据
     */
    public List<SysOperateType> selectOperateTypeList(OperateTypeListReqDTO reqDTO);

    ///**
    // * 查询作业类型树结构信息
    // */
    //public List<TreeSelect> selectDeptTreeList(SysDept dept);
    //
    ///**
    // * 构建前端所需要树结构
    // */
    //public List<SysDept> buildDeptTree(List<SysDept> depts);
    //
    ///**
    // * 构建前端所需要下拉树结构
    // */
    //public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts);

    /**
     * 根据作业类型ID查询信息
     */
    public SysOperateType selectOperateTypeById(Long deptId);

    ///**
    // * 根据ID查询所有子作业类型（正常状态）
    // */
    //public int selectNormalChildrenDeptById(Long deptId);

    /**
     * 是否存在作业类型子节点
     */
    public boolean hasChildByOperateTypeId(Long id);
    //
    ///**
    // * 查询作业类型是否存在用户
    // */
    //public boolean checkDeptExistUser(Long deptId);

    /**
     * 校验作业类型名称是否唯一
     */
    public boolean checkOperateTypeNameUnique(String name,Long parentId);

    /**
     * 新增保存作业类型信息
     */
    public int insertOperateType(OperateTypeAddReqDTO type);

    /**
     * 修改保存作业类型信息
     */
    public int updateOperateType(OperateTypeEditReqDTO reqDTO);

    /**
     * 删除作业类型管理信息
     */
    public int deleteOperateTypeById(Long id);

    /**
     * 根据id获取作业类型完整姓名
     */
    public SysOperateTypeWholeNameBO getOperateTypeWholeNameById(Long id);

    /**
     * 加载字典缓存数据
     */
    public void loadingOperateTypeCache();

    /**
     * 清空字典缓存数据
     */
    public void clearOperateTypeCache();

    /**
     * 重置字典缓存数据
     */
    public void resetOperateTypeCache();

}


 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDeptServiceImpl.java

@@ -45,7 +45,9 @@
    @DataScope(deptAlias = "d")
    public List<SysDept> selectDeptList(SysDept dept)
    {
        return deptMapper.selectDeptList(dept);
        List<SysDept> sysDepts = deptMapper.selectDeptList(dept);
        return sysDepts;
        //return deptMapper.selectDeptList(dept);
    }

    /**

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysOperateTypeServiceImpl.java

对比新文件
@@ -0,0 +1,381 @@
package com.ruoyi.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.constant.ResultConstants;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.coalmineEnums.DeleteStatusEnum;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.system.domain.SysOperateType;
import com.ruoyi.system.domain.bo.SysOperateTypeWholeNameBO;
import com.ruoyi.system.domain.req.OperateTypeEditReqDTO;
import com.ruoyi.system.domain.req.OperateTypeListReqDTO;
import com.ruoyi.system.domain.req.OperateTypeAddReqDTO;
import com.ruoyi.system.mapper.SysOperateTypeMapper;
import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.service.SysOperateTypeService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author hz
 * @since 2023-09-07 17:10:10
 */
@Service("sysOperateTypeService")
public class SysOperateTypeServiceImpl extends ServiceImpl<SysOperateTypeMapper, SysOperateType> implements SysOperateTypeService {

    @Autowired
    private SysOperateTypeMapper operateTypeMapper;

    @Autowired
    private SysRoleMapper roleMapper;

    @PostConstruct
    public void init()
    {
        loadingOperateTypeCache();
    }

    @Override
    public void loadingOperateTypeCache() {
        LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysOperateType::getDelFlag, DeleteStatusEnum.YES.getStatus());
        List<SysOperateType> sysOperateTypes = operateTypeMapper.selectList(wrapper);
        if (!CollectionUtils.isEmpty(sysOperateTypes)){
            Map<Long, SysOperateTypeWholeNameBO> map = new HashMap<>();
            for (SysOperateType sysOperateType : sysOperateTypes) {
                SysOperateTypeWholeNameBO nameBO = this.getOperateTypeWholeNameById(sysOperateType.getId());
                map.put(sysOperateType.getId(),nameBO);
            }
            SpringUtils.getBean(RedisCache.class).setCacheObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY, map);
        }
    }

    @Override
    public void clearOperateTypeCache() {
        if (SpringUtils.getBean(RedisCache.class).hasKey(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY)){
            SpringUtils.getBean(RedisCache.class).deleteObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
        }
    }

    @Override
    public void resetOperateTypeCache() {
        clearOperateTypeCache();
        loadingOperateTypeCache();
    }

    /**
     * 查询作业类型管理数据
     */
    @Override
    public List<SysOperateType> selectOperateTypeList(OperateTypeListReqDTO reqDTO) {
        LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysOperateType::getDelFlag, DeleteStatusEnum.YES.getStatus());
        if (reqDTO != null && !StringUtils.isBlank(reqDTO.getName())){
            wrapper.eq(SysOperateType::getName,reqDTO.getName());
        }
        return operateTypeMapper.selectList(wrapper);
    }

    ///**
    // * 查询作业类型树结构信息
    // */
    //@Override
    //public List<TreeSelect> selectDeptTreeList(SysDept dept)
    //{
    //    List<SysDept> depts = SpringUtils.getAopProxy(this).selectDeptList(dept);
    //    return buildDeptTreeSelect(depts);
    //}
    //
    ///**
    // * 构建前端所需要树结构
    // */
    //@Override
    //public List<SysDept> buildDeptTree(List<SysDept> depts)
    //{
    //    List<SysDept> returnList = new ArrayList<SysDept>();
    //    List<Long> tempList = depts.stream().map(SysDept::getDeptId).collect(Collectors.toList());
    //    for (SysDept dept : depts)
    //    {
    //        // 如果是顶级节点, 遍历该父节点的所有子节点
    //        if (!tempList.contains(dept.getParentId()))
    //        {
    //            recursionFn(depts, dept);
    //            returnList.add(dept);
    //        }
    //    }
    //    if (returnList.isEmpty())
    //    {
    //        returnList = depts;
    //    }
    //    return returnList;
    //}
    //
    ///**
    // * 构建前端所需要下拉树结构
    // */
    //@Override
    //public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts)
    //{
    //    List<SysDept> deptTrees = buildDeptTree(depts);
    //    return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    //}
    //
    ///**
    // * 根据角色ID查询作业类型树信息
    // */
    //@Override
    //public List<Long> selectDeptListByRoleId(Long roleId)
    //{
    //    SysRole role = roleMapper.selectRoleById(roleId);
    //    return operateTypeMapper.selectDeptListByRoleId(roleId, role.isDeptCheckStrictly());
    //}
    //
    /**
     * 根据作业类型ID查询信息
     */
    @Override
    public SysOperateType selectOperateTypeById(Long operateTypeId) {
        if (operateTypeId == null)
            throw new BusinessException(this.getClass(), ResultConstants.PARAM_ERROR);
        return operateTypeMapper.selectOperateTypeById(operateTypeId);
    }
    //
    ///**
    // * 根据ID查询所有子作业类型（正常状态）
    // */
    //@Override
    //public int selectNormalChildrenDeptById(Long deptId)
    //{
    //    return operateTypeMapper.selectNormalChildrenDeptById(deptId);
    //}
    //
    /**
     * 是否存在子节点
     */
    @Override
    public boolean hasChildByOperateTypeId(Long id)
    {
        int result = operateTypeMapper.hasChildByOperateTypeId(id);
        return result > 0;
    }
    //
    ///**
    // * 查询作业类型是否存在用户
    // */
    //@Override
    //public boolean checkDeptExistUser(Long deptId)
    //{
    //    int result = operateTypeMapper.checkDeptExistUser(deptId);
    //    return result > 0;
    //}
    //
    /**
     * 校验作业类型名称是否唯一
     */
    @Override
    public boolean checkOperateTypeNameUnique(String name,Long parentId) {
        if (StringUtils.isBlank(name) || StringUtils.isNull(parentId))
            throw new BusinessException(this.getClass(),ResultConstants.PARAM_ERROR);
        LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysOperateType::getDelFlag,DeleteStatusEnum.NO.getStatus())
                .eq(SysOperateType::getName,name)
                .eq(SysOperateType::getParentId,parentId)
                .last(" limit 1");
        SysOperateType sysOperateType = operateTypeMapper.selectOne(wrapper);
        if (StringUtils.isNotNull(sysOperateType))
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 新增保存作业类型信息
     */
    @Override
    public int insertOperateType(OperateTypeAddReqDTO type) {
        SysOperateType operateType = new SysOperateType();
        BeanUtils.copyProperties(type,operateType);
        if (type.getParentId() != 0) {
            SysOperateType info = operateTypeMapper.selectOperateTypeById(type.getParentId());
            // 如果父节点不为正常状态,则不允许新增子节点
            if (info == null) {
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL, "作业类型不存在，不允许新增");
            }
            operateType.setAncestors(info.getAncestors() + "," + type.getParentId());
            int length = getOperateTypeValue(operateType.getAncestors()).length;
            operateType.setType(length);
        }else {
            operateType.setAncestors("0");
            operateType.setType(1);
        }
        resetOperateTypeCache();
        return operateTypeMapper.insert(operateType);
    }

    private String[] getOperateTypeValue(String ancestors) {
        String[] arr = ancestors.split(",");
        return arr;
    }

    /**
     * 修改保存作业类型信息
     */
    @Override
    public int updateOperateType(OperateTypeEditReqDTO reqDTO)
    {
        SysOperateType newParentOperateType = operateTypeMapper.selectOperateTypeById(reqDTO.getParentId());
        SysOperateType oldOperateType = operateTypeMapper.selectOperateTypeById(reqDTO.getId());
        if ((StringUtils.isNotNull(newParentOperateType) || reqDTO.getParentId() == 0) && StringUtils.isNotNull(oldOperateType))
        {
            String newAncestors;
            if (reqDTO.getParentId() == 0){
                newAncestors =  "0";
            }else {
                newAncestors = newParentOperateType.getAncestors() + "," + newParentOperateType.getId();
            }
            String oldAncestors = oldOperateType.getAncestors();
            BeanUtils.copyProperties(reqDTO,oldOperateType);
            oldOperateType.setAncestors(newAncestors);
            updateOperateTypeChildren(reqDTO.getId(), newAncestors, oldAncestors);
        }
        int result = operateTypeMapper.updateById(oldOperateType);
        resetOperateTypeCache();
        return result;
    }
    //
    ///**
    // * 修改该作业类型的父级作业类型状态
    // *
    // * @param dept 当前作业类型
    // */
    //private void updateParentDeptStatusNormal(SysDept dept)
    //{
    //    String ancestors = dept.getAncestors();
    //    Long[] deptIds = Convert.toLongArray(ancestors);
    //    operateTypeMapper.updateDeptStatusNormal(deptIds);
    //}
    //
    /**
     * 修改子元素关系
     */
    public void updateOperateTypeChildren(Long OperateTypeId, String newAncestors, String oldAncestors)
    {
        List<SysOperateType> children = operateTypeMapper.selectChildrenOperateTypeById(OperateTypeId);
        for (SysOperateType child : children)
        {
            child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            operateTypeMapper.updateOperateTypeChildren(children);
        }
    }

    /**
     * 删除作业类型管理信息
     */
    @Override
    public int deleteOperateTypeById(Long id)
    {
        SysOperateType sysOperateType = operateTypeMapper.selectOperateTypeById(id);
        if (sysOperateType == null)
            return 1;
        sysOperateType.setDelFlag(DeleteStatusEnum.YES.getStatus());
        resetOperateTypeCache();
        return this.operateTypeMapper.updateById(sysOperateType);
    }

    @Override
    public SysOperateTypeWholeNameBO getOperateTypeWholeNameById(Long id) {
        SysOperateType sysOperateType = operateTypeMapper.selectOperateTypeById(id);
        if (sysOperateType == null)
            return null;
        Integer type = sysOperateType.getType();
        SysOperateTypeWholeNameBO bo = new SysOperateTypeWholeNameBO();
        bo.setType(sysOperateType.getType());
        if (type == 1) {
            bo.setQualificationType(sysOperateType.getName());
            return bo;
        }
        String[] value = getOperateTypeValue(sysOperateType.getAncestors());
        List<Long> list = new ArrayList<>();
        for (int i = 0; i < value.length; i++) {
            if (i>0){
                list.add(Long.valueOf(value[i]));
            }
        }
        list.add(id);
        List<SysOperateType> sysOperateTypes = operateTypeMapper.selectOperateTypeByIds(list);
        for (SysOperateType operateType : sysOperateTypes) {
            if (operateType.getType() == 1)
                bo.setQualificationType(operateType.getName());
            if (operateType.getType() == 2)
                bo.setJobCategory(operateType.getName());
            if (operateType.getType() == 3)
                bo.setOperationItems(operateType.getName());
        }
        return bo;
    }
    //
    ///**
    // * 递归列表
    // */
    //private void recursionFn(List<SysDept> list, SysDept t)
    //{
    //    // 得到子节点列表
    //    List<SysDept> childList = getChildList(list, t);
    //    t.setChildren(childList);
    //    for (SysDept tChild : childList)
    //    {
    //        if (hasChild(list, tChild))
    //        {
    //            recursionFn(list, tChild);
    //        }
    //    }
    //}
    //
    ///**
    // * 得到子节点列表
    // */
    //private List<SysDept> getChildList(List<SysDept> list, SysDept t)
    //{
    //    List<SysDept> tlist = new ArrayList<SysDept>();
    //    Iterator<SysDept> it = list.iterator();
    //    while (it.hasNext())
    //    {
    //        SysDept n = (SysDept) it.next();
    //        if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getDeptId().longValue())
    //        {
    //            tlist.add(n);
    //        }
    //    }
    //    return tlist;
    //}
    //
    ///**
    // * 判断是否有子节点
    // */
    //private boolean hasChild(List<SysDept> list, SysDept t)
    //{
    //    return getChildList(list, t).size() > 0;
    //}

}


 ruoyi-system/src/main/resources/mapper/system/SysOperateTypeMapper.xml

对比新文件
@@ -0,0 +1,65 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.system.mapper.SysOperateTypeMapper">

    <resultMap type="com.ruoyi.system.domain.SysOperateType" id="SysOperateTypeResult">
        <id     property="id"     column="id"     />
        <result property="parentId"   column="parent_id"   />
        <result property="ancestors"  column="ancestors"   />
        <result property="code"   column="code"   />
        <result property="name"   column="name"   />
        <result property="type"     column="type"      />
        <result property="delFlag"    column="del_flag"    />
        <result property="createBy"   column="create_by"   />
        <result property="createTime" column="create_time" />
        <result property="updateBy"   column="update_by"   />
        <result property="updateTime" column="update_time" />
    </resultMap>

    <sql id="selectOperateTypeCommon">
        select id, parent_id, ancestors, code, name, type, del_flag, create_by, create_time,update_by,update_time
        from sys_operate_type
    </sql>
    <update id="updateOperateTypeChildren">
        update sys_dept set ancestors =
        <foreach collection="sysOperateTypes" item="item" index="index"
                 separator=" " open="case id" close="end">
            when #{item.id} then #{item.ancestors}
        </foreach>
        where id in
        <foreach collection="sysOperateTypes" item="item" index="index"
                 separator="," open="(" close=")">
            #{item.id}
        </foreach>
    </update>
    <delete id="deleteOperateTypeById">
        update sys_operate_type set del_flag = '2' where id = #{id}
    </delete>

    <select id="selectOperateTypeById" resultType="com.ruoyi.system.domain.SysOperateType">
        <include refid="selectOperateTypeCommon"/>
        where del_flag = '0'
        <if test="id != null">
            AND id = #{id}
        </if>
    </select>

    <select id="selectChildrenOperateTypeById" resultType="com.ruoyi.system.domain.SysOperateType">
        select * from sys_operate_type where find_in_set(#{id}, ancestors)
    </select>
    <select id="hasChildByOperateTypeId" resultType="java.lang.Integer">
        select count(1) from sys_operate_type
        where del_flag = '0' and parent_id = #{id} limit 1
    </select>

    <select id="selectOperateTypeByIds" resultType="com.ruoyi.system.domain.SysOperateType">
        <include refid="selectOperateTypeCommon"/>
        where del_flag = '0' and  id in
        <foreach collection="list" item="id" index="index"
                 separator="," open="(" close=")">
            #{id}
        </foreach>
    </select>
</mapper>