flowable工作流 config配置

lyh

2025-02-25 ed9f1d757d6d3486dd69a726454eb69c3c9bc538

flowable工作流 config配置

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/controller/AssignFileStreamController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,111 @@
package org.jeecg.modules.flow.controller;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.modules.flow.service.IAssignFileStreamService;
import org.jeecg.modules.flow.entity.AssignFileStream;
import org.jeecg.modules.flow.ext.AssignFileStreamExt;
import org.jeecg.modules.flow.request.ApproveBatchRequest;
import org.jeecg.modules.flow.request.AssignFileRequest;
import org.jeecg.modules.flow.request.AssignFileStreamQueryRequest;
import org.jeecg.modules.dnc.response.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

@Slf4j
@Api(tags = "DNC指派设备流程操作")
@RestController
@RequestMapping("/nc/activit")
public class AssignFileStreamController  {
    @Resource
    private IAssignFileStreamService assignFileStreamService;

    @AutoLog(value = "DNC指派设备流程操作-启动流程 ä¿å­˜ç›¸åº”的数据 ç»‘定businessKey")
    @ApiOperation(value = "DNC指派设备流程操作-启动流程 ä¿å­˜ç›¸åº”的数据 ç»‘定businessKey", notes = "DNC指派设备流程操作-启动流程 ä¿å­˜ç›¸åº”的数据 ç»‘定businessKey")
    @PostMapping("/assign/file/apply")
    public ResponseResult applyAssignFile(@RequestBody AssignFileStream stream) {
        ResponseResult b = assignFileStreamService.applyAssignFile(stream);
        if(b.isSuccess()) {
            return new ResponseResult(CommonCode.SUCCESS);
        }
        return b;
    }

    @AutoLog(value = "DNC指派设备流程操作-审批服务")
    @ApiOperation(value = "DNC指派设备流程操作-审批服务", notes = "DNC指派设备流程操作-审批服务")
    @PostMapping("/assign/file/approve/{taskId}/{streamId}")
    public ResponseResult approveAssignFile(@PathVariable("taskId") String taskId, @PathVariable("streamId") String streamId,
                                            @RequestBody AssignFileStream stream) {
        boolean b = assignFileStreamService.approveAssignFile(taskId, streamId, stream);
        if(b)
            return new ResponseResult(CommonCode.SUCCESS);
        return new ResponseResult(CommonCode.FAIL);
    }

//    @AutoLog(value = "DNC指派设备流程操作-获取当前用户的待办及可拾取的任务")
//    @ApiOperation(value = "DNC指派设备流程操作-获取当前用户的待办及可拾取的任务", notes = "DNC指派设备流程操作-获取当前用户的待办及可拾取的任务")
//    @GetMapping("/find/task/list")
//    public Result<?> getUndoTaskList(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
//                                                               @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize) {
//        IPage<ActTaskExt> actTaskExtIPage = assignFileStreamService.getUndoTaskList(pageNo,pageSize);
//        return Result.ok(actTaskExtIPage);
//    }

    @AutoLog(value = "DNC指派设备流程操作-批量指派到设备")
    @ApiOperation(value = "DNC指派设备流程操作-批量指派到设备", notes = "DNC指派设备流程操作-批量指派到设备")
    @PostMapping("/assign/file/batch/apply")
    public ResponseResult applyBatchAssignFile(@RequestBody AssignFileRequest assignFileRequest) {
        boolean b = assignFileStreamService.applyBatchAssignFile(assignFileRequest);
        if(b)
            return new ResponseResult(CommonCode.SUCCESS);
        return new ResponseResult(CommonCode.FAIL);
    }

    @AutoLog(value = "DNC指派设备流程操作-批量审批")
    @ApiOperation(value = "DNC指派设备流程操作-批量审批", notes = "DNC指派设备流程操作-批量审批")
    @PostMapping("/assign/file/batch/approve")
    public ResponseResult approveBatchAssignFile(@RequestBody ApproveBatchRequest approveBatchRequest) {
        boolean b = assignFileStreamService.approveBatchAssignFile(approveBatchRequest);
        if(b)
            return new ResponseResult(CommonCode.SUCCESS);
        return new ResponseResult(CommonCode.FAIL);
    }

    @AutoLog(value = "DNC指派设备流程操作-已办列表获取")
    @ApiOperation(value = "DNC指派设备流程操作-已办列表获取", notes = "DNC指派设备流程操作-已办列表获取")
    @GetMapping("/find/page")
    public Result<?> findPageList(@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                                     @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize, AssignFileStreamQueryRequest request) {
        return assignFileStreamService.findPageList(pageNo, pageSize, request);
    }

    @AutoLog(value = "DNC指派设备流程操作-查询文档的审批记录")
    @ApiOperation(value = "DNC指派设备流程操作-查询文档的审批记录", notes = "DNC指派设备流程操作-查询文档的审批记录")
    @GetMapping("/find/page/{page}/{size}/{docId}")
    public QueryPageResponseResult<AssignFileStreamExt> findPageListByDocId(@PathVariable("page") int page, @PathVariable("size") int size, @PathVariable("docId") String docId) {
        return assignFileStreamService.findPageListByDocId(page, size, docId);
    }

    @AutoLog(value = "DNC指派设备流程操作-获取启用流程的标记")
    @ApiOperation(value = "DNC指派设备流程操作-获取启用流程的标记", notes = "DNC指派设备流程操作-获取启用流程的标记")
    @GetMapping("/get/enable/flag")
    public DataResponseResult<Boolean> getActiveEnable() {
        Boolean b = assignFileStreamService.getFlowableEnable();
        return new DataResponseResult<>(CommonCode.SUCCESS, b);
    }

    @AutoLog(value = "DNC指派设备流程操作-扫码传输程序 ä¸ç»è¿‡å®¡æ‰¹ æ–‡ä»¶å­˜åœ¨é‡‡ç”¨è¦†ç›–")
    @ApiOperation(value = "DNC指派设备流程操作-扫码传输程序 ä¸ç»è¿‡å®¡æ‰¹ æ–‡ä»¶å­˜åœ¨é‡‡ç”¨è¦†ç›–", notes = "DNC指派设备流程操作-扫码传输程序 ä¸ç»è¿‡å®¡æ‰¹ æ–‡ä»¶å­˜åœ¨é‡‡ç”¨è¦†ç›–")
    @PostMapping("/transfer/doc")
    public ResponseResult transferDocFile(String pnCode, String deviceNo) {
        boolean b = assignFileStreamService.transferDocFile(pnCode, deviceNo);
        if(b)
            return new ResponseResult(CommonCode.SUCCESS);
        return new ResponseResult(CommonCode.FAIL);
    }
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/entity/ActivitiDefinition.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package org.jeecg.modules.flow.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.Api;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.jeecg.common.aspect.annotation.Dict;

import java.util.Date;

@Data
@NoArgsConstructor
@TableName("nc_activiti_definition_info")
@Api(value= "DNC指派设备流程定义")
public class ActivitiDefinition {
    @TableId(value = "id")
    private String id;
    @TableField(value = "act_name")
    private String actName;
    @TableField(value = "depart_id")
    @Dict(dictTable = "mdc_production",dicCode = "id",dicText = "production_name")
    private String departId;
    @TableField(value = "approve_users")
    @Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
    private String approveUsers;
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    @TableField(value = "create_time", fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(value = "update_time", fill = FieldFill.UPDATE)
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date updateTime;
    @JsonIgnore
    @TableField(value = "create_user", select = false, fill = FieldFill.INSERT)
    private String createUser;
    @JsonIgnore
    @TableField(value = "update_user", select = false, fill = FieldFill.UPDATE)
    private String updateUser;
    @JsonIgnore
    @TableLogic
    @TableField(value = "delete_flag", select = false)
    private Integer deleteFlag = 0;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/entity/ActivitiSignExamine.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,53 @@
package org.jeecg.modules.flow.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.Api;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.jeecg.common.aspect.annotation.Dict;

import java.util.Date;

@Data
@NoArgsConstructor
@TableName("nc_assign_to_sign_examine")
@Api(value= "NC程序签派流程定义")
public class ActivitiSignExamine {
    @TableId(value = "id")
    private String id;
    @TableField(value = "act_name")
    private String actName;
    @TableField(value = "depart_id")
    @Dict(dictTable = "mdc_production",dicCode = "id",dicText = "production_name")
    private String departId;
    @TableField(value = "proofreader_user")
    @Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
    private String proofreaderUser;
    @TableField(value = "approving_user")
    @Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
    private String approveUser;
    @TableField(value = "cutter_user")
    @Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
    private String cutterUser;
    @TableField(value = "typecast_user")
    @Dict(dictTable = "sys_user", dicCode = "id", dicText = "realname")
    private String typecastUser;
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    @TableField(value = "create_time", fill = FieldFill.INSERT)
    private Date createTime;
    @TableField(value = "update_time", fill = FieldFill.UPDATE)
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date updateTime;
    @JsonIgnore
    @TableField(value = "create_by", select = false, fill = FieldFill.INSERT)
    private String createBy;
    @JsonIgnore
    @TableField(value = "update_by", select = false, fill = FieldFill.UPDATE)
    private String updateBy;
    @JsonIgnore
    @TableLogic
    @TableField(value = "delete_flag", select = false)
    private Integer deleteFlag = 0;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/entity/AssignFileStream.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,75 @@
package org.jeecg.modules.flow.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.Api;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.jeecg.common.aspect.annotation.Dict;

import java.util.Date;

@Data
@NoArgsConstructor
@TableName("nc_assign_file_stream")
@Api(value= "DNC指派设备流程操作")
public class AssignFileStream {
    @TableId(value = "stream_id")
    private String streamId;
    @TableField(value = "product_id")
    private String productId;
    @TableField(value = "component_id")
    private String componentId;
    @TableField(value = "parts_id")
    private String partsId;
    @TableField(value = "process_id")
    private String processId;
    @TableField(value = "step_id")
    private String stepId;
    @TableField(value = "doc_id")
    private String docId;
    @TableField(value = "file_id")
    private String fileId;
    @TableField(value = "device_id")
    private String deviceId;
    @TableField(value = "apply_user_id")
    private String applyUserId;
    @TableField(value = "apply_reason")
    private String applyReason;
    @TableField(value = "apply_time")
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date applyTime;
    @TableField(value = "approve_user_id")
    private String approveUserId;
    @TableField(value = "approve_content")
    private String approveContent;
    @TableField(value = "approve_time")
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date approveTime;
    @TableField(value = "status")
    @Dict(dicCode = "dnc_assign_stream_status")
    private Integer status;
    @JsonIgnore
    @TableField(value = "create_time", select = false, fill = FieldFill.INSERT)
    private Date createTime;
    @JsonIgnore
    @TableField(value = "update_time", select = false, fill = FieldFill.UPDATE)
    private Date updateTime;
    @JsonIgnore
    @TableField(value = "create_user", select = false, fill = FieldFill.INSERT)
    private String createUser;
    @JsonIgnore
    @TableField(value = "update_user", select = false, fill = FieldFill.UPDATE)
    private String updateUser;
    @JsonIgnore
    @TableLogic
    @TableField(value = "delete_flag", select = false)
    private Integer deleteFlag = 0;

    /**指派设备专用-所属ID*/
    private transient String attributionId;

    /**指派设备专用-所属type*/
    private transient String attributionType;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/entity/ToEquipmentTask.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,62 @@
package org.jeecg.modules.flow.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@TableName("nc_to_equipment_lists")
public class ToEquipmentTask {
    @TableId(value = "code")
    private String code;
    @TableField(value = "doc_id")
    private String docId;
    @TableField(value = "file_id")
    private String fileId;
    @TableField(value = "device_id")
    private String deviceId;
    @TableField(value = "device_no")
    private String deviceNo;
    @TableField(value = "depart_id")
    private String departId;
    @TableField(value = "file_name")
    private String fileName;
    @TableField(value = "file_encode_name")
    private String fileEncodeName;
    @TableField(value = "file_path")
    private String filePath;
    @TableField(value = "file_suffix")
    private String fileSuffix;
    @TableField(value = "doc_version")
    private String docVersion;
    @TableField(value = "file_size")
    private Long fileSize;
    @TableField(value = "sync_flag")
    private Integer syncFlag;
    @TableField(value = "sync_time")
    private Date syncTime;
    @TableField(value = "apply_user")
    private String applyUser;
    @TableField(value = "apply_time")
    private Date applyTime;
    @JsonIgnore
    @TableField(value = "create_time", select = false, fill = FieldFill.INSERT)
    private Date createTime;
    @JsonIgnore
    @TableField(value = "update_time", select = false, fill = FieldFill.UPDATE)
    private Date updateTime;
    @JsonIgnore
    @TableField(value = "create_user", select = false, fill = FieldFill.INSERT)
    private String createUser;
    @JsonIgnore
    @TableField(value = "update_user", select = false, fill = FieldFill.UPDATE)
    private String updateUser;
    @JsonIgnore
    @TableLogic
    @TableField(value = "delete_flag", select = false)
    private Integer deleteFlag = 0;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/ext/ActTaskExt.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package org.jeecg.modules.flow.ext;

import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class ActTaskExt {
    private String id;
    private String name;
    private String processInstanceId;
    private String assignee;
    private String executionId;
    private String processDefinitionId;
    private String businessKey;
    private AssignFileStreamExt assignFileStream;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/ext/AssignFileStreamExt.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package org.jeecg.modules.flow.ext;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.jeecg.modules.flow.entity.AssignFileStream;

@Data
@NoArgsConstructor
public class AssignFileStreamExt extends AssignFileStream {
    private String productName;
    private String componentName;
    private String partsName;
    private String docName;
    private String version;
    private String applyUser;
    private String approveUser;
    private String deviceName;
    private String docSuffix;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/mapper/ActivitiDefinitionMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,7 @@
package org.jeecg.modules.flow.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.jeecg.modules.flow.entity.ActivitiDefinition;

public interface ActivitiDefinitionMapper extends BaseMapper<ActivitiDefinition> {
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/mapper/ActivitiSignExamineMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,7 @@
package org.jeecg.modules.flow.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.jeecg.modules.flow.entity.ActivitiSignExamine;

public interface ActivitiSignExamineMapper extends BaseMapper<ActivitiSignExamine> {
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/mapper/AssignFileStreamMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,26 @@
package org.jeecg.modules.flow.mapper;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.flow.entity.AssignFileStream;
import org.jeecg.modules.flow.ext.AssignFileStreamExt;

public interface AssignFileStreamMapper extends BaseMapper<AssignFileStream> {
    /**
     * å…³è”用户表 èŽ·å–用户昵称
     * @param streamId
     * @return
     */
    AssignFileStreamExt getAssignFileStreamDetail(@Param("streamId") String streamId);

    /**
     * åˆ†é¡µæŸ¥è¯¢å·²åŠžä»»åŠ¡
     * @param page
     * @param wrapper
     * @return
     */
    IPage<AssignFileStreamExt> findByPage(IPage<AssignFileStreamExt> page, @Param(Constants.WRAPPER) Wrapper<AssignFileStreamExt> wrapper);
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/mapper/ToEquipmentTaskMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,7 @@
package org.jeecg.modules.flow.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.jeecg.modules.flow.entity.ToEquipmentTask;

public interface ToEquipmentTaskMapper extends BaseMapper<ToEquipmentTask> {
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/mapper/xml/AssignFileStreamMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,89 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="org.jeecg.modules.flow.mapper.AssignFileStreamMapper">
    <select id="getAssignFileStreamDetail" resultType="org.jeecg.modules.flow.ext.AssignFileStreamExt" parameterType="String">
        select a.stream_id
        , a.product_id
        , a.component_id
        , a.parts_id
        , a.process_id
        , a.doc_id
        , a.file_id
        , a.device_id
        , a.apply_user_id
        , a.apply_reason
        , a.apply_time
        , a.approve_user_id
        , a.approve_content
        , a.approve_time
        , a.status
        , u1.realname as applyUser
        , u2.realname as approveUser
        , p.product_name as productName
        , c.component_name as componentName
        , pt.parts_name as partsName
        , dc.doc_name as docName
        , dc.publish_version as version
        , dc.doc_suffix as docSuffix
        , de.device_name as deviceName
        from (select * from nc_assign_file_stream where stream_id=#{streamId}) a
        left join sys_user u1
        on a.apply_user_id=u1.id
        left join sys_user u2
        on a.approve_user_id=u2.id
        left join nc_product_info p
        on a.product_id=p.product_id
        left join nc_component_info c
        on a.component_id=c.component_id
        left join nc_parts_info pt
        on a.parts_id=pt.parts_id
        left join nc_doc_info dc
        on a.doc_id=dc.doc_id
        left join nc_device_info de
        on a.device_id=de.device_id

    </select>

    <select id="findByPage" resultType="org.jeecg.modules.flow.ext.AssignFileStreamExt" parameterType="String">
        select a.stream_id
        , a.product_id
        , a.component_id
        , a.parts_id
        , a.process_id
        , a.doc_id
        , a.file_id
        , a.device_id
        , a.apply_user_id
        , a.apply_reason
        , a.apply_time
        , a.approve_user_id
        , a.approve_content
        , a.approve_time
        , a.status
        , u1.realname as applyUser
        , u2.realname as approveUser
        , p.product_name as productName
        , c.component_name as componentName
        , pt.parts_name as partsName
        , dc.doc_name as docName
        , dc.publish_version as version
        , dc.doc_suffix as docSuffix
        , de.device_name as deviceName
        from (select * from nc_assign_file_stream where delete_flag=0 and approve_time is not null) a
        left join sys_user u1
        on a.apply_user_id=u1.id
        left join sys_user u2
        on a.approve_user_id=u2.id
        left join nc_product_info p
        on a.product_id=p.product_id
        left join nc_component_info c
        on a.component_id=c.component_id
        left join nc_parts_info pt
        on a.parts_id=pt.parts_id
        left join nc_doc_info dc
        on a.doc_id=dc.doc_id
        left join nc_device_info de
        on a.device_id=de.device_id
        ${ew.customSqlSegment}
    </select>
</mapper>

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/request/ActivitiDefinitionRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,11 @@
package org.jeecg.modules.flow.request;

import lombok.Data;

@Data
public class ActivitiDefinitionRequest {
    private String actName;
    //排序字段
    private String descStr;
    private String ascStr;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/request/ApproveBatchRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
package org.jeecg.modules.flow.request;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.List;

@Data
@NoArgsConstructor
public class ApproveBatchRequest implements Serializable {
    private String approveContent;
    private Integer status;
    private List<TaskRequest> taskArr;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/request/AssignFileRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package org.jeecg.modules.flow.request;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
public class AssignFileRequest implements Serializable {
    private String processId;
    private String fileId;
    private String docId;
    private String applyReason;
    private String[] deviceIds;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/request/AssignFileStreamQueryRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
package org.jeecg.modules.flow.request;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@ApiModel(value = "已办任务查询条件", description = "已办任务查询")
public class AssignFileStreamQueryRequest {
    //排序字段
    @ApiModelProperty(value = "降序排列", notes="排序字段为数据库具体字段名，需要解析； å¤šä¸ªå­—段以英文逗号分隔")
    private String descStr;
    @ApiModelProperty(value = "升序排列", notes="排序字段为数据库具体字段名，需要解析； å¤šä¸ªå­—段以英文逗号分隔")
    private String ascStr;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/request/TaskRequest.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,13 @@
package org.jeecg.modules.flow.request;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
public class TaskRequest implements Serializable {
    private String id;
    private String businessKey;
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/IActivitiDefinitionService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,60 @@
package org.jeecg.modules.flow.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.flow.entity.ActivitiDefinition;
import org.jeecg.modules.flow.request.ActivitiDefinitionRequest;

import java.util.List;

public interface IActivitiDefinitionService extends IService<ActivitiDefinition> {
    /**
     * æ·»åŠ é…ç½®
     * @param definition
     * @return
     */
    boolean addDefinition(ActivitiDefinition definition);
    /**
     * ç¼–辑配置
     * @param definition
     * @return
     */
    boolean editDefinition(String id, ActivitiDefinition definition);

    /**
     * åˆ é™¤é…ç½®
     * @param id
     * @return
     */
    boolean deleteDefinition(String id);

    /**
     * èŽ·å–部门的流程定义
     * @param departId
     * @return
     */
    ActivitiDefinition getByDepartId(String departId);

    /**
     * åˆ†é¡µæŸ¥è¯¢
     * @param page
     * @param size
     * @param request
     * @return
     */
    Result<?> findPageList(int page, int size, ActivitiDefinitionRequest request);

    /**
     * èŽ·å–多个部门的审批人 åŽ»é‡
     * @param departIds
     * @return
     */
    List<String> getByDepartIds(List<String> departIds);

    /**
     * æ ¹æ®ç”¨æˆ·ä¿¡æ¯èŽ·å–审批
     * @param userId
     * @return
     */
    List<ActivitiDefinition> findByUserId(String userId);
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/IActivitiSignExamineService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,9 @@
package org.jeecg.modules.flow.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.flow.entity.ActivitiSignExamine;


public interface IActivitiSignExamineService extends IService<ActivitiSignExamine> {

}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/IAssignFileStreamService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,95 @@
package org.jeecg.modules.flow.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.flow.entity.AssignFileStream;
import org.jeecg.modules.flow.ext.AssignFileStreamExt;
import org.jeecg.modules.flow.request.ApproveBatchRequest;
import org.jeecg.modules.flow.request.AssignFileRequest;
import org.jeecg.modules.flow.request.AssignFileStreamQueryRequest;
import org.jeecg.modules.dnc.response.QueryPageResponseResult;
import org.jeecg.modules.dnc.response.ResponseResult;

public interface IAssignFileStreamService extends IService<AssignFileStream> {
    /**
     * å¯åŠ¨æµç¨‹ ä¿å­˜ç›¸åº”的数据 ç»‘定businessKey
     * @param stream
     * @return
     */
    ResponseResult applyAssignFile(AssignFileStream stream);

    /**securedoc
     * å¯åŠ¨æµç¨‹ ä¿å­˜ç›¸åº”的数据 ç»‘定businessKey
     * @param stream
     * @return
     */
    boolean applyAssignFileActive(AssignFileStream stream);
    /**
     * å¯åŠ¨æµç¨‹ ä¿å­˜ç›¸åº”的数据 ç»‘定businessKey
     * @param stream
     * @return
     */
    ResponseResult applyAssignFileNonActive(AssignFileStream stream);


    /**
     * å…³è”用户表 èŽ·å–用户昵称
     * @param streamId
     * @return
     */
    AssignFileStreamExt getAssignFileStreamDetail(String streamId);

    /**
     * å®¡æ‰¹æœåŠ¡
     * @param taskId
     * @param streamId
     * @param stream
     * @return
     */
    boolean approveAssignFile(String taskId, String streamId, AssignFileStream stream);

    /**
     * æ‰¹é‡æŒ‡æ´¾åˆ°è®¾å¤‡
     * @param assignFileRequest
     * @return
     */
    boolean applyBatchAssignFile(AssignFileRequest assignFileRequest);

    /**
     * æ‰¹é‡å®¡æ‰¹
     * @param approveBatchRequest
     * @return
     */
    boolean approveBatchAssignFile(ApproveBatchRequest approveBatchRequest);

    /**
     * å·²åŠžåˆ—表获取
     * @param page
     * @param size
     * @return
     */
    Result<?> findPageList(int page, int size, AssignFileStreamQueryRequest request);

    /**
     * æŸ¥è¯¢æ–‡æ¡£çš„审批记录
     * @param page
     * @param size
     * @param docId
     * @return
     */
    QueryPageResponseResult<AssignFileStreamExt> findPageListByDocId(int page, int size, String docId);

    /**
     * èŽ·å–启用流程的标记
     * @return
     */
    Boolean getFlowableEnable();

    /**
     * æ‰«ç ä¼ è¾“程序 ä¸ç»è¿‡å®¡æ‰¹ æ–‡ä»¶å­˜åœ¨é‡‡ç”¨è¦†ç›–
     * @param pnCode
     * @param deviceNo
     * @return
     */
    boolean transferDocFile(String pnCode, String deviceNo);
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/IToEquipmentTaskService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,7 @@
package org.jeecg.modules.flow.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.flow.entity.ToEquipmentTask;

public interface IToEquipmentTaskService extends IService<ToEquipmentTask> {
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/impl/ActivitiDefinitionServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,150 @@
package org.jeecg.modules.flow.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.flow.service.IActivitiDefinitionService;
import org.jeecg.modules.flow.entity.ActivitiDefinition;
import org.jeecg.modules.flow.mapper.ActivitiDefinitionMapper;
import org.jeecg.modules.flow.request.ActivitiDefinitionRequest;
import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.mapper.DepartmentMapper;
import org.jeecg.modules.dnc.response.ActivitiDefinitionCode;
import org.jeecg.modules.dnc.response.CommonCode;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class ActivitiDefinitionServiceImpl extends ServiceImpl<ActivitiDefinitionMapper, ActivitiDefinition> implements IActivitiDefinitionService {
    @Autowired
    private DepartmentMapper departmentMapper;
    @Autowired
    private ISysUserService userService;
    @Autowired
    private IMdcProductionService iMdcProductionService;
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addDefinition(ActivitiDefinition definition) {
        if(definition == null || !ValidateUtil.validateString(definition.getDepartId())
        || !ValidateUtil.validateString(definition.getActName()) || !ValidateUtil.validateString(definition.getApproveUsers()))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ActivitiDefinition en = getByDepartId(definition.getDepartId());
        if(en != null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_IS_EXIST);
        //修改为mdc车间
        MdcProduction mdcProduction=iMdcProductionService.getById(definition.getDepartId());
        if(mdcProduction == null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_DEPART_NONE);
        String[] userIds = definition.getApproveUsers().split(",");
        if(userIds == null|| userIds.length < 1)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        List<String> userIdList = new ArrayList<>(userIds.length);
        Collections.addAll(userIdList, userIds);
        Collection<SysUser> userList = userService.listByIds(userIdList);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        return super.save(definition);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editDefinition(String id, ActivitiDefinition definition) {
        if(!ValidateUtil.validateString(id) || definition == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ActivitiDefinition en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_NOT_EXIST);
        String[] userIds = definition.getApproveUsers().split(",");
        if(userIds == null|| userIds.length < 1)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        List<String> userIdList = new ArrayList<>(userIds.length);
        Collections.addAll(userIdList, userIds);
        Collection<SysUser> userList = userService.listByIds(userIdList);
        if(userList == null || userList.isEmpty() || userList.size() != userIds.length)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_USER_NONE);
        definition.setId(id);
        definition.setDepartId(null);
        return super.updateById(definition);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteDefinition(String id) {
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        ActivitiDefinition en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(ActivitiDefinitionCode.DEF_NOT_EXIST);
        return super.removeById(id);
    }

    @Override
    public ActivitiDefinition getByDepartId(String departId) {
        if(!ValidateUtil.validateString(departId))
            return null;
        List<ActivitiDefinition> list = super.lambdaQuery().eq(ActivitiDefinition::getDepartId, departId).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public Result<?> findPageList(int page, int size, ActivitiDefinitionRequest request) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<ActivitiDefinition> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<ActivitiDefinition> lambdaQuery = super.lambdaQuery();
        if(request != null) {
            if(ValidateUtil.validateString(request.getActName())) {
                lambdaQuery.like(ActivitiDefinition::getActName, request.getActName());
            }
        }
        lambdaQuery.orderByDesc(ActivitiDefinition::getCreateTime);
        IPage<ActivitiDefinition> definitionIPage = lambdaQuery.page(pageData);
        return Result.ok(definitionIPage);

    }

    @Override
    public List<String> getByDepartIds(List<String> departIds) {
        if(departIds == null || departIds.isEmpty())
            return null;
        List<ActivitiDefinition> list = super.lambdaQuery().in(ActivitiDefinition::getDepartId, departIds).list();
        if(list == null || list.isEmpty())
            return null;
        Map<String, String> userIdMap = new HashMap<>();
        list.forEach(item -> {
            if(ValidateUtil.validateString(item.getApproveUsers())) {
                String[] arr = item.getApproveUsers().split(",");
                if(arr != null && arr.length > 0) {
                    for (String s : arr) {
                        userIdMap.put(s, s);
                    }
                }
            }
        });
        if(userIdMap.isEmpty())
            return null;
        List<String> userIds = new ArrayList<>();
        userIdMap.forEach((key, value) -> {
            userIds.add(key);
        });
        return userIds;
    }

    @Override
    public List<ActivitiDefinition> findByUserId(String userId) {
        return super.lambdaQuery().like(ActivitiDefinition::getApproveUsers, userId).list();
    }
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/impl/ActivitiSignExamineServiceimpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,11 @@
package org.jeecg.modules.flow.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.flow.entity.ActivitiSignExamine;
import org.jeecg.modules.flow.mapper.ActivitiSignExamineMapper;
import org.jeecg.modules.flow.service.IActivitiSignExamineService;
import org.springframework.stereotype.Service;

@Service
public class ActivitiSignExamineServiceimpl extends ServiceImpl<ActivitiSignExamineMapper, ActivitiSignExamine> implements IActivitiSignExamineService {
}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/impl/AssignFileStreamServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,788 @@
package org.jeecg.modules.flow.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.flowable.engine.TaskService;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.Task;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.flow.entity.ToEquipmentTask;
import org.jeecg.modules.flow.service.IActivitiDefinitionService;
import org.jeecg.modules.flow.service.IAssignFileStreamService;
import org.jeecg.modules.flow.service.IToEquipmentTaskService;
import org.jeecg.modules.flow.entity.AssignFileStream;
import org.jeecg.modules.flow.ext.AssignFileStreamExt;
import org.jeecg.modules.flow.mapper.AssignFileStreamMapper;
import org.jeecg.modules.flow.request.ApproveBatchRequest;
import org.jeecg.modules.flow.request.AssignFileRequest;
import org.jeecg.modules.flow.request.AssignFileStreamQueryRequest;
import org.jeecg.modules.flow.request.TaskRequest;
import org.jeecg.modules.dnc.entity.*;
import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.ext.NcTxtFilePathInfo;
import org.jeecg.modules.dnc.response.*;
import org.jeecg.modules.dnc.service.*;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.dnc.utils.date.DateUtil;
import org.jeecg.modules.dnc.utils.file.FileUtilS;
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
import org.jeecg.modules.mdc.entity.MdcEquipment;
import org.jeecg.modules.mdc.service.IMdcEquipmentService;
import org.jeecg.modules.system.entity.MdcProduction;
import org.jeecg.modules.system.service.IMdcProductionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class AssignFileStreamServiceImpl extends ServiceImpl<AssignFileStreamMapper, AssignFileStream> implements IAssignFileStreamService {
    private static final String PROCESS_KEY = "assign_nc_to_device";
    private static final String APPLY_VARIABLE = "apply_user";
    private static final String APPROVE_VARIABLE = "approve_users";
    private static final String SEND_CODE = "SEND";

    @Value("${flowable.enable}")
    private Boolean flowableEnable;

    @Autowired
    private IDocInfoService docInfoService;
    @Autowired
    private IProcessStreamService processStreamService;
    @Autowired
    private IWorkStepService workStepService;
    @Autowired
    private IPermissionStreamService permissionStreamService;
    @Autowired
    private IDocClassificationService classificationService;
    @Autowired
    private IToEquipmentTaskService equipmentTaskService;
    @Autowired
    private IDeviceInfoService deviceInfoService;
    @Autowired
    private IDocFileService docFileService;
    @Autowired
    private IActivitiDefinitionService definitionService;
    @Autowired
    private IDocRelativeService docRelativeService;
    @Autowired
    private ISynchronizedFlagService synchronizedFlagService;
    @Autowired
    private IDeviceGroupService deviceGroupService;
    @Autowired
    private IDncPassLogService dncPassLogService;
    @Autowired
    private IDeviceCharactersService iDeviceCharactersService;
    @Autowired
    private IMdcEquipmentService iMdcEquipmentService;
    @Autowired
    private IMdcProductionService iMdcProductionService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private TaskService taskService;
    @Resource
    private FlowCommonService flowCommonService;
    @Resource
    private IFlowDefinitionService flowDefinitionService;

    @Value("${securedoc.serverIp}")
    private String serverIp;
    @Value("${securedoc.serverPort}")
    private int serverPort;
    @Value("${securedoc.whether}")
    private String whether;
    @Value("${securedoc.localFilePath}")
    private String localFilePath;

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResult applyAssignFile(AssignFileStream stream) {
        synchronized (this){
            //判断设备特殊字符
            String specialChar = getDeviceSpecialChar(stream.getDeviceId(),stream.getFileId());
            if (StrUtil.isNotEmpty(specialChar)){
                //抛出特殊字符异常
                return createSpecialCharErrorResponse(specialChar);
            }
            if(flowableEnable) {
                boolean b = applyAssignFileActive(stream);
                if (b) {
                    return ResponseResult.SUCCESS();
                } else {
                    return ResponseResult.SUCCESS();
                }

            }else {
                return applyAssignFileNonActive(stream);
            }
        }
    }

    /**
     * åˆ¤æ–­è®¾å¤‡ç‰¹æ®Šå­—符
     * @param deviceId,fileId
     * è®¾å¤‡ID，文件ID
     */
    public String getDeviceSpecialChar(String deviceId, String fileId){
        //替换为mdc设备表
//        DeviceInfo deviceInfo = deviceInfoService.getById(deviceId);
        MdcEquipment mdcEquipment = iMdcEquipmentService.getById(deviceId);
        if(mdcEquipment == null)
            ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
//        DocFile docFile = docFileService.getById(fileId);
        DocInfo docInfo = docInfoService.getOne(new QueryWrapper<DocInfo>().eq("publish_file_id",fileId));
        if(docInfo == null)
            ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
        List<DeviceCharacters> deviceCharactersList=iDeviceCharactersService.list(
                new LambdaQueryWrapper<DeviceCharacters>().eq(DeviceCharacters::getDeviceNo,mdcEquipment.getEquipmentId()));
        if (deviceCharactersList.isEmpty()){
            return "";
        }else {
            List<String> specialCharList=deviceCharactersList.stream().map(DeviceCharacters::getCharacters).collect(Collectors.toList());
            if(!specialCharList.isEmpty()){
                //对比文件名是否包含特殊字符
                String fileName=docInfo.getDocName();
                for(String specialChar:specialCharList){
                    if (fileName.contains(specialChar)){
                        return specialChar;
                    }
                }
            }else {
                return "";
            }
        }
        return "";
    }

    private ResponseResult createSpecialCharErrorResponse(String specialChar) {
        return new ResponseResult(new ResultCode() {
            @Override
            public boolean success() {
                return false;
            }
            @Override
            public int code() {
                return 88881;
            }
            @Override
            public String message() {
                return "文件名称存在设备特殊字符" + specialChar;
            }
        });
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean applyAssignFileActive(AssignFileStream stream) {
        validateParams(stream);
        DocInfo docInfo = getDocInfo(stream);
        MdcEquipment mdcEquipment = getMdcEquipment(stream);
        DocFile docFile = docFileService.getById(stream.getFileId());
        DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(stream.getDocId(), 4, stream.getDeviceId());
        if (deviceDoc != null) {
            handleExistingDeviceDoc(docFile, mdcEquipment, stream.getDeviceId());
        }
        deviceDoc = docInfoService.findByAttrAndDocName(docInfo.getDocName(), 4, stream.getDeviceId());
        if (deviceDoc != null) {
            handleExistingDeviceDoc(docFile, mdcEquipment, stream.getDeviceId());
        }
        List<PermissionStream> permissionStreams = getPermissionStreams(stream);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
//        List<String> departIds = getDepartIds(permissionStreams, userId);
//        List<String> userIdList = getUserIdList(departIds);
//        saveBusinessObject(stream, userId);
//        ProcessInstance processInstance = startProcessInstance(stream, userIdList);
//        completeTask(processInstance, userId);
        System.out.println("指派NC文档到设备流程：" + stream.getDocId());
        flowCommonService.initActBusiness("指派NC文档到设备流程：" + stream.getStreamId(), stream.getStreamId(), "IAssignFileStreamService", "assign_nc_to_device", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("id", stream.getStreamId());
        variables.put("approveContent", stream.getApproveContent());
        flowDefinitionService.startProcessInstanceByKey("assign_nc_to_device", variables);
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public ResponseResult applyAssignFileNonActive(AssignFileStream stream) {
        //权限校验
        validateParams(stream);
        DocInfo docInfo = getDocInfo(stream);
        MdcEquipment mdcEquipment = getMdcEquipment(stream);
        DocFile docFile = getDocFile(stream);
        DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(stream.getDocId(), 4, stream.getDeviceId());
        if(deviceDoc != null) {
            // åˆ é™¤ å¤‡ä»½  è¦†ç›– åŽŸæœ‰çš„
            List<String> strings=iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
            if (strings != null && !strings.isEmpty()) {
                String path = StringUtils.join(strings.toArray(), "/");
                boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/"+ mdcEquipment.getEquipmentId(),
                        docFile.getFileName(), docFile.getFileSuffix());
            }
        }
        /*deviceDoc = docInfoService.findByAttrAndDocName(docInfo.getDocName(), 4, stream.getDeviceId());
        if(deviceDoc != null) {
            // åˆ é™¤ å¤‡ä»½  è¦†ç›– åŽŸæœ‰çš„
            List<String> strings =  deviceGroupService.findListParentTreeAll(deviceInfo.getGroupId());
            if (strings != null && !strings.isEmpty()) {
                String path = StringUtils.join(strings.toArray(), "/");
                boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/"+ deviceInfo.getDeviceNo(),
                        docFile.getFileName(), docFile.getFileSuffix());
            }
        }*/
        getPermissionStreams(stream);
        //插入文档到设备发送文档
        if(deviceDoc == null) {
            DocClassification classification = classificationService.getByCode(SEND_CODE);
            if(classification == null)
                ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
            DocRelative docRelative = new DocRelative();
            docRelative.setDocId(docInfo.getDocId());
            docRelative.setClassificationId(classification.getClassificationId());
            docRelative.setAttributionType(4);
            docRelative.setAttributionId(stream.getDeviceId());
            boolean b = docRelativeService.save(docRelative);
            if(!b) {
                ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
            }

        }
        handleFileTransfer(mdcEquipment, docFile);
        handleFileProcessing(docFile, mdcEquipment, whether, localFilePath);
        synchronizedFlagService.updateFlag(2);
        return new ResponseResult(CommonCode.SUCCESS);
    }

    @Override
    public AssignFileStreamExt getAssignFileStreamDetail(String streamId) {
        if(!ValidateUtil.validateString(streamId))
            return null;
        return super.getBaseMapper().getAssignFileStreamDetail(streamId);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean approveAssignFile(String taskId, String streamId, AssignFileStream stream) {
        if(!ValidateUtil.validateString(taskId) || !ValidateUtil.validateString(streamId) || stream == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        if(!ValidateUtil.validateInteger(stream.getStatus()))
            ExceptionCast.cast(ActivitiCode.ACT_STATUS_ERROR);
        AssignFileStream en = super.getById(streamId);
        if(en == null)
            ExceptionCast.cast(ActivitiCode.ACT_BUSINESS_DETAIL_ERROR);
        Task task = taskService.createTaskQuery().taskId(taskId).taskCandidateOrAssigned(userId).singleResult();
        if(task == null)
            ExceptionCast.cast(ActivitiCode.ACT_TASK_ERROR);
        if(!ValidateUtil.validateString(task.getAssignee())) {
            //拾取任务
            taskService.claim(task.getId(), userId);
            //完成任务
            taskService.complete(task.getId());
        }else {
            //完成任务
            taskService.complete(task.getId());
        }
        //更新对象封装
        AssignFileStream up = new AssignFileStream();
        up.setApproveContent(stream.getApproveContent());
        up.setStatus(stream.getStatus());
        up.setApproveUserId(userId);
        up.setApproveTime(DateUtil.getNow());
        up.setStreamId(streamId);
        boolean b = super.updateById(up);
        if(!b)
            ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
        if(up.getStatus() == 2) {
            //同意操作
            DocInfo docInfo = docInfoService.getByDocAttrAndDocId(en.getDocId(), 5, en.getProcessId());
            if(docInfo == null || docInfo.getDocStatus() == 3)
                ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR);
            DeviceInfo deviceInfo = deviceInfoService.getById(en.getDeviceId());
            if(deviceInfo == null)
                ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
            DocFile docFile = docFileService.getById(en.getFileId());
            if(docFile == null)
                ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
            DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(en.getDocId(),4, en.getDeviceId());
            if(deviceDoc != null) {
                // åˆ é™¤ å¤‡ä»½  è¦†ç›– åŽŸæœ‰çš„
                List<String> strings =  deviceGroupService.findListParentTreeAll(deviceInfo.getGroupId());
                if (strings != null && !strings.isEmpty()) {
                    String path = StringUtils.join(strings.toArray(), "/");
                    boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/"+ deviceInfo.getDeviceNo(),
                            docFile.getFileName(), docFile.getFileSuffix());
                  /*  //docInfoService.getBaseMapper().deleteById(deviceDoc.getDocId());
                    boolean doc = docRelativeService.deleteCopyDocByAttrNext(deviceDoc.getDocId(),4,stream.getDeviceId());
                    if (!doc) {
                        ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR_DELEVE);
                    }*/

                }
            } else {
                //插入文档到设备发送文档
                DocClassification classification = classificationService.getByCode(SEND_CODE);
                if(classification == null)
                    ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);

                DocRelative docRelative = new DocRelative();
                docRelative.setDocId(docInfo.getDocId());
                docRelative.setClassificationId(classification.getClassificationId());
                docRelative.setAttributionType(4);
                docRelative.setAttributionId(en.getDeviceId());
                b = docRelativeService.save(docRelative);
            }
            if(!b)
                ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
            if (deviceInfo != null) {
                List<String> strings =  deviceGroupService.findListParentTreeAll(deviceInfo.getGroupId());
                if (strings != null && !strings.isEmpty()) {
                    String path = StringUtils.join(strings.toArray(), "/");
                    boolean copyFileNc = FileUtilS.copyFileNc(docFile.getFilePath(),path + "/"+ deviceInfo.getDeviceNo(),
                            docFile.getFileEncodeName(),
                            docFile.getFileName(),docFile.getFileSuffix());
                    if (!copyFileNc) {
                        ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
                    } else {
                        FileUtilS.deleteZipFromToSend(path + "/"+ deviceInfo.getDeviceNo(),
                                docFile.getFileName(),docFile.getFileSuffix());

                    }
                }

            }
            return synchronizedFlagService.updateFlag(1);
        }else if(up.getStatus() == 3) {
            //拒绝操作 ä»€ä¹ˆä¹Ÿä¸åš
            return true;
        }else {
            ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean applyBatchAssignFile(AssignFileRequest assignFileRequest) {
        if(assignFileRequest == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        String[] deviceIds = assignFileRequest.getDeviceIds();
        if(deviceIds == null || deviceIds.length < 1)
            ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
        AssignFileStream stream;
        for(String id : deviceIds) {
            stream = new AssignFileStream();
            stream.setProcessId(assignFileRequest.getProcessId());
            stream.setDocId(assignFileRequest.getDocId());
            stream.setFileId(assignFileRequest.getFileId());
            stream.setApplyReason(assignFileRequest.getApplyReason());
            stream.setDeviceId(id);
            ResponseResult b = applyAssignFile(stream);
            if(!b.isSuccess())
                ExceptionCast.cast(ActivitiCode.ACT_APPLY_ERROR);
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean approveBatchAssignFile(ApproveBatchRequest approveBatchRequest) {
        if(approveBatchRequest == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        List<TaskRequest> list = approveBatchRequest.getTaskArr();
        if(list == null || list.isEmpty())
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        list.forEach(item -> {
            AssignFileStream stream = new AssignFileStream();
            stream.setApproveContent(approveBatchRequest.getApproveContent());
            stream.setStatus(approveBatchRequest.getStatus());
            boolean b = approveAssignFile(item.getId(), item.getBusinessKey(), stream);
            if(!b)
                ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
        });
        return synchronizedFlagService.updateFlag(1);
    }

    @Override
    public Result<?> findPageList(int page, int size, AssignFileStreamQueryRequest request) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        LambdaQueryWrapper<AssignFileStreamExt> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(AssignFileStreamExt::getApproveUserId, userId);
        lambdaQueryWrapper.orderByDesc(AssignFileStreamExt::getApproveTime);
        IPage<AssignFileStreamExt> pageData = new Page<>(page, size);
        if(request != null) {
            if(ValidateUtil.validateString(request.getAscStr())) {
                String[] ascArr = request.getAscStr().split(",");
//                ((Page<AssignFileStreamExt>) pageData).setAsc(ascArr);
            }
            if(ValidateUtil.validateString(request.getDescStr())) {
                String[] descStr = request.getDescStr().split(",");
//                ((Page<AssignFileStreamExt>) pageData).setDesc(descStr);
            }
        }
        IPage<AssignFileStreamExt> streamExtIPage = super.getBaseMapper().findByPage(pageData, lambdaQueryWrapper);
        return Result.ok(streamExtIPage);
    }

    @Override
    public QueryPageResponseResult<AssignFileStreamExt> findPageListByDocId(int page, int size, String docId) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        if(!ValidateUtil.validateString(docId))
            ExceptionCast.cast(ActivitiCode.ACT_DOC_ID_NONE);
        QueryWrapper<AssignFileStreamExt> queryWrapper =  Wrappers.query();
        queryWrapper.eq("a.doc_id", docId);
        queryWrapper.orderByDesc("approve_time");
        IPage<AssignFileStreamExt> pageData = new Page<>(page, size);
        IPage<AssignFileStreamExt> streamExtIPage = super.getBaseMapper().findByPage(pageData, queryWrapper);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, streamExtIPage);
    }

    @Override
    public Boolean getFlowableEnable(){
        if(flowableEnable != null) {
            return flowableEnable;
        }
        return false;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean transferDocFile(String pnCode, String deviceNo) {
        List<ProcessStream> streams = processStreamService.validateDeviceProcessInfo(pnCode, deviceNo);
        DeviceInfo deviceInfo = deviceInfoService.getByDeviceNo(deviceNo);
        if(deviceInfo == null)
            ExceptionCast.cast(DeviceCode.DEVICE_NOT_EXIST);
        //删除原来设备下的所有文档
        docRelativeService.deleteByDocAttr(4, deviceInfo.getDeviceId());
        List<DocInfo> docInfoList = docInfoService.getByProcessIds(streams);
        if(docInfoList == null || docInfoList.isEmpty())
            ExceptionCast.cast(DocumentCode.DOC_NOT_EXIST);
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        for(DocInfo docInfo : docInfoList) {
            DocFile docFile = docFileService.getById(docInfo.getPublishFileId());
            if(docFile == null)
                ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
            //插入文档到设备发送文档
            DocClassification classification = classificationService.getByCode(SEND_CODE);
            if(classification == null)
                ExceptionCast.cast(DocumentCode.DOC_CLASS_ERROR);
            DocRelative docRelative = new DocRelative();
            docRelative.setDocId(docInfo.getDocId());
            docRelative.setClassificationId(classification.getClassificationId());
            docRelative.setAttributionType(4);
            docRelative.setAttributionId(deviceInfo.getDeviceId());
            boolean b = docRelativeService.save(docRelative);
            if(!b)
                ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
            //插入文件传输任务表
            ToEquipmentTask equipmentTask = new ToEquipmentTask();
            //不能直接从doc中拿fileId å’Œversion  å¯èƒ½ä¼šå­˜åœ¨æ–Œæ›´
            //equipmentTask.setFileId(docInfo.getPublishFileId());
            //equipmentTask.setDocVersion(docInfo.getPublishVersion());
            equipmentTask.setDocId(docInfo.getDocId());
            equipmentTask.setSyncFlag(1);
            equipmentTask.setDeviceNo(deviceInfo.getDeviceNo());
            equipmentTask.setDeviceId(deviceInfo.getDeviceId());
            equipmentTask.setDepartId(deviceInfo.getDepartId());
            //文件相关信息
            equipmentTask.setFileId(docFile.getFileId());
            equipmentTask.setDocVersion(docFile.getDocVersion());
            equipmentTask.setFileName(docInfo.getDocName());
            equipmentTask.setFileEncodeName(docFile.getFileEncodeName());
            equipmentTask.setFilePath(docFile.getFilePath());
            equipmentTask.setFileSuffix(docFile.getFileSuffix());
            equipmentTask.setFileSize(docFile.getFileSize());
            b = equipmentTaskService.save(equipmentTask);
            if(!b) {
                ExceptionCast.cast(ActivitiCode.ACT_APPROVE_ERROR);
            }
        }
        return synchronizedFlagService.updateFlag(1);
    }

    //传参验证
    private void validateParams(AssignFileStream stream) {
        if (stream == null) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        if (!ValidateUtil.validateString(stream.getAttributionId()) || !ValidateUtil.validateString(stream.getDocId())
                || !ValidateUtil.validateString(stream.getFileId()) || !ValidateUtil.validateString(stream.getAttributionType())) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        if (!ValidateUtil.validateString(stream.getDeviceId())) {
            ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
        }
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        String userId = user.getId();
        if (!ValidateUtil.validateString(userId)) {
            ExceptionCast.cast(UcenterCode.UCENTER_ACCOUNT_NOT_EXIST);
        }
    }

    //获取文件信息
    private DocInfo getDocInfo(AssignFileStream stream) {
        DocInfo docInfo = docInfoService.getByDocAttrAndDocId(stream.getDocId(), Integer.parseInt(stream.getAttributionType()), stream.getAttributionId());
        if (docInfo == null || docInfo.getDocStatus() == 3) {
            ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR);
        }
        return docInfo;
    }

    //获取文件
    private void handleExistingDeviceDoc(DocFile docFile, MdcEquipment mdcEquipment, String deviceId) {
        List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getEquipmentId());
        if (strings != null && !strings.isEmpty()) {
            String path = StringUtils.join(strings.toArray(), "/");
            boolean copyFileNc = FileUtilS.copyFileNcToBak(path + "/" + mdcEquipment.getEquipmentId(),
                    docFile.getFileName(), docFile.getFileSuffix());
            if (!copyFileNc) {
                ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
            } else {
                DocInfo deviceDoc = docInfoService.getByDocAttrAndDocId(deviceId, 4, deviceId);
                boolean doc = docRelativeService.deleteDocByAttr(deviceDoc.getDocId(), 4, deviceId);
                if (!doc) {
                    ExceptionCast.cast(ActivitiCode.ACT_DOC_ERROR_DELEVE);
                }
            }
        }
    }

    //权限校验
    private List<PermissionStream> getPermissionStreams(AssignFileStream stream) {
        List<PermissionStream> permissionStreams = new ArrayList<>();
        if (stream.getAttributionType().equals("5")) {
            // å·¥åº
            ProcessStream processStream = processStreamService.getById(stream.getAttributionId());
            if (processStream == null) {
                ExceptionCast.cast(CommonCode.INVALID_PARAM);
            }
            stream.setProductId(processStream.getProductId());
            stream.setComponentId(processStream.getComponentId());
            stream.setPartsId(processStream.getPartsId());
            stream.setProcessId(processStream.getProcessId());
            permissionStreams = permissionStreamService
                    .getByProcessId(processStream.getProductId(), processStream.getComponentId(), processStream.getPartsId(), processStream.getProcessId());
        } else {
            // å·¥æ­¥
            WorkStep workStep = workStepService.getById(stream.getAttributionId());
            if (workStep == null) {
                ExceptionCast.cast(CommonCode.INVALID_PARAM);
            }
            stream.setProductId(workStep.getProductId());
            stream.setComponentId(workStep.getComponentId());
            stream.setPartsId(workStep.getPartsId());
            stream.setProcessId(workStep.getProcessId());
            stream.setStepId(workStep.getId());
            permissionStreams = permissionStreamService
                    .getByStepId(workStep.getProductId(), workStep.getComponentId(), workStep.getPartsId(), workStep.getProcessId(), workStep.getId());
        }
        if (permissionStreams == null || permissionStreams.isEmpty()) {
            ExceptionCast.cast(ActivitiCode.ACT_NODE_DEPART_NONE);
        }
        return permissionStreams;
    }

    //获取部门信息
    //todo ä¿®æ”¹
    private List<String> getDepartIds(List<PermissionStream> permissionStreams, String userId) {
        Map<String, MdcProduction> map = iMdcProductionService.getUserAssignedDepart(userId);
        List<String> departIds = permissionStreams.stream()
                .filter(item -> map.containsKey(item.getDepartId()))
                .map(PermissionStream::getDepartId)
                .collect(Collectors.toList());
        if (departIds.isEmpty()) {
            ExceptionCast.cast(ActivitiCode.ACT_USER_NOT_PERM);
        }
        return departIds;
    }

    //获取多个部门的审批人 åŽ»é‡
    private List<String> getUserIdList(List<String> departIds) {
        List<String> userIdList = definitionService.getByDepartIds(departIds);
        if (userIdList == null || userIdList.isEmpty()) {
            ExceptionCast.cast(ActivitiCode.ACT_APPROVE_USERS_NONE);
        }
        return userIdList;
    }

    //封装数据
    private void saveBusinessObject(AssignFileStream stream, String userId) {
        String streamId = IdWorker.getIdStr();
        stream.setStreamId(streamId);
        stream.setApplyUserId(userId);
        stream.setApplyTime(DateUtil.getNow());
        stream.setStatus(1);
        boolean b = super.save(stream);
        if (!b) {
            ExceptionCast.cast(ActivitiCode.ACT_BUSINESS_SAVE_ERROR);
        }
    }

    //开始工作流
//    private ProcessInstance startProcessInstance(AssignFileStream stream, List<String> userIdList) {
//        String approveUsers = String.join(",", userIdList);
//        Map<String, Object> avariableMap = new HashMap<>();
//        avariableMap.put(APPLY_VARIABLE, stream.getApplyUserId());
//        avariableMap.put(APPROVE_VARIABLE, approveUsers);
//        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(PROCESS_KEY, stream.getStreamId(), avariableMap);
//        if (processInstance == null) {
//            ExceptionCast.cast(ActivitiCode.ACT_APPROVE_USERS_NONE);
//        }
//        return processInstance;
//    }

    //拾取任务
    private void completeTask(ProcessInstance processInstance, String userId) {
        Task task = taskService.createTaskQuery().processDefinitionKey(PROCESS_KEY).taskAssignee(userId)
                .processInstanceId(processInstance.getId()).singleResult();
        if (task == null) {
            ExceptionCast.cast(ActivitiCode.ACT_APPROVE_USERS_NONE);
        }
        taskService.complete(task.getId());
    }

    //获取设备
    private MdcEquipment getMdcEquipment(AssignFileStream stream) {
        MdcEquipment mdcEquipment = iMdcEquipmentService.getById(stream.getDeviceId());
        if (mdcEquipment == null) {
            ExceptionCast.cast(ActivitiCode.ACT_ASSIGN_DEVICE_NONE);
        }
        return mdcEquipment;
    }

    //获取文件
    private DocFile getDocFile(AssignFileStream stream) {
        DocFile docFile = docFileService.getById(stream.getFileId());
        if (docFile == null) {
            ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
        }
        return docFile;
    }

    //插入文件传输任务表
    private void handleFileTransfer(MdcEquipment mdcEquipment, DocFile docFile) {
        List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
        if (strings != null && !strings.isEmpty()) {
            String path = StringUtils.join(strings.toArray(), "/");
            boolean copyFileNc = FileUtilS.copyFileNc(docFile.getFilePath(), path + "/" + mdcEquipment.getEquipmentId(),
                    docFile.getFileEncodeName(),
                    docFile.getFileName(), docFile.getFileSuffix());
            if (!copyFileNc) {
                ExceptionCast.cast(ActivitiCode.ACT_FILE_ERROR);
            } else {
                FileUtilS.deleteZipFromToSend(path + "/" + mdcEquipment.getEquipmentId(),
                        docFile.getFileName(), docFile.getFileSuffix());
            }
        } else {
            throw new RuntimeException("文件传输路径获取失败");
        }
    }

    //封装处理文件
    private void handleFileProcessing(DocFile docFile, MdcEquipment mdcEquipment, String whether, String localFilePath) {
        if (whether.equals("true") && !docFile.getFileSuffix().equals("zip") && !docFile.getFileSuffix().equals("rar")) {
            String size = FileUtilS.fileSizeNC(docFile.getFilePath(), docFile.getFileEncodeName());
            List<String> strings = iMdcProductionService.findListParentTreeAll(mdcEquipment.getId());
            if (strings != null && !strings.isEmpty()) {
                String path = StringUtils.join(strings.toArray(), "/");
                Date dateFirst = DateUtil.getNow();
                DncPassLog passInfoTxt = new DncPassLog();
                passInfoTxt.setDayTime(DateUtil.format(dateFirst, DateUtil.STR_YEARMONTHDAY));
                DncPassLog dncPassLog = dncPassLogService.findDayTime(DateUtil.format(dateFirst, DateUtil.STR_YEARMONTHDAY));
                Integer fileTxt = 0, fileNc = 0;
                if (dncPassLog != null) {
                    fileTxt = dncPassLog.getSequenceNumber() + 1;
                    fileNc = fileTxt + 1;
                } else {
                    fileTxt = 1;
                    fileNc = fileTxt + 1;
                }
                String sequence = String.format("%06d", fileTxt);
                String sequenceNc = String.format("%06d", fileNc);
                passInfoTxt.setSequenceNumber(fileTxt);
                passInfoTxt.setSequenceOrder(sequence);
                passInfoTxt.setCreateTime(dateFirst);
                passInfoTxt.setPassType("02");
                dncPassLogService.save(passInfoTxt);

                DncPassLog passInfoNc = new DncPassLog();
                passInfoNc.setSequenceNumber(fileNc);
                passInfoNc.setSequenceOrder(sequenceNc);
                passInfoNc.setDayTime(DateUtil.format(dateFirst, DateUtil.STR_YEARMONTHDAY));
                passInfoNc.setPassType("02");
                passInfoNc.setPassName(docFile.getFileName());
                try {
                    Thread.sleep(1000);
                    Date date = new Date();
                    passInfoNc.setCreateTime(date);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                dncPassLogService.save(passInfoNc);

                NcTxtFilePathInfo ncTxt = new NcTxtFilePathInfo();
                ncTxt.setEquipmentId(mdcEquipment.getEquipmentId());
                ncTxt.setFileNcName("02A" + DateUtil.format(dateFirst, DateUtil.STR_YEARMONTHDAY) + sequenceNc);
                ncTxt.setFileTxtName("02A" + DateUtil.format(dateFirst, DateUtil.STR_YEARMONTHDAY) + sequence);
                ncTxt.setFilePath(path + "/" + mdcEquipment.getEquipmentId() + "/");
                ncTxt.setOrigFileName(docFile.getFileName());
                ncTxt.setOrigFileSuffix(docFile.getFileSuffix());
                ncTxt.setFileAddOrDelete(1);
                String loFilePath = localFilePath + ncTxt.getFileTxtName() + ".nc";
                try {
                    String allList = ncTxt.getFileTxtName() + "\n"
                            + ncTxt.getFileNcName() + "\n"
                            + ncTxt.getOrigFileName() + "\n"
                            + ncTxt.getOrigFileSuffix() + "\n"
                            + ncTxt.getFilePath() + "\n"
                            + ncTxt.getEquipmentId() + "\n"
                            + ncTxt.getFileAddOrDelete().toString() + "\n"
                            + size + "\n";
                    FileUtilS.fileWriterSql(loFilePath, allList);
                    boolean copyFileNc = FileUtilS.copyFileUpName(path + "/" + mdcEquipment.getEquipmentId() + "/send/" +
                                    docFile.getFileName(),
                            localFilePath + ncTxt.getFileNcName(),
                            docFile.getFileSuffix(), "NC");
                    if (!copyFileNc) {
                        FileUtilS.deleteNcFile(loFilePath);
                    }
                } catch (IOException e) {
                    throw new RuntimeException("文件处理失败", e);
                }
            }
        }
    }

}

 lxzn-module-dnc/src/main/java/org/jeecg/modules/flow/service/impl/ToEquipmentTaskServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,11 @@
package org.jeecg.modules.flow.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.modules.flow.entity.ToEquipmentTask;
import org.jeecg.modules.flow.service.IToEquipmentTaskService;
import org.jeecg.modules.flow.mapper.ToEquipmentTaskMapper;
import org.springframework.stereotype.Service;

@Service
public class ToEquipmentTaskServiceImpl extends ServiceImpl<ToEquipmentTaskMapper, ToEquipmentTask> implements IToEquipmentTaskService {
}

 lxzn-module-flowable/pom.xml

@@ -22,7 +22,7 @@
            <groupId>org.flowable</groupId>
            <artifactId>flowable-engine</artifactId>
            <scope>compile</scope>
            <version>6.4.0</version>
            <version>6.5.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mybatis</groupId>
@@ -33,7 +33,7 @@
        <dependency>
            <groupId>org.flowable</groupId>
            <artifactId>flowable-spring-boot-starter-basic</artifactId>
            <version>6.4.0</version>
            <version>6.5.0</version>
        </dependency>
        <!--表达式解析工具-->
        <dependency>
@@ -47,6 +47,20 @@
            <artifactId>xercesImpl</artifactId>
            <version>2.12.0</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

 lxzn-module-flowable/src/main/java/org/jeecg/JeecgFlowableCloudApplication.java

ÎļþÒÑɾ³ý

 lxzn-module-flowable/src/main/java/org/jeecg/modules/flowable/apithird/service/FlowCommonService.java

@@ -7,8 +7,9 @@
import org.jeecg.modules.flowable.apithird.business.service.impl.FlowMyBusinessServiceImpl;
import org.jeecg.modules.flowable.apithird.common.exception.CustomException;
import org.jeecg.modules.flowable.service.impl.FlowInstanceServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 *业务模块调用API的集合
@@ -18,9 +19,9 @@
 */
@Service
public class FlowCommonService {
    @Autowired
    @Resource
    FlowMyBusinessServiceImpl flowMyBusinessService;
    @Autowired
    @Resource
    FlowInstanceServiceImpl flowInstanceService;
    /**
     * åˆå§‹ç”Ÿæˆæˆ–修改业务与流程的关联信息<br/>

 lxzn-module-flowable/src/main/java/org/jeecg/modules/flowable/config/FlowableConfig.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,65 @@
package org.jeecg.modules.flowable.config;
import org.flowable.engine.ProcessEngine;
import org.flowable.engine.ProcessEngineConfiguration;
import org.flowable.engine.impl.cfg.StandaloneProcessEngineConfiguration;
import org.flowable.eventregistry.impl.EventRegistryEngineConfiguration;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.flowable.eventregistry.impl.EventRegistryEngine;
import javax.sql.DataSource;

@Configuration
public class FlowableConfig {

    @Value("${spring.datasource.dynamic.datasource.master.url}")
    private String jdbcUrl;
    @Value("${spring.datasource.dynamic.datasource.master.username}")
    private String jdbcUsername;
    @Value("${spring.datasource.dynamic.datasource.master.password}")
    private String jdbcPassword;
    @Value("${spring.datasource.dynamic.datasource.master.driver-class-name}")
    private String jdbcDriver;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUrl(jdbcUrl);
        dataSource.setUsername(jdbcUsername);
        dataSource.setPassword(jdbcPassword);
        dataSource.setDriverClassName(jdbcDriver);
        return dataSource;
    }

    @Bean(name = "processEngine")
    @DependsOn("dataSource")
    public ProcessEngine createProcessEngine(DataSource dataSource) {
        StandaloneProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration();
        cfg.setDataSource(dataSource);
        cfg.setDatabaseType("mssql");

        // å¯ä»¥æ ¹æ®éœ€è¦æ·»åŠ æ›´å¤šé…ç½®
        cfg.setActivityFontName("宋体");
        cfg.setLabelFontName("宋体");
        cfg.setAnnotationFontName("宋体");

        // è®¾ç½®æ•°æ®åº“模式更新策略为自动更新
        cfg.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        return cfg.buildProcessEngine();
    }

    @Bean(name = "eventRegistryEngine")
    public EventRegistryEngine eventRegistryEngine(DataSource dataSource) {
        EventRegistryEngineConfiguration config = new EventRegistryEngineConfiguration();
        config.setDataSource(dataSource);
        // è®¾ç½®æ•°æ®åº“模式更新策略，这里选择自动更新
        config.setDatabaseSchemaUpdate("true");
        return config.buildEventRegistryEngine();
    }
}




 lxzn-module-flowable/src/main/java/org/jeecg/modules/flowable/flow/FlowableConfig.java

ÎļþÒÑɾ³ý

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/mapper/MdcProductionMapper.java

@@ -41,4 +41,11 @@
     * @return
     */
    String findThreeProductionId(@Param("userId") String userId);

    /**
     * æ ¹æ®ç”¨æˆ·id查询用户全部车间权限
     * @param userId
     * @return
     */
    List<MdcProduction> findAllProductionId(@Param("userId") String userId);
}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/mapper/xml/MdcProductionMapper.xml

@@ -31,4 +31,15 @@
    <select id="findThreeProductionId" resultType="java.lang.String">
        SELECT TOP 1 t2.id id FROM mdc_user_production t1 LEFT JOIN mdc_production t2 ON t1.pro_id = t2.id WHERE t1.user_id = #{userId} AND t2.org_type = '3'
    </select>
</mapper>
    <select id="findAllProductionId" resultType="org.jeecg.modules.system.entity.MdcProduction">
        SELECT
            t1.*
        FROM
            mdc_production t1
                LEFT JOIN mdc_user_production t2 ON t1.id = t2.pro_id
                LEFT JOIN sys_user t3 on t3.ID=t2.user_id
        WHERE
            t3.id = #{userId}
          AND t1.org_type = '3'
    </select>
</mapper>

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/service/IMdcProductionService.java

@@ -6,6 +6,7 @@
import org.jeecg.modules.system.model.ProductionIdModel;

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

/**
 * @Description: äº§çº¿è¡¨
@@ -103,4 +104,11 @@
     * @return
     */
    List<String> findListParentTree(String parentId,List<String> stringList);

    /**
     * èŽ·å–用户所在的部门
     * @param userId
     * @return
     */
    Map<String, MdcProduction> getUserAssignedDepart(String userId);
}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/system/service/impl/MdcProductionServiceImpl.java

@@ -1,5 +1,6 @@
package org.jeecg.modules.system.service.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -368,4 +369,23 @@
        }
        return stringList;
    }

    /**
     * èŽ·å–用户已分配的部门列表
     * @param userId
     * @return
     */
     @Override
     public Map<String, MdcProduction> getUserAssignedDepart(String userId){
         if(StrUtil.isEmpty(userId))
             return null;
         List<MdcProduction> userPermDepart = this.baseMapper.findAllProductionId(userId);
         if(userPermDepart == null || userPermDepart.isEmpty())
             return null;
         Map<String, MdcProduction> map = new HashMap<>();
         userPermDepart.forEach(item -> {
             map.put(item.getId(), item);
         });
         return map;
    }
}

 lxzn-module-system/lxzn-system-start/src/main/java/org/jeecg/JeecgSystemApplication.java

@@ -1,6 +1,7 @@
package org.jeecg;

import lombok.extern.slf4j.Slf4j;
import org.flowable.spring.boot.eventregistry.EventRegistryServicesAutoConfiguration;
import org.jeecg.common.util.oConvertUtils;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration;
@@ -20,7 +21,7 @@
*/
@Slf4j
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class,
        ManagementWebSecurityAutoConfiguration.class})
        ManagementWebSecurityAutoConfiguration.class, EventRegistryServicesAutoConfiguration.class})
//@EnableAutoConfiguration(exclude={MongoAutoConfiguration.class})
public class JeecgSystemApplication extends SpringBootServletInitializer {


 lxzn-module-system/lxzn-system-start/src/main/resources/application-dev.yml

@@ -151,6 +151,7 @@
#    async-executor-activate: false
#    async-executor-enabled: true
flowable:
  enable: true
  #关闭定时任务JOB
  async-executor-activate: false
  database-schema-update: true

 lxzn-module-system/lxzn-system-start/src/main/resources/application.yml

@@ -3,4 +3,4 @@
    name: jeecg-system
  profiles:
    active: '@profile.name@'
#    active: dev
#    active: dev