1、事件流程相关接口（为了快速联调，本次只提交接口不分内容-写死临时数据，联调后会全部提交）

liyj

2024-09-07 6775e01c3ed863aa20911c4c120cddced3b21799

1、事件流程相关接口（为了快速联调，本次只提交接口不分内容-写死临时数据，联调后会全部提交）

 dyh-service/dyh-base/src/main/java/cn/huge/module/mediate/constant/FlowNodeBaseEnum.java

New file
@@ -0,0 +1,144 @@
package cn.huge.module.mediate.constant;

/**
 * @title": 工作流节点枚举类
 * @description": 工作流节点枚举类
 * @company": hugeinfo
 * @author": liyj
 * @time": 2021-11-05 16":51":48
 * @version": 1.0.0
 */
public enum FlowNodeBaseEnum {

    /**
     * 节点
     */
    FLOW_NODE_ZXSL("ZXSL", "自行受理"),
    FLOW_NODE_BLFK("BLFK", "办理反馈"),
    FLOW_NODE_JASQ("JASQ", "结案申请"),
    FLOW_NODE_JASH("JASH", "结案审核"),
    FLOW_NODE_DSRPJ("DSRPJ", "当事人评价"),
    FLOW_NODE_JAGD("JAGD", "结案归档"),
    // 镇街级
    FLOW_NODE_ZJ_DFP("ZJ_DFP", "镇街综治中心待分派"),
    FLOW_NODE_ZJ_DSL("ZJ_DSL", "镇街级组织待受理"),
    FLOW_NODE_ZJ_HTSH("ZJ_HTSH", "镇街综治中心回退待审核"),
    // 区级
    FLOW_NODE_QJ_SBSH("QJ_SBSH", "区综治中心上报待审核"),
    FLOW_NODE_QJ_DFP("QJ_DFP", "区综治中心待分派"),
    FLOW_NODE_QJ_DSL("QJ_DSL", "区级组织待受理"),
    FLOW_NODE_QJ_HTSH("QJ_HTSH", "区综治中心回退待审核"),
    // 市级
    FLOW_NODE_SJ_SBSH("SJ_SBSH", "市综治中心上报待审核"),
    FLOW_NODE_SJ_DFP("SJ_DFP", "市综治中心待分派"),
    FLOW_NODE_SJ_DSL("SJ_DSL", "市级组织待受理"),
    FLOW_NODE_SJ_HTSH("SJ_HTSH", "市综治中心回退待审核");

    /**
     * 代码编号
     */
    private String index;

    /**
     * 名称
     */
    private String des;

    public String getIndex() {
        return index;
    }

    public void setIndex(String index) {
        this.index = index;
    }

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    FlowNodeBaseEnum(String index, String des) {
        this.index = index;
        this.des = des;
    }

    /**
     * 静态方法
     * @param index
     * @return
     */
    public static String getDes(String index) {
        for (FlowNodeBaseEnum flowNodeBaseEnum : FlowNodeBaseEnum.values()) {
            if (flowNodeBaseEnum.getIndex().equals(index)) {
                return flowNodeBaseEnum.des;
            }
        }
        return null;
    }

    /**
     * 静态方法
     * @param des
     * @return
     */
    public static String getIndex(String des) {
        for (FlowNodeBaseEnum flowNodeBaseEnum : FlowNodeBaseEnum.values()) {
            if (flowNodeBaseEnum.getDes().equals(des)) {
                return flowNodeBaseEnum.index;
            }
        }
        return null;
    }

    /**
     * 静态方法
     * @param index
     * @return
     */
    public static FlowNodeBaseEnum getByIndex(final String index) {
        switch (index) {
            case "ZXSL":
                return FLOW_NODE_ZXSL;
            case "BLFK":
                return FLOW_NODE_BLFK;
            case "JASQ":
                return FLOW_NODE_JASQ;
            case "JASH":
                return FLOW_NODE_JASH;
            case "DSRPJ":
                return FLOW_NODE_DSRPJ;
            case "JAGD":
                return FLOW_NODE_JAGD;

            case "ZJ_DFP":
                return FLOW_NODE_ZJ_DFP;
            case "ZJ_DSL":
                return FLOW_NODE_ZJ_DSL;
            case "ZJ_HTSH":
                return FLOW_NODE_ZJ_HTSH;

            case "QJ_SBSH":
                return FLOW_NODE_QJ_SBSH;
            case "QJ_DFP":
                return FLOW_NODE_QJ_DFP;
            case "QJ_DSL":
                return FLOW_NODE_QJ_DSL;
            case "QJ_HTSH":
                return FLOW_NODE_SJ_HTSH;

            case "SJ_SBSH":
                return FLOW_NODE_SJ_SBSH;
            case "SJ_DFP":
                return FLOW_NODE_SJ_DFP;
            case "SJ_DSL":
                return FLOW_NODE_SJ_DSL;
            case "SJ_HTSH":
                return FLOW_NODE_SJ_HTSH;
            default:
                return null;
        }
    }
}

 dyh-service/dyh-base/src/main/java/cn/huge/module/sys/constant/FileBaseConsts.java

@@ -16,6 +16,34 @@
    public static final int UPLOADER_TYPE_1 = 1;
    public static final int UPLOADER_TYPE_2 = 2;

    /**
     * 工作流通用任务条件，
     * 前进：forward，退回：back，
     */
    public static final String OPERATION_forward = "forward";
    public static final String OPERATION_back = "back";
    /**
     * 工作流业务任务条件，
     * 自行受理：zxsl
     * 交办给直属组织：jb_zszz，交办给综治中心：jb_zzzx
     * 受理：sl
     * 回退申请：htsq，回退审核同意：htsh_ty，回退审核不同意：htsh_bty
     * 上报：sb，上报审核同意：htsq_ty，上报审核不同意：htsq_bty
     * 结案审核同意：jash_ty，结案审核不同意：jash_bty
     */
    public static final String OPERATION_zxsl = "zxsl";
    public static final String OPERATION_jb_zszz = "jb_zszz";
    public static final String OPERATION_jb_zzzx = "jb_zzzx";
    public static final String OPERATION_sl = "sl";
    public static final String OPERATION_htsq = "htsq";
    public static final String OPERATION_htsh_ty = "htsh_ty";
    public static final String OPERATION_htsh_bty = "htsh_bty";
    public static final String OPERATION_sb = "sb";
    public static final String OPERATION_sbsh_ty = "sbsh_ty";
    public static final String OPERATION_sbsh_bty = "sbsh_bty";
    public static final String OPERATION_jash_ty = "jash_ty";
    public static final String OPERATION_jash_bty = "jash_bty";

}
/**
 * -------------------_ooOoo_-------------------

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/buildcode/service/BuildCodeService.java

@@ -117,7 +117,7 @@
            this.buildWebController(tplData);
            // 可选
//            this.buildWechatController(tplData);
//            this.buildJson(tplData);
            this.buildJson(tplData);
//            this.buildJsForm(tplData);
        } catch (TemplateNotFoundException e) {
            log.error("TemplateNotFoundException");

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseAppearWebController.java

New file
@@ -0,0 +1,245 @@
package cn.huge.module.cases.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.cases.domain.po.CaseAppear;
import cn.huge.module.cases.service.CaseAppearService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 纠纷上报信息表接口api-web端
 * @description: 纠纷上报信息表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-07 00:06:20
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/caseAppear")
public class CaseAppearWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private CaseAppearService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 主键编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 纠纷编号
        String caseId = request.getParameter("caseId");
        if (StringUtils.isNotBlank(caseId)){
            terms.put("caseId", caseId);
        }
        // 上报组织编号
        String appearUnitId = request.getParameter("appearUnitId");
        if (StringUtils.isNotBlank(appearUnitId)){
            terms.put("appearUnitId", appearUnitId);
        }
        // 上报组织名称
        String appearUnitName = request.getParameter("appearUnitName");
        if (StringUtils.isNotBlank(appearUnitName)){
            terms.put("appearUnitName", appearUnitName);
        }
        // 上报人编号
        String appearUserId = request.getParameter("appearUserId");
        if (StringUtils.isNotBlank(appearUserId)){
            terms.put("appearUserId", appearUserId);
        }
        // 上报人名称
        String appearUserName = request.getParameter("appearUserName");
        if (StringUtils.isNotBlank(appearUserName)){
            terms.put("appearUserName", appearUserName);
        }
        // 上报理由
        String appearContent = request.getParameter("appearContent");
        if (StringUtils.isNotBlank(appearContent)){
            terms.put("appearContent", appearContent);
        }
        // 上报时间
        String appearTime = request.getParameter("appearTime");
        if (StringUtils.isNotBlank(appearTime)){
            terms.put("appearTime", appearTime);
        }
        // 上报审核纠纷任务编号
        String caseTaskId = request.getParameter("caseTaskId");
        if (StringUtils.isNotBlank(caseTaskId)){
            terms.put("caseTaskId", caseTaskId);
        }
        // 上报申请状态，0：待审核，1：已审核
        String applyStatus = request.getParameter("applyStatus");
        if (StringUtils.isNotBlank(applyStatus)){
            terms.put("applyStatus", applyStatus);
        }
        // 上报审核组织编号
        String auditUnitId = request.getParameter("auditUnitId");
        if (StringUtils.isNotBlank(auditUnitId)){
            terms.put("auditUnitId", auditUnitId);
        }
        // 上报审核组织名称
        String auditUnitName = request.getParameter("auditUnitName");
        if (StringUtils.isNotBlank(auditUnitName)){
            terms.put("auditUnitName", auditUnitName);
        }
        // 上报审核人编号
        String auditUserId = request.getParameter("auditUserId");
        if (StringUtils.isNotBlank(auditUserId)){
            terms.put("auditUserId", auditUserId);
        }
        // 上报审核人名称
        String auditUserName = request.getParameter("auditUserName");
        if (StringUtils.isNotBlank(auditUserName)){
            terms.put("auditUserName", auditUserName);
        }
        // 上报审核时间
        String auditTime = request.getParameter("auditTime");
        if (StringUtils.isNotBlank(auditTime)){
            terms.put("auditTime", auditTime);
        }
        // 上报审核结果
        String auditResult = request.getParameter("auditResult");
        if (StringUtils.isNotBlank(auditResult)){
            terms.put("auditResult", auditResult);
        }
        // 上报审核结果名称
        String auditResultName = request.getParameter("auditResultName");
        if (StringUtils.isNotBlank(auditResultName)){
            terms.put("auditResultName", auditResultName);
        }
        // 上报审核理由
        String audit_content = request.getParameter("audit_content");
        if (StringUtils.isNotBlank(audit_content)){
            terms.put("audit_content", audit_content);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 顾客编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 更新时间区间
        String updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/caseAppear/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/caseAppear/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<CaseAppear> caseAppearPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseAppearPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/caseAppear/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/caseAppear/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/caseAppear/saveCaseAppear
    * @param caseAppear 实体对象
    * @return Object
    */
    @PostMapping("/saveCaseAppear")
    public Object saveCaseAppear(@RequestBody CaseAppear caseAppear) {
        try {
            service.saveCaseAppear(caseAppear);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseAssistApplyWebController.java

File was renamed from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/controller/web/CaseAssistApplyWebController.java
@@ -1,10 +1,10 @@
package cn.huge.module.assist.controller.web;
package cn.huge.module.cases.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.assist.service.CaseAssistApplyService;
import cn.huge.module.cases.domain.po.CaseAssistApply;
import cn.huge.module.cases.service.CaseAssistApplyService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
@@ -16,8 +16,6 @@

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 联合处置申请信息表接口api-web端

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseFeedbackWebController.java

@@ -182,7 +182,22 @@
    }

    /**
     * 获取办理反馈信息
     * 获取办理信息
     * @url {ctx}/api/web/CaseFeedback/getFeedbackInfo
     * @param caseTaskId 纠纷任务编号
     * @return Object
     */
    @GetMapping("/getFeedbackInfo")
    public Object getFeedbackInfo(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(service.getFeedbackInfo(caseTaskId, userId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 获取办理反馈记录
     * @url {ctx}/api/web/CaseFeedback/listFeedback
     * @param id 实体对象
     * @return Object

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseReturnWebController.java

New file
@@ -0,0 +1,245 @@
package cn.huge.module.cases.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.cases.domain.po.CaseReturn;
import cn.huge.module.cases.service.CaseReturnService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 纠纷回退信息表接口api-web端
 * @description: 纠纷回退信息表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-07 00:06:20
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/caseReturn")
public class CaseReturnWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private CaseReturnService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 主键编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 纠纷编号
        String caseId = request.getParameter("caseId");
        if (StringUtils.isNotBlank(caseId)){
            terms.put("caseId", caseId);
        }
        // 回退组织编号
        String returnUnitId = request.getParameter("returnUnitId");
        if (StringUtils.isNotBlank(returnUnitId)){
            terms.put("returnUnitId", returnUnitId);
        }
        // 回退组织名称
        String returnUnitName = request.getParameter("returnUnitName");
        if (StringUtils.isNotBlank(returnUnitName)){
            terms.put("returnUnitName", returnUnitName);
        }
        // 回退人编号
        String returnUserId = request.getParameter("returnUserId");
        if (StringUtils.isNotBlank(returnUserId)){
            terms.put("returnUserId", returnUserId);
        }
        // 回退人名称
        String returnUserName = request.getParameter("returnUserName");
        if (StringUtils.isNotBlank(returnUserName)){
            terms.put("returnUserName", returnUserName);
        }
        // 回退理由
        String returnContent = request.getParameter("returnContent");
        if (StringUtils.isNotBlank(returnContent)){
            terms.put("returnContent", returnContent);
        }
        // 回退时间
        String returnTime = request.getParameter("returnTime");
        if (StringUtils.isNotBlank(returnTime)){
            terms.put("returnTime", returnTime);
        }
        // 回退状态，0：待审核，1：已审核
        String returnStatus = request.getParameter("returnStatus");
        if (StringUtils.isNotBlank(returnStatus)){
            terms.put("returnStatus", returnStatus);
        }
        // 回退审核纠纷任务编号
        String caseTaskId = request.getParameter("caseTaskId");
        if (StringUtils.isNotBlank(caseTaskId)){
            terms.put("caseTaskId", caseTaskId);
        }
        // 回退审核组织编号
        String auditUnitId = request.getParameter("auditUnitId");
        if (StringUtils.isNotBlank(auditUnitId)){
            terms.put("auditUnitId", auditUnitId);
        }
        // 回退审核组织名称
        String auditUnitName = request.getParameter("auditUnitName");
        if (StringUtils.isNotBlank(auditUnitName)){
            terms.put("auditUnitName", auditUnitName);
        }
        // 回退审核人编号
        String auditUserId = request.getParameter("auditUserId");
        if (StringUtils.isNotBlank(auditUserId)){
            terms.put("auditUserId", auditUserId);
        }
        // 回退审核人名称
        String auditUserName = request.getParameter("auditUserName");
        if (StringUtils.isNotBlank(auditUserName)){
            terms.put("auditUserName", auditUserName);
        }
        // 回退审核时间
        String auditTime = request.getParameter("auditTime");
        if (StringUtils.isNotBlank(auditTime)){
            terms.put("auditTime", auditTime);
        }
        // 回退审核结果
        String auditResult = request.getParameter("auditResult");
        if (StringUtils.isNotBlank(auditResult)){
            terms.put("auditResult", auditResult);
        }
        // 回退审核结果名称
        String auditResultName = request.getParameter("auditResultName");
        if (StringUtils.isNotBlank(auditResultName)){
            terms.put("auditResultName", auditResultName);
        }
        // 回退审核理由
        String audit_content = request.getParameter("audit_content");
        if (StringUtils.isNotBlank(audit_content)){
            terms.put("audit_content", audit_content);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 顾客编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 更新时间区间
        String updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/caseReturn/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/caseReturn/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<CaseReturn> caseReturnPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseReturnPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/caseReturn/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/caseReturn/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/caseReturn/saveCaseReturn
    * @param caseReturn 实体对象
    * @return Object
    */
    @PostMapping("/saveCaseReturn")
    public Object saveCaseReturn(@RequestBody CaseReturn caseReturn) {
        try {
            service.saveCaseReturn(caseReturn);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseTaskWebController.java

New file
@@ -0,0 +1,234 @@
package cn.huge.module.cases.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.cases.domain.dto.AssignTaskDTO;
import cn.huge.module.cases.domain.po.CaseAppear;
import cn.huge.module.cases.domain.po.CaseReturn;
import cn.huge.module.cases.domain.po.CaseTask;
import cn.huge.module.cases.domain.po.CaseWindupApply;
import cn.huge.module.cases.service.CaseAppearService;
import cn.huge.module.cases.service.CaseReturnService;
import cn.huge.module.cases.service.CaseTaskService;
import cn.huge.module.cases.service.CaseWindupApplyService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 纠纷任务表接口api-web端
 * @description: 纠纷任务表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/caseTask")
public class CaseTaskWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private CaseTaskService service;
    @Autowired
    private CaseWindupApplyService caseWindupApplyService;
    @Autowired
    private CaseReturnService caseReturnService;
    @Autowired
    private CaseAppearService caseAppearService;

    /**
    * web端-任务处理页面-初始化tab和按钮
    * @url {ctx}/api/web/caseTask/getTabButton
    * @param caseTaskId 纠纷任务编号
    * @return Object
    */
    @GetMapping("/getTabButton")
    public Object getTabButton(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(service.webGetTabButton("caseTaskId", userId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-结案申请
     * @url {ctx}/api/web/caseTask/windupApply
     * @param caseWindupApply 结案申请表单
     * @return Object
     */
    @PostMapping("/windupApply")
    public Object windupApply(@RequestBody CaseWindupApply caseWindupApply, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-结案审核-查询结案申请信息
     * @url {ctx}/api/web/caseTask/getWindupApplyInfo
     * @param caseTaskId 纠纷任务编号
     * @return Object
     */
    @GetMapping("/getWindupApplyInfo")
    public Object getWindupApplyInfo(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(caseWindupApplyService.getByCaseTaskId(caseTaskId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-结案审核
     * @url {ctx}/api/web/caseTask/windupAudit
     * @param caseWindupApply 结案审核表单
     * @return Object
     */
    @PostMapping("/windupAudit")
    public Object windupAudit(@RequestBody CaseWindupApply caseWindupApply, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-回退申请
     * @url {ctx}/api/web/caseTask/returnApply
     * @param caseReturn 回退申请表单
     * @return Object
     */
    @PostMapping("/returnApply")
    public Object returnApply(@RequestBody CaseReturn caseReturn, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-回退审核-查询回退申请信息
     * @url {ctx}/api/web/caseTask/getReturnApplyInfo
     * @param caseTaskId 纠纷任务编号
     * @return Object
     */
    @GetMapping("/getReturnApplyInfo")
    public Object getReturnApplyInfo(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(caseReturnService.getByCaseTaskId(caseTaskId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-回退审核
     * @url {ctx}/api/web/caseTask/returnAudit
     * @param caseReturn 回退审核表单
     * @return Object
     */
    @PostMapping("/returnAudit")
    public Object returnAudit(@RequestBody CaseReturn caseReturn, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-上报申请
     * @url {ctx}/api/web/caseTask/appearApply
     * @param caseAppear 上报申请表单
     * @return Object
     */
    @PostMapping("/appearApply")
    public Object appearApply(@RequestBody CaseAppear caseAppear, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-上报审核-查询上报申请信息
     * @url {ctx}/api/web/caseTask/getAppearApplyInfo
     * @param caseTaskId 纠纷任务编号
     * @return Object
     */
    @GetMapping("/getAppearApplyInfo")
    public Object getAppearApplyInfo(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(caseAppearService.getByCaseTaskId(caseTaskId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-上报审核
     * @url {ctx}/api/web/caseTask/appearAudit
     * @param caseAppear 上报审核表单
     * @return Object
     */
    @PostMapping("/appearAudit")
    public Object appearAudit(@RequestBody CaseAppear caseAppear, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-交办
     * @url {ctx}/api/web/caseTask/assign
     * @param assignTaskDTO 交办表单
     * @return Object
     */
    @PostMapping("/assign")
    public Object assign(@RequestBody AssignTaskDTO assignTaskDTO, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-查询流程进度
     * @url {ctx}/api/web/caseTask/listCaseFlow
     * @param caseId 纠纷编号
     * @return Object
     */
    @GetMapping("/listCaseFlow")
    public Object listCaseFlow(@RequestParam(value = "caseId") String caseId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(service.webListCaseFlow(caseId, userId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseWindupApplyWebController.java

copy from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/controller/web/CaseAssistApplyWebController.java
copy to dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseWindupApplyWebController.java
File was copied from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/controller/web/CaseAssistApplyWebController.java
@@ -1,10 +1,9 @@
package cn.huge.module.assist.controller.web;
package cn.huge.module.cases.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.assist.service.CaseAssistApplyService;
import cn.huge.module.cases.domain.po.CaseWindupApply;
import cn.huge.module.cases.service.CaseWindupApplyService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
@@ -20,23 +19,23 @@
import java.util.stream.Stream;

/**
 * @title: 联合处置申请信息表接口api-web端
 * @description: 联合处置申请信息表接口api-web端
 * @title: 纠纷结案申请信息表接口api-web端
 * @description: 纠纷结案申请信息表接口api-web端
 * @company: hugeinfo
 * @author: wangwh
 * @time: 2024-09-05 17:25:04
 * @author: liyj
 * @time: 2024-09-06 23:57:02
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/caseAssistApply")
public class CaseAssistApplyWebController {
@RequestMapping("/api/web/caseWindupApply")
public class CaseWindupApplyWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private CaseAssistApplyService service;
    private CaseWindupApplyService service;

    /**
    * 获取请求URL参数
@@ -54,87 +53,112 @@
        if (StringUtils.isNotBlank(caseId)){
            terms.put("caseId", caseId);
        }
        // 申请组织编号
        // 结案申请组织编号
        String applyUnitId = request.getParameter("applyUnitId");
        if (StringUtils.isNotBlank(applyUnitId)){
            terms.put("applyUnitId", applyUnitId);
        }
        // 申请组织名称
        // 结案申请组织名称
        String applyUnitName = request.getParameter("applyUnitName");
        if (StringUtils.isNotBlank(applyUnitName)){
            terms.put("applyUnitName", applyUnitName);
        }
        // 申请人编号
        // 结案申请人编号
        String applyUserId = request.getParameter("applyUserId");
        if (StringUtils.isNotBlank(applyUserId)){
            terms.put("applyUserId", applyUserId);
        }
        // 申请人名称
        // 结案申请人名称
        String applyUserName = request.getParameter("applyUserName");
        if (StringUtils.isNotBlank(applyUserName)){
            terms.put("applyUserName", applyUserName);
        }
        // 申请配合组织，多个用,隔开
        String applyAssistUnitId = request.getParameter("applyAssistUnitId");
        if (StringUtils.isNotBlank(applyAssistUnitId)){
            terms.put("applyAssistUnitId", applyAssistUnitId);
        }
        // 申请配合组织名称，多个用、隔开
        String applyAssistUnitName = request.getParameter("applyAssistUnitName");
        if (StringUtils.isNotBlank(applyAssistUnitName)){
            terms.put("applyAssistUnitName", applyAssistUnitName);
        }
        // 申请理由
        String applyContent = request.getParameter("applyContent");
        if (StringUtils.isNotBlank(applyContent)){
            terms.put("applyContent", applyContent);
        }
        // 申请时间
        // 结案申请时间
        String applyTime = request.getParameter("applyTime");
        if (StringUtils.isNotBlank(applyTime)){
            terms.put("applyTime", applyTime);
        }
        // 申请状态，0：待审核，1：已审核
        // 结案申请状态，0：待审核，1：已审核
        String applyStatus = request.getParameter("applyStatus");
        if (StringUtils.isNotBlank(applyStatus)){
            terms.put("applyStatus", applyStatus);
        }
        // 审核组织编号
        // 调解结果
        String mediResult = request.getParameter("mediResult");
        if (StringUtils.isNotBlank(mediResult)){
            terms.put("mediResult", mediResult);
        }
        // 调解结果名称
        String mediResultName = request.getParameter("mediResultName");
        if (StringUtils.isNotBlank(mediResultName)){
            terms.put("mediResultName", mediResultName);
        }
        // 达成协议类型
        String agreeType = request.getParameter("agreeType");
        if (StringUtils.isNotBlank(agreeType)){
            terms.put("agreeType", agreeType);
        }
        // 达成协议类型名称
        String agreeTypeName = request.getParameter("agreeTypeName");
        if (StringUtils.isNotBlank(agreeTypeName)){
            terms.put("agreeTypeName", agreeTypeName);
        }
        // 协议要点/已达成协议
        String agreeContent = request.getParameter("agreeContent");
        if (StringUtils.isNotBlank(agreeContent)){
            terms.put("agreeContent", agreeContent);
        }
        // 无法化解理由
        String failReason = request.getParameter("failReason");
        if (StringUtils.isNotBlank(failReason)){
            terms.put("failReason", failReason);
        }
        // 结案意见
        String windupContent = request.getParameter("windupContent");
        if (StringUtils.isNotBlank(windupContent)){
            terms.put("windupContent", windupContent);
        }
        // 结案审核纠纷任务编号
        String caseTaskId = request.getParameter("caseTaskId");
        if (StringUtils.isNotBlank(caseTaskId)){
            terms.put("caseTaskId", caseTaskId);
        }
        // 结案审核组织编号
        String auditUnitId = request.getParameter("auditUnitId");
        if (StringUtils.isNotBlank(auditUnitId)){
            terms.put("auditUnitId", auditUnitId);
        }
        // 审核组织名称
        // 结案审核组织名称
        String auditUnitName = request.getParameter("auditUnitName");
        if (StringUtils.isNotBlank(auditUnitName)){
            terms.put("auditUnitName", auditUnitName);
        }
        // 审核人编号
        // 结案审核人编号
        String auditUserId = request.getParameter("auditUserId");
        if (StringUtils.isNotBlank(auditUserId)){
            terms.put("auditUserId", auditUserId);
        }
        // 审核人名称
        // 结案审核人名称
        String auditUserName = request.getParameter("auditUserName");
        if (StringUtils.isNotBlank(auditUserName)){
            terms.put("auditUserName", auditUserName);
        }
        // 审核时间
        // 结案审核时间
        String auditTime = request.getParameter("auditTime");
        if (StringUtils.isNotBlank(auditTime)){
            terms.put("auditTime", auditTime);
        }
        // 审核结果
        // 结案审核结果
        String auditResult = request.getParameter("auditResult");
        if (StringUtils.isNotBlank(auditResult)){
            terms.put("auditResult", auditResult);
        }
        // 审核结果名称
        // 结案审核结果名称
        String auditResultName = request.getParameter("auditResultName");
        if (StringUtils.isNotBlank(auditResultName)){
            terms.put("auditResultName", auditResultName);
        }
        // 审核理由
        // 结案审核理由
        String audit_content = request.getParameter("audit_content");
        if (StringUtils.isNotBlank(audit_content)){
            terms.put("audit_content", audit_content);
@@ -168,7 +192,7 @@

    /**
    * 条件查询多个
    * @url {ctx}/api/web/caseAssistApply/listQuery
    * @url {ctx}/api/web/caseWindupApply/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
@@ -183,7 +207,7 @@

    /**
    * 条件分页查询
    * @url {ctx}/api/web/caseAssistApply/pageQuery
    * @url {ctx}/api/web/caseWindupApply/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
@@ -194,8 +218,8 @@
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<CaseAssistApply> caseAssistApplyPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseAssistApplyPage);
            Page<CaseWindupApply> caseWindupApplyPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseWindupApplyPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
@@ -203,7 +227,7 @@

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/caseAssistApply/getById
    * @url {ctx}/api/web/caseWindupApply/getById
    * @param id 主键编号
    * @return Object
    */
@@ -218,7 +242,7 @@

    /**
    * 根据主键单个
    * @url {ctx}/api/web/caseAssistApply/deleteById
    * @url {ctx}/api/web/caseWindupApply/deleteById
    * @param id 主键编号
    * @return Object
    */
@@ -234,46 +258,14 @@

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/caseAssistApply/saveCaseAssistApply
    * @param caseAssistApply 实体对象
    * @url {ctx}/api/web/caseWindupApply/saveCaseWindupApply
    * @param caseWindupApply 实体对象
    * @return Object
    */
    @PostMapping("/saveCaseAssistApply")
    public Object saveCaseAssistApply(@RequestBody CaseAssistApply caseAssistApply) {
    @PostMapping("/saveCaseWindupApply")
    public Object saveCaseWindupApply(@RequestBody CaseWindupApply caseWindupApply) {
        try {
            service.saveCaseAssistApply(caseAssistApply);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 添加联合处置申请
     * @url {ctx}/api/web/caseAssistApply/addCaseAssistApply
     * @param caseAssistApply 实体对象
     * @return Object
     */
    @PostMapping("/addCaseAssistApply")
    public Object addCaseAssistApply(@CurrentUser String userId, @RequestBody CaseAssistApply caseAssistApply) {
        try {
            service.addCaseAssistApply(caseAssistApply, userId);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 审核联合审核
     * @url {ctx}/api/web/caseAssistApply/addCaseAssistApply
     * @param caseAssistApply 实体对象
     * @return Object
     */
    @PostMapping("/reviewCaseAssistApply")
    public Object reviewCaseAssistApply(@CurrentUser String userId, @RequestBody CaseAssistApply caseAssistApply) {
        try {
            service.reviewCaseAssistApply(caseAssistApply, userId);
            service.saveCaseWindupApply(caseWindupApply);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseAppearMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.cases.dao.mapper;

import cn.huge.module.cases.domain.po.CaseAppear;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 纠纷上报信息表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-07 00:06:20
* @version 1.0.0
*/
@Repository
public interface CaseAppearMapper extends BaseMapper<CaseAppear>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateCaseAppear(@Param("entity") CaseAppear entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateCaseAppearTerms(@Param("entity") CaseAppear entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteCaseAppear(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<CaseAppear>
    */
    List<CaseAppear> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<CaseAppear>
    */
    List<CaseAppear> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseAssistApplyMapper.java

File was renamed from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/CaseAssistApplyMapper.java
@@ -1,6 +1,6 @@
package cn.huge.module.assist.dao.mapper;
package cn.huge.module.cases.dao.mapper;

import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.cases.domain.po.CaseAssistApply;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseReturnMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.cases.dao.mapper;

import cn.huge.module.cases.domain.po.CaseReturn;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 纠纷回退信息表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-07 00:06:20
* @version 1.0.0
*/
@Repository
public interface CaseReturnMapper extends BaseMapper<CaseReturn>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateCaseReturn(@Param("entity") CaseReturn entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateCaseReturnTerms(@Param("entity") CaseReturn entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteCaseReturn(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<CaseReturn>
    */
    List<CaseReturn> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<CaseReturn>
    */
    List<CaseReturn> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseTaskMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.cases.dao.mapper;

import cn.huge.module.cases.domain.po.CaseTask;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 纠纷任务表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-06 15:50:06
* @version 1.0.0
*/
@Repository
public interface CaseTaskMapper extends BaseMapper<CaseTask>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateCaseTask(@Param("entity") CaseTask entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateCaseTaskTerms(@Param("entity") CaseTask entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteCaseTask(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<CaseTask>
    */
    List<CaseTask> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<CaseTask>
    */
    List<CaseTask> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseWindupApplyMapper.java

copy from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/CaseAssistApplyMapper.java
copy to dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/CaseWindupApplyMapper.java
File was copied from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/CaseAssistApplyMapper.java
@@ -1,6 +1,6 @@
package cn.huge.module.assist.dao.mapper;
package cn.huge.module.cases.dao.mapper;

import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.cases.domain.po.CaseWindupApply;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
@@ -10,41 +10,41 @@
import java.util.Map;

/**
* @title: 联合处置申请信息表持久层业务处理
* @title: 纠纷结案申请信息表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: wangwh
* @time: 2024-09-05 17:25:04
* @author: liyj
* @time: 2024-09-06 23:57:02
* @version 1.0.0
*/
@Repository
public interface CaseAssistApplyMapper extends BaseMapper<CaseAssistApply>{
public interface CaseWindupApplyMapper extends BaseMapper<CaseWindupApply>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateCaseAssistApply(@Param("entity") CaseAssistApply entity);
    void updateCaseWindupApply(@Param("entity") CaseWindupApply entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateCaseAssistApplyTerms(@Param("entity") CaseAssistApply entity, @Param("terms") Map<String, Object> terms);
    void updateCaseWindupApplyTerms(@Param("entity") CaseWindupApply entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteCaseAssistApply(@Param("id") String id);
    void deleteCaseWindupApply(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<CaseAssistApply>
    * @return List<CaseWindupApply>
    */
    List<CaseAssistApply> listTerms(@Param("terms") Map<String, Object> terms);
    List<CaseWindupApply> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
@@ -57,8 +57,8 @@
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<CaseAssistApply>
    * @return List<CaseWindupApply>
    */
    List<CaseAssistApply> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);
    List<CaseWindupApply> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseAppearMapper.xml

copy from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
copy to dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseAppearMapper.xml
File was copied from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
@@ -1,26 +1,25 @@
<?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">
<!-- 
 * @title: 联合处置申请信息表
 * @title: 纠纷上报信息表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: wangwh
 * @time:2024-09-05 17:25:04
 * @author: liyj
 * @time:2024-09-07 00:06:20
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.assist.dao.mapper.CaseAssistApplyMapper">
<mapper namespace="cn.huge.module.cases.dao.mapper.CaseAppearMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.assist.domain.po.CaseAssistApply">
    <resultMap id="dataResult" type="cn.huge.module.cases.domain.po.CaseAppear">
            <result property="id" column="id"/>
            <result property="caseId" column="case_id"/>
            <result property="applyUnitId" column="apply_unit_id"/>
            <result property="applyUnitName" column="apply_unit_name"/>
            <result property="applyUserId" column="apply_user_id"/>
            <result property="applyUserName" column="apply_user_name"/>
            <result property="applyAssistUnitId" column="apply_assist_unit_id"/>
            <result property="applyAssistUnitName" column="apply_assist_unit_name"/>
            <result property="applyContent" column="apply_content"/>
            <result property="applyTime" column="apply_time"/>
            <result property="appearUnitId" column="appear_unit_id"/>
            <result property="appearUnitName" column="appear_unit_name"/>
            <result property="appearUserId" column="appear_user_id"/>
            <result property="appearUserName" column="appear_user_name"/>
            <result property="appearContent" column="appear_content"/>
            <result property="appearTime" column="appear_time"/>
            <result property="caseTaskId" column="case_task_id"/>
            <result property="applyStatus" column="apply_status"/>
            <result property="auditUnitId" column="audit_unit_id"/>
            <result property="auditUnitName" column="audit_unit_name"/>
@@ -36,19 +35,18 @@
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_case_assist_apply</sql>
    <sql id='table-name'>dyh_case_appear</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        case_id,
        apply_unit_id,
        apply_unit_name,
        apply_user_id,
        apply_user_name,
        apply_assist_unit_id,
        apply_assist_unit_name,
        apply_content,
        apply_time,
        appear_unit_id,
        appear_unit_name,
        appear_user_id,
        appear_user_name,
        appear_content,
        appear_time,
        case_task_id,
        apply_status,
        audit_unit_id,
        audit_unit_name,
@@ -66,14 +64,13 @@
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.caseId != null">case_id = #{entity.caseId},</if>
            <if test="entity.applyUnitId != null">apply_unit_id = #{entity.applyUnitId},</if>
            <if test="entity.applyUnitName != null">apply_unit_name = #{entity.applyUnitName},</if>
            <if test="entity.applyUserId != null">apply_user_id = #{entity.applyUserId},</if>
            <if test="entity.applyUserName != null">apply_user_name = #{entity.applyUserName},</if>
            <if test="entity.applyAssistUnitId != null">apply_assist_unit_id = #{entity.applyAssistUnitId},</if>
            <if test="entity.applyAssistUnitName != null">apply_assist_unit_name = #{entity.applyAssistUnitName},</if>
            <if test="entity.applyContent != null">apply_content = #{entity.applyContent},</if>
            <if test="entity.applyTime != null">apply_time = #{entity.applyTime},</if>
            <if test="entity.appearUnitId != null">appear_unit_id = #{entity.appearUnitId},</if>
            <if test="entity.appearUnitName != null">appear_unit_name = #{entity.appearUnitName},</if>
            <if test="entity.appearUserId != null">appear_user_id = #{entity.appearUserId},</if>
            <if test="entity.appearUserName != null">appear_user_name = #{entity.appearUserName},</if>
            <if test="entity.appearContent != null">appear_content = #{entity.appearContent},</if>
            <if test="entity.appearTime != null">appear_time = #{entity.appearTime},</if>
            <if test="entity.caseTaskId != null">case_task_id = #{entity.caseTaskId},</if>
            <if test="entity.applyStatus != null">apply_status = #{entity.applyStatus},</if>
            <if test="entity.auditUnitId != null">audit_unit_id = #{entity.auditUnitId},</if>
            <if test="entity.auditUnitName != null">audit_unit_name = #{entity.auditUnitName},</if>
@@ -98,29 +95,26 @@
                <if test="terms.caseId != null and terms.caseId !=''">
                    and case_id = #{terms.caseId}
                </if>
                <if test="terms.applyUnitId != null and terms.applyUnitId !=''">
                    and apply_unit_id = #{terms.applyUnitId}
                <if test="terms.appearUnitId != null and terms.appearUnitId !=''">
                    and appear_unit_id = #{terms.appearUnitId}
                </if>
                <if test="terms.applyUnitName != null and terms.applyUnitName !=''">
                    and apply_unit_name = #{terms.applyUnitName}
                <if test="terms.appearUnitName != null and terms.appearUnitName !=''">
                    and appear_unit_name = #{terms.appearUnitName}
                </if>
                <if test="terms.applyUserId != null and terms.applyUserId !=''">
                    and apply_user_id = #{terms.applyUserId}
                <if test="terms.appearUserId != null and terms.appearUserId !=''">
                    and appear_user_id = #{terms.appearUserId}
                </if>
                <if test="terms.applyUserName != null and terms.applyUserName !=''">
                    and apply_user_name = #{terms.applyUserName}
                <if test="terms.appearUserName != null and terms.appearUserName !=''">
                    and appear_user_name = #{terms.appearUserName}
                </if>
                <if test="terms.applyAssistUnitId != null and terms.applyAssistUnitId !=''">
                    and apply_assist_unit_id = #{terms.applyAssistUnitId}
                <if test="terms.appearContent != null and terms.appearContent !=''">
                    and appear_content = #{terms.appearContent}
                </if>
                <if test="terms.applyAssistUnitName != null and terms.applyAssistUnitName !=''">
                    and apply_assist_unit_name = #{terms.applyAssistUnitName}
                <if test="terms.appearTime != null and terms.appearTime !=''">
                    and appear_time = #{terms.appearTime}
                </if>
                <if test="terms.applyContent != null and terms.applyContent !=''">
                    and apply_content = #{terms.applyContent}
                </if>
                <if test="terms.applyTime != null and terms.applyTime !=''">
                    and apply_time = #{terms.applyTime}
                <if test="terms.caseTaskId != null and terms.caseTaskId !=''">
                    and case_task_id = #{terms.caseTaskId}
                </if>
                <if test="terms.applyStatus != null and terms.applyStatus !=''">
                    and apply_status = #{terms.applyStatus}
@@ -176,7 +170,7 @@
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateCaseAssistApply">
    <update id="updateCaseAppear">
        update
        <include refid="table-name"/>
        <set>
@@ -187,7 +181,7 @@
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateCaseAssistApplyTerms">
    <update id="updateCaseAppearTerms">
        update
        <include refid="table-name"/>
        <set>
@@ -196,7 +190,7 @@
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteCaseAssistApply">
    <delete id="deleteCaseAppear">
        delete from
        <include refid="table-name" />
        where id = #{id}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseAssistApplyMapper.xml

File was renamed from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
@@ -8,9 +8,9 @@
 * @time:2024-09-05 17:25:04
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.assist.dao.mapper.CaseAssistApplyMapper">
<mapper namespace="cn.huge.module.cases.dao.mapper.CaseAssistApplyMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.assist.domain.po.CaseAssistApply">
    <resultMap id="dataResult" type="cn.huge.module.cases.domain.po.CaseAssistApply">
            <result property="id" column="id"/>
            <result property="caseId" column="case_id"/>
            <result property="applyUnitId" column="apply_unit_id"/>

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseReturnMapper.xml

copy from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
copy to dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseReturnMapper.xml
File was copied from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
@@ -1,27 +1,26 @@
<?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">
<!-- 
 * @title: 联合处置申请信息表
 * @title: 纠纷回退信息表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: wangwh
 * @time:2024-09-05 17:25:04
 * @author: liyj
 * @time:2024-09-07 00:06:20
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.assist.dao.mapper.CaseAssistApplyMapper">
<mapper namespace="cn.huge.module.cases.dao.mapper.CaseReturnMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.assist.domain.po.CaseAssistApply">
    <resultMap id="dataResult" type="cn.huge.module.cases.domain.po.CaseReturn">
            <result property="id" column="id"/>
            <result property="caseId" column="case_id"/>
            <result property="applyUnitId" column="apply_unit_id"/>
            <result property="applyUnitName" column="apply_unit_name"/>
            <result property="applyUserId" column="apply_user_id"/>
            <result property="applyUserName" column="apply_user_name"/>
            <result property="applyAssistUnitId" column="apply_assist_unit_id"/>
            <result property="applyAssistUnitName" column="apply_assist_unit_name"/>
            <result property="applyContent" column="apply_content"/>
            <result property="applyTime" column="apply_time"/>
            <result property="applyStatus" column="apply_status"/>
            <result property="returnUnitId" column="return_unit_id"/>
            <result property="returnUnitName" column="return_unit_name"/>
            <result property="returnUserId" column="return_user_id"/>
            <result property="returnUserName" column="return_user_name"/>
            <result property="returnContent" column="return_content"/>
            <result property="returnTime" column="return_time"/>
            <result property="returnStatus" column="return_status"/>
            <result property="caseTaskId" column="case_task_id"/>
            <result property="auditUnitId" column="audit_unit_id"/>
            <result property="auditUnitName" column="audit_unit_name"/>
            <result property="auditUserId" column="audit_user_id"/>
@@ -36,20 +35,19 @@
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_case_assist_apply</sql>
    <sql id='table-name'>dyh_case_return</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        case_id,
        apply_unit_id,
        apply_unit_name,
        apply_user_id,
        apply_user_name,
        apply_assist_unit_id,
        apply_assist_unit_name,
        apply_content,
        apply_time,
        apply_status,
        return_unit_id,
        return_unit_name,
        return_user_id,
        return_user_name,
        return_content,
        return_time,
        return_status,
        case_task_id,
        audit_unit_id,
        audit_unit_name,
        audit_user_id,
@@ -66,15 +64,14 @@
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.caseId != null">case_id = #{entity.caseId},</if>
            <if test="entity.applyUnitId != null">apply_unit_id = #{entity.applyUnitId},</if>
            <if test="entity.applyUnitName != null">apply_unit_name = #{entity.applyUnitName},</if>
            <if test="entity.applyUserId != null">apply_user_id = #{entity.applyUserId},</if>
            <if test="entity.applyUserName != null">apply_user_name = #{entity.applyUserName},</if>
            <if test="entity.applyAssistUnitId != null">apply_assist_unit_id = #{entity.applyAssistUnitId},</if>
            <if test="entity.applyAssistUnitName != null">apply_assist_unit_name = #{entity.applyAssistUnitName},</if>
            <if test="entity.applyContent != null">apply_content = #{entity.applyContent},</if>
            <if test="entity.applyTime != null">apply_time = #{entity.applyTime},</if>
            <if test="entity.applyStatus != null">apply_status = #{entity.applyStatus},</if>
            <if test="entity.returnUnitId != null">return_unit_id = #{entity.returnUnitId},</if>
            <if test="entity.returnUnitName != null">return_unit_name = #{entity.returnUnitName},</if>
            <if test="entity.returnUserId != null">return_user_id = #{entity.returnUserId},</if>
            <if test="entity.returnUserName != null">return_user_name = #{entity.returnUserName},</if>
            <if test="entity.returnContent != null">return_content = #{entity.returnContent},</if>
            <if test="entity.returnTime != null">return_time = #{entity.returnTime},</if>
            <if test="entity.returnStatus != null">return_status = #{entity.returnStatus},</if>
            <if test="entity.caseTaskId != null">case_task_id = #{entity.caseTaskId},</if>
            <if test="entity.auditUnitId != null">audit_unit_id = #{entity.auditUnitId},</if>
            <if test="entity.auditUnitName != null">audit_unit_name = #{entity.auditUnitName},</if>
            <if test="entity.auditUserId != null">audit_user_id = #{entity.auditUserId},</if>
@@ -98,32 +95,29 @@
                <if test="terms.caseId != null and terms.caseId !=''">
                    and case_id = #{terms.caseId}
                </if>
                <if test="terms.applyUnitId != null and terms.applyUnitId !=''">
                    and apply_unit_id = #{terms.applyUnitId}
                <if test="terms.returnUnitId != null and terms.returnUnitId !=''">
                    and return_unit_id = #{terms.returnUnitId}
                </if>
                <if test="terms.applyUnitName != null and terms.applyUnitName !=''">
                    and apply_unit_name = #{terms.applyUnitName}
                <if test="terms.returnUnitName != null and terms.returnUnitName !=''">
                    and return_unit_name = #{terms.returnUnitName}
                </if>
                <if test="terms.applyUserId != null and terms.applyUserId !=''">
                    and apply_user_id = #{terms.applyUserId}
                <if test="terms.returnUserId != null and terms.returnUserId !=''">
                    and return_user_id = #{terms.returnUserId}
                </if>
                <if test="terms.applyUserName != null and terms.applyUserName !=''">
                    and apply_user_name = #{terms.applyUserName}
                <if test="terms.returnUserName != null and terms.returnUserName !=''">
                    and return_user_name = #{terms.returnUserName}
                </if>
                <if test="terms.applyAssistUnitId != null and terms.applyAssistUnitId !=''">
                    and apply_assist_unit_id = #{terms.applyAssistUnitId}
                <if test="terms.returnContent != null and terms.returnContent !=''">
                    and return_content = #{terms.returnContent}
                </if>
                <if test="terms.applyAssistUnitName != null and terms.applyAssistUnitName !=''">
                    and apply_assist_unit_name = #{terms.applyAssistUnitName}
                <if test="terms.returnTime != null and terms.returnTime !=''">
                    and return_time = #{terms.returnTime}
                </if>
                <if test="terms.applyContent != null and terms.applyContent !=''">
                    and apply_content = #{terms.applyContent}
                <if test="terms.returnStatus != null and terms.returnStatus !=''">
                    and return_status = #{terms.returnStatus}
                </if>
                <if test="terms.applyTime != null and terms.applyTime !=''">
                    and apply_time = #{terms.applyTime}
                </if>
                <if test="terms.applyStatus != null and terms.applyStatus !=''">
                    and apply_status = #{terms.applyStatus}
                <if test="terms.caseTaskId != null and terms.caseTaskId !=''">
                    and case_task_id = #{terms.caseTaskId}
                </if>
                <if test="terms.auditUnitId != null and terms.auditUnitId !=''">
                    and audit_unit_id = #{terms.auditUnitId}
@@ -176,7 +170,7 @@
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateCaseAssistApply">
    <update id="updateCaseReturn">
        update
        <include refid="table-name"/>
        <set>
@@ -187,7 +181,7 @@
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateCaseAssistApplyTerms">
    <update id="updateCaseReturnTerms">
        update
        <include refid="table-name"/>
        <set>
@@ -196,7 +190,7 @@
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteCaseAssistApply">
    <delete id="deleteCaseReturn">
        delete from
        <include refid="table-name" />
        where id = #{id}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseTaskMapper.xml

New file
@@ -0,0 +1,322 @@
<?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">
<!-- 
 * @title: 纠纷任务表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: liyj
 * @time:2024-09-06 15:50:06
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.cases.dao.mapper.CaseTaskMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.cases.domain.po.CaseTask">
            <result property="id" column="id"/>
            <result property="caseId" column="case_id"/>
            <result property="flowableId" column="flowable_id"/>
            <result property="processInstanceId" column="process_instance_id"/>
            <result property="processTaskId" column="process_task_id"/>
            <result property="taskType" column="task_type"/>
            <result property="nodeType" column="node_type"/>
            <result property="nodeId" column="node_id"/>
            <result property="nodeName" column="node_name"/>
            <result property="flowId" column="flow_id"/>
            <result property="nodeShowName" column="node_show_name"/>
            <result property="caseTaskType" column="case_task_type"/>
            <result property="candeType" column="cande_type"/>
            <result property="candeUnitId" column="cande_unit_id"/>
            <result property="candeUnitName" column="cande_unit_name"/>
            <result property="candeDeptId" column="cande_dept_id"/>
            <result property="candeDeptName" column="cande_dept_name"/>
            <result property="candeRoleCode" column="cande_role_code"/>
            <result property="candeRoleName" column="cande_role_name"/>
            <result property="candeUserId" column="cande_user_id"/>
            <result property="candeUserName" column="cande_user_name"/>
            <result property="signStatus" column="sign_status"/>
            <result property="signExpireTime" column="sign_expire_time"/>
            <result property="signTime" column="sign_time"/>
            <result property="signUserId" column="sign_user_id"/>
            <result property="signUserName" column="sign_user_name"/>
            <result property="expireTime" column="expire_time"/>
            <result property="status" column="status"/>
            <result property="handleUserId" column="handle_user_id"/>
            <result property="handleUserName" column="handle_user_name"/>
            <result property="handleResult" column="handle_result"/>
            <result property="handleContent" column="handle_content"/>
            <result property="handleTime" column="handle_time"/>
            <result property="deleteStatus" column="delete_status"/>
            <result property="custId" column="cust_id"/>
            <result property="createTime" column="create_time"/>
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_case_task</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        case_id,
        flowable_id,
        process_instance_id,
        process_task_id,
        task_type,
        node_type,
        node_id,
        node_name,
        flow_id,
        node_show_name,
        case_task_type,
        cande_type,
        cande_unit_id,
        cande_unit_name,
        cande_dept_id,
        cande_dept_name,
        cande_role_code,
        cande_role_name,
        cande_user_id,
        cande_user_name,
        sign_status,
        sign_expire_time,
        sign_time,
        sign_user_id,
        sign_user_name,
        expire_time,
        status,
        handle_user_id,
        handle_user_name,
        handle_result,
        handle_content,
        handle_time,
        delete_status,
        cust_id,
        create_time,
        update_time
    </sql>
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.caseId != null">case_id = #{entity.caseId},</if>
            <if test="entity.flowableId != null">flowable_id = #{entity.flowableId},</if>
            <if test="entity.processInstanceId != null">process_instance_id = #{entity.processInstanceId},</if>
            <if test="entity.processTaskId != null">process_task_id = #{entity.processTaskId},</if>
            <if test="entity.taskType != null">task_type = #{entity.taskType},</if>
            <if test="entity.nodeType != null">node_type = #{entity.nodeType},</if>
            <if test="entity.nodeId != null">node_id = #{entity.nodeId},</if>
            <if test="entity.nodeName != null">node_name = #{entity.nodeName},</if>
            <if test="entity.flowId != null">flow_id = #{entity.flowId},</if>
            <if test="entity.nodeShowName != null">node_show_name = #{entity.nodeShowName},</if>
            <if test="entity.caseTaskType != null">case_task_type = #{entity.caseTaskType},</if>
            <if test="entity.candeType != null">cande_type = #{entity.candeType},</if>
            <if test="entity.candeUnitId != null">cande_unit_id = #{entity.candeUnitId},</if>
            <if test="entity.candeUnitName != null">cande_unit_name = #{entity.candeUnitName},</if>
            <if test="entity.candeDeptId != null">cande_dept_id = #{entity.candeDeptId},</if>
            <if test="entity.candeDeptName != null">cande_dept_name = #{entity.candeDeptName},</if>
            <if test="entity.candeRoleCode != null">cande_role_code = #{entity.candeRoleCode},</if>
            <if test="entity.candeRoleName != null">cande_role_name = #{entity.candeRoleName},</if>
            <if test="entity.candeUserId != null">cande_user_id = #{entity.candeUserId},</if>
            <if test="entity.candeUserName != null">cande_user_name = #{entity.candeUserName},</if>
            <if test="entity.signStatus != null">sign_status = #{entity.signStatus},</if>
            <if test="entity.signExpireTime != null">sign_expire_time = #{entity.signExpireTime},</if>
            <if test="entity.signTime != null">sign_time = #{entity.signTime},</if>
            <if test="entity.signUserId != null">sign_user_id = #{entity.signUserId},</if>
            <if test="entity.signUserName != null">sign_user_name = #{entity.signUserName},</if>
            <if test="entity.expireTime != null">expire_time = #{entity.expireTime},</if>
            <if test="entity.status != null">status = #{entity.status},</if>
            <if test="entity.handleUserId != null">handle_user_id = #{entity.handleUserId},</if>
            <if test="entity.handleUserName != null">handle_user_name = #{entity.handleUserName},</if>
            <if test="entity.handleResult != null">handle_result = #{entity.handleResult},</if>
            <if test="entity.handleContent != null">handle_content = #{entity.handleContent},</if>
            <if test="entity.handleTime != null">handle_time = #{entity.handleTime},</if>
            <if test="entity.deleteStatus != null">delete_status = #{entity.deleteStatus},</if>
            <if test="entity.custId != null">cust_id = #{entity.custId},</if>
            <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
            <if test="entity.updateTime != null">update_time = #{entity.updateTime}</if>
    </sql>
    <!-- 条件 -->
    <sql id="where-part">
        <if test="terms != null">
            <where>
                <if test="terms.id != null and terms.id !=''">
                    and id = #{terms.id}
                </if>
                <if test="terms.caseId != null and terms.caseId !=''">
                    and case_id = #{terms.caseId}
                </if>
                <if test="terms.flowableId != null and terms.flowableId !=''">
                    and flowable_id = #{terms.flowableId}
                </if>
                <if test="terms.processInstanceId != null and terms.processInstanceId !=''">
                    and process_instance_id = #{terms.processInstanceId}
                </if>
                <if test="terms.processTaskId != null and terms.processTaskId !=''">
                    and process_task_id = #{terms.processTaskId}
                </if>
                <if test="terms.taskType != null and terms.taskType !=''">
                    and task_type = #{terms.taskType}
                </if>
                <if test="terms.nodeType != null and terms.nodeType !=''">
                    and node_type = #{terms.nodeType}
                </if>
                <if test="terms.nodeId != null and terms.nodeId !=''">
                    and node_id = #{terms.nodeId}
                </if>
                <if test="terms.nodeName != null and terms.nodeName !=''">
                    and node_name = #{terms.nodeName}
                </if>
                <if test="terms.flowId != null and terms.flowId !=''">
                    and flow_id = #{terms.flowId}
                </if>
                <if test="terms.nodeShowName != null and terms.nodeShowName !=''">
                    and node_show_name = #{terms.nodeShowName}
                </if>
                <if test="terms.caseTaskType != null and terms.caseTaskType !=''">
                    and case_task_type = #{terms.caseTaskType}
                </if>
                <if test="terms.candeType != null and terms.candeType !=''">
                    and cande_type = #{terms.candeType}
                </if>
                <if test="terms.candeUnitId != null and terms.candeUnitId !=''">
                    and cande_unit_id = #{terms.candeUnitId}
                </if>
                <if test="terms.candeUnitName != null and terms.candeUnitName !=''">
                    and cande_unit_name = #{terms.candeUnitName}
                </if>
                <if test="terms.candeDeptId != null and terms.candeDeptId !=''">
                    and cande_dept_id = #{terms.candeDeptId}
                </if>
                <if test="terms.candeDeptName != null and terms.candeDeptName !=''">
                    and cande_dept_name = #{terms.candeDeptName}
                </if>
                <if test="terms.candeRoleCode != null and terms.candeRoleCode !=''">
                    and cande_role_code = #{terms.candeRoleCode}
                </if>
                <if test="terms.candeRoleName != null and terms.candeRoleName !=''">
                    and cande_role_name = #{terms.candeRoleName}
                </if>
                <if test="terms.candeUserId != null and terms.candeUserId !=''">
                    and cande_user_id = #{terms.candeUserId}
                </if>
                <if test="terms.candeUserName != null and terms.candeUserName !=''">
                    and cande_user_name = #{terms.candeUserName}
                </if>
                <if test="terms.signStatus != null and terms.signStatus !=''">
                    and sign_status = #{terms.signStatus}
                </if>
                <if test="terms.signExpireTime != null and terms.signExpireTime !=''">
                    and sign_expire_time = #{terms.signExpireTime}
                </if>
                <if test="terms.signTime != null and terms.signTime !=''">
                    and sign_time = #{terms.signTime}
                </if>
                <if test="terms.signUserId != null and terms.signUserId !=''">
                    and sign_user_id = #{terms.signUserId}
                </if>
                <if test="terms.signUserName != null and terms.signUserName !=''">
                    and sign_user_name = #{terms.signUserName}
                </if>
                <if test="terms.expireTime != null and terms.expireTime !=''">
                    and expire_time = #{terms.expireTime}
                </if>
                <if test="terms.status != null and terms.status !=''">
                    and status = #{terms.status}
                </if>
                <if test="terms.handleUserId != null and terms.handleUserId !=''">
                    and handle_user_id = #{terms.handleUserId}
                </if>
                <if test="terms.handleUserName != null and terms.handleUserName !=''">
                    and handle_user_name = #{terms.handleUserName}
                </if>
                <if test="terms.handleResult != null and terms.handleResult !=''">
                    and handle_result = #{terms.handleResult}
                </if>
                <if test="terms.handleContent != null and terms.handleContent !=''">
                    and handle_content = #{terms.handleContent}
                </if>
                <if test="terms.handleTime != null and terms.handleTime !=''">
                    and handle_time = #{terms.handleTime}
                </if>
                <if test="terms.deleteStatus = null and terms.deleteStatus =''">
                    and delete_status = 0
                </if>
                <if test="terms.deleteStatus != null and terms.deleteStatus !=''">
                    and delete_status = #{terms.deleteStatus}
                </if>
                <if test="terms.custId != null and terms.custId !=''">
                    and cust_id = #{terms.custId}
                </if>
                <if test="terms.createTime != null and terms.createTime !=''">
                    and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
                </if>
                <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
                    and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
                        and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
                </if>
                <if test="terms.updateTime != null and terms.updateTime !=''">
                    and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
                </if>
                <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
                    and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
                        and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
                </if>
            </where>
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateCaseTask">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <where>
            id = #{entity.id}
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateCaseTaskTerms">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteCaseTask">
        delete from
        <include refid="table-name" />
        where id = #{id}
    </delete>
    <!--  根据条件查询  -->
    <select id="listTerms" resultMap="dataResult">
        select
        <include refid="column-part"/>
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件统计  -->
    <select id="countTerms" resultType="java.lang.Long">
        select
        COUNT(1)
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件分页查询  -->
    <select id="pageTerms" resultMap="dataResult">
        SELECT
        <include refid="column-part"/>
        FROM
        <include refid="table-name" />
        <include refid="where-part"/>
        <if test="page.sort != null">
            <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
                isnull(${s.property}), ${s.property} ${s.direction}
            </foreach>
        </if>
        <if test="page.sort == null">
            order by isnull(create_time), create_time desc
        </if>
        limit #{page.offset}, #{page.size}
    </select>

</mapper> 

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseWindupApplyMapper.xml

copy from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
copy to dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/dao/mapper/xml/CaseWindupApplyMapper.xml
File was copied from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/dao/mapper/xml/CaseAssistApplyMapper.xml
@@ -1,27 +1,32 @@
<?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">
<!-- 
 * @title: 联合处置申请信息表
 * @title: 纠纷结案申请信息表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: wangwh
 * @time:2024-09-05 17:25:04
 * @author: liyj
 * @time:2024-09-06 23:57:02
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.assist.dao.mapper.CaseAssistApplyMapper">
<mapper namespace="cn.huge.module.cases.dao.mapper.CaseWindupApplyMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.assist.domain.po.CaseAssistApply">
    <resultMap id="dataResult" type="cn.huge.module.cases.domain.po.CaseWindupApply">
            <result property="id" column="id"/>
            <result property="caseId" column="case_id"/>
            <result property="applyUnitId" column="apply_unit_id"/>
            <result property="applyUnitName" column="apply_unit_name"/>
            <result property="applyUserId" column="apply_user_id"/>
            <result property="applyUserName" column="apply_user_name"/>
            <result property="applyAssistUnitId" column="apply_assist_unit_id"/>
            <result property="applyAssistUnitName" column="apply_assist_unit_name"/>
            <result property="applyContent" column="apply_content"/>
            <result property="applyTime" column="apply_time"/>
            <result property="applyStatus" column="apply_status"/>
            <result property="mediResult" column="medi_result"/>
            <result property="mediResultName" column="medi_result_name"/>
            <result property="agreeType" column="agree_type"/>
            <result property="agreeTypeName" column="agree_type_name"/>
            <result property="agreeContent" column="agree_content"/>
            <result property="failReason" column="fail_reason"/>
            <result property="windupContent" column="windup_content"/>
            <result property="caseTaskId" column="case_task_id"/>
            <result property="auditUnitId" column="audit_unit_id"/>
            <result property="auditUnitName" column="audit_unit_name"/>
            <result property="auditUserId" column="audit_user_id"/>
@@ -36,7 +41,7 @@
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_case_assist_apply</sql>
    <sql id='table-name'>dyh_case_windup_apply</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
@@ -45,11 +50,16 @@
        apply_unit_name,
        apply_user_id,
        apply_user_name,
        apply_assist_unit_id,
        apply_assist_unit_name,
        apply_content,
        apply_time,
        apply_status,
        medi_result,
        medi_result_name,
        agree_type,
        agree_type_name,
        agree_content,
        fail_reason,
        windup_content,
        case_task_id,
        audit_unit_id,
        audit_unit_name,
        audit_user_id,
@@ -70,11 +80,16 @@
            <if test="entity.applyUnitName != null">apply_unit_name = #{entity.applyUnitName},</if>
            <if test="entity.applyUserId != null">apply_user_id = #{entity.applyUserId},</if>
            <if test="entity.applyUserName != null">apply_user_name = #{entity.applyUserName},</if>
            <if test="entity.applyAssistUnitId != null">apply_assist_unit_id = #{entity.applyAssistUnitId},</if>
            <if test="entity.applyAssistUnitName != null">apply_assist_unit_name = #{entity.applyAssistUnitName},</if>
            <if test="entity.applyContent != null">apply_content = #{entity.applyContent},</if>
            <if test="entity.applyTime != null">apply_time = #{entity.applyTime},</if>
            <if test="entity.applyStatus != null">apply_status = #{entity.applyStatus},</if>
            <if test="entity.mediResult != null">medi_result = #{entity.mediResult},</if>
            <if test="entity.mediResultName != null">medi_result_name = #{entity.mediResultName},</if>
            <if test="entity.agreeType != null">agree_type = #{entity.agreeType},</if>
            <if test="entity.agreeTypeName != null">agree_type_name = #{entity.agreeTypeName},</if>
            <if test="entity.agreeContent != null">agree_content = #{entity.agreeContent},</if>
            <if test="entity.failReason != null">fail_reason = #{entity.failReason},</if>
            <if test="entity.windupContent != null">windup_content = #{entity.windupContent},</if>
            <if test="entity.caseTaskId != null">case_task_id = #{entity.caseTaskId},</if>
            <if test="entity.auditUnitId != null">audit_unit_id = #{entity.auditUnitId},</if>
            <if test="entity.auditUnitName != null">audit_unit_name = #{entity.auditUnitName},</if>
            <if test="entity.auditUserId != null">audit_user_id = #{entity.auditUserId},</if>
@@ -110,20 +125,35 @@
                <if test="terms.applyUserName != null and terms.applyUserName !=''">
                    and apply_user_name = #{terms.applyUserName}
                </if>
                <if test="terms.applyAssistUnitId != null and terms.applyAssistUnitId !=''">
                    and apply_assist_unit_id = #{terms.applyAssistUnitId}
                </if>
                <if test="terms.applyAssistUnitName != null and terms.applyAssistUnitName !=''">
                    and apply_assist_unit_name = #{terms.applyAssistUnitName}
                </if>
                <if test="terms.applyContent != null and terms.applyContent !=''">
                    and apply_content = #{terms.applyContent}
                </if>
                <if test="terms.applyTime != null and terms.applyTime !=''">
                    and apply_time = #{terms.applyTime}
                </if>
                <if test="terms.applyStatus != null and terms.applyStatus !=''">
                    and apply_status = #{terms.applyStatus}
                </if>
                <if test="terms.mediResult != null and terms.mediResult !=''">
                    and medi_result = #{terms.mediResult}
                </if>
                <if test="terms.mediResultName != null and terms.mediResultName !=''">
                    and medi_result_name = #{terms.mediResultName}
                </if>
                <if test="terms.agreeType != null and terms.agreeType !=''">
                    and agree_type = #{terms.agreeType}
                </if>
                <if test="terms.agreeTypeName != null and terms.agreeTypeName !=''">
                    and agree_type_name = #{terms.agreeTypeName}
                </if>
                <if test="terms.agreeContent != null and terms.agreeContent !=''">
                    and agree_content = #{terms.agreeContent}
                </if>
                <if test="terms.failReason != null and terms.failReason !=''">
                    and fail_reason = #{terms.failReason}
                </if>
                <if test="terms.windupContent != null and terms.windupContent !=''">
                    and windup_content = #{terms.windupContent}
                </if>
                <if test="terms.caseTaskId != null and terms.caseTaskId !=''">
                    and case_task_id = #{terms.caseTaskId}
                </if>
                <if test="terms.auditUnitId != null and terms.auditUnitId !=''">
                    and audit_unit_id = #{terms.auditUnitId}
@@ -176,7 +206,7 @@
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateCaseAssistApply">
    <update id="updateCaseWindupApply">
        update
        <include refid="table-name"/>
        <set>
@@ -187,7 +217,7 @@
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateCaseAssistApplyTerms">
    <update id="updateCaseWindupApplyTerms">
        update
        <include refid="table-name"/>
        <set>
@@ -196,7 +226,7 @@
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteCaseAssistApply">
    <delete id="deleteCaseWindupApply">
        delete from
        <include refid="table-name" />
        where id = #{id}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/bo/CaseAppearBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.cases.domain.bo;

import cn.huge.module.cases.domain.po.CaseAppear;

/**
 * @title: 纠纷上报信息表业务扩展类
 * @description: 纠纷上报信息表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-07 00:06:20
 * @version: 1.0.0
 * @see cn.huge.module.cases.domain.po.CaseAppear
 */
public class CaseAppearBO extends CaseAppear {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/bo/CaseAssistApplyBO.java

File was renamed from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/domain/bo/CaseAssistApplyBO.java
@@ -1,6 +1,6 @@
package cn.huge.module.assist.domain.bo;
package cn.huge.module.cases.domain.bo;

import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.cases.domain.po.CaseAssistApply;

/**
 * @title: 联合处置申请信息表业务扩展类
@@ -9,7 +9,7 @@
 * @author: wangwh
 * @time: 2024-09-05 17:25:04
 * @version: 1.0.0
 * @see cn.huge.module.assist.domain.po.CaseAssistApply
 * @see CaseAssistApply
 */
public class CaseAssistApplyBO extends CaseAssistApply {


 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/bo/CaseReturnBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.cases.domain.bo;

import cn.huge.module.cases.domain.po.CaseReturn;

/**
 * @title: 纠纷回退信息表业务扩展类
 * @description: 纠纷回退信息表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-07 00:06:20
 * @version: 1.0.0
 * @see cn.huge.module.cases.domain.po.CaseReturn
 */
public class CaseReturnBO extends CaseReturn {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/bo/CaseTaskBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.cases.domain.bo;

import cn.huge.module.cases.domain.po.CaseTask;

/**
 * @title: 纠纷任务表业务扩展类
 * @description: 纠纷任务表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 * @see cn.huge.module.cases.domain.po.CaseTask
 */
public class CaseTaskBO extends CaseTask {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/bo/CaseWindupApplyBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.cases.domain.bo;

import cn.huge.module.cases.domain.po.CaseWindupApply;

/**
 * @title: 纠纷结案申请信息表业务扩展类
 * @description: 纠纷结案申请信息表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 23:57:02
 * @version: 1.0.0
 * @see cn.huge.module.cases.domain.po.CaseWindupApply
 */
public class CaseWindupApplyBO extends CaseWindupApply {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/dto/AssignAssistUnitDTO.java

New file
@@ -0,0 +1,32 @@
package cn.huge.module.cases.domain.dto;

import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.domain.po.CasePerson;
import lombok.Data;

import java.util.List;

/**
 * @title: 交办配合部门传输对象
 * @description: 交办配合部门传输对象
 * @company: hugeinfo
 * @author: liyj
 * @time: 2022-03-11 11:43:25
 * @version: 1.0.0
 * @see CaseInfo
 */
@Data
public class AssignAssistUnitDTO {

    /**
     * 配合部门编号
     */
    private String uitId;

    /**
     * 配合部门名称
     */
    private String uitName;


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/dto/AssignTaskDTO.java

New file
@@ -0,0 +1,44 @@
package cn.huge.module.cases.domain.dto;

import cn.huge.module.cases.domain.po.CaseAgent;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.domain.po.CasePerson;
import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import lombok.Data;

import java.util.List;

/**
 * @title: 交办任务传输对象
 * @description: 交办任务传输对象
 * @company: hugeinfo
 * @author: liyj
 * @time: 2022-03-11 11:43:25
 * @version: 1.0.0
 * @see CaseInfo
 */
@Data
public class AssignTaskDTO {

    /**
     * 承办部门编号
     */
    private String handleUnitId;

    /**
     * 承办部门名称
     */
    private String handleUnitName;

    /**
     * 配合部门
     */
    private List<AssignAssistUnitDTO> assistUnitList;

    /**
     * 交办意见
     */
    private String assignContent;


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/dto/CaseFlowDTO.java

New file
@@ -0,0 +1,74 @@
package cn.huge.module.cases.domain.dto;

import cn.huge.module.cases.domain.po.CaseInfo;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;

import java.util.Date;
import java.util.List;

/**
 * @title: 纠纷流程进度传输对象
 * @description: 纠纷流程进度传输对象
 * @company: hugeinfo
 * @author: liyj
 * @time: 2022-03-11 11:43:25
 * @version: 1.0.0
 * @see CaseInfo
 */
@Data
public class CaseFlowDTO {

    /**
     * 流程进度名称
     */
    private String processName;

    /**
     * 流程节点名称
     */
    private String nodeShowName;

    /**
     * 操作部门名称
     */
    private String handleUnitName;

    /**
     * 操作人名称
     */
    private String handleUserName;

    /**
     * 操作时间
     */
    private Date handleTime;

    /**
     * 节点处理备注
     */
    private String handleNotes;

    /**
     * 节点审核结果
     */
    private String auditResult;

    /**
     * 节点审核结果名称
     */
    private String auditResultName;

    /**
     * 流程节点类型，1：正常，2：退回；3：上报
     */
    private Integer taskType;

    /**
     * 流程状态，1：进行中，2：已完成
     */
    private Integer status;



}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/dto/TabButtonDTO.java

New file
@@ -0,0 +1,34 @@
package cn.huge.module.cases.domain.dto;

import cn.huge.module.cases.domain.po.CaseAgent;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.domain.po.CasePerson;
import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import lombok.Data;

import java.util.List;

/**
 * @title: 初始化tab和按钮数据传输对象
 * @description: 初始化tab和按钮数据传输对象
 * @company: hugeinfo
 * @author: liyj
 * @time: 2022-03-11 11:43:25
 * @version: 1.0.0
 * @see CaseInfo
 */
@Data
public class TabButtonDTO {

    /**
     * tab数据
     */
    private List<TabButtonInfoDTO> tabList;

    /**
     * button数据
     */
    private List<TabButtonInfoDTO> buttonList;


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/dto/TabButtonInfoDTO.java

New file
@@ -0,0 +1,29 @@
package cn.huge.module.cases.domain.dto;

import cn.huge.module.cases.domain.po.CaseInfo;
import lombok.Data;

/**
 * @title: 初始化tab和按钮数据传输对象
 * @description: 初始化tab和按钮数据传输对象
 * @company: hugeinfo
 * @author: liyj
 * @time: 2022-03-11 11:43:25
 * @version: 1.0.0
 * @see CaseInfo
 */
@Data
public class TabButtonInfoDTO {

    /**
     * tab/button的id
     */
    private String id;

    /**
     * tab/button的名称
     */
    private String name;


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/json/CaseAppear.json

New file
@@ -0,0 +1,21 @@
{
    "id": "主键编号",
    "caseId": "纠纷编号",
    "appearUnitId": "上报组织编号",
    "appearUnitName": "上报组织名称",
    "appearUserId": "上报人编号",
    "appearUserName": "上报人名称",
    "appearContent": "上报理由",
    "appearTime": "上报时间",
    "caseTaskId": "上报审核纠纷任务编号",
    "applyStatus": 0,
    "auditUnitId": "上报审核组织编号",
    "auditUnitName": "上报审核组织名称",
    "auditUserId": "上报审核人编号",
    "auditUserName": "上报审核人名称",
    "auditTime": "上报审核时间",
    "auditResult": "上报审核结果",
    "auditResultName": "上报审核结果名称",
    "audit_content": "上报审核理由",
    "custId": "顾客编号",
}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/json/CaseReturn.json

New file
@@ -0,0 +1,21 @@
{
    "id": "主键编号",
    "caseId": "纠纷编号",
    "returnUnitId": "回退组织编号",
    "returnUnitName": "回退组织名称",
    "returnUserId": "回退人编号",
    "returnUserName": "回退人名称",
    "returnContent": "回退理由",
    "returnTime": "回退时间",
    "returnStatus": 0,
    "caseTaskId": "回退审核纠纷任务编号",
    "auditUnitId": "回退审核组织编号",
    "auditUnitName": "回退审核组织名称",
    "auditUserId": "回退审核人编号",
    "auditUserName": "回退审核人名称",
    "auditTime": "回退审核时间",
    "auditResult": "回退审核结果",
    "auditResultName": "回退审核结果名称",
    "audit_content": "回退审核理由",
    "custId": "顾客编号",
}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/json/CaseWindupApply.json

New file
@@ -0,0 +1,27 @@
{
    "id": "主键编号",
    "caseId": "纠纷编号",
    "applyUnitId": "结案申请组织编号",
    "applyUnitName": "结案申请组织名称",
    "applyUserId": "结案申请人编号",
    "applyUserName": "结案申请人名称",
    "applyTime": "结案申请时间",
    "applyStatus": 0,
    "mediResult": "调解结果",
    "mediResultName": "调解结果名称",
    "agreeType": "达成协议类型",
    "agreeTypeName": "达成协议类型名称",
    "agreeContent": "协议要点/已达成协议",
    "failReason": "无法化解理由",
    "windupContent": "结案意见",
    "caseTaskId": "结案审核纠纷任务编号",
    "auditUnitId": "结案审核组织编号",
    "auditUnitName": "结案审核组织名称",
    "auditUserId": "结案审核人编号",
    "auditUserName": "结案审核人名称",
    "auditTime": "结案审核时间",
    "auditResult": "结案审核结果",
    "auditResultName": "结案审核结果名称",
    "audit_content": "结案审核理由",
    "custId": "顾客编号",
}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/po/CaseAppear.java

New file
@@ -0,0 +1,156 @@
package cn.huge.module.cases.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 纠纷上报信息表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-07 00:06:20
 * @version 1.0.0
 */
@TableName(value = "dyh_case_appear")
@Data
public class CaseAppear {

    /**
    * 主键编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 纠纷编号
    */
    @TableField(value = "case_id")
    private String caseId;

    /**
    * 上报组织编号
    */
    @TableField(value = "appear_unit_id")
    private String appearUnitId;

    /**
    * 上报组织名称
    */
    @TableField(value = "appear_unit_name")
    private String appearUnitName;

    /**
    * 上报人编号
    */
    @TableField(value = "appear_user_id")
    private String appearUserId;

    /**
    * 上报人名称
    */
    @TableField(value = "appear_user_name")
    private String appearUserName;

    /**
    * 上报理由
    */
    @TableField(value = "appear_content")
    private String appearContent;

    /**
    * 上报时间
    */
    @TableField(value = "appear_time")
    private Date appearTime;

    /**
    * 上报审核纠纷任务编号
    */
    @TableField(value = "case_task_id")
    private String caseTaskId;

    /**
    * 上报申请状态，0：待审核，1：已审核
    */
    @TableField(value = "apply_status")
    private Integer applyStatus;

    /**
    * 上报审核组织编号
    */
    @TableField(value = "audit_unit_id")
    private String auditUnitId;

    /**
    * 上报审核组织名称
    */
    @TableField(value = "audit_unit_name")
    private String auditUnitName;

    /**
    * 上报审核人编号
    */
    @TableField(value = "audit_user_id")
    private String auditUserId;

    /**
    * 上报审核人名称
    */
    @TableField(value = "audit_user_name")
    private String auditUserName;

    /**
    * 上报审核时间
    */
    @TableField(value = "audit_time")
    private Date auditTime;

    /**
    * 上报审核结果
    */
    @TableField(value = "audit_result")
    private String auditResult;

    /**
    * 上报审核结果名称
    */
    @TableField(value = "audit_result_name")
    private String auditResultName;

    /**
    * 上报审核理由
    */
    @TableField(value = "audit__content")
    private String audit_content;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 顾客编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/po/CaseAssistApply.java

File was renamed from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/domain/po/CaseAssistApply.java
@@ -1,4 +1,4 @@
package cn.huge.module.assist.domain.po;
package cn.huge.module.cases.domain.po;

import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import com.baomidou.mybatisplus.annotation.TableField;

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/po/CaseReturn.java

New file
@@ -0,0 +1,156 @@
package cn.huge.module.cases.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 纠纷回退信息表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-07 00:06:20
 * @version 1.0.0
 */
@TableName(value = "dyh_case_return")
@Data
public class CaseReturn {

    /**
    * 主键编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 纠纷编号
    */
    @TableField(value = "case_id")
    private String caseId;

    /**
    * 回退组织编号
    */
    @TableField(value = "return_unit_id")
    private String returnUnitId;

    /**
    * 回退组织名称
    */
    @TableField(value = "return_unit_name")
    private String returnUnitName;

    /**
    * 回退人编号
    */
    @TableField(value = "return_user_id")
    private String returnUserId;

    /**
    * 回退人名称
    */
    @TableField(value = "return_user_name")
    private String returnUserName;

    /**
    * 回退理由
    */
    @TableField(value = "return_content")
    private String returnContent;

    /**
    * 回退时间
    */
    @TableField(value = "return_time")
    private Date returnTime;

    /**
    * 回退状态，0：待审核，1：已审核
    */
    @TableField(value = "return_status")
    private Integer returnStatus;

    /**
    * 回退审核纠纷任务编号
    */
    @TableField(value = "case_task_id")
    private String caseTaskId;

    /**
    * 回退审核组织编号
    */
    @TableField(value = "audit_unit_id")
    private String auditUnitId;

    /**
    * 回退审核组织名称
    */
    @TableField(value = "audit_unit_name")
    private String auditUnitName;

    /**
    * 回退审核人编号
    */
    @TableField(value = "audit_user_id")
    private String auditUserId;

    /**
    * 回退审核人名称
    */
    @TableField(value = "audit_user_name")
    private String auditUserName;

    /**
    * 回退审核时间
    */
    @TableField(value = "audit_time")
    private String auditTime;

    /**
    * 回退审核结果
    */
    @TableField(value = "audit_result")
    private String auditResult;

    /**
    * 回退审核结果名称
    */
    @TableField(value = "audit_result_name")
    private String auditResultName;

    /**
    * 回退审核理由
    */
    @TableField(value = "audit__content")
    private String audit_content;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 顾客编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/po/CaseTask.java

New file
@@ -0,0 +1,246 @@
package cn.huge.module.cases.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 纠纷任务表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version 1.0.0
 */
@TableName(value = "dyh_case_task")
@Data
public class CaseTask {

    /**
    * 纠纷任务编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 纠纷编号
    */
    @TableField(value = "case_id")
    private String caseId;

    /**
    * 工作流流程定义编号
    */
    @TableField(value = "flowable_id")
    private String flowableId;

    /**
    * 工作流流程实例编号
    */
    @TableField(value = "process_instance_id")
    private String processInstanceId;

    /**
    * 工作流流程实例任务编号
    */
    @TableField(value = "process_task_id")
    private String processTaskId;

    /**
    * 工作流任务类型，1：正常任务，2：退回任务；3：上报任务
    */
    @TableField(value = "task_type")
    private Integer taskType;

    /**
    * 工作流节点类型，1：首节点，2：普通节点，3：结束节点
    */
    @TableField(value = "node_type")
    private Integer nodeType;

    /**
    * 工作流节点
    */
    @TableField(value = "node_id")
    private String nodeId;

    /**
    * 工作流节点名称
    */
    @TableField(value = "node_name")
    private String nodeName;

    /**
    * 业务流程
    */
    @TableField(value = "flow_id")
    private String flowId;

    /**
    * 流程页面展示名称
    */
    @TableField(value = "node_show_name")
    private String nodeShowName;

    /**
    * 纠纷任务类型，1：承办，2：配合
    */
    @TableField(value = "case_task_type")
    private Integer caseTaskType;

    /**
    * 任务候选执行者类型：1：所有人，2：上一步骤选择，3：上一步骤执行者，4：自定义指定（单位部门角色人组合）
    */
    @TableField(value = "cande_type")
    private Integer candeType;

    /**
    * 任务候选执行组织编号
    */
    @TableField(value = "cande_unit_id")
    private String candeUnitId;

    /**
    * 任务候选执行组织名称
    */
    @TableField(value = "cande_unit_name")
    private String candeUnitName;

    /**
    * 任务候选执行部门编号
    */
    @TableField(value = "cande_dept_id")
    private String candeDeptId;

    /**
    * 任务候选执行部门名称
    */
    @TableField(value = "cande_dept_name")
    private String candeDeptName;

    /**
    * 任务候选执行角色代码编号
    */
    @TableField(value = "cande_role_code")
    private String candeRoleCode;

    /**
    * 任务候选执行角色名称
    */
    @TableField(value = "cande_role_name")
    private String candeRoleName;

    /**
    * 任务候选执行人员编号
    */
    @TableField(value = "cande_user_id")
    private String candeUserId;

    /**
    * 任务候选执行人员名称
    */
    @TableField(value = "cande_user_name")
    private String candeUserName;

    /**
    * 任务签收状态，0：不用签收，1：未签收，:2：已签收
    */
    @TableField(value = "sign_status")
    private Integer signStatus;

    /**
    * 任务签收到期时间
    */
    @TableField(value = "sign_expire_time")
    private Date signExpireTime;

    /**
    * 任务签收时间
    */
    @TableField(value = "sign_time")
    private Date signTime;

    /**
    * 任务签收人编号
    */
    @TableField(value = "sign_user_id")
    private String signUserId;

    /**
    * 任务签收人名称
    */
    @TableField(value = "sign_user_name")
    private String signUserName;

    /**
    * 任务到期时间
    */
    @TableField(value = "expire_time")
    private Date expireTime;

    /**
    * 任务进度，1：进行中，2：已完成
    */
    @TableField(value = "status")
    private Integer status;

    /**
    * 任务处理人编号
    */
    @TableField(value = "handle_user_id")
    private String handleUserId;

    /**
    * 任务处理人名称
    */
    @TableField(value = "handle_user_name")
    private String handleUserName;

    /**
    * 处理结果，1：通过，2：退回，3：终止流程
    */
    @TableField(value = "handle_result")
    private Integer handleResult;

    /**
    * 处理说明
    */
    @TableField(value = "handle_content")
    private String handleContent;

    /**
    * 任任务处理时间
    */
    @TableField(value = "handle_time")
    private Date handleTime;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 顾客编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/po/CaseWindupApply.java

copy from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/domain/po/CaseAssistApply.java
copy to dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/domain/po/CaseWindupApply.java
File was copied from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/domain/po/CaseAssistApply.java
@@ -1,6 +1,5 @@
package cn.huge.module.assist.domain.po;
package cn.huge.module.cases.domain.po;

import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
@@ -8,19 +7,18 @@
import lombok.Data;

import java.util.Date;
import java.util.List;

/**
 * @title: 联合处置申请信息表数据库对应关系类
 * @title: 纠纷结案申请信息表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: wangwh
 * @time: 2024-09-05 17:25:04
 * @author: liyj
 * @time: 2024-09-06 23:57:02
 * @version 1.0.0
 */
@TableName(value = "dyh_case_assist_apply")
@TableName(value = "dyh_case_windup_apply")
@Data
public class CaseAssistApply {
public class CaseWindupApply {

    /**
    * 主键编号
@@ -35,103 +33,133 @@
    private String caseId;

    /**
    * 申请组织编号
    * 结案申请组织编号
    */
    @TableField(value = "apply_unit_id")
    private String applyUnitId;

    /**
    * 申请组织名称
    * 结案申请组织名称
    */
    @TableField(value = "apply_unit_name")
    private String applyUnitName;

    /**
    * 申请人编号
    * 结案申请人编号
    */
    @TableField(value = "apply_user_id")
    private String applyUserId;

    /**
    * 申请人名称
    * 结案申请人名称
    */
    @TableField(value = "apply_user_name")
    private String applyUserName;

    /**
    * 申请配合组织，多个用,隔开
    */
    @TableField(value = "apply_assist_unit_id")
    private String applyAssistUnitId;

    /**
    * 申请配合组织名称，多个用、隔开
    */
    @TableField(value = "apply_assist_unit_name")
    private String applyAssistUnitName;

    /**
    * 申请理由
    */
    @TableField(value = "apply_content")
    private String applyContent;

    /**
    * 申请时间
    * 结案申请时间
    */
    @TableField(value = "apply_time")
    private Date applyTime;

    /**
    * 申请状态，0：待审核，1：已审核
    * 结案申请状态，0：待审核，1：已审核
    */
    @TableField(value = "apply_status")
    private Integer applyStatus;

    /**
    * 审核组织编号
    * 调解结果
    */
    @TableField(value = "medi_result")
    private String mediResult;

    /**
    * 调解结果名称
    */
    @TableField(value = "medi_result_name")
    private String mediResultName;

    /**
    * 达成协议类型
    */
    @TableField(value = "agree_type")
    private String agreeType;

    /**
    * 达成协议类型名称
    */
    @TableField(value = "agree_type_name")
    private String agreeTypeName;

    /**
    * 协议要点/已达成协议
    */
    @TableField(value = "agree_content")
    private String agreeContent;

    /**
    * 无法化解理由
    */
    @TableField(value = "fail_reason")
    private String failReason;

    /**
    * 结案意见
    */
    @TableField(value = "windup_content")
    private String windupContent;

    /**
    * 结案审核纠纷任务编号
    */
    @TableField(value = "case_task_id")
    private String caseTaskId;

    /**
    * 结案审核组织编号
    */
    @TableField(value = "audit_unit_id")
    private String auditUnitId;

    /**
    * 审核组织名称
    * 结案审核组织名称
    */
    @TableField(value = "audit_unit_name")
    private String auditUnitName;

    /**
    * 审核人编号
    * 结案审核人编号
    */
    @TableField(value = "audit_user_id")
    private String auditUserId;

    /**
    * 审核人名称
    * 结案审核人名称
    */
    @TableField(value = "audit_user_name")
    private String auditUserName;

    /**
    * 审核时间
    * 结案审核时间
    */
    @TableField(value = "audit_time")
    private Date auditTime;
    private String auditTime;

    /**
    * 审核结果
    * 结案审核结果
    */
    @TableField(value = "audit_result")
    private String auditResult;

    /**
    * 审核结果名称
    * 结案审核结果名称
    */
    @TableField(value = "audit_result_name")
    private String auditResultName;

    /**
    * 审核理由
    * 结案审核理由
    */
    @TableField(value = "audit__content")
    private String audit_content;
@@ -161,6 +189,4 @@
    @TableField(value = "update_time")
    private Date updateTime;

    @TableField(exist = false)
    private List<FileTypeInfoBaseDTO> fileTypeInfoBaseDTOList;
}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseAppearService.java

New file
@@ -0,0 +1,151 @@
package cn.huge.module.cases.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.cases.domain.po.CaseReturn;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseAppearMapper;
import cn.huge.module.cases.domain.po.CaseAppear;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 纠纷上报信息表业务逻辑处理
 * @Description 纠纷上报信息表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-07 00:06:20
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseAppearService extends ServiceImpl<CaseAppearMapper, CaseAppear>{

    @Autowired
    private CaseAppearMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateCaseAppear(CaseAppear entity){
        try{
            mapper.updateCaseAppear(entity);
        }catch (Exception e){
            log.error("[CaseAppearService.updateCaseAppear]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseAppearService.updateCaseAppear", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateCaseAppearTerms(CaseAppear entity, Map<String, Object> terms){
        try{
            mapper.updateCaseAppearTerms(entity, terms);
        }catch (Exception e){
            log.error("[CaseAppearService.updateCaseAppearTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseAppearService.updateCaseAppearTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteCaseAppear(String id){
        try{
            mapper.deleteCaseAppear(id);
        }catch (Exception e){
            log.error("[CaseAppearService.deleteCaseAppear]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseAppearService.deleteCaseAppear", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CaseAppear> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<CaseAppear> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CaseAppear> content = mapper.pageTerms(page, terms);
        return new PageImpl<CaseAppear>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param caseAppear 实体对象
    */
    public void saveCaseAppear(CaseAppear caseAppear){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(caseAppear.getId())){
                caseAppear.setId(utilsClient.getNewTimeId());
                caseAppear.setCreateTime(nowDate);
            }
            caseAppear.setUpdateTime(nowDate);
            this.saveOrUpdate(caseAppear);
        }catch (Exception e){
            log.error("[CaseAppearService.saveCaseAppear]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseAppearService.saveCaseAppear", e);
        }
    }

    /**
     * 根据纠纷任务编号查询
     * @param caseTaskId
     * @return
     */
    public CaseAppear getByCaseTaskId(String caseTaskId){
        try{
            QueryWrapper<CaseAppear> caseAppearQueryWrapper = new QueryWrapper<>();
            caseAppearQueryWrapper.eq("case_task_id", caseTaskId);
            return mapper.selectOne(caseAppearQueryWrapper);
        }catch (Exception e){
            log.error("[CaseAppearService.getByCaseTaskId]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseAppearService.getByCaseTaskId", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseAssistApplyService.java

File was renamed from dyh-service/dyh-mediate/src/main/java/cn/huge/module/assist/service/CaseAssistApplyService.java
@@ -1,30 +1,26 @@
package cn.huge.module.assist.service;
package cn.huge.module.cases.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.assist.dao.mapper.CaseAssistApplyMapper;
import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.cases.dao.mapper.CaseAssistApplyMapper;
import cn.huge.module.cases.domain.po.CaseAssistApply;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.mediate.constant.CaseBaseConsts;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @title: 联合处置申请信息表业务逻辑处理

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseFeedbackService.java

@@ -3,8 +3,10 @@
import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.module.cases.domain.po.CaseFeedbackHis;
import cn.huge.module.cases.domain.po.CaseInfoUnfold;
import cn.huge.module.cases.domain.po.CaseTask;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.SysClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
@@ -16,6 +18,8 @@
import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -62,6 +66,9 @@

    @Autowired
    private CaseInfoUnfoldService unfoldService;

    @Autowired
    private CaseTaskService caseTaskService;

    /**
    * 更新对象
@@ -154,7 +161,30 @@
    }

    /**
     * 获取办理反馈信息
     * 获取办理信息
     * @param caseTaskId
     * @param userId
     * @return
     */
    public Map<String, Object> getFeedbackInfo(String caseTaskId, String userId){
        // 临时给前端联调数据
        Map<String, Object> result = Maps.newHashMap();
        result.put("handleUnitName", "白云区教育局");
        result.put("handleUserName", "王一顺");
        result.put("assistUnitName", "白云区司法局");
        result.put("acceptTime", "2024-09-07 12:34");
//        CaseTask caseTask = caseTaskService.getById(caseTaskId);
//        if (ObjectUtils.isNotEmpty(caseTask)){
//            result.put("handleUnitName", caseTask.getCandeUnitName());
//            result.put("handleUserName", caseTask.getCandeUserName());
//            result.put("assistUnitName", caseTask.getCandeUnitName());
//            result.put("acceptTime", caseTask.getCreateTime());
//        }
        return result;
    }

    /**
     * 获取办理反馈记录
     * @param id 条件
     * @return Page
     */

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseInfoUnfoldService.java

@@ -4,10 +4,8 @@
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.module.assist.domain.po.CaseAssistApply;
import cn.huge.module.assist.service.CaseAssistApplyService;
import cn.huge.module.cases.domain.po.CaseAssistApply;
import cn.huge.module.cases.domain.dto.TransactResultDTO;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseInfoUnfoldMapper;
@@ -20,13 +18,11 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseReturnService.java

New file
@@ -0,0 +1,151 @@
package cn.huge.module.cases.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.cases.domain.po.CaseWindupApply;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseReturnMapper;
import cn.huge.module.cases.domain.po.CaseReturn;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 纠纷回退信息表业务逻辑处理
 * @Description 纠纷回退信息表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-07 00:06:20
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseReturnService extends ServiceImpl<CaseReturnMapper, CaseReturn>{

    @Autowired
    private CaseReturnMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateCaseReturn(CaseReturn entity){
        try{
            mapper.updateCaseReturn(entity);
        }catch (Exception e){
            log.error("[CaseReturnService.updateCaseReturn]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseReturnService.updateCaseReturn", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateCaseReturnTerms(CaseReturn entity, Map<String, Object> terms){
        try{
            mapper.updateCaseReturnTerms(entity, terms);
        }catch (Exception e){
            log.error("[CaseReturnService.updateCaseReturnTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseReturnService.updateCaseReturnTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteCaseReturn(String id){
        try{
            mapper.deleteCaseReturn(id);
        }catch (Exception e){
            log.error("[CaseReturnService.deleteCaseReturn]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseReturnService.deleteCaseReturn", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CaseReturn> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<CaseReturn> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CaseReturn> content = mapper.pageTerms(page, terms);
        return new PageImpl<CaseReturn>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param caseReturn 实体对象
    */
    public void saveCaseReturn(CaseReturn caseReturn){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(caseReturn.getId())){
                caseReturn.setId(utilsClient.getNewTimeId());
                caseReturn.setCreateTime(nowDate);
            }
            caseReturn.setUpdateTime(nowDate);
            this.saveOrUpdate(caseReturn);
        }catch (Exception e){
            log.error("[CaseReturnService.saveCaseReturn]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseReturnService.saveCaseReturn", e);
        }
    }

    /**
     * 根据纠纷任务编号查询
     * @param caseTaskId
     * @return
     */
    public CaseReturn getByCaseTaskId(String caseTaskId){
        try{
            QueryWrapper<CaseReturn> caseReturnQueryWrapper = new QueryWrapper<>();
            caseReturnQueryWrapper.eq("case_task_id", caseTaskId);
            return mapper.selectOne(caseReturnQueryWrapper);
        }catch (Exception e){
            log.error("[CaseReturnService.getByCaseTaskId]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseReturnService.getByCaseTaskId", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java

New file
@@ -0,0 +1,335 @@
package cn.huge.module.cases.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.cases.domain.dto.CaseFlowDTO;
import cn.huge.module.cases.domain.dto.TabButtonDTO;
import cn.huge.module.cases.domain.dto.TabButtonInfoDTO;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseTaskMapper;
import cn.huge.module.cases.domain.po.CaseTask;
import cn.huge.module.mediate.constant.CaseBaseConsts;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * @title: 纠纷任务表业务逻辑处理
 * @Description 纠纷任务表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-06 15:50:06
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseTaskService extends ServiceImpl<CaseTaskMapper, CaseTask>{

    @Autowired
    private CaseTaskMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateCaseTask(CaseTask entity){
        try{
            mapper.updateCaseTask(entity);
        }catch (Exception e){
            log.error("[CaseTaskService.updateCaseTask]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.updateCaseTask", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateCaseTaskTerms(CaseTask entity, Map<String, Object> terms){
        try{
            mapper.updateCaseTaskTerms(entity, terms);
        }catch (Exception e){
            log.error("[CaseTaskService.updateCaseTaskTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.updateCaseTaskTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteCaseTask(String id){
        try{
            mapper.deleteCaseTask(id);
        }catch (Exception e){
            log.error("[CaseTaskService.deleteCaseTask]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.deleteCaseTask", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CaseTask> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<CaseTask> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CaseTask> content = mapper.pageTerms(page, terms);
        return new PageImpl<CaseTask>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param caseTask 实体对象
    */
    public void saveCaseTask(CaseTask caseTask){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(caseTask.getId())){
                caseTask.setId(utilsClient.getNewTimeId());
                caseTask.setCreateTime(nowDate);
            }
            caseTask.setUpdateTime(nowDate);
            this.saveOrUpdate(caseTask);
        }catch (Exception e){
            log.error("[CaseTaskService.saveCaseTask]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.saveCaseTask", e);
        }
    }

    /**
     * web端-任务出来页面-初始化tab和按钮
     * @param caseTaskId
     * @return
     */
    public TabButtonDTO webGetTabButton(String caseTaskId, String userId){
        try{
            // 临时给前端联调数据
            TabButtonDTO tabButtonDTO = new TabButtonDTO();
            List<TabButtonInfoDTO> tabList = new LinkedList<>();
            TabButtonInfoDTO sxxq = new TabButtonInfoDTO();
            sxxq.setId("sxxq");
            sxxq.setName("事项详情");
            tabList.add(sxxq);

            TabButtonInfoDTO dslxq = new TabButtonInfoDTO();
            dslxq.setId("dslxq");
            dslxq.setName("详情");
            tabList.add(dslxq);

            TabButtonInfoDTO sxbl = new TabButtonInfoDTO();
            sxbl.setId("sxbl");
            sxbl.setName("事项办理");
            tabList.add(sxbl);

            TabButtonInfoDTO sqjl = new TabButtonInfoDTO();
            sqjl.setId("sqjl");
            sqjl.setName("申请记录");
            tabList.add(sqjl);

            TabButtonInfoDTO htsh = new TabButtonInfoDTO();
            htsh.setId("htsh");
            htsh.setName("回退审核");
            tabList.add(htsh);

            TabButtonInfoDTO sbsh = new TabButtonInfoDTO();
            sbsh.setId("sbsh");
            sbsh.setName("上报审核");
            tabList.add(sbsh);

            TabButtonInfoDTO jash = new TabButtonInfoDTO();
            jash.setId("jash");
            jash.setName("结案审核");
            tabList.add(jash);

            TabButtonInfoDTO lhczsh = new TabButtonInfoDTO();
            lhczsh.setId("lhczsh");
            lhczsh.setName("联合处置申请审核");
            tabList.add(lhczsh);

            TabButtonInfoDTO lcdb = new TabButtonInfoDTO();
            lcdb.setId("lcdb");
            lcdb.setName("流程督办");
            tabList.add(lcdb);

            TabButtonInfoDTO daxx = new TabButtonInfoDTO();
            daxx.setId("daxx");
            daxx.setName("档案信息");
            tabList.add(daxx);
            tabButtonDTO.setTabList(tabList);

            List<TabButtonInfoDTO> buttonList = new LinkedList<>();
            TabButtonInfoDTO tjbljl = new TabButtonInfoDTO();
            tjbljl.setId("tjbljl");
            tjbljl.setName("添加办理记录");
            buttonList.add(tjbljl);

            TabButtonInfoDTO lhczsq = new TabButtonInfoDTO();
            lhczsq.setId("lhczsq");
            lhczsq.setName("联合处置申请");
            buttonList.add(lhczsq);

            TabButtonInfoDTO jasq = new TabButtonInfoDTO();
            jasq.setId("jasq");
            jasq.setName("结案申请");
            buttonList.add(jasq);

            TabButtonInfoDTO db = new TabButtonInfoDTO();
            db.setId("db");
            db.setName("督办");
            buttonList.add(db);

            TabButtonInfoDTO sl = new TabButtonInfoDTO();
            sl.setId("sl");
            sl.setName("受理");
            buttonList.add(sl);

            TabButtonInfoDTO ht = new TabButtonInfoDTO();
            ht.setId("ht");
            ht.setName("回退");
            buttonList.add(ht);

            TabButtonInfoDTO zxsl = new TabButtonInfoDTO();
            zxsl.setId("zxsl");
            zxsl.setName("自行受理");
            buttonList.add(zxsl);

            TabButtonInfoDTO jb = new TabButtonInfoDTO();
            jb.setId("jb");
            jb.setName("交办");
            buttonList.add(jb);

            TabButtonInfoDTO sb = new TabButtonInfoDTO();
            sb.setId("sb");
            sb.setName("上报");
            buttonList.add(sb);
            tabButtonDTO.setButtonList(buttonList);
            return tabButtonDTO;
        }catch (Exception e){
            log.error("[CaseTaskService.webGetTabButton]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webGetTabButton", e);
        }
    }

    /**
     * web端-查询流程进度
     * @param caseId 纠纷编号
     * @return
     */
    public Map<String, Object> webListCaseFlow(String caseId, String userId){
        try{
            // 临时给前端联调数据
            Map<String, Object> result = Maps.newHashMap();

            List<CaseFlowDTO> handleCaseFlowList = new LinkedList<>();
            CaseFlowDTO lfdj = new CaseFlowDTO();
            lfdj.setNodeShowName("来访登记");
            lfdj.setHandleUnitName("白云区新市综治中心");
            lfdj.setHandleUserName("李晓明");
            lfdj.setTaskType(1);
            lfdj.setStatus(2);
            lfdj.setHandleTime(new Date());
            handleCaseFlowList.add(lfdj);

            CaseFlowDTO xtpd = new CaseFlowDTO();
            xtpd.setNodeShowName("事件流转");
            xtpd.setHandleUnitName("系统派单");
            xtpd.setHandleTime(new Date());
            xtpd.setHandleNotes("派单至：白云区新市司法所");
            xtpd.setTaskType(1);
            xtpd.setStatus(2);
            handleCaseFlowList.add(xtpd);

            CaseFlowDTO sjlz = new CaseFlowDTO();
            sjlz.setNodeShowName("事件流转");
            sjlz.setHandleUnitName("白云区新市司法所");
            sjlz.setHandleUserName("赵菲菲");
            sjlz.setHandleTime(new Date());
            sjlz.setHandleNotes("已签收");
            sjlz.setTaskType(1);
            sjlz.setStatus(2);
            handleCaseFlowList.add(sjlz);

            CaseFlowDTO sjht = new CaseFlowDTO();
            sjht.setNodeShowName("事件回退");
            sjht.setHandleUnitName("白云区新市司法所");
            sjht.setHandleUserName("赵菲菲");
            sjht.setHandleTime(new Date());
            sjht.setTaskType(2);
            sjht.setStatus(2);
            handleCaseFlowList.add(sjht);

            CaseFlowDTO htsh = new CaseFlowDTO();
            htsh.setNodeShowName("回退审核");
            htsh.setHandleUnitName("白云区新市综治中心");
            htsh.setHandleUserName("李晓明");
            htsh.setHandleTime(new Date());
            htsh.setAuditResult("24_00004-1");
            htsh.setAuditResultName("通过");
            htsh.setHandleTime(new Date());
            htsh.setTaskType(1);
            htsh.setStatus(2);
            handleCaseFlowList.add(htsh);

            CaseFlowDTO dsl = new CaseFlowDTO();
            dsl.setProcessName("待受理");
            dsl.setHandleUnitName("白云区新市综治中心");
            dsl.setTaskType(1);
            dsl.setStatus(1);
            handleCaseFlowList.add(dsl);
            result.put("handleCaseFlowList", handleCaseFlowList);

            List<CaseFlowDTO> assistCaseFlowList = new LinkedList<>();
            CaseFlowDTO xtpd2 = new CaseFlowDTO();
            xtpd2.setNodeShowName("事件流转");
            xtpd2.setHandleUnitName("联合处置申请");
            xtpd2.setHandleTime(new Date());
            xtpd2.setHandleNotes("联合处置申请：白云区永平司法所");
            xtpd2.setTaskType(1);
            xtpd2.setStatus(2);
            assistCaseFlowList.add(xtpd2);
            result.put("assistCaseFlowList", assistCaseFlowList);
            return result;
        }catch (Exception e){
            log.error("[CaseTaskService.webGetTabButton]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webGetTabButton", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseWindupApplyService.java

New file
@@ -0,0 +1,150 @@
package cn.huge.module.cases.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.cases.dao.mapper.CaseWindupApplyMapper;
import cn.huge.module.cases.domain.po.CaseWindupApply;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 纠纷结案申请信息表业务逻辑处理
 * @Description 纠纷结案申请信息表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-06 23:57:02
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CaseWindupApplyService extends ServiceImpl<CaseWindupApplyMapper, CaseWindupApply>{

    @Autowired
    private CaseWindupApplyMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateCaseWindupApply(CaseWindupApply entity){
        try{
            mapper.updateCaseWindupApply(entity);
        }catch (Exception e){
            log.error("[CaseWindupApplyService.updateCaseWindupApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseWindupApplyService.updateCaseWindupApply", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateCaseWindupApplyTerms(CaseWindupApply entity, Map<String, Object> terms){
        try{
            mapper.updateCaseWindupApplyTerms(entity, terms);
        }catch (Exception e){
            log.error("[CaseWindupApplyService.updateCaseWindupApplyTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseWindupApplyService.updateCaseWindupApplyTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteCaseWindupApply(String id){
        try{
            mapper.deleteCaseWindupApply(id);
        }catch (Exception e){
            log.error("[CaseWindupApplyService.deleteCaseWindupApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseWindupApplyService.deleteCaseWindupApply", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CaseWindupApply> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<CaseWindupApply> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CaseWindupApply> content = mapper.pageTerms(page, terms);
        return new PageImpl<CaseWindupApply>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param caseWindupApply 实体对象
    */
    public void saveCaseWindupApply(CaseWindupApply caseWindupApply){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(caseWindupApply.getId())){
                caseWindupApply.setId(utilsClient.getNewTimeId());
                caseWindupApply.setCreateTime(nowDate);
            }
            caseWindupApply.setUpdateTime(nowDate);
            this.saveOrUpdate(caseWindupApply);
        }catch (Exception e){
            log.error("[CaseWindupApplyService.saveCaseWindupApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseWindupApplyService.saveCaseWindupApply", e);
        }
    }

    /**
     * 根据纠纷任务编号查询
     * @param caseTaskId
     * @return
     */
    public CaseWindupApply getByCaseTaskId(String caseTaskId){
        try{
            QueryWrapper<CaseWindupApply> caseWindupApplyQueryWrapper = new QueryWrapper<>();
            caseWindupApplyQueryWrapper.eq("case_task_id", caseTaskId);
            return mapper.selectOne(caseWindupApplyQueryWrapper);
        }catch (Exception e){
            log.error("[CaseWindupApplyService.getByCaseTaskId]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseWindupApplyService.getByCaseTaskId", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/client/api/DispClient.java

New file
@@ -0,0 +1,29 @@
package cn.huge.module.client.api;

import cn.huge.base.common.bo.ReturnBO;
import cn.huge.module.disp.dto.DispCaseBaseDTO;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @title: 公共工具微服务调用接口
 * @description: 公共工具微服务调用接口
 * @company: hugeinfo
 * @author: liyj
 * @time: 2021-11-05 16:51:48
 * @version: 1.0.0
 */
@FeignClient(name = "dyh-disp")
public interface DispClient {

    /**
     * 系统调度
     * @url {ctx}/api/client/caseDisp/sysDisp
     * @param dispCaseBaseDTO 纠纷事件信息
     * @return Object
     */
    @GetMapping("/api/client/caseDisp/sysDisp")
    ReturnBO sysDisp(@RequestBody DispCaseBaseDTO dispCaseBaseDTO);
}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/client/api/impl/DispClientImpl.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.client.api.impl;

import cn.huge.base.common.bo.ReturnBO;
import cn.huge.base.common.constant.ReturnConsts;
import cn.huge.base.common.exception.ClientException;
import cn.huge.base.common.exception.ServiceException;
import cn.huge.module.client.api.DispClient;
import cn.huge.module.client.api.UtilsClient;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.disp.dto.CaseDispBaseDTO;
import cn.huge.module.disp.dto.DispCaseBaseDTO;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * @title: 公共工具微服务调用接口
 * @description: 公共工具微服务调用接口
 * @company: hugeinfo
 * @author: liyj
 * @time: 2021-11-05 16:51:48
 * @version: 1.0.0
 */
@Slf4j
@Component
public class DispClientImpl {

    private DispClient dispClient;

    @Autowired
    public DispClientImpl(DispClient dispClient) {
        this.dispClient = dispClient;
    }

    /**
     * ObjectMapper工具类
     */
    private ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 系统调度
     * @url {ctx}/api/client/caseDisp/sysDisp
     * @param dispCaseBaseDTO 纠纷事件信息
     * @return Object
     */
    public CaseDispBaseDTO sysDisp(DispCaseBaseDTO dispCaseBaseDTO){
        try{
            ReturnBO returnBo = dispClient.sysDisp(dispCaseBaseDTO);
            if (ReturnConsts.OK == returnBo.getCode()){
                CaseDispBaseDTO caseDispBaseDTO = objectMapper.convertValue(returnBo.getData(), CaseDispBaseDTO.class);
                return caseDispBaseDTO;
            }else{
                log.error("Client外服务接口[DispClientImpl.sysDisp]请求失败，异常信息：" + returnBo.getMsg(), returnBo.getMsg());
                throw new ClientException("DispClientImpl.sysDisp", returnBo.getMsg());
            }
        }catch (Exception e){
            log.error("service方法[DispClientImpl.sysDisp]请求成功，处理异常："+e, e);
            throw new ServiceException("DispClientImpl.sysDisp", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/controller/web/FlowInfoWebController.java

New file
@@ -0,0 +1,205 @@
package cn.huge.module.flow.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.flow.domain.po.FlowInfo;
import cn.huge.module.flow.service.FlowInfoService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 业务流程信息表接口api-web端
 * @description: 业务流程信息表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/flowInfo")
public class FlowInfoWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private FlowInfoService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 主键编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 工作流流程编号
        String flowableId = request.getParameter("flowableId");
        if (StringUtils.isNotBlank(flowableId)){
            terms.put("flowableId", flowableId);
        }
        // 工作流流程名称
        String flowableName = request.getParameter("flowableName");
        if (StringUtils.isNotBlank(flowableName)){
            terms.put("flowableName", flowableName);
        }
        // 流程类型，1：主流程
        String flowType = request.getParameter("flowType");
        if (StringUtils.isNotBlank(flowType)){
            terms.put("flowType", flowType);
        }
        // 调解类型
        String mediType = request.getParameter("mediType");
        if (StringUtils.isNotBlank(mediType)){
            terms.put("mediType", mediType);
        }
        // 纠纷类型（最小级）
        String caseType = request.getParameter("caseType");
        if (StringUtils.isNotBlank(caseType)){
            terms.put("caseType", caseType);
        }
        // 流程处理时限，以天为单位
        String expire = request.getParameter("expire");
        if (StringUtils.isNotBlank(expire)){
            terms.put("expire", expire);
        }
        // 所属组织编号
        String unitId = request.getParameter("unitId");
        if (StringUtils.isNotBlank(unitId)){
            terms.put("unitId", unitId);
        }
        // 描述
        String flowDes = request.getParameter("flowDes");
        if (StringUtils.isNotBlank(flowDes)){
            terms.put("flowDes", flowDes);
        }
        // 操作人编号
        String userId = request.getParameter("userId");
        if (StringUtils.isNotBlank(userId)){
            terms.put("userId", userId);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 客户编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 更新时间区间
        String updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/flowInfo/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/flowInfo/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<FlowInfo> flowInfoPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", flowInfoPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/flowInfo/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/flowInfo/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/flowInfo/saveFlowInfo
    * @param flowInfo 实体对象
    * @return Object
    */
    @PostMapping("/saveFlowInfo")
    public Object saveFlowInfo(@RequestBody FlowInfo flowInfo) {
        try {
            service.saveFlowInfo(flowInfo);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/controller/web/FlowNodeWebController.java

New file
@@ -0,0 +1,275 @@
package cn.huge.module.flow.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.flow.domain.po.FlowNode;
import cn.huge.module.flow.service.FlowNodeService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 业务流程节点表接口api-web端
 * @description: 业务流程节点表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/flowNode")
public class FlowNodeWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private FlowNodeService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 主键编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 业务流程编号
        String flowId = request.getParameter("flowId");
        if (StringUtils.isNotBlank(flowId)){
            terms.put("flowId", flowId);
        }
        // 工作流流程编号
        String flowableId = request.getParameter("flowableId");
        if (StringUtils.isNotBlank(flowableId)){
            terms.put("flowableId", flowableId);
        }
        // 工作流节点编号
        String nodeId = request.getParameter("nodeId");
        if (StringUtils.isNotBlank(nodeId)){
            terms.put("nodeId", nodeId);
        }
        // 流程页面展示名称
        String nodeShowName = request.getParameter("nodeShowName");
        if (StringUtils.isNotBlank(nodeShowName)){
            terms.put("nodeShowName", nodeShowName);
        }
        // 工作流节点名称
        String nodeName = request.getParameter("nodeName");
        if (StringUtils.isNotBlank(nodeName)){
            terms.put("nodeName", nodeName);
        }
        // 工作流节点类型，1：首节点，2：普通节点，3：尾节点
        String nodeType = request.getParameter("nodeType");
        if (StringUtils.isNotBlank(nodeType)){
            terms.put("nodeType", nodeType);
        }
        // 工作流节点顺序
        String nodeIndex = request.getParameter("nodeIndex");
        if (StringUtils.isNotBlank(nodeIndex)){
            terms.put("nodeIndex", nodeIndex);
        }
        // 节点图标
        String nodeIcon = request.getParameter("nodeIcon");
        if (StringUtils.isNotBlank(nodeIcon)){
            terms.put("nodeIcon", nodeIcon);
        }
        // 对应请求接口方式，POST：post请求，GET：get请求，PUT：put请求，DELETE：delete请求
        String apiType = request.getParameter("apiType");
        if (StringUtils.isNotBlank(apiType)){
            terms.put("apiType", apiType);
        }
        // 对应请求接口
        String api = request.getParameter("api");
        if (StringUtils.isNotBlank(api)){
            terms.put("api", api);
        }
        // 节点处理时限，单位：天
        String expire = request.getParameter("expire");
        if (StringUtils.isNotBlank(expire)){
            terms.put("expire", expire);
        }
        // 节点候选执行者类型：1：所有人，2：上一步骤选择，3：上一步骤执行者，4：自定义指定（单位部门角色人组合）
        String candeType = request.getParameter("candeType");
        if (StringUtils.isNotBlank(candeType)){
            terms.put("candeType", candeType);
        }
        // 节点候选执行组织编号
        String candeUnitId = request.getParameter("candeUnitId");
        if (StringUtils.isNotBlank(candeUnitId)){
            terms.put("candeUnitId", candeUnitId);
        }
        // 节点候选执行组织名称
        String candeUnitName = request.getParameter("candeUnitName");
        if (StringUtils.isNotBlank(candeUnitName)){
            terms.put("candeUnitName", candeUnitName);
        }
        // 节点候选执行部门编号
        String candeDeptId = request.getParameter("candeDeptId");
        if (StringUtils.isNotBlank(candeDeptId)){
            terms.put("candeDeptId", candeDeptId);
        }
        // 节点候选执行部门名称
        String candeDeptName = request.getParameter("candeDeptName");
        if (StringUtils.isNotBlank(candeDeptName)){
            terms.put("candeDeptName", candeDeptName);
        }
        // 节点候选执行角色代码编号
        String candeRoleCode = request.getParameter("candeRoleCode");
        if (StringUtils.isNotBlank(candeRoleCode)){
            terms.put("candeRoleCode", candeRoleCode);
        }
        // 节点候选执行角色名称
        String candeRoleName = request.getParameter("candeRoleName");
        if (StringUtils.isNotBlank(candeRoleName)){
            terms.put("candeRoleName", candeRoleName);
        }
        // 节点候选执行人员编号
        String candeUserId = request.getParameter("candeUserId");
        if (StringUtils.isNotBlank(candeUserId)){
            terms.put("candeUserId", candeUserId);
        }
        // 节点候选执行人员名称
        String candeUserName = request.getParameter("candeUserName");
        if (StringUtils.isNotBlank(candeUserName)){
            terms.put("candeUserName", candeUserName);
        }
        // 节点前进条件
        String goCond = request.getParameter("goCond");
        if (StringUtils.isNotBlank(goCond)){
            terms.put("goCond", goCond);
        }
        // 节点退回条件
        String backCond = request.getParameter("backCond");
        if (StringUtils.isNotBlank(backCond)){
            terms.put("backCond", backCond);
        }
        // 描述
        String des = request.getParameter("des");
        if (StringUtils.isNotBlank(des)){
            terms.put("des", des);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 顾客编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 更新时间区间
        String updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/flowNode/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/flowNode/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<FlowNode> flowNodePage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", flowNodePage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/flowNode/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/flowNode/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/flowNode/saveFlowNode
    * @param flowNode 实体对象
    * @return Object
    */
    @PostMapping("/saveFlowNode")
    public Object saveFlowNode(@RequestBody FlowNode flowNode) {
        try {
            service.saveFlowNode(flowNode);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/controller/web/FlowableInfoWebController.java

New file
@@ -0,0 +1,175 @@
package cn.huge.module.flow.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.flow.domain.po.FlowableInfo;
import cn.huge.module.flow.service.FlowableInfoService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 工作流流程信息表接口api-web端
 * @description: 工作流流程信息表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:05
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/flowableInfo")
public class FlowableInfoWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private FlowableInfoService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 工作流流程编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 流程名称
        String name = request.getParameter("name");
        if (StringUtils.isNotBlank(name)){
            terms.put("name", name);
        }
        // 描述
        String des = request.getParameter("des");
        if (StringUtils.isNotBlank(des)){
            terms.put("des", des);
        }
        // 操作人编号
        String userId = request.getParameter("userId");
        if (StringUtils.isNotBlank(userId)){
            terms.put("userId", userId);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 客户编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 更新时间区间
        String updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/flowableInfo/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/flowableInfo/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<FlowableInfo> flowableInfoPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", flowableInfoPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/flowableInfo/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/flowableInfo/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/flowableInfo/saveFlowableInfo
    * @param flowableInfo 实体对象
    * @return Object
    */
    @PostMapping("/saveFlowableInfo")
    public Object saveFlowableInfo(@RequestBody FlowableInfo flowableInfo) {
        try {
            service.saveFlowableInfo(flowableInfo);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/controller/web/FlowableNodeWebController.java

New file
@@ -0,0 +1,195 @@
package cn.huge.module.flow.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.flow.domain.po.FlowableNode;
import cn.huge.module.flow.service.FlowableNodeService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 工作流流程节点信息表接口api-web端
 * @description: 工作流流程节点信息表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/flowableNode")
public class FlowableNodeWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private FlowableNodeService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 流程节点定义编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 节点名称
        String name = request.getParameter("name");
        if (StringUtils.isNotBlank(name)){
            terms.put("name", name);
        }
        // 节点描述
        String des = request.getParameter("des");
        if (StringUtils.isNotBlank(des)){
            terms.put("des", des);
        }
        // 节点图标
        String icon = request.getParameter("icon");
        if (StringUtils.isNotBlank(icon)){
            terms.put("icon", icon);
        }
        // 对应请求接口方式，POST：post请求，GET：get请求，PUT：put请求，DELETE：delete请求
        String apiType = request.getParameter("apiType");
        if (StringUtils.isNotBlank(apiType)){
            terms.put("apiType", apiType);
        }
        // 对应请求接口
        String api = request.getParameter("api");
        if (StringUtils.isNotBlank(api)){
            terms.put("api", api);
        }
        // 对应纠纷进度
        String caseProcess = request.getParameter("caseProcess");
        if (StringUtils.isNotBlank(caseProcess)){
            terms.put("caseProcess", caseProcess);
        }
        // 对应纠纷进度名称
        String caseProcessName = request.getParameter("caseProcessName");
        if (StringUtils.isNotBlank(caseProcessName)){
            terms.put("caseProcessName", caseProcessName);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 客户编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 更新时间区间
        String updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/flowableNode/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/flowableNode/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<FlowableNode> flowableNodePage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", flowableNodePage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/flowableNode/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/flowableNode/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/flowableNode/saveFlowableNode
    * @param flowableNode 实体对象
    * @return Object
    */
    @PostMapping("/saveFlowableNode")
    public Object saveFlowableNode(@RequestBody FlowableNode flowableNode) {
        try {
            service.saveFlowableNode(flowableNode);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/FlowInfoMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.flow.dao.mapper;

import cn.huge.module.flow.domain.po.FlowInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 业务流程信息表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-06 15:50:06
* @version 1.0.0
*/
@Repository
public interface FlowInfoMapper extends BaseMapper<FlowInfo>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateFlowInfo(@Param("entity") FlowInfo entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateFlowInfoTerms(@Param("entity") FlowInfo entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteFlowInfo(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<FlowInfo>
    */
    List<FlowInfo> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<FlowInfo>
    */
    List<FlowInfo> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/FlowNodeMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.flow.dao.mapper;

import cn.huge.module.flow.domain.po.FlowNode;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 业务流程节点表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-06 15:50:06
* @version 1.0.0
*/
@Repository
public interface FlowNodeMapper extends BaseMapper<FlowNode>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateFlowNode(@Param("entity") FlowNode entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateFlowNodeTerms(@Param("entity") FlowNode entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteFlowNode(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<FlowNode>
    */
    List<FlowNode> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<FlowNode>
    */
    List<FlowNode> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/FlowableInfoMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.flow.dao.mapper;

import cn.huge.module.flow.domain.po.FlowableInfo;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 工作流流程信息表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-06 15:50:05
* @version 1.0.0
*/
@Repository
public interface FlowableInfoMapper extends BaseMapper<FlowableInfo>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateFlowableInfo(@Param("entity") FlowableInfo entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateFlowableInfoTerms(@Param("entity") FlowableInfo entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteFlowableInfo(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<FlowableInfo>
    */
    List<FlowableInfo> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<FlowableInfo>
    */
    List<FlowableInfo> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/FlowableNodeMapper.java

New file
@@ -0,0 +1,64 @@
package cn.huge.module.flow.dao.mapper;

import cn.huge.module.flow.domain.po.FlowableNode;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
* @title: 工作流流程节点信息表持久层业务处理
* @Description 此处仅涉及复杂SQL操作，务必不要在此再次写单表的CRUD操作，因为mybatisPlus已经实现。
* @company: hugeinfo
* @author: liyj
* @time: 2024-09-06 15:50:06
* @version 1.0.0
*/
@Repository
public interface FlowableNodeMapper extends BaseMapper<FlowableNode>{

    /**
    * 更新对象
    * @param entity 对象
    */
    void updateFlowableNode(@Param("entity") FlowableNode entity);

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    void updateFlowableNodeTerms(@Param("entity") FlowableNode entity, @Param("terms") Map<String, Object> terms);

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    void deleteFlowableNode(@Param("id") String id);

    /**
    * 按条件查询结果集
    * @param terms 查询条件集合
    * @return List<FlowableNode>
    */
    List<FlowableNode> listTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体总数
    * @param terms 查询条件集合
    * @return long
    */
    long countTerms(@Param("terms") Map<String, Object> terms);

    /**
    * 按条件查询实体分页结果集
    * @param page 分页对象
    * @param terms 查询条件集合
    * @return List<FlowableNode>
    */
    List<FlowableNode> pageTerms(@Param("page") PageRequest page, @Param("terms") Map<String, Object> terms);

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/xml/FlowInfoMapper.xml

New file
@@ -0,0 +1,184 @@
<?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">
<!-- 
 * @title: 业务流程信息表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: liyj
 * @time:2024-09-06 15:50:06
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.flow.dao.mapper.FlowInfoMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.flow.domain.po.FlowInfo">
            <result property="id" column="id"/>
            <result property="flowableId" column="flowable_id"/>
            <result property="flowableName" column="flowable_name"/>
            <result property="flowType" column="flow_type"/>
            <result property="mediType" column="medi_type"/>
            <result property="caseType" column="case_type"/>
            <result property="expire" column="expire"/>
            <result property="unitId" column="unit_id"/>
            <result property="flowDes" column="flow_des"/>
            <result property="userId" column="user_id"/>
            <result property="deleteStatus" column="delete_status"/>
            <result property="custId" column="cust_id"/>
            <result property="createTime" column="create_time"/>
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_flow_info</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        flowable_id,
        flowable_name,
        flow_type,
        medi_type,
        case_type,
        expire,
        unit_id,
        flow_des,
        user_id,
        delete_status,
        cust_id,
        create_time,
        update_time
    </sql>
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.flowableId != null">flowable_id = #{entity.flowableId},</if>
            <if test="entity.flowableName != null">flowable_name = #{entity.flowableName},</if>
            <if test="entity.flowType != null">flow_type = #{entity.flowType},</if>
            <if test="entity.mediType != null">medi_type = #{entity.mediType},</if>
            <if test="entity.caseType != null">case_type = #{entity.caseType},</if>
            <if test="entity.expire != null">expire = #{entity.expire},</if>
            <if test="entity.unitId != null">unit_id = #{entity.unitId},</if>
            <if test="entity.flowDes != null">flow_des = #{entity.flowDes},</if>
            <if test="entity.userId != null">user_id = #{entity.userId},</if>
            <if test="entity.deleteStatus != null">delete_status = #{entity.deleteStatus},</if>
            <if test="entity.custId != null">cust_id = #{entity.custId},</if>
            <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
            <if test="entity.updateTime != null">update_time = #{entity.updateTime}</if>
    </sql>
    <!-- 条件 -->
    <sql id="where-part">
        <if test="terms != null">
            <where>
                <if test="terms.id != null and terms.id !=''">
                    and id = #{terms.id}
                </if>
                <if test="terms.flowableId != null and terms.flowableId !=''">
                    and flowable_id = #{terms.flowableId}
                </if>
                <if test="terms.flowableName != null and terms.flowableName !=''">
                    and flowable_name = #{terms.flowableName}
                </if>
                <if test="terms.flowType != null and terms.flowType !=''">
                    and flow_type = #{terms.flowType}
                </if>
                <if test="terms.mediType != null and terms.mediType !=''">
                    and medi_type = #{terms.mediType}
                </if>
                <if test="terms.caseType != null and terms.caseType !=''">
                    and case_type = #{terms.caseType}
                </if>
                <if test="terms.expire != null and terms.expire !=''">
                    and expire = #{terms.expire}
                </if>
                <if test="terms.unitId != null and terms.unitId !=''">
                    and unit_id = #{terms.unitId}
                </if>
                <if test="terms.flowDes != null and terms.flowDes !=''">
                    and flow_des = #{terms.flowDes}
                </if>
                <if test="terms.userId != null and terms.userId !=''">
                    and user_id = #{terms.userId}
                </if>
                <if test="terms.deleteStatus = null and terms.deleteStatus =''">
                    and delete_status = 0
                </if>
                <if test="terms.deleteStatus != null and terms.deleteStatus !=''">
                    and delete_status = #{terms.deleteStatus}
                </if>
                <if test="terms.custId != null and terms.custId !=''">
                    and cust_id = #{terms.custId}
                </if>
                <if test="terms.createTime != null and terms.createTime !=''">
                    and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
                </if>
                <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
                    and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
                        and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
                </if>
                <if test="terms.updateTime != null and terms.updateTime !=''">
                    and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
                </if>
                <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
                    and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
                        and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
                </if>
            </where>
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateFlowInfo">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <where>
            id = #{entity.id}
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateFlowInfoTerms">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteFlowInfo">
        delete from
        <include refid="table-name" />
        where id = #{id}
    </delete>
    <!--  根据条件查询  -->
    <select id="listTerms" resultMap="dataResult">
        select
        <include refid="column-part"/>
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件统计  -->
    <select id="countTerms" resultType="java.lang.Long">
        select
        COUNT(1)
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件分页查询  -->
    <select id="pageTerms" resultMap="dataResult">
        SELECT
        <include refid="column-part"/>
        FROM
        <include refid="table-name" />
        <include refid="where-part"/>
        <if test="page.sort != null">
            <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
                isnull(${s.property}), ${s.property} ${s.direction}
            </foreach>
        </if>
        <if test="page.sort == null">
            order by isnull(create_time), create_time desc
        </if>
        limit #{page.offset}, #{page.size}
    </select>

</mapper> 

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/xml/FlowNodeMapper.xml

New file
@@ -0,0 +1,268 @@
<?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">
<!-- 
 * @title: 业务流程节点表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: liyj
 * @time:2024-09-06 15:50:06
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.flow.dao.mapper.FlowNodeMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.flow.domain.po.FlowNode">
            <result property="id" column="id"/>
            <result property="flowId" column="flow_id"/>
            <result property="flowableId" column="flowable_id"/>
            <result property="nodeId" column="node_id"/>
            <result property="nodeShowName" column="node_show_name"/>
            <result property="nodeName" column="node_name"/>
            <result property="nodeType" column="node_type"/>
            <result property="nodeIndex" column="node_index"/>
            <result property="nodeIcon" column="node_icon"/>
            <result property="apiType" column="api_type"/>
            <result property="api" column="api"/>
            <result property="expire" column="expire"/>
            <result property="candeType" column="cande_type"/>
            <result property="candeUnitId" column="cande_unit_id"/>
            <result property="candeUnitName" column="cande_unit_name"/>
            <result property="candeDeptId" column="cande_dept_id"/>
            <result property="candeDeptName" column="cande_dept_name"/>
            <result property="candeRoleCode" column="cande_role_code"/>
            <result property="candeRoleName" column="cande_role_name"/>
            <result property="candeUserId" column="cande_user_id"/>
            <result property="candeUserName" column="cande_user_name"/>
            <result property="goCond" column="go_cond"/>
            <result property="backCond" column="back_cond"/>
            <result property="des" column="des"/>
            <result property="deleteStatus" column="delete_status"/>
            <result property="custId" column="cust_id"/>
            <result property="createTime" column="create_time"/>
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_flow_node</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        flow_id,
        flowable_id,
        node_id,
        node_show_name,
        node_name,
        node_type,
        node_index,
        node_icon,
        api_type,
        api,
        expire,
        cande_type,
        cande_unit_id,
        cande_unit_name,
        cande_dept_id,
        cande_dept_name,
        cande_role_code,
        cande_role_name,
        cande_user_id,
        cande_user_name,
        go_cond,
        back_cond,
        des,
        delete_status,
        cust_id,
        create_time,
        update_time
    </sql>
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.flowId != null">flow_id = #{entity.flowId},</if>
            <if test="entity.flowableId != null">flowable_id = #{entity.flowableId},</if>
            <if test="entity.nodeId != null">node_id = #{entity.nodeId},</if>
            <if test="entity.nodeShowName != null">node_show_name = #{entity.nodeShowName},</if>
            <if test="entity.nodeName != null">node_name = #{entity.nodeName},</if>
            <if test="entity.nodeType != null">node_type = #{entity.nodeType},</if>
            <if test="entity.nodeIndex != null">node_index = #{entity.nodeIndex},</if>
            <if test="entity.nodeIcon != null">node_icon = #{entity.nodeIcon},</if>
            <if test="entity.apiType != null">api_type = #{entity.apiType},</if>
            <if test="entity.api != null">api = #{entity.api},</if>
            <if test="entity.expire != null">expire = #{entity.expire},</if>
            <if test="entity.candeType != null">cande_type = #{entity.candeType},</if>
            <if test="entity.candeUnitId != null">cande_unit_id = #{entity.candeUnitId},</if>
            <if test="entity.candeUnitName != null">cande_unit_name = #{entity.candeUnitName},</if>
            <if test="entity.candeDeptId != null">cande_dept_id = #{entity.candeDeptId},</if>
            <if test="entity.candeDeptName != null">cande_dept_name = #{entity.candeDeptName},</if>
            <if test="entity.candeRoleCode != null">cande_role_code = #{entity.candeRoleCode},</if>
            <if test="entity.candeRoleName != null">cande_role_name = #{entity.candeRoleName},</if>
            <if test="entity.candeUserId != null">cande_user_id = #{entity.candeUserId},</if>
            <if test="entity.candeUserName != null">cande_user_name = #{entity.candeUserName},</if>
            <if test="entity.goCond != null">go_cond = #{entity.goCond},</if>
            <if test="entity.backCond != null">back_cond = #{entity.backCond},</if>
            <if test="entity.des != null">des = #{entity.des},</if>
            <if test="entity.deleteStatus != null">delete_status = #{entity.deleteStatus},</if>
            <if test="entity.custId != null">cust_id = #{entity.custId},</if>
            <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
            <if test="entity.updateTime != null">update_time = #{entity.updateTime}</if>
    </sql>
    <!-- 条件 -->
    <sql id="where-part">
        <if test="terms != null">
            <where>
                <if test="terms.id != null and terms.id !=''">
                    and id = #{terms.id}
                </if>
                <if test="terms.flowId != null and terms.flowId !=''">
                    and flow_id = #{terms.flowId}
                </if>
                <if test="terms.flowableId != null and terms.flowableId !=''">
                    and flowable_id = #{terms.flowableId}
                </if>
                <if test="terms.nodeId != null and terms.nodeId !=''">
                    and node_id = #{terms.nodeId}
                </if>
                <if test="terms.nodeShowName != null and terms.nodeShowName !=''">
                    and node_show_name = #{terms.nodeShowName}
                </if>
                <if test="terms.nodeName != null and terms.nodeName !=''">
                    and node_name = #{terms.nodeName}
                </if>
                <if test="terms.nodeType != null and terms.nodeType !=''">
                    and node_type = #{terms.nodeType}
                </if>
                <if test="terms.nodeIndex != null and terms.nodeIndex !=''">
                    and node_index = #{terms.nodeIndex}
                </if>
                <if test="terms.nodeIcon != null and terms.nodeIcon !=''">
                    and node_icon = #{terms.nodeIcon}
                </if>
                <if test="terms.apiType != null and terms.apiType !=''">
                    and api_type = #{terms.apiType}
                </if>
                <if test="terms.api != null and terms.api !=''">
                    and api = #{terms.api}
                </if>
                <if test="terms.expire != null and terms.expire !=''">
                    and expire = #{terms.expire}
                </if>
                <if test="terms.candeType != null and terms.candeType !=''">
                    and cande_type = #{terms.candeType}
                </if>
                <if test="terms.candeUnitId != null and terms.candeUnitId !=''">
                    and cande_unit_id = #{terms.candeUnitId}
                </if>
                <if test="terms.candeUnitName != null and terms.candeUnitName !=''">
                    and cande_unit_name = #{terms.candeUnitName}
                </if>
                <if test="terms.candeDeptId != null and terms.candeDeptId !=''">
                    and cande_dept_id = #{terms.candeDeptId}
                </if>
                <if test="terms.candeDeptName != null and terms.candeDeptName !=''">
                    and cande_dept_name = #{terms.candeDeptName}
                </if>
                <if test="terms.candeRoleCode != null and terms.candeRoleCode !=''">
                    and cande_role_code = #{terms.candeRoleCode}
                </if>
                <if test="terms.candeRoleName != null and terms.candeRoleName !=''">
                    and cande_role_name = #{terms.candeRoleName}
                </if>
                <if test="terms.candeUserId != null and terms.candeUserId !=''">
                    and cande_user_id = #{terms.candeUserId}
                </if>
                <if test="terms.candeUserName != null and terms.candeUserName !=''">
                    and cande_user_name = #{terms.candeUserName}
                </if>
                <if test="terms.goCond != null and terms.goCond !=''">
                    and go_cond = #{terms.goCond}
                </if>
                <if test="terms.backCond != null and terms.backCond !=''">
                    and back_cond = #{terms.backCond}
                </if>
                <if test="terms.des != null and terms.des !=''">
                    and des = #{terms.des}
                </if>
                <if test="terms.deleteStatus = null and terms.deleteStatus =''">
                    and delete_status = 0
                </if>
                <if test="terms.deleteStatus != null and terms.deleteStatus !=''">
                    and delete_status = #{terms.deleteStatus}
                </if>
                <if test="terms.custId != null and terms.custId !=''">
                    and cust_id = #{terms.custId}
                </if>
                <if test="terms.createTime != null and terms.createTime !=''">
                    and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
                </if>
                <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
                    and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
                        and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
                </if>
                <if test="terms.updateTime != null and terms.updateTime !=''">
                    and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
                </if>
                <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
                    and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
                        and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
                </if>
            </where>
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateFlowNode">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <where>
            id = #{entity.id}
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateFlowNodeTerms">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteFlowNode">
        delete from
        <include refid="table-name" />
        where id = #{id}
    </delete>
    <!--  根据条件查询  -->
    <select id="listTerms" resultMap="dataResult">
        select
        <include refid="column-part"/>
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件统计  -->
    <select id="countTerms" resultType="java.lang.Long">
        select
        COUNT(1)
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件分页查询  -->
    <select id="pageTerms" resultMap="dataResult">
        SELECT
        <include refid="column-part"/>
        FROM
        <include refid="table-name" />
        <include refid="where-part"/>
        <if test="page.sort != null">
            <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
                isnull(${s.property}), ${s.property} ${s.direction}
            </foreach>
        </if>
        <if test="page.sort == null">
            order by isnull(create_time), create_time desc
        </if>
        limit #{page.offset}, #{page.size}
    </select>

</mapper> 

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/xml/FlowableInfoMapper.xml

New file
@@ -0,0 +1,148 @@
<?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">
<!-- 
 * @title: 工作流流程信息表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: liyj
 * @time:2024-09-06 15:50:05
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.flow.dao.mapper.FlowableInfoMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.flow.domain.po.FlowableInfo">
            <result property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="des" column="des"/>
            <result property="userId" column="user_id"/>
            <result property="deleteStatus" column="delete_status"/>
            <result property="custId" column="cust_id"/>
            <result property="createTime" column="create_time"/>
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_flowable_info</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        name,
        des,
        user_id,
        delete_status,
        cust_id,
        create_time,
        update_time
    </sql>
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.name != null">name = #{entity.name},</if>
            <if test="entity.des != null">des = #{entity.des},</if>
            <if test="entity.userId != null">user_id = #{entity.userId},</if>
            <if test="entity.deleteStatus != null">delete_status = #{entity.deleteStatus},</if>
            <if test="entity.custId != null">cust_id = #{entity.custId},</if>
            <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
            <if test="entity.updateTime != null">update_time = #{entity.updateTime}</if>
    </sql>
    <!-- 条件 -->
    <sql id="where-part">
        <if test="terms != null">
            <where>
                <if test="terms.id != null and terms.id !=''">
                    and id = #{terms.id}
                </if>
                <if test="terms.name != null and terms.name !=''">
                    and name = #{terms.name}
                </if>
                <if test="terms.des != null and terms.des !=''">
                    and des = #{terms.des}
                </if>
                <if test="terms.userId != null and terms.userId !=''">
                    and user_id = #{terms.userId}
                </if>
                <if test="terms.deleteStatus = null and terms.deleteStatus =''">
                    and delete_status = 0
                </if>
                <if test="terms.deleteStatus != null and terms.deleteStatus !=''">
                    and delete_status = #{terms.deleteStatus}
                </if>
                <if test="terms.custId != null and terms.custId !=''">
                    and cust_id = #{terms.custId}
                </if>
                <if test="terms.createTime != null and terms.createTime !=''">
                    and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
                </if>
                <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
                    and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
                        and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
                </if>
                <if test="terms.updateTime != null and terms.updateTime !=''">
                    and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
                </if>
                <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
                    and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
                        and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
                </if>
            </where>
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateFlowableInfo">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <where>
            id = #{entity.id}
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateFlowableInfoTerms">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteFlowableInfo">
        delete from
        <include refid="table-name" />
        where id = #{id}
    </delete>
    <!--  根据条件查询  -->
    <select id="listTerms" resultMap="dataResult">
        select
        <include refid="column-part"/>
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件统计  -->
    <select id="countTerms" resultType="java.lang.Long">
        select
        COUNT(1)
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件分页查询  -->
    <select id="pageTerms" resultMap="dataResult">
        SELECT
        <include refid="column-part"/>
        FROM
        <include refid="table-name" />
        <include refid="where-part"/>
        <if test="page.sort != null">
            <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
                isnull(${s.property}), ${s.property} ${s.direction}
            </foreach>
        </if>
        <if test="page.sort == null">
            order by isnull(create_time), create_time desc
        </if>
        limit #{page.offset}, #{page.size}
    </select>

</mapper> 

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/dao/mapper/xml/FlowableNodeMapper.xml

New file
@@ -0,0 +1,172 @@
<?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">
<!-- 
 * @title: 工作流流程节点信息表
 * @description: 自定义sql，请自行实现业务逻辑
 * @company: hugeinfo
 * @author: liyj
 * @time:2024-09-06 15:50:06
 * @version 1.0.0
-->
<mapper namespace="cn.huge.module.flow.dao.mapper.FlowableNodeMapper">
    <!-- 结果集 -->
    <resultMap id="dataResult" type="cn.huge.module.flow.domain.po.FlowableNode">
            <result property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="des" column="des"/>
            <result property="icon" column="icon"/>
            <result property="apiType" column="api_type"/>
            <result property="api" column="api"/>
            <result property="caseProcess" column="case_process"/>
            <result property="caseProcessName" column="case_process_name"/>
            <result property="deleteStatus" column="delete_status"/>
            <result property="custId" column="cust_id"/>
            <result property="createTime" column="create_time"/>
            <result property="updateTime" column="update_time"/>
    </resultMap>
    <!-- 表 -->
    <sql id='table-name'>dyh_flowable_node</sql>
    <!-- 字段 -->
    <sql id="column-part">
        id,
        name,
        des,
        icon,
        api_type,
        api,
        case_process,
        case_process_name,
        delete_status,
        cust_id,
        create_time,
        update_time
    </sql>
    <!-- 更新实体字段 -->
    <sql id="set-part">
            <if test="entity.name != null">name = #{entity.name},</if>
            <if test="entity.des != null">des = #{entity.des},</if>
            <if test="entity.icon != null">icon = #{entity.icon},</if>
            <if test="entity.apiType != null">api_type = #{entity.apiType},</if>
            <if test="entity.api != null">api = #{entity.api},</if>
            <if test="entity.caseProcess != null">case_process = #{entity.caseProcess},</if>
            <if test="entity.caseProcessName != null">case_process_name = #{entity.caseProcessName},</if>
            <if test="entity.deleteStatus != null">delete_status = #{entity.deleteStatus},</if>
            <if test="entity.custId != null">cust_id = #{entity.custId},</if>
            <if test="entity.createTime != null">create_time = #{entity.createTime},</if>
            <if test="entity.updateTime != null">update_time = #{entity.updateTime}</if>
    </sql>
    <!-- 条件 -->
    <sql id="where-part">
        <if test="terms != null">
            <where>
                <if test="terms.id != null and terms.id !=''">
                    and id = #{terms.id}
                </if>
                <if test="terms.name != null and terms.name !=''">
                    and name = #{terms.name}
                </if>
                <if test="terms.des != null and terms.des !=''">
                    and des = #{terms.des}
                </if>
                <if test="terms.icon != null and terms.icon !=''">
                    and icon = #{terms.icon}
                </if>
                <if test="terms.apiType != null and terms.apiType !=''">
                    and api_type = #{terms.apiType}
                </if>
                <if test="terms.api != null and terms.api !=''">
                    and api = #{terms.api}
                </if>
                <if test="terms.caseProcess != null and terms.caseProcess !=''">
                    and case_process = #{terms.caseProcess}
                </if>
                <if test="terms.caseProcessName != null and terms.caseProcessName !=''">
                    and case_process_name = #{terms.caseProcessName}
                </if>
                <if test="terms.deleteStatus = null and terms.deleteStatus =''">
                    and delete_status = 0
                </if>
                <if test="terms.deleteStatus != null and terms.deleteStatus !=''">
                    and delete_status = #{terms.deleteStatus}
                </if>
                <if test="terms.custId != null and terms.custId !=''">
                    and cust_id = #{terms.custId}
                </if>
                <if test="terms.createTime != null and terms.createTime !=''">
                    and DATE_FORMAT(create_time,'%Y-%m-%d') = #{terms.createTime}
                </if>
                <if test="terms.createStart != null and terms.createStart !='' and terms.createEnd != null and terms.createEnd !=''">
                    and (DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.createStart}
                        and DATE_FORMAT(create_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.createEnd})
                </if>
                <if test="terms.updateTime != null and terms.updateTime !=''">
                    and DATE_FORMAT(update_time,'%Y-%m-%d') = #{terms.updateTime}
                </if>
                <if test="terms.updateStart != null and terms.updateStart !='' and terms.updateEnd != null and terms.updateEnd !=''">
                    and (DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ >= ]]> #{terms.updateStart}
                        and DATE_FORMAT(update_time,'%Y-%m-%d') <![CDATA[ <= ]]> #{terms.updateEnd})
                </if>
            </where>
        </if>
    </sql>
    <!-- 更新对象 -->
    <update id="updateFlowableNode">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <where>
            id = #{entity.id}
        </where>
    </update>
    <!-- 条件更新对象 -->
    <update id="updateFlowableNodeTerms">
        update
        <include refid="table-name"/>
        <set>
            <include refid="set-part"/>
        </set>
        <include refid="where-part"/>
    </update>
    <!--  根据编号物理删除  -->
    <delete id="deleteFlowableNode">
        delete from
        <include refid="table-name" />
        where id = #{id}
    </delete>
    <!--  根据条件查询  -->
    <select id="listTerms" resultMap="dataResult">
        select
        <include refid="column-part"/>
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件统计  -->
    <select id="countTerms" resultType="java.lang.Long">
        select
        COUNT(1)
        from
        <include refid="table-name" />
        <include refid="where-part"/>
    </select>
    <!--  根据条件分页查询  -->
    <select id="pageTerms" resultMap="dataResult">
        SELECT
        <include refid="column-part"/>
        FROM
        <include refid="table-name" />
        <include refid="where-part"/>
        <if test="page.sort != null">
            <foreach collection="page.sort" item="s" index="index" separator="," open="order by ">
                isnull(${s.property}), ${s.property} ${s.direction}
            </foreach>
        </if>
        <if test="page.sort == null">
            order by isnull(create_time), create_time desc
        </if>
        limit #{page.offset}, #{page.size}
    </select>

</mapper> 

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/bo/FlowInfoBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.flow.domain.bo;

import cn.huge.module.flow.domain.po.FlowInfo;

/**
 * @title: 业务流程信息表业务扩展类
 * @description: 业务流程信息表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 * @see cn.huge.module.flow.domain.po.FlowInfo
 */
public class FlowInfoBO extends FlowInfo {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/bo/FlowNodeBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.flow.domain.bo;

import cn.huge.module.flow.domain.po.FlowNode;

/**
 * @title: 业务流程节点表业务扩展类
 * @description: 业务流程节点表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 * @see cn.huge.module.flow.domain.po.FlowNode
 */
public class FlowNodeBO extends FlowNode {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/bo/FlowableInfoBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.flow.domain.bo;

import cn.huge.module.flow.domain.po.FlowableInfo;

/**
 * @title: 工作流流程信息表业务扩展类
 * @description: 工作流流程信息表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:05
 * @version: 1.0.0
 * @see cn.huge.module.flow.domain.po.FlowableInfo
 */
public class FlowableInfoBO extends FlowableInfo {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/bo/FlowableNodeBO.java

New file
@@ -0,0 +1,17 @@
package cn.huge.module.flow.domain.bo;

import cn.huge.module.flow.domain.po.FlowableNode;

/**
 * @title: 工作流流程节点信息表业务扩展类
 * @description: 工作流流程节点信息表业务扩展类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version: 1.0.0
 * @see cn.huge.module.flow.domain.po.FlowableNode
 */
public class FlowableNodeBO extends FlowableNode {


}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/po/FlowInfo.java

New file
@@ -0,0 +1,108 @@
package cn.huge.module.flow.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 业务流程信息表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version 1.0.0
 */
@TableName(value = "dyh_flow_info")
@Data
public class FlowInfo {

    /**
    * 主键编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 工作流流程编号
    */
    @TableField(value = "flowable_id")
    private String flowableId;

    /**
    * 工作流流程名称
    */
    @TableField(value = "flowable_name")
    private String flowableName;

    /**
    * 流程类型，1：主流程
    */
    @TableField(value = "flow_type")
    private String flowType;

    /**
    * 调解类型
    */
    @TableField(value = "medi_type")
    private String mediType;

    /**
    * 纠纷类型（最小级）
    */
    @TableField(value = "case_type")
    private String caseType;

    /**
    * 流程处理时限，以天为单位
    */
    @TableField(value = "expire")
    private Integer expire;

    /**
    * 所属组织编号
    */
    @TableField(value = "unit_id")
    private String unitId;

    /**
    * 描述
    */
    @TableField(value = "flow_des")
    private String flowDes;

    /**
    * 操作人编号
    */
    @TableField(value = "user_id")
    private String userId;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 客户编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/po/FlowNode.java

New file
@@ -0,0 +1,192 @@
package cn.huge.module.flow.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 业务流程节点表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version 1.0.0
 */
@TableName(value = "dyh_flow_node")
@Data
public class FlowNode {

    /**
    * 主键编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 业务流程编号
    */
    @TableField(value = "flow_id")
    private String flowId;

    /**
    * 工作流流程编号
    */
    @TableField(value = "flowable_id")
    private String flowableId;

    /**
    * 工作流节点编号
    */
    @TableField(value = "node_id")
    private String nodeId;

    /**
    * 流程页面展示名称
    */
    @TableField(value = "node_show_name")
    private String nodeShowName;

    /**
    * 工作流节点名称
    */
    @TableField(value = "node_name")
    private String nodeName;

    /**
    * 工作流节点类型，1：首节点，2：普通节点，3：尾节点
    */
    @TableField(value = "node_type")
    private Integer nodeType;

    /**
    * 工作流节点顺序
    */
    @TableField(value = "node_index")
    private Integer nodeIndex;

    /**
    * 节点图标
    */
    @TableField(value = "node_icon")
    private String nodeIcon;

    /**
    * 对应请求接口方式，POST：post请求，GET：get请求，PUT：put请求，DELETE：delete请求
    */
    @TableField(value = "api_type")
    private String apiType;

    /**
    * 对应请求接口
    */
    @TableField(value = "api")
    private String api;

    /**
    * 节点处理时限，单位：天
    */
    @TableField(value = "expire")
    private Integer expire;

    /**
    * 节点候选执行者类型：1：所有人，2：上一步骤选择，3：上一步骤执行者，4：自定义指定（单位部门角色人组合）
    */
    @TableField(value = "cande_type")
    private Integer candeType;

    /**
    * 节点候选执行组织编号
    */
    @TableField(value = "cande_unit_id")
    private String candeUnitId;

    /**
    * 节点候选执行组织名称
    */
    @TableField(value = "cande_unit_name")
    private String candeUnitName;

    /**
    * 节点候选执行部门编号
    */
    @TableField(value = "cande_dept_id")
    private String candeDeptId;

    /**
    * 节点候选执行部门名称
    */
    @TableField(value = "cande_dept_name")
    private String candeDeptName;

    /**
    * 节点候选执行角色代码编号
    */
    @TableField(value = "cande_role_code")
    private String candeRoleCode;

    /**
    * 节点候选执行角色名称
    */
    @TableField(value = "cande_role_name")
    private String candeRoleName;

    /**
    * 节点候选执行人员编号
    */
    @TableField(value = "cande_user_id")
    private String candeUserId;

    /**
    * 节点候选执行人员名称
    */
    @TableField(value = "cande_user_name")
    private String candeUserName;

    /**
    * 节点前进条件
    */
    @TableField(value = "go_cond")
    private String goCond;

    /**
    * 节点退回条件
    */
    @TableField(value = "back_cond")
    private String backCond;

    /**
    * 描述
    */
    @TableField(value = "des")
    private String des;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 顾客编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/po/FlowableInfo.java

New file
@@ -0,0 +1,72 @@
package cn.huge.module.flow.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 工作流流程信息表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:05
 * @version 1.0.0
 */
@TableName(value = "dyh_flowable_info")
@Data
public class FlowableInfo {

    /**
    * 工作流流程编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 流程名称
    */
    @TableField(value = "name")
    private String name;

    /**
    * 描述
    */
    @TableField(value = "des")
    private String des;

    /**
    * 操作人编号
    */
    @TableField(value = "user_id")
    private String userId;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 客户编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/domain/po/FlowableNode.java

New file
@@ -0,0 +1,96 @@
package cn.huge.module.flow.domain.po;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @title: 工作流流程节点信息表数据库对应关系类
 * @description: PO中的属性与数据表是一一对应关系，如需根据业务处理不同，请使用BO对象。
 * @company:hugeinfo
 * @author: liyj
 * @time: 2024-09-06 15:50:06
 * @version 1.0.0
 */
@TableName(value = "dyh_flowable_node")
@Data
public class FlowableNode {

    /**
    * 流程节点定义编号
    */
    @TableId(value = "id")
    private String id;

    /**
    * 节点名称
    */
    @TableField(value = "name")
    private String name;

    /**
    * 节点描述
    */
    @TableField(value = "des")
    private String des;

    /**
    * 节点图标
    */
    @TableField(value = "icon")
    private String icon;

    /**
    * 对应请求接口方式，POST：post请求，GET：get请求，PUT：put请求，DELETE：delete请求
    */
    @TableField(value = "api_type")
    private String apiType;

    /**
    * 对应请求接口
    */
    @TableField(value = "api")
    private String api;

    /**
    * 对应纠纷进度
    */
    @TableField(value = "case_process")
    private String caseProcess;

    /**
    * 对应纠纷进度名称
    */
    @TableField(value = "case_process_name")
    private String caseProcessName;

    /**
    * 删除状态，0：未删除，1：已删除
    */
    @TableLogic
    @TableField(value = "delete_status")
    private Integer deleteStatus;

    /**
    * 客户编号
    */
    @TableField(value = "cust_id")
    private String custId;

    /**
    * 创建时间
    */
    @TableField(value = "create_time")
    private Date createTime;

    /**
    * 更新时间
    */
    @TableField(value = "update_time")
    private Date updateTime;

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/service/FlowInfoService.java

New file
@@ -0,0 +1,133 @@
package cn.huge.module.flow.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.flow.dao.mapper.FlowInfoMapper;
import cn.huge.module.flow.domain.po.FlowInfo;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 业务流程信息表业务逻辑处理
 * @Description 业务流程信息表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-06 15:50:06
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class FlowInfoService extends ServiceImpl<FlowInfoMapper, FlowInfo>{

    @Autowired
    private FlowInfoMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateFlowInfo(FlowInfo entity){
        try{
            mapper.updateFlowInfo(entity);
        }catch (Exception e){
            log.error("[FlowInfoService.updateFlowInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowInfoService.updateFlowInfo", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateFlowInfoTerms(FlowInfo entity, Map<String, Object> terms){
        try{
            mapper.updateFlowInfoTerms(entity, terms);
        }catch (Exception e){
            log.error("[FlowInfoService.updateFlowInfoTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowInfoService.updateFlowInfoTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteFlowInfo(String id){
        try{
            mapper.deleteFlowInfo(id);
        }catch (Exception e){
            log.error("[FlowInfoService.deleteFlowInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowInfoService.deleteFlowInfo", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<FlowInfo> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<FlowInfo> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<FlowInfo> content = mapper.pageTerms(page, terms);
        return new PageImpl<FlowInfo>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param flowInfo 实体对象
    */
    public void saveFlowInfo(FlowInfo flowInfo){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(flowInfo.getId())){
                flowInfo.setId(utilsClient.getNewTimeId());
                flowInfo.setCreateTime(nowDate);
            }
            flowInfo.setUpdateTime(nowDate);
            this.saveOrUpdate(flowInfo);
        }catch (Exception e){
            log.error("[FlowInfoService.saveFlowInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowInfoService.saveFlowInfo", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/service/FlowNodeService.java

New file
@@ -0,0 +1,133 @@
package cn.huge.module.flow.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.flow.dao.mapper.FlowNodeMapper;
import cn.huge.module.flow.domain.po.FlowNode;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 业务流程节点表业务逻辑处理
 * @Description 业务流程节点表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-06 15:50:06
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class FlowNodeService extends ServiceImpl<FlowNodeMapper, FlowNode>{

    @Autowired
    private FlowNodeMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateFlowNode(FlowNode entity){
        try{
            mapper.updateFlowNode(entity);
        }catch (Exception e){
            log.error("[FlowNodeService.updateFlowNode]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowNodeService.updateFlowNode", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateFlowNodeTerms(FlowNode entity, Map<String, Object> terms){
        try{
            mapper.updateFlowNodeTerms(entity, terms);
        }catch (Exception e){
            log.error("[FlowNodeService.updateFlowNodeTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowNodeService.updateFlowNodeTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteFlowNode(String id){
        try{
            mapper.deleteFlowNode(id);
        }catch (Exception e){
            log.error("[FlowNodeService.deleteFlowNode]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowNodeService.deleteFlowNode", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<FlowNode> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<FlowNode> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<FlowNode> content = mapper.pageTerms(page, terms);
        return new PageImpl<FlowNode>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param flowNode 实体对象
    */
    public void saveFlowNode(FlowNode flowNode){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(flowNode.getId())){
                flowNode.setId(utilsClient.getNewTimeId());
                flowNode.setCreateTime(nowDate);
            }
            flowNode.setUpdateTime(nowDate);
            this.saveOrUpdate(flowNode);
        }catch (Exception e){
            log.error("[FlowNodeService.saveFlowNode]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowNodeService.saveFlowNode", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/service/FlowableInfoService.java

New file
@@ -0,0 +1,133 @@
package cn.huge.module.flow.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.flow.dao.mapper.FlowableInfoMapper;
import cn.huge.module.flow.domain.po.FlowableInfo;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 工作流流程信息表业务逻辑处理
 * @Description 工作流流程信息表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-06 15:50:05
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class FlowableInfoService extends ServiceImpl<FlowableInfoMapper, FlowableInfo>{

    @Autowired
    private FlowableInfoMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateFlowableInfo(FlowableInfo entity){
        try{
            mapper.updateFlowableInfo(entity);
        }catch (Exception e){
            log.error("[FlowableInfoService.updateFlowableInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableInfoService.updateFlowableInfo", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateFlowableInfoTerms(FlowableInfo entity, Map<String, Object> terms){
        try{
            mapper.updateFlowableInfoTerms(entity, terms);
        }catch (Exception e){
            log.error("[FlowableInfoService.updateFlowableInfoTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableInfoService.updateFlowableInfoTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteFlowableInfo(String id){
        try{
            mapper.deleteFlowableInfo(id);
        }catch (Exception e){
            log.error("[FlowableInfoService.deleteFlowableInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableInfoService.deleteFlowableInfo", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<FlowableInfo> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<FlowableInfo> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<FlowableInfo> content = mapper.pageTerms(page, terms);
        return new PageImpl<FlowableInfo>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param flowableInfo 实体对象
    */
    public void saveFlowableInfo(FlowableInfo flowableInfo){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(flowableInfo.getId())){
                flowableInfo.setId(utilsClient.getNewTimeId());
                flowableInfo.setCreateTime(nowDate);
            }
            flowableInfo.setUpdateTime(nowDate);
            this.saveOrUpdate(flowableInfo);
        }catch (Exception e){
            log.error("[FlowableInfoService.saveFlowableInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableInfoService.saveFlowableInfo", e);
        }
    }

}

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/flow/service/FlowableNodeService.java

New file
@@ -0,0 +1,133 @@
package cn.huge.module.flow.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.flow.dao.mapper.FlowableNodeMapper;
import cn.huge.module.flow.domain.po.FlowableNode;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 工作流流程节点信息表业务逻辑处理
 * @Description 工作流流程节点信息表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-06 15:50:06
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class FlowableNodeService extends ServiceImpl<FlowableNodeMapper, FlowableNode>{

    @Autowired
    private FlowableNodeMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateFlowableNode(FlowableNode entity){
        try{
            mapper.updateFlowableNode(entity);
        }catch (Exception e){
            log.error("[FlowableNodeService.updateFlowableNode]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableNodeService.updateFlowableNode", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateFlowableNodeTerms(FlowableNode entity, Map<String, Object> terms){
        try{
            mapper.updateFlowableNodeTerms(entity, terms);
        }catch (Exception e){
            log.error("[FlowableNodeService.updateFlowableNodeTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableNodeService.updateFlowableNodeTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteFlowableNode(String id){
        try{
            mapper.deleteFlowableNode(id);
        }catch (Exception e){
            log.error("[FlowableNodeService.deleteFlowableNode]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableNodeService.deleteFlowableNode", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<FlowableNode> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<FlowableNode> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<FlowableNode> content = mapper.pageTerms(page, terms);
        return new PageImpl<FlowableNode>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param flowableNode 实体对象
    */
    public void saveFlowableNode(FlowableNode flowableNode){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(flowableNode.getId())){
                flowableNode.setId(utilsClient.getNewTimeId());
                flowableNode.setCreateTime(nowDate);
            }
            flowableNode.setUpdateTime(nowDate);
            this.saveOrUpdate(flowableNode);
        }catch (Exception e){
            log.error("[FlowableNodeService.saveFlowableNode]调用失败，异常信息："+e, e);
            throw new ServiceException("FlowableNodeService.saveFlowableNode", e);
        }
    }

}

 dyh-service/dyh-mediate/src/test/java/cn/huge/module/BuildCodeServiceTest.java

@@ -12,7 +12,7 @@

    //数据库为jdbc连接url中设置的默认库
    private String basePackage = "cn.huge.module";
    private String packageName = "ctuser";
    private String packageName = "cases";
    private String className = "CtUnit";
    private String tableSchema = "gzdyh_dev";
    private String tableName = "dyh_ct_unit";
@@ -21,7 +21,8 @@

    @Test
    public void buildAllTest() {
        service.buildAll(basePackage, packageName, className, tableSchema, tableName, author, version);
        service.buildAll(basePackage, packageName, "CaseReturn", tableSchema, "dyh_case_return", author, version);
        service.buildAll(basePackage, packageName, "CaseAppear", tableSchema, "dyh_case_appear", author, version);

    }