Merge branch 'develop' of http://gitlab.sothing.top/843502640/jyzb_platformV2 into develop-zhaojw

# Conflicts:
#	jyzb-process/src/main/java/com/junmp/junmpProcess/service/Bussiness/impl/WorkProcessServiceImpl.java

.gitignore

@@ -113,3 +113,5 @@ Thumbs.db
 /jyzb-biz/pom.xml
 /.idea/compiler.xml
 /jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/UpdateOrderReq.java
+/jyzb-boot/src/main/resources/application-local.yml
+/jyzb-boot/src/main/resources/application-local.yml

.idea/dataSources.xml

@@ -7,5 +7,12 @@
       <jdbc-driver>com.mysql.jdbc.Driver</jdbc-driver>
       <jdbc-url>jdbc:mysql://192.168.3.128:3306/db_jyzb?characterEncoding=UTF-8&amp;useUnicode=true&amp;useSSL=false&amp;tinyInt1isBit=false&amp;allowPublicKeyRetrieval=true&amp;serverTimezone=Asia/Shanghai</jdbc-url>
     </data-source>
+    <data-source source="LOCAL" name="local" uuid="134b9a70-dbff-479c-9337-8e4869b6525e">
+      <driver-ref>mysql.8</driver-ref>
+      <synchronize>true</synchronize>
+      <jdbc-driver>com.mysql.jdbc.Driver</jdbc-driver>
+      <jdbc-url>jdbc:mysql://127.0.0.1:3306/junmp?characterEncoding=UTF-8&amp;useUnicode=true&amp;useSSL=false&amp;tinyInt1isBit=false&amp;allowPublicKeyRetrieval=true&amp;serverTimezone=Asia/Shanghai</jdbc-url>
+      <working-dir>$ProjectFileDir$</working-dir>
+    </data-source>
   </component>
 </project>
\ No newline at end of file

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/dto/BusFormDto.java

@@ -27,7 +27,7 @@ public class BusFormDto  {
     /**
      * 单据编号
      */
-    private String orderCode;
+    private String bussinessCode;
 
     /**
      * 组织机构id

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/dto/OrderMainDto.java

@@ -22,6 +22,7 @@ public class OrderMainDto implements Serializable {
 
     //订单编号
     private String orderCode;
+    private String bussinessCode;
 
     //发物单位
     private Long startOrgId;

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/OrderDetailReq.java

@@ -48,6 +48,8 @@ public class OrderDetailReq extends BaseRequest {
 
     private String updateUser;
 
+    private String warehouseId;
+
     /**
      * 修改后数量
      */

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/OrderMainReq.java

@@ -24,6 +24,7 @@ public class OrderMainReq extends BaseRequest {
     private String bussinessType;
 
     private String orderCode;
+    private String bussinessCode;
 
     private Long startOrgId;
 

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/OrderUploadReq.java

@@ -10,7 +10,7 @@ import java.math.BigDecimal;
 import java.util.List;
 
 /**
- *
+ *单据状态上报请求实体类
  */
 @Data
 @EqualsAndHashCode(callSuper = true)

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/PoliceReassignmentReq.java

@@ -21,4 +21,8 @@ public class PoliceReassignmentReq {
     //需要带走的装备信息列表
     private List<FormEqsReq> eqsReqList;
 
+    //调岗原因
+    private String note;
+    //工作流id
+
 }

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/QueryBusFormReq.java

@@ -31,7 +31,7 @@ public class QueryBusFormReq extends BaseRequest {
     /**
      * 单据编号
      */
-    private String orderCode;
+    private String bussinessCode;
 
     /**
      * 组织机构id

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/BaseOrderItemReq.java

@@ -9,6 +9,9 @@ import lombok.EqualsAndHashCode;
 import java.math.BigDecimal;
 import java.util.Date;
 
+/**
+ * 个人装备移交、报废、维修的子单据请求实体类
+ */
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class BaseOrderItemReq extends BaseRequest {

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/BaseOrderReq.java

@@ -11,6 +11,9 @@ import java.math.BigDecimal;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * 个人装备移交、报废、维修请求实体类
+ */
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class BaseOrderReq extends BaseRequest {

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/BatchEditingInvsReq.java

@@ -7,6 +7,9 @@ import java.math.BigDecimal;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * 装备批量信息修改的请求实体类
+ */
 @Data
 public class BatchEditingInvsReq {
     /**

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/DetailListReq.java

@@ -5,6 +5,9 @@ import lombok.Data;
 import java.io.Serializable;
 import java.math.BigDecimal;
 
+/**
+ * 记账时的子单据请求实体类
+ */
 @Data
 public class DetailListReq implements Serializable {
     /**

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/EquipmentBindReq.java

@@ -9,6 +9,9 @@ import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.NotNull;
 import java.util.List;
 
+/**
+ * 装备绑定箱门请求实体类
+ */
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class EquipmentBindReq extends BaseRequest {

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/ManufacturerReq.java

@@ -7,6 +7,9 @@ import javax.validation.constraints.NotBlank;
 import java.util.Date;
 import java.util.List;
 
+/**
+ * 生产厂商请求实体类
+ */
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class ManufacturerReq extends BaseRequest {

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/UpdateBusFormReq.java

@@ -18,10 +18,11 @@ public class UpdateBusFormReq extends BaseRequest {
     @NotBlank(message = "单据id不能为空",groups = {edit.class})
     private String id;
 
+    private String userId;
     /**
      * 工作流id
      */
-    private String processId;
+    private String processDefinitionId;
 
     /**
      * 单据业务类型
@@ -32,7 +33,7 @@ public class UpdateBusFormReq extends BaseRequest {
     /**
      * 单据编号
      */
-    private String orderCode;
+    private String bussinessCode;
 
     /**
      * 组织机构id

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/UpdateOrderReq.java

@@ -31,7 +31,6 @@ public class UpdateOrderReq extends BaseRequest implements Serializable {
     private String  processDefinitionId;
 
 
-
     /**
      * 单据业务类型
      */
@@ -41,6 +40,8 @@ public class UpdateOrderReq extends BaseRequest implements Serializable {
      * 订单号
      */
     private String  orderCode;
+
+    private String bussinessCode;
     /**
      * 发物单位
      */

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/UpdateStocktakeReq.java

@@ -15,10 +15,11 @@ public class UpdateStocktakeReq extends BaseRequest {
     @NotBlank(message = "id不能为空",groups = {edit.class})
     private String id;
 
+    private String userId;
     /**
      * 工作流
      */
-    private String processId;
+    private String processDefinitionId;
 
     /**
      * 单据业务类型：盘库stocktake

jyzb-biz/src/main/java/com/junmp/jyzb/controller/BussinessController.java

@@ -35,7 +35,7 @@ public class BussinessController {
     @ApiOperation("创建业务单")
     public ApiRes<String> AddBussinessOrder(@RequestBody @Validated(ValidationApi.add.class) UpdateBusFormReq req){
         //判断是否有工作流id，如果有则将状态进行修改
-        if (ObjectUtil.isEmpty(req.getProcessId()))
+        if (ObjectUtil.isEmpty(req.getProcessDefinitionId()))
         {
             req.setExamineState("none");
         }

jyzb-biz/src/main/java/com/junmp/jyzb/controller/PoliceController.java

@@ -126,9 +126,14 @@ public class PoliceController {
     }
 
 
+    @PostMapping("/PoliceReassignment")
+    @ApiOperation("警员调岗申请单")
+    public ApiRes<String> PoliceReassignment(){
+        return ApiRes.success(policemanService.PoliceReassignment());
+    }
 
     @PostMapping("/ChangePoliceOrg")
-    @ApiOperation("警员调岗")
+    @ApiOperation("警员调岗（业务过程）")
     public ApiRes<Boolean> changePoliceOrg(@RequestBody @Validated(ValidationApi.edit.class)PoliceReassignmentReq req){
         return ApiRes.success(policemanService.changePoliceOrg(req));
     }

jyzb-biz/src/main/java/com/junmp/jyzb/controller/StocktakeController.java

 package com.junmp.jyzb.controller;
 
 import cn.hutool.core.util.ObjectUtil;
-import com.junmp.jyzb.api.bean.dto.StocktakeDto;
 import com.junmp.jyzb.api.bean.query.StocktakeReq;
-import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
 import com.junmp.jyzb.api.bean.req.UpdateStocktakeReq;
-import com.junmp.jyzb.entity.OrderNum;
 import com.junmp.jyzb.entity.Stocktake;
 import com.junmp.jyzb.service.StocktakeService;
 import com.junmp.v2.common.bean.request.ValidationApi;
@@ -24,7 +21,7 @@ import javax.annotation.Resource;
 
 @RestController
 @Slf4j
-@Api("盘库管理")
+@Api(tags ="盘库管理")
 @RequestMapping("/Stocktake")
 public class StocktakeController {
 
@@ -36,7 +33,7 @@ public class StocktakeController {
     @ApiOperation("盘库申请")
     public ApiRes<String> AddStocktakeOrder (@RequestBody @Validated(ValidationApi.add.class) UpdateStocktakeReq req){
         //判断是否有工作流id，如果有则将状态进行修改
-        if (ObjectUtil.isEmpty(req.getProcessId()))
+        if (ObjectUtil.isEmpty(req.getProcessDefinitionId()))
         {
             req.setExamineState("none");
         }
@@ -56,7 +53,7 @@ public class StocktakeController {
 
     //修改单据
     @PostMapping("/UpdateStocktakeOrder")
-    @ApiOperation("修改任务单")
+    @ApiOperation("修改盘库业务单")
     public ApiRes<Boolean> UpdateStocktakeOrder(@RequestBody @Validated(ValidationApi.edit.class) UpdateStocktakeReq req) {
         return ApiRes.success(stocktakeService.UpdateStocktakeOrder(req));
     }

jyzb-biz/src/main/java/com/junmp/jyzb/entity/BusForm.java

@@ -35,8 +35,8 @@ public class BusForm implements Serializable {
     /**
      * 单据编号
      */
-    @TableField(value = "order_code")
-    private String orderCode;
+    @TableField(value = "bussiness_code")
+    private String bussinessCode;
 
     /**
      * 组织机构id

jyzb-biz/src/main/java/com/junmp/jyzb/entity/OrderMain.java

@@ -29,6 +29,9 @@ public class OrderMain implements Serializable {
     @TableField("order_code")
     private String orderCode;
 
+    @TableField("bussiness_code")
+    private String bussinessCode;
+
     @TableField("start_org_id")
     private Long startOrgId;
 

jyzb-biz/src/main/java/com/junmp/jyzb/entity/Reassignment.java

+package com.junmp.jyzb.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.io.Serializable;
+import java.util.Date;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 警员调岗申请单
+ * @TableName bussiness_reassignment
+ */
+@TableName(value ="bussiness_reassignment")
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+public class Reassignment implements Serializable {
+    /**
+     * id
+     */
+
+    private String id;
+
+    /**
+     * 工作流id
+     */
+    @TableField(value = "process_id")
+    private String processId;
+
+    /**
+     * 调岗警员id
+     */
+    @TableField(value = "police_id")
+    private String policeId;
+
+    /**
+     * 调岗警员姓名
+     */
+    @TableField(value = "police_name")
+    private String policeName;
+
+    /**
+     * 警员带走装备
+     */
+    @TableField(value = "eqs_list")
+    private String eqsList;
+
+    /**
+     * 组织机构id（谁申请，就是谁的组织机构号）
+     */
+    @TableField(value = "org_id")
+    private Long orgId;
+
+    /**
+     * 目标组织机构id
+     */
+    @TableField(value = "target_org_id")
+    private Long targetOrgId;
+
+    /**
+     * 调岗原因
+     */
+    @TableField(value = "note")
+    private String note;
+
+    /**
+     * 审核状态(none未接入工作流，working审批中，finished审批完成)
+     */
+    @TableField(value = "examine_state")
+    private String examineState;
+
+    /**
+     * 创建时间
+     */
+    @TableField(value = "create_time")
+    private Date createTime;
+
+    /**
+     * 更新时间
+     */
+    @TableField(value = "update_time")
+    private Date updateTime;
+
+    /**
+     * 创建人员
+     */
+    @TableField(value = "create_user")
+    private String createUser;
+
+    /**
+     * 更新人员
+     */
+    @TableField(value = "update_user")
+    private String updateUser;
+
+    private static final long serialVersionUID = 1L;
+
+}
\ No newline at end of file

jyzb-biz/src/main/java/com/junmp/jyzb/entity/Stocktake.java

@@ -75,10 +75,22 @@ public class Stocktake implements Serializable {
     private String shelfId;
 
     /**
-     * 货架位置（类型为1时特有）
+     * 排
      */
-    @TableField(value = "shelf_location")
-    private String shelfLocation;
+    @TableField(value = "shelf_ranges")
+    private Integer shelfRanges;
+
+    /**
+     * 列
+     */
+    @TableField(value = "shelf_columns")
+    private Integer shelfColumns;
+
+    /**
+     * 行
+     */
+    @TableField(value = "shelf_rows")
+    private Integer shelfRows;
 
     /**
      * 号型id（类型为2时特有）

jyzb-biz/src/main/java/com/junmp/jyzb/mapper/ReassignmentMapper.java

+package com.junmp.jyzb.mapper;
+
+import com.junmp.jyzb.entity.Reassignment;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+* @author lxh专属坐骑
+* @description 针对表【bussiness_reassignment(警员调岗申请单)】的数据库操作Mapper
+* @createDate 2023-10-07 16:49:31
+* @Entity com.junmp.jyzb.entity.Reassignment
+*/
+public interface ReassignmentMapper extends BaseMapper<Reassignment> {
+
+}
+
+
+
+

jyzb-biz/src/main/java/com/junmp/jyzb/service/PolicemanService.java

@@ -74,5 +74,9 @@ public interface PolicemanService extends IService<Policeman> {
     //获取警员的装备信息
     PageResult<PoliceEquipment> GetPoliceEqs(PolicemanReq req);
 
+    //警员调岗业务逻辑
     boolean UpdatePoliceUser();
+
+    //警员调岗申请单
+    String PoliceReassignment();
 }

jyzb-biz/src/main/java/com/junmp/jyzb/service/ReassignmentService.java

+package com.junmp.jyzb.service;
+
+import com.junmp.jyzb.entity.Reassignment;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+* @author lxh专属坐骑
+* @description 针对表【bussiness_reassignment(警员调岗申请单)】的数据库操作Service
+* @createDate 2023-10-07 16:49:31
+*/
+public interface ReassignmentService extends IService<Reassignment> {
+
+}

jyzb-biz/src/main/java/com/junmp/jyzb/service/impl/BusFormServiceImpl.java

@@ -5,6 +5,8 @@ import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.junmp.junmpProcess.dto.StartProcessInstanceDTO;
+import com.junmp.junmpProcess.service.IFlowInstanceService;
 import com.junmp.jyzb.api.bean.dto.BusFormDto;
 import com.junmp.jyzb.api.bean.query.QueryBusFormReq;
 import com.junmp.jyzb.api.bean.req.UpdateBusFormReq;
@@ -37,6 +39,9 @@ public class BusFormServiceImpl extends ServiceImpl<BusFormMapper, BusForm> impl
     @Resource
     public StocktakeService stocktakeService;
 
+    @Resource
+    private IFlowInstanceService FlowInstanceService;
+
     /**
      * 创建业务单
      * @param req
@@ -48,10 +53,21 @@ public class BusFormServiceImpl extends ServiceImpl<BusFormMapper, BusForm> impl
         BeanUtil.copyProperties(req,busForm);
         OrderNum orderNum = stocktakeService.setOrderCode(req.getBussinessType(), req.getOrgId());
         String codeValue=String.format("%04d",orderNum.getNum());
-        busForm.setOrderCode(orderNum.getBussinessType()+"-"+orderNum.getYear()+"-"+
+        busForm.setBussinessCode(orderNum.getBussinessType()+"-"+orderNum.getYear()+"-"+
                 LocalDateTime.now().getMonth().getValue()+"-"+LocalDateTime.now().getDayOfMonth()+"-"+codeValue);
         busForm.setCreateTime(DateTimeUtil.getCurrentDateTime());
         save(busForm);
+        //执行工作流
+        if (req.getExamineState().equals("working"))
+        {
+            StartProcessInstanceDTO startProcessInstanceDTO=new StartProcessInstanceDTO();
+            startProcessInstanceDTO.setProcessDefinitionId(req.getProcessDefinitionId());
+            startProcessInstanceDTO.setOrderId(busForm.getId());
+            startProcessInstanceDTO.setOrderType("workOrder");
+            startProcessInstanceDTO.setUserId(req.getUserId());
+            String ProcessInstanceId= FlowInstanceService.startProcessInstanceById(startProcessInstanceDTO);
+            busForm.setProcessId(ProcessInstanceId);
+        }
         return busForm.getId();
     }
 
@@ -87,8 +103,11 @@ public class BusFormServiceImpl extends ServiceImpl<BusFormMapper, BusForm> impl
             req.setOrder(req.getOrder().toLowerCase());
         }
         LambdaQueryWrapper<BusForm> eq = new LambdaQueryWrapper<BusForm>()
+                //单据类型
                 .eq(ObjectUtil.isNotNull(req.getBussinessType()), BusForm::getBussinessType, req.getBussinessType())
+                //审核状态
                 .eq(ObjectUtil.isNotNull(req.getExamineState()), BusForm::getExamineState, req.getExamineState())
+                //
                 .eq(ObjectUtil.isNotNull(req.getWarehouseId()), BusForm::getWarehouseId, req.getWarehouseId())
                 .eq(ObjectUtil.isNotNull(req.getOrgId()),BusForm::getOrgId,req.getOrgId())
                 .ge(ObjectUtil.isNotNull(req.getStartTime()), BusForm::getCreateTime, req.getStartTime())

jyzb-biz/src/main/java/com/junmp/jyzb/service/impl/OrderMainServiceImpl.java

@@ -83,6 +83,12 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
     @Resource
     private OfficeExcelApi officeExcelApi;
 
+    @Resource
+    private InventorySummaryService inventorySummaryService;
+
+    @Resource
+    private WarehouseService warehouseService;
+
 
     //新增任务单
     @Transactional(rollbackFor = Exception.class)
@@ -257,6 +263,7 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
             }
             orderDetailService.removeBatchByIds(req.getDeleteList());
         }
+        //方法1（分为两步进行操作）--------------------------------------------------
         //对detaillist进行处理
         List<OrderDetail> addList = new ArrayList<>();//新增的
         List<OrderDetail> updateList = new ArrayList<>();//更新
@@ -295,6 +302,7 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
         }
         orderDetailService.updateBatchById(updateList);
         orderDetailService.saveBatch(addList);
+        // 方法2（直接删除并重新插入数据）----------------------------------------------
         BeanPlusUtil.copyProperties(req,order);
         return this.updateById(order);
     }
@@ -357,7 +365,6 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
                     .last("order by "+req.getColumn() +" "+req.getOrder()));
 
         } else {
-
             list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
                     .eq(OrderDetail::getOrderId, req.getId())
                     .orderByDesc(OrderDetail::getCreateTime));
@@ -411,7 +418,6 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
         if (req.getChildrenOrder().size()==0){
             throw new ServiceException(OrderExceptionEnum.ORDERDETAIL_ISNOT_NULL);
         }
-        Set<Long> collect = req.getChildrenOrder().stream().map(OrderDetailReq::getId).collect(Collectors.toSet());
         //前端传递的子单数据
         List<OrderDetailReq> reqList = req.getChildrenOrder();
         //将记账数量进行相加
@@ -421,44 +427,83 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
         //获取子单据
         List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
                 .eq(OrderDetail::getOrderId,req.getId()));
-        Set<Long> existingIds = list.stream()
-                .map(OrderDetail::getId)
-                .collect(Collectors.toSet());
-        //创建记账操作记录并且记录到数据表order_log中
-        OrderLog orderLog = new OrderLog();
-        BeanPlusUtil.copyProperties(req,orderLog);
-        orderLog.setId(UUID.randomUUID().toString());
+        //获取所有传递的子单据id
+        Set<Long> collect = req.getChildrenOrder().stream().map(OrderDetailReq::getId).collect(Collectors.toSet());
+        //获取所有数据库的子单据id
+        Set<Long> existingIds = list.stream().map(OrderDetail::getId).collect(Collectors.toSet());
+        //创建一个操作记录
         StringBuilder stringBuilder = new StringBuilder();
         List<OrderDetail> orderDetailList=new ArrayList<>();
+        //创建一个列表用于修改summary数据库表中数据。
+        List<OrderDetailReq> orderDetailReqList=new ArrayList<>();
         //比较两个子单id完全一致,判断传递的子单据id在数据库中是否存在，如果不存在则抛出子单据不存在异常
         if (collect.size() == existingIds.size() && collect.containsAll(existingIds) && existingIds.containsAll(collect)){
             for (OrderDetailReq uploadDetailReq : reqList) {
                 OrderDetail orderDetail = new OrderDetail();
                 BeanPlusUtil.copyProperties(uploadDetailReq,orderDetail);
-                //获取修改后的数量并且记录
+                //获取修改后的数量并且记录(如果modifyQuantity不为空则表示该子单据进行了修改)
                 if (ObjectUtil.isNotNull(uploadDetailReq.getModifyQuantity())){
-                    String log = "将"+uploadDetailReq.getTypeName()+"-"+
+                    String log = "将"+uploadDetailReq.getTypeName()+"："+
                             uploadDetailReq.getSizeName()+"的物资数量从"+uploadDetailReq.getActualNum()+"修改为"+uploadDetailReq.getModifyQuantity()+";";
                     stringBuilder.append(log);
-                    //修改单子数量数据
+                    //修改单子数量数据,价格
                     orderDetail.setActualNum(uploadDetailReq.getModifyQuantity());
                     orderDetail.setUpdateTime(DateTimeUtil.getCurrentDateTime());
                     orderDetailList.add(orderDetail);
+                    orderDetailReqList.add(uploadDetailReq);
                     //修改后数量
                     updateQuantity+=uploadDetailReq.getModifyQuantity();
                     priceTotal=priceTotal.add(BigDecimal.valueOf(uploadDetailReq.getModifyQuantity()).multiply(uploadDetailReq.getPrice()));
-                    System.out.println("priceTotal = " + priceTotal);
                 }else {
                     //修改后数量
                     updateQuantity+=uploadDetailReq.getActualNum();
                     priceTotal=priceTotal.add(BigDecimal.valueOf(uploadDetailReq.getActualNum()).multiply(uploadDetailReq.getPrice()));
-                    System.out.println("priceTotal = " + priceTotal);
                 }
 
             }
         }else {
             throw new ServiceException(OrderExceptionEnum.ORDERDETAIL_ERROR);
         }
+        //批量更新子单据数量
+        if (orderDetailList.size()!=0){
+            orderDetailService.updateBatchById(orderDetailList);
+        }
+
+        //将修改内容存储记录（历史操作，数量，单据，价格，组织机构）
+        //创建记账操作记录并且记录到数据表order_log中
+        saveAccountingLog(req,stringBuilder,updateQuantity);
+
+        //修改装备汇总表中的数据 inventory_summary
+        Long orgId;
+        if (orderMain.getOrderType().equals("in")){
+            orgId=orderMain.getEndOrgId();
+        }
+        else {
+            orgId=orderMain.getStartOrgId();
+        }
+        updateSummaryInfo(req,orderDetailReqList,orgId);
+
+        //修改仓库表中的数量汇总信息(warehouse)
+        updateWarehouseInfo(req,orderDetailReqList,orgId);
+
+        //更新主单据的数量和价格
+        //记账直接将单子结束
+        //修改记账状态，0未记账，1已记账
+        orderMain.setActualQuantity(updateQuantity);
+        orderMain.setPrice(priceTotal);
+        orderMain.setOrderState("finished");
+        orderMain.setManualState(1);
+        orderMain.setUpdateTime(DateTimeUtil.getCurrentDateTime());
+        //更新主单据
+        return updateById(orderMain);
+    }
+
+    //将修改内容存储记录（历史操作，数量，单据，价格，组织机构）
+    //创建记账操作记录并且记录到数据表order_log中
+    public void saveAccountingLog (OrderMainReq req,StringBuilder stringBuilder,Integer updateQuantity){
+        OrderLog orderLog = new OrderLog();
+        BeanPlusUtil.copyProperties(req,orderLog);
+        orderLog.setId(UUID.randomUUID().toString());
         orderLog.setHistoryMsg(stringBuilder.toString());
         orderLog.setUpdateQuantity(updateQuantity);
         if (req.getOrderType().equals("in")){
@@ -472,22 +517,59 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
         orderLog.setCreateTime(DateTimeUtil.getCurrentDateTime());
         //将记账记录保存
         orderLogService.save(orderLog);
-        //批量更新子单据数量
-        if (orderDetailList.size()!=0){
-            orderDetailService.updateBatchById(orderDetailList);
-        }
-        //更新主单据的数量和价格
-        orderMain.setActualQuantity(updateQuantity);
-        orderMain.setPrice(priceTotal);
-        //记账直接将单子结束
-        orderMain.setOrderState("finished");
-        //修改记账状态，0未记账，1已记账
-        orderMain.setManualState(1);
-        orderMain.setUpdateTime(DateTimeUtil.getCurrentDateTime());
-        //更新主单据
-        return updateById(orderMain);
     }
 
+    //修改装备汇总表中的数据inventory_summary
+    public void updateSummaryInfo(OrderMainReq req,List<OrderDetailReq> orderDetailReqList,Long orgId){
+        //根据遍历该子单据，将summary中的对应数据进行修改
+        List<InventorySummary> collect = orderDetailReqList.stream()
+                .map(orderDetailReq -> {
+                    InventorySummary one = inventorySummaryService.getOne(new LambdaQueryWrapper<InventorySummary>()
+                            .eq(InventorySummary::getOrgId, orgId)
+                            .eq(InventorySummary::getSizeId, orderDetailReq.getSizeId())
+                            .eq(InventorySummary::getTypeId, orderDetailReq.getTypeId())
+                            .eq(InventorySummary::getLocationId, orderDetailReq.getWarehouseId())
+                            .eq(InventorySummary::getPrice, orderDetailReq.getPrice()));
+                    //更新数量和总价格，在库数和出库数也需要对应进行修改
+                    //修改的数量和价格
+                    BigDecimal totalPrice = one.getPrice().subtract(BigDecimal.valueOf(orderDetailReq.getActualNum()).multiply(orderDetailReq.getPrice()))
+                            .add(BigDecimal.valueOf(orderDetailReq.getModifyQuantity()).multiply(orderDetailReq.getPrice()));
+                    Integer totalNUmber = one.getNumber()-orderDetailReq.getActualNum()+orderDetailReq.getModifyQuantity();
+                    one.setPrice(totalPrice);
+                    one.setNumber(totalNUmber);
+                    //判断单据是in还是out，对出库数量和在库数量进行修改
+                    if (req.getOrderType().equals("in")){
+                        one.setStockNumber(one.getStockNumber()-orderDetailReq.getActualNum()+orderDetailReq.getModifyQuantity());
+                    }else {
+                        one.setOutboundNumber(one.getOutboundNumber()-orderDetailReq.getActualNum()+orderDetailReq.getModifyQuantity());
+                    }
+                    return one;
+                })
+                .collect(Collectors.toList());
+        inventorySummaryService.updateBatchById(collect);
+    }
+
+    //修改仓库表中的数量汇总信息
+    public void updateWarehouseInfo(OrderMainReq req,List<OrderDetailReq> orderDetailReqList,Long orgId){
+        for (OrderDetailReq orderDetailReq:orderDetailReqList) {
+            Warehouse one = warehouseService.getOne(new LambdaQueryWrapper<Warehouse>()
+                    .eq(Warehouse::getOrgId, orgId)
+                    .eq(Warehouse::getId, orderDetailReq.getWarehouseId()));
+            //修改总数量和总价格，并且判断单据类型来修改出库数量或者在库数量
+            Integer totalNUmber = one.getSum()-orderDetailReq.getActualNum()+orderDetailReq.getModifyQuantity();
+            BigDecimal totalPrice = one.getPriceTotal().subtract(BigDecimal.valueOf(orderDetailReq.getActualNum()).multiply(orderDetailReq.getPrice()))
+                    .add(BigDecimal.valueOf(orderDetailReq.getModifyQuantity()).multiply(orderDetailReq.getPrice()));
+            one.setPriceTotal(totalPrice);
+            one.setSum(totalNUmber);
+            //判断单据是in还是out，对出库数量和在库数量进行修改
+            if (req.getOrderType().equals("in")){
+                one.setInSum(one.getInSum()-orderDetailReq.getActualNum()+orderDetailReq.getModifyQuantity());
+            }else {
+                one.setOutSum(one.getOutSum()-orderDetailReq.getActualNum()+orderDetailReq.getModifyQuantity());
+            }
+            warehouseService.updateById(one);
+        }
+    }
     /**
      * 查看记账列表
      * @param req

jyzb-biz/src/main/java/com/junmp/jyzb/service/impl/PolicemanServiceImpl.java

@@ -611,4 +611,9 @@ public class PolicemanServiceImpl extends ServiceImpl<PolicemanMapper, Policeman
         return updateBatchById(policemanList);
     }
 
+    @Override
+    public String PoliceReassignment() {
+        return null;
+    }
+
 }

jyzb-biz/src/main/java/com/junmp/jyzb/service/impl/ReassignmentServiceImpl.java

+package com.junmp.jyzb.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.junmp.jyzb.entity.Reassignment;
+import com.junmp.jyzb.service.ReassignmentService;
+import com.junmp.jyzb.mapper.ReassignmentMapper;
+import org.springframework.stereotype.Service;
+
+/**
+* @author lxh专属坐骑
+* @description 针对表【bussiness_reassignment(警员调岗申请单)】的数据库操作Service实现
+* @createDate 2023-10-07 16:49:31
+*/
+@Service
+public class ReassignmentServiceImpl extends ServiceImpl<ReassignmentMapper, Reassignment>
+    implements ReassignmentService{
+
+}
+
+
+
+

jyzb-biz/src/main/java/com/junmp/jyzb/service/impl/StocktakeServiceImpl.java

@@ -4,6 +4,8 @@ import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.junmp.junmpProcess.dto.StartProcessInstanceDTO;
+import com.junmp.junmpProcess.service.IFlowInstanceService;
 import com.junmp.jyzb.api.bean.dto.StocktakeDto;
 import com.junmp.jyzb.api.bean.query.StocktakeReq;
 import com.junmp.jyzb.api.bean.req.UpdateStocktakeReq;
@@ -43,6 +45,9 @@ public class StocktakeServiceImpl extends ServiceImpl<StocktakeMapper, Stocktake
     @Resource
     private OrderNumService orderNumService;
 
+    @Resource
+    private IFlowInstanceService FlowInstanceService;
+
     //盘库申请
     @Override
     @Transactional(rollbackFor = Exception.class)
@@ -54,25 +59,20 @@ public class StocktakeServiceImpl extends ServiceImpl<StocktakeMapper, Stocktake
         String codeValue=String.format("%04d",orderNum.getNum());
         stocktake.setOrderCode(orderNum.getBussinessType()+"-"+orderNum.getYear()+"-"+
                 LocalDateTime.now().getMonth().getValue()+"-"+LocalDateTime.now().getDayOfMonth()+"-"+codeValue);
-        //如果盘库类型为1：根据货架进行盘点，判断参数排列行是否进行传递，如果传递则需要进行一个参数拼接
-        String shelfLocation="";
-        if (ObjectUtil.isNotNull(req.getShelfRanges()) && !req.getShelfRanges().toString().trim().isEmpty()) {
-            shelfLocation += req.getShelfRanges()+"/";
-            stocktake.setShelfLocation(shelfLocation);
-        }
-
-        if (ObjectUtil.isNotNull(req.getShelfColumns()) && !req.getShelfColumns().toString().trim().isEmpty()) {
-            shelfLocation += req.getShelfColumns()+"/";
-            stocktake.setShelfLocation(shelfLocation);
-        }
-
-        if (ObjectUtil.isNotNull(req.getShelfRows())  && !req.getShelfRows().toString().trim().isEmpty()) {
-            shelfLocation += req.getShelfRows();
-            stocktake.setShelfLocation(shelfLocation);
-        }
         stocktake.setCreateTime(DateTimeUtil.getCurrentDateTime());
         stocktake.setApplyTime(DateTimeUtil.getCurrentDateTime());
         this.save(stocktake);
+        //执行工作流
+        if (req.getExamineState().equals("working"))
+        {
+            StartProcessInstanceDTO startProcessInstanceDTO=new StartProcessInstanceDTO();
+            startProcessInstanceDTO.setProcessDefinitionId(req.getProcessDefinitionId());
+            startProcessInstanceDTO.setOrderId(stocktake.getId());
+            startProcessInstanceDTO.setOrderType("workOrder");
+            startProcessInstanceDTO.setUserId(req.getUserId());
+            String ProcessInstanceId= FlowInstanceService.startProcessInstanceById(startProcessInstanceDTO);
+            stocktake.setProcessId(ProcessInstanceId);
+        }
         return stocktake.getId();
     }
 
@@ -120,7 +120,6 @@ public class StocktakeServiceImpl extends ServiceImpl<StocktakeMapper, Stocktake
     public OrderNum setOrderCode(String bussinessType,Long orgId){
         //设置采购单号，需要先判断该组织机构的采购单号是否存在，如果存在则将数量进行增加，如果不存在则新增一条对应的数据
         OrderNum orderNum = new OrderNum();
-        //获取年,月，日，获取组织机构id，获取业务类型
         orderNum.setYear(LocalDateTime.now().getYear());
         orderNum.setBussinessType(bussinessType);
         orderNum.setOrgId(orgId);

jyzb-biz/src/main/java/com/junmp/jyzb/task/UpdateSummaryAction.java

@@ -12,7 +12,7 @@ public class UpdateSummaryAction implements JobAction {
     @Resource
     private InventoryService inventoryService;
     public void action(){
-        inventoryService.setInventoryMsg();
+//        inventoryService.setInventoryMsg();
     }
 
 }

jyzb-biz/src/main/resources/mapper/ReassignmentMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.junmp.jyzb.mapper.ReassignmentMapper">
+
+    <resultMap id="BaseResultMap" type="com.junmp.jyzb.entity.Reassignment">
+            <id property="id" column="id" jdbcType="VARCHAR"/>
+            <result property="processId" column="process_id" jdbcType="VARCHAR"/>
+            <result property="policeId" column="police_id" jdbcType="VARCHAR"/>
+            <result property="policeName" column="police_name" jdbcType="VARCHAR"/>
+            <result property="eqsList" column="eqs_list" jdbcType="VARCHAR"/>
+            <result property="orgId" column="org_id" jdbcType="BIGINT"/>
+            <result property="targetOrgId" column="target_org_id" jdbcType="BIGINT"/>
+            <result property="note" column="note" jdbcType="VARCHAR"/>
+            <result property="examineState" column="examine_state" jdbcType="VARCHAR"/>
+            <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
+            <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
+            <result property="createUser" column="create_user" jdbcType="VARCHAR"/>
+            <result property="updateUser" column="update_user" jdbcType="VARCHAR"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,process_id,police_id,
+        police_name,eqs_list,org_id,
+        target_org_id,note,examine_state,
+        create_time,update_time,create_user,
+        update_user
+    </sql>
+</mapper>

jyzb-boot/src/main/resources/application-local.yml

@@ -26,9 +26,9 @@ knife4j:
 spring:
   datasource:
     driver-class-name: com.mysql.cj.jdbc.Driver
-    url: jdbc:mysql://192.168.3.128:3306/db_jyzb?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&serverTimezone=CTT&nullCatalogMeansCurrent=true
-    username: junmp
-    password: 123456
+    url: jdbc:mysql://127.0.0.1:3306/junmp?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&serverTimezone=CTT&nullCatalogMeansCurrent=true
+    username: root
+    password: vkeline
 
   redis:
     #host: 192.168.3.188

jyzb-process/src/main/java/com/junmp/junmpProcess/service/Bussiness/impl/WorkProcessServiceImpl.java

@@ -285,6 +285,7 @@ public class WorkProcessServiceImpl extends ServiceImpl<ProcessTemplatesMapper,
     @Override
     public Boolean suspendOrActivateProcessDefinitionById(SuspendOrActivateDefinitionReq req) {
         ProcessTemplates processTemplates = processTemplateService.getById(req.getFormId());
+        ProcessTemplates processTemplates = processTemplateService.getById(req.getProcessDefinitionId());
         if (req.getIsStop() == true){
             repositoryService.suspendProcessDefinitionById(req.getProcessDefinitionId(), true, null);
             processTemplates.setIsStop(true);

jyzb-process/src/main/java/com/junmp/junmpProcess/service/Bussiness/impl/WorkProcessServiceImpl.java.orig

+package com.junmp.junmpProcess.service.Bussiness.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.PageUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.Lists;
+import com.junmp.junmpProcess.cmd.DeleteFlowableProcessInstanceCmd;
+import com.junmp.junmpProcess.common.utils.HttpStatus;
+import com.junmp.junmpProcess.common.utils.ResponseResult;
+import com.junmp.junmpProcess.common.utils.ReturnMsg;
+import com.junmp.junmpProcess.dto.*;
+import com.junmp.junmpProcess.dto.json.*;
+import com.junmp.junmpProcess.entity.ProcessTemplates;
+import com.junmp.junmpProcess.exception.WorkFlowException;
+import com.junmp.junmpProcess.mapper.OrgUserMapper;
+import com.junmp.junmpProcess.mapper.ProcessTemplatesMapper;
+import com.junmp.junmpProcess.mapper.TemplateGroupMapper;
+import com.junmp.junmpProcess.service.Bussiness.WorkProcessService;
+import com.junmp.junmpProcess.service.Repository.ProcessTemplateService;
+import com.junmp.junmpProcess.utils.IdWorker;
+import com.junmp.junmpProcess.utils.SpringContextHolder;
+import com.junmp.junmpProcess.vo.*;
+import com.junmp.jyzb.api.bean.query.ProcessReq.FormReq;
+import com.junmp.jyzb.api.bean.query.ProcessReq.SuspendOrActivateDefinitionReq;
+
+import com.junmp.v2.auth.api.LoginUserApi;
+import com.junmp.v2.auth.api.bean.login.LoginUser;
+import com.junmp.v2.auth.api.context.LoginContext;
+import com.junmp.v2.common.bean.request.BaseRequest;
+import com.junmp.v2.common.bean.response.ApiRes;
+import com.junmp.v2.common.util.BeanPlusUtil;
+import com.junmp.v2.db.api.factory.PageFactory;
+import com.junmp.v2.db.api.factory.PageResultFactory;
+import com.junmp.v2.db.api.page.PageResult;
+import com.junmp.v2.sys.user.entity.SysUser;
+import com.junmp.v2.sys.user.service.SysUserService;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.DateFormatUtils;
+import org.flowable.bpmn.BpmnAutoLayout;
+import org.flowable.bpmn.model.*;
+import org.flowable.bpmn.model.Process;
+import org.flowable.common.engine.impl.identity.Authentication;
+import org.flowable.engine.*;
+import org.flowable.engine.delegate.ExecutionListener;
+import org.flowable.engine.history.HistoricActivityInstance;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.history.HistoricProcessInstanceQuery;
+import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
+import org.flowable.engine.repository.Deployment;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.flowable.engine.runtime.ActivityInstance;
+import org.flowable.engine.runtime.Execution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.engine.runtime.ProcessInstanceBuilder;
+import org.flowable.engine.task.Attachment;
+import org.flowable.engine.task.Comment;
+import org.flowable.task.api.DelegationState;
+import org.flowable.task.api.Task;
+import org.flowable.task.api.history.HistoricTaskInstance;
+import com.junmp.junmpProcess.common.Result;
+import com.junmp.junmpProcess.common.WorkFlowConstants;
+import com.junmp.junmpProcess.dto.json.flowJson.FlowChildNode;
+import com.junmp.junmpProcess.dto.json.flowJson.Inout;
+import org.flowable.task.service.impl.persistence.entity.TaskEntity;
+import org.flowable.task.service.impl.persistence.entity.TaskEntityImpl;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.junmp.junmpProcess.common.CommonConstants.*;
+import static com.junmp.junmpProcess.common.WorkFlowConstants.PROCESS_PREFIX;
+import static com.junmp.junmpProcess.utils.BpmnConvert.toBpmn;
+import static com.junmp.junmpProcess.utils.BpmnModelUtils.*;
+
+
+@Service
+public class WorkProcessServiceImpl extends ServiceImpl<ProcessTemplatesMapper, ProcessTemplates> implements WorkProcessService {
+
+
+    @Autowired
+    private ProcessTemplateService processTemplateService;
+    @Resource
+    private RepositoryService repositoryService;
+    @Autowired
+    protected ManagementService managementService;
+    @Resource
+    private OrgUserMapper orgUserMapper;
+    @Resource
+    private SysUserService sysUserService;
+    @Resource
+    private RuntimeService runtimeService;
+    @Resource
+    private HistoryService historyService;
+    @Resource
+    private TaskService taskService;
+    @Resource
+    private IdWorker idWorker;
+
+
+    /**
+     * 创建子任务
+     *
+     * @param ptask    创建子任务
+     * @param assignee 子任务的执行人
+     * @return
+     */
+    protected  TaskEntity createSubTask(TaskEntity ptask, String ptaskId, String assignee) {
+        TaskEntity task = null;
+        if (ptask != null) {
+            //1.生成子任务
+            task = (TaskEntity) taskService.newTask(UUID.randomUUID().toString());
+            task.setCategory(ptask.getCategory());
+            task.setDescription(ptask.getDescription());
+            task.setTenantId(ptask.getTenantId());
+            task.setAssignee(assignee);
+            task.setName(ptask.getName());
+            task.setParentTaskId(ptaskId);
+            task.setProcessDefinitionId(ptask.getProcessDefinitionId());
+            task.setProcessInstanceId(ptask.getProcessInstanceId());
+            task.setTaskDefinitionKey(ptask.getTaskDefinitionKey());
+            task.setTaskDefinitionId(ptask.getTaskDefinitionId());
+            task.setPriority(ptask.getPriority());
+            task.setCreateTime(new Date());
+            taskService.saveTask(task);
+        }
+        return task;
+    }
+    public  Boolean turn(TurnVo turns)
+    {
+
+
+        TaskEntityImpl currTask = (TaskEntityImpl) taskService.createTaskQuery().taskId(turns.getTaskId()).singleResult();
+        if (currTask != null) {
+            //1.生成历史记录
+            TaskEntity task =this.createSubTask(currTask,currTask.getId(),turns.getUserId());
+            //2.添加审批意见
+//          this.addComment(task.getId(), turnTaskVo.getUserCode(), turnTaskVo.getProcessInstanceId(), CommentTypeEnum.ZB.toString(), turnTaskVo.getMessage());
+            taskService.saveTask(task);
+            taskService.complete(task.getId());
+            //3.转办
+            taskService.setAssignee(turns.getTaskId(), turns.getUserId());
+            String[] assigneeList=turns.getAssigneeList();
+            for (String owner :assigneeList
+                 ) {
+                taskService.setOwner(turns.getTaskId(), owner);
+            }
+
+            return  true;
+        } else {
+            return  false;
+
+        }
+    }
+    public PageResult<TemplateGroupVo> getFormList(BaseRequest br)
+    {
+        LambdaQueryWrapper<ProcessTemplates> wrapper = new LambdaQueryWrapper<ProcessTemplates>();
+        wrapper.orderByDesc(ProcessTemplates::getUpdated);
+        TemplateGroupMapper templateGroupMapper = SpringContextHolder.getBean(TemplateGroupMapper.class);
+        Page<ProcessTemplates> allformAndGroups =this.page(PageFactory.getDefaultPage(),wrapper);
+//        templateGroupMapper.getAllFormAndGroups();
+        Map<Integer, List<ProcessTemplates>> coverMap = new LinkedHashMap<>();
+        allformAndGroups.getRecords().forEach(fg -> {
+            List<ProcessTemplates> bos = coverMap.get(fg.getGroupId());
+            if (CollectionUtil.isEmpty(bos)) {
+                List<ProcessTemplates> list = new ArrayList<>();
+                list.add(fg);
+                coverMap.put(fg.getGroupId(), list);
+            } else {
+                bos.add(fg);
+            }
+        });
+        PageResult<TemplateGroupVo> pageResult=new  PageResult<TemplateGroupVo>();
+
+        coverMap.forEach((key, val) -> {
+            List<TemplateGroupVo> templates = new ArrayList<>();
+            val.forEach(v -> {
+                if (ObjectUtil.isNotNull(v.getTemplateId())) {
+                    String defId="";
+                    ProcessDefinition ProDef=repositoryService.createProcessDefinitionQuery()
+                            .processDefinitionKey("Process_"+v.getTemplateId())
+                            .latestVersion()
+                            .singleResult();
+                    if(ProDef!=null)
+                    {
+                        defId=ProDef.getId();
+                    }
+                    templates.add(TemplateGroupVo.builder()
+                            .formId(v.getTemplateId())
+                            .remark(v.getRemark())
+                            .formName(v.getFormName())
+                            .isStop(v.getIsStop())
+                            .updated(DateFormatUtils.format(v.getUpdated(),"yyyy年MM月dd日 HH时:mm分:ss秒"))
+                            .templateId(v.getTemplateId())
+                            .processDefinitionId(defId)
+                            .build());
+                }
+            });
+            pageResult.setRecords( templates);
+        });
+        pageResult.setPageSize(allformAndGroups.getSize());
+        pageResult.setTotalRows( allformAndGroups.getTotal());
+        pageResult.setPageNo(allformAndGroups.getPages());
+        pageResult.setTotalPage(PageUtil.totalPage(Convert.toInt(pageResult.getTotalRows()), Convert.toInt(pageResult.getPageSize())));
+        return  pageResult;
+    }
+
+
+
+        public List<EndEvent> findEndFlowElement(String processDefId) {
+            BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefId);
+            if (bpmnModel != null) {
+                Process process = bpmnModel.getMainProcess();
+                return process.findFlowElementsOfType(EndEvent.class);
+            } else {
+                return null;
+            }
+        }
+    //    /**
+    //    * @Author: Zhaojw
+    //    * @Description: 终止流程实例
+    //    * @DateTime: 2023/7/24 15:17
+    //    * @Params:
+    //    * @Return
+    //    */
+    public ApiRes<Boolean> stopProcessInstanceById(HandleDataDTO handleDataDTO)
+    {
+
+        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(handleDataDTO.getProcessInstanceId()).singleResult();
+        if (processInstance != null) {
+            //2、执行终止
+            List<Execution> executions = runtimeService.createExecutionQuery().parentId(handleDataDTO.getProcessInstanceId()).list();
+            List<String> executionIds = new ArrayList<>();
+            List<EndEvent> endNodes = this.findEndFlowElement(processInstance.getProcessDefinitionId());
+            String endId = endNodes.get(0).getId();
+
+            executions.forEach(execution -> executionIds.add(execution.getId()));
+            runtimeService.createChangeActivityStateBuilder()
+                    .moveExecutionsToSingleActivityId(executionIds, endId)
+                    .changeState();
+
+            return  ApiRes.success(true);
+        }else {
+            return  ApiRes.failure("不存在运行的流程实例,请确认!");
+        }
+
+    }
+    /**
+    * @Author: Zhaojw
+    * @Description: 创建新表单
+    * @DateTime: 2023/7/24 11:50
+    * @Params:
+    * @Return
+    */
+    public Boolean createNewForm(FormReq req)  {
+
+        ProcessTemplates processTemplates = ProcessTemplates.builder().build();
+        String templateId = idWorker.nextId()+"";
+        processTemplates.setTemplateId(templateId);
+        processTemplates.setFormName(req.getFormName());
+        processTemplates.setRemark(req.getRemark());
+        processTemplates.setIsStop(true);
+        Date date= new Date();
+
+        processTemplates.setUpdated(date);
+        processTemplateService.save(processTemplates);
+        return true;
+    }
+
+
+    @Override
+    public Boolean suspendOrActivateProcessDefinitionById(SuspendOrActivateDefinitionReq req) {
+<<<<<<< HEAD
+        ProcessTemplates processTemplates = processTemplateService.getById(req.getFormId());
+=======
+//        ProcessTemplates processTemplates = processTemplateService.getById(req.getTemplateId());
+        ProcessTemplates processTemplates = processTemplateService.getById(req.getProcessDefinitionId());
+>>>>>>> e81b1ed8a1eb0658c7920604e063a9d64b1edd64
+        if (req.getIsStop() == true){
+            repositoryService.suspendProcessDefinitionById(req.getProcessDefinitionId(), true, null);
+            processTemplates.setIsStop(true);
+        }else {
+            processTemplates.setIsStop(false);
+            repositoryService.activateProcessDefinitionById(req.getProcessDefinitionId(), true, null);
+
+        }
+        processTemplates.setUpdated(new Date());
+       return   processTemplateService.updateById(processTemplates);//更新表单明细表信息
+
+    }
+
+    public Boolean createBpmn(ProcessVO processVO) throws JsonProcessingException {
+        //流程定义
+        ObjectMapper objectMapper = new ObjectMapper();
+        JsonNode processJsonNode = objectMapper.readTree(processVO.getProcessJson());
+        JsonNode formJsonNode = objectMapper.readTree(processVO.getFormJson());
+        String formName=processVO.getFormName().toString();
+        ProcessTemplates processTemplates = ProcessTemplates.builder().build();
+        String templateId = idWorker.nextId()+"";
+        processTemplates.setTemplateId(templateId);
+
+        processTemplates.setFormJson(formJsonNode.toString());
+        processTemplates.setProcessJson(processJsonNode.toString());
+        processTemplates.setFormName(processVO.getFormName());
+        processTemplates.setIsStop(false);
+        Date date= new Date();
+
+        processTemplates.setUpdated(date);
+        processTemplateService.save(processTemplates);
+        //将json转换为bpmn
+
+        BpmnModel bpmnModel = toBpmn(processJsonNode,formJsonNode,formName,templateId);
+        Deployment deploy = repositoryService.createDeployment()
+                .addBpmnModel(formName+".bpmn20.xml", bpmnModel)
+                .name(formName)
+                .category(templateId)
+                .deploy();
+
+        return true;
+
+    }
+
+
+    /**
+    * @Author: Zhaojw
+    * @Description: 删除流程实例
+    * @DateTime: 2023/7/22 10:16
+    * @Params:
+    * @Return
+    */
+    public  Boolean deleteProcessInstance(ProcessDTO processInstance)
+    {
+        List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery()
+                .processDefinitionId(processInstance.getProcessDefinitionId())
+                .list();
+        // 使用增强型 for 循环遍历列表
+        for (ProcessInstance processInstancesItem : processInstances) {
+            // 在这里对每个 ProcessInstance 进行处理
+
+            long count = runtimeService.createProcessInstanceQuery().processInstanceId(processInstancesItem.getId()).count();
+            if (count > 0) {
+
+                DeleteFlowableProcessInstanceCmd cmd = new DeleteFlowableProcessInstanceCmd(processInstancesItem.getId(), "删除流程实例", true);
+                managementService.executeCommand(cmd);
+
+                // 删除与已删除流程定义相关的部署数据
+                repositoryService.deleteDeployment(processInstancesItem.getDeploymentId(), true);
+            } else {
+                HistoricProcessInstanceQuery query= historyService.createHistoricProcessInstanceQuery()
+                        .processInstanceId(processInstancesItem.getId());
+                // 查询历史流程实例数据
+                HistoricProcessInstance historicProcessInstance = query.singleResult();
+                if (historicProcessInstance != null) {
+                    historyService.deleteHistoricProcessInstance(processInstancesItem.getId());
+                }
+            }
+        }
+        ProcessTemplates pro=processTemplateService.getById(processInstance.getTemplateId());
+        if (pro!=null)
+        {
+            processTemplateService.removeById(processInstance.getTemplateId());
+        }
+        return  true;
+
+
+    }
+
+
+    /**
+    * @Author: Zhaojw
+    * @Description: 修改表单名称
+    * @DateTime: 2023/7/21 14:30
+    * @Params:
+    * @Return
+    */
+    public Boolean updateFormName(UpdateProcessVO process)  {
+        ProcessTemplates processTemplates = processTemplateService.getById(process.getTemplateId());
+        processTemplates.setFormName(process.getFormName());
+        processTemplates.setRemark(process.getRemark());
+        processTemplates.setUpdated(new Date());
+
+        return processTemplateService.updateById(processTemplates);//更新表单明细表信息
+
+
+    }
+    
+    /**
+     * 编辑表单详情
+     *
+     * @return 修改结果
+     */
+
+    @Transactional
+    public Boolean updateForm(UpdateProcessVO process) throws JsonProcessingException {
+        ObjectMapper objectMapper = new ObjectMapper();
+        JsonNode processJsonNode = objectMapper.readTree(process.getProcessJson());
+        JsonNode formJsonNode = objectMapper.readTree(process.getFormJson());
+        String formName="";
+        ProcessTemplates processTemplates = processTemplateService.getById(process.getTemplateId());
+        if (ObjectUtil.isNotEmpty(process.getFormName()))
+        {
+            formName= process.getFormName().toString();
+            processTemplates.setFormName(process.getFormName());
+        }
+        else
+        {
+            formName = processTemplates.getFormName();
+        }
+//        processTemplates.setFormJson(formJsonNode.toString());//暂时用不到，以后会用
+
+        processTemplates.setProcessJson(process.getProcessJson().toString());
+        processTemplates.setUpdated(new Date());
+        processTemplateService.updateById(processTemplates);//更新表单明细表信息
+        BpmnModel bpmnModel = toBpmn(processJsonNode,formJsonNode,formName,process.getTemplateId());
+
+
+        Deployment deploy = repositoryService.createDeployment()
+                .addBpmnModel(formName+".bpmn20.xml", bpmnModel)
+                .name(formName)
+                .category(process.getTemplateId())
+                .deploy();
+        return true;
+
+    }
+
+    @Override
+    public ResponseResult getFormDetail(String templateId) {
+        ProcessTemplates processTemplates = processTemplateService.getById(templateId);
+        processTemplates.setIcon(processTemplates.getIcon());
+        processTemplates.setTemplateId(processTemplates.getTemplateId());
+        processTemplates.setFormName(processTemplates.getFormName());
+        Object aa= repositoryService.createProcessDefinitionQuery();
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey("Process_"+templateId).latestVersion().singleResult();
+        if(processDefinition==null){
+            throw  new WorkFlowException("该流程暂未接入Flowable,请重试");
+        }
+        processTemplates.setProcessDefinitionId(processDefinition.getId());
+
+        return new ResponseResult(HttpStatus.SUCCESS, ReturnMsg.PASS,processTemplates);
+    }
+
+    /**
+     * 绘制节点
+     *
+     * @param process       bpmn process 图纸
+     * @param node          json的节点
+     * @param preId         上一节点id
+     * @param endId         结束节点
+     * @param preExpression 上一节点表达式
+     */
+    public void drawNode(Process process, JsonNode node, String preId, String endId, String preExpression) {
+        // 根据type绘制不同种类的节点
+        Inout inout = drawNodeByType(process, node);
+        // 绘制前一根线
+        process.addFlowElement(createSequenceFlow(preId, inout.getIn(), preExpression));
+        if (node.get("childNode").toString().equals("null")) {
+            // 没有下一步, 绘制指向结束的线
+            process.addFlowElement(createSequenceFlow(inout.getOut(), endId, null));
+        } else {
+            // 有下一步, 递归绘制下一个节点
+            drawNode(process, node.get("childNode"), inout.getOut(), endId, null);
+        }
+    }
+
+    /**
+     * 绘制不同种类节点
+     *
+     * @param process
+     * @param node
+     * @return
+     */
+    private Inout drawNodeByType(Process process, JsonNode node) {
+        if (node.get("type").toString().equals("0")) {//根节点或起始节点
+            return drawRootNode(process, node);
+        } else if (node.get("type").toString().equals("1")) {//审核节点
+            return drawAuditNode(process, node);
+        } else if (node.get("type").toString().equals("3")) {//分支节点
+            return drawExclusiveNode(process, node);
+        } else if (node.get("type").toString().equals("4")) {//分支节点
+            return drawExclusiveNode(process, node);
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    /**
+     * 绘制分支节点
+     *
+     * @param process
+     * @param node
+     * @return
+     */
+    private Inout drawExclusiveNode(Process process, JsonNode node) {
+        // 开始网关
+        String startId = "Exclusive_" + UUID.randomUUID();
+        ExclusiveGateway startGateway = new ExclusiveGateway();
+        startGateway.setId(startId);
+        process.addFlowElement(startGateway);
+        // 结束网关
+        String endId = "Exclusive_" + UUID.randomUUID();
+        ExclusiveGateway endGateway = new ExclusiveGateway();
+        endGateway.setId(endId);
+        process.addFlowElement(endGateway);
+
+        // int和out不一样
+        return new Inout(startId, endId);
+    }
+
+    /**
+     * 创建连线
+     *
+     * @param from
+     * @param to
+     * @return
+     */
+    public SequenceFlow createSequenceFlow(String from, String to, String conditionExpression) {
+        SequenceFlow flow = new SequenceFlow();
+        flow.setId(from + "-" + to);
+        flow.setSourceRef(from);
+        flow.setTargetRef(to);
+        if (conditionExpression != null) {
+            flow.setConditionExpression(conditionExpression);
+        }
+        return flow;
+    }
+
+    /**
+     * 绘制根节点
+     *
+     * @param process
+     * @param node
+     * @return
+     */
+    private Inout drawRootNode(Process process, JsonNode node) {
+
+        String id = "Node_" + UUID.randomUUID();
+        // 如果当前任务还有后续任务，则遍历创建后续任务
+        JsonNode nextNode = node.get("childNode");
+        UserTask userTask = new UserTask();
+        userTask.setName(node.get("name").toString());
+        userTask.setId(id);
+        process.addFlowElement(userTask);
+        return new Inout(id, id);
+
+    }
+
+    private static String createSimpleUserTask(JSONObject flowNode, Process process, List<SequenceFlow> sequenceFlows) {
+        List<String> incoming = flowNode.getJSONArray("incoming").toJavaList(String.class);
+        // 自动生成id
+        String id = id("userTask");
+        if (incoming != null && !incoming.isEmpty()) {
+            UserTask userTask = new UserTask();
+            userTask.setName(flowNode.getString("name"));
+            userTask.setId(id);
+            process.addFlowElement(userTask);
+            process.addFlowElement(connect(incoming.get(0), id, sequenceFlows));
+        }
+        return id;
+    }
+
+    /**
+     * 连线
+     *
+     * @param from
+     * @param to
+     * @param sequenceFlows
+     * @return
+     */
+    protected static SequenceFlow connect(String from, String to, List<SequenceFlow> sequenceFlows) {
+        SequenceFlow flow = new SequenceFlow();
+        flow.setId(id("sequenceFlow"));
+        flow.setSourceRef(from);
+        flow.setTargetRef(to);
+        sequenceFlows.add(flow);
+        return flow;
+    }
+
+    private static String id(String prefix) {
+        return prefix + "_" + UUID.randomUUID().toString().replace("-", "").toLowerCase();
+    }
+
+    /**
+     * 绘制审核节点
+     *
+     * @param process
+     * @param node
+     * @return
+     */
+    private Inout drawAuditNode(Process process, JsonNode node) {
+        // 绘制节点
+        String id = "Node_" + UUID.randomUUID();
+        UserTask userTask = new UserTask();
+        userTask.setId(id);
+        userTask.setName(node.get("name").toString());
+        // 设置多实例
+        MultiInstanceLoopCharacteristics multiInstanceLoopCharacteristics = new MultiInstanceLoopCharacteristics();
+        multiInstanceLoopCharacteristics.setElementVariable("user");
+        // 完成条件
+        multiInstanceLoopCharacteristics.setCompletionCondition("${nrOfInstances == nrOfCompletedInstances}");
+        multiInstanceLoopCharacteristics.setInputDataItem("${users}");
+        userTask.setLoopCharacteristics(multiInstanceLoopCharacteristics);
+        // 保存json节点配置到扩展属性
+        Map<String, Object> extensions = new HashMap<>();
+        extensions.put("node", node);
+        process.addFlowElement(userTask);
+        ;
+        return new Inout(id, id);
+    }
+
+
+
+
+
+
+    /**
+     * 通过模板id查看流程信息 会附带流程定义id
+     *
+     * @return
+     */
+    @Override
+    public Result<ProcessTemplates> detail(String templateId) {
+        ProcessTemplates processTemplates = processTemplateService.getById(templateId);
+        processTemplates.setFormId(processTemplates.getTemplateId());
+        processTemplates.setFormName(processTemplates.getFormName());
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_PREFIX + templateId).latestVersion().singleResult();
+        if (processDefinition == null) {
+            throw new WorkFlowException("该流程暂未接入Flowable,请重试");
+        }
+
+        return Result.OK(processTemplates);
+    }
+
+    /**
+     * 通过流程定义id启动流程
+     *
+     * @return
+     */
+    @Override
+    public String start(StartProcessInstanceDTO processInstanceDto) {
+        try {
+
+            LoginUser StartUser=new LoginUser();
+            if (processInstanceDto.getUserId()!=null)//优先拿接口中的信息，方便调试
+            {
+                StartUser.setUserId(Long.valueOf(processInstanceDto.getUserId()) );
+            }
+            else
+            {
+                StartUser= LoginContext.getContext().getLoginUser();
+            }
+
+            JSONObject formData = processInstanceDto.getFormData();
+            Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+            Map<String,Object> processVariables= new HashMap<>();
+            processVariables.put(FORM_VAR,formData);
+            processVariables.put(ORDER_ID,processInstanceDto.getOrderId());
+            processVariables.put(ORDER_TYPE,processInstanceDto.getOrderType());
+            processVariables.put(START_USER_INFO,JSONObject.toJSONString(StartUser));
+            processVariables.put(PROCESS_STATUS,BUSINESS_STATUS_1);
+            ArrayList<LoginUser> userInfos = CollUtil.newArrayList(StartUser);
+            if (formData!=null)
+            {
+                Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+                processVariables.putAll(formValue);
+            }
+
+            ProcessInstanceBuilder processInstanceBuilder = runtimeService.createProcessInstanceBuilder();
+            ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(processInstanceDto.getProcessDefinitionId())
+                    .latestVersion().singleResult();
+//            if (processDefinition == null )
+//            {
+//                return  ApiRes.failure("流程不存在或已挂起");
+//
+//           }
+//            if (processDefinition != null && processDefinition.isSuspended())
+//            {
+//                return  ApiRes.failure("流程不存在或已挂起");
+//            }
+
+            ProcessInstance processInstance = processInstanceBuilder
+                    .processDefinitionId(processInstanceDto.getProcessDefinitionId())
+                    .variable("initiator",StartUser.getUserId())
+                    .variables(processVariables)
+                    .businessStatus(BUSINESS_STATUS_1)
+                        .start();
+                        //手动完成第一个任务
+            Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+            task.setAssignee(StartUser.getUserId().toString());
+//            Object ts=new Object();
+//            if(task!=null){
+//                taskService.complete(task.getId());
+//
+//            }
+            return  processInstance.getProcessInstanceId();
+        }
+        catch (Exception e){
+            Throwable cause = e.getCause();
+            if(cause instanceof WorkFlowException){
+                WorkFlowException workFlowException=(WorkFlowException)cause;
+                return  workFlowException.getMessage();
+
+
+            }
+            e.printStackTrace();
+            return  "流程不存在或已挂起";
+        }
+    }
+
+    @Override
+    public ApiRes<List<TaskDetailVO>> record(String processInstanceId) {
+        List<Comment> processInstanceComments = taskService.getProcessInstanceComments(processInstanceId);
+        Map<String, List<Comment>> commentsMap = processInstanceComments.stream()
+                .collect(Collectors.groupingBy(Comment::getTaskId));
+        List<Attachment> processInstanceAttachments = taskService.getProcessInstanceAttachments(processInstanceId);
+        Map<String, List<Attachment>> attachmentMap = processInstanceAttachments.stream()
+                .collect(Collectors.groupingBy(Attachment::getTaskId));
+        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).orderByHistoricActivityInstanceStartTime().asc().list();
+        List<TaskDetailVO> taskDetailVOS= new ArrayList<>();
+        for (HistoricActivityInstance historicActivityInstance : list) {
+            if("startEvent".equals(historicActivityInstance.getActivityType())){
+                TaskDetailVO taskDetailVO= new TaskDetailVO();
+                taskDetailVO.setTaskId(historicActivityInstance.getTaskId());
+                taskDetailVO.setActivityId(historicActivityInstance.getActivityId());
+                taskDetailVO.setName("流程开始");
+                taskDetailVO.setCreateTime(historicActivityInstance.getStartTime());
+                taskDetailVO.setEndTime(historicActivityInstance.getEndTime());
+//                List<Comment> comments = commentsMap.get(historicActivityInstance.getTaskId());
+//                taskDetailVO.setComment(comments.get(0).getFullMessage());
+                if (historicActivityInstance.getAssignee()!=null)
+                {List<UserListDTO> userList= orgUserMapper.QueryUserWithParentOrg(historicActivityInstance.getAssignee());
+                    taskDetailVO.setUserId(userList.get(0).getUserID());
+                    taskDetailVO.setUserName(userList.get(0).getRealName());}
+
+                taskDetailVOS.add(taskDetailVO);
+
+//                taskDetailVO.setSignImage();
+//                taskDetailVO.setAttachmentVOList();
+//                taskDetailVO.setOptionVOList();
+//                taskDetailVO.setCommentVOList();
+            }
+            else if("endEvent".equals(historicActivityInstance.getActivityType())){
+                TaskDetailVO taskDetailVO= new TaskDetailVO();
+                taskDetailVO.setTaskId(historicActivityInstance.getTaskId());
+                taskDetailVO.setActivityId(historicActivityInstance.getActivityId());
+                taskDetailVO.setName("流程结束");
+                taskDetailVO.setCreateTime(historicActivityInstance.getStartTime());
+                taskDetailVO.setEndTime(historicActivityInstance.getEndTime());
+//                List<Comment> comments = commentsMap.get(historicActivityInstance.getTaskId());
+//                taskDetailVO.setComment(comments.get(0).getFullMessage());
+                if (historicActivityInstance.getAssignee()!=null)
+                {List<UserListDTO> userList= orgUserMapper.QueryUserWithParentOrg(historicActivityInstance.getAssignee());
+                    taskDetailVO.setUserId(userList.get(0).getUserID());
+                    taskDetailVO.setUserName(userList.get(0).getRealName());}
+                taskDetailVOS.add(taskDetailVO);
+            }
+            else if("userTask".equals(historicActivityInstance.getActivityType())){
+                List<Comment> comments = commentsMap.get(historicActivityInstance.getTaskId());
+                if(CollUtil.isNotEmpty(comments)){
+                    for (Comment comment : comments) {
+                        if("opinion".equals(comment.getType())){
+
+
+                            TaskDetailVO taskDetailVO= new TaskDetailVO();
+                            taskDetailVO.setTaskId(historicActivityInstance.getTaskId());
+                            if (historicActivityInstance.getAssignee()!=null)
+                            {List<UserListDTO> userList= orgUserMapper.QueryUserWithParentOrg(historicActivityInstance.getAssignee());
+                                taskDetailVO.setUserId(userList.get(0).getUserID());
+                                taskDetailVO.setUserName(userList.get(0).getRealName());}
+                            taskDetailVO.setActivityId(historicActivityInstance.getActivityId());
+                            taskDetailVO.setName(historicActivityInstance.getActivityName());
+                            taskDetailVO.setCreateTime(historicActivityInstance.getStartTime());
+                            taskDetailVO.setEndTime(historicActivityInstance.getEndTime());
+//                            taskDetailVO.setComment(comment.getFullMessage());
+                            List<Attachment> attachments = attachmentMap.get(historicActivityInstance.getTaskId());
+                            List<AttachmentVO> attachmentVOList = new ArrayList<>();
+
+                            if (attachments!=null)
+                            {
+                                for (Attachment attachment : attachments) {
+                                    AttachmentVO attachmentVO = new AttachmentVO();
+                                    attachmentVO.setId(attachment.getId());
+                                    attachmentVO.setName(attachment.getName());
+                                    attachmentVO.setUrl(attachment.getUrl());
+                                    attachmentVOList.add(attachmentVO);
+                                }
+                            }
+
+
+                            for (Comment comment1 : comments) {
+                                if("sign".equals(comment1.getType())){
+                                    taskDetailVO.setSignImage(comment1.getFullMessage());
+                                }
+                            }
+                            taskDetailVO.setComment(comments.get(0).getFullMessage());
+                            taskDetailVO.setAttachmentVOList(attachmentVOList);
+                            taskDetailVOS.add(taskDetailVO);
+                        }
+                    }
+                }
+            }
+        }
+        return ApiRes.success(taskDetailVOS);
+
+    }
+
+    /**
+     * 查看我发起的流程
+     *
+     * @return
+     */
+    @Override
+    public PageResult<HistoryProcessInstanceVO>  applyList(ApplyDTO applyDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (applyDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(applyDTO.getCurrentUserInfo().getUserId());
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+        PageResult<HistoryProcessInstanceVO> pageResult=new  PageResult<HistoryProcessInstanceVO>();
+        List<HistoricProcessInstance> historicProcessInstances =
+                historyService.createHistoricProcessInstanceQuery()
+                        .includeProcessVariables()
+                        .startedBy(StartUser.getUserId().toString())
+                        .orderByProcessInstanceStartTime().desc()
+                        .listPage((applyDTO.getPageNo() - 1) * applyDTO.getPageSize(), applyDTO.getPageSize());
+        long count = historyService.createHistoricProcessInstanceQuery()
+                .startedBy(StartUser.getUserId().toString()).count();
+        List<HistoryProcessInstanceVO> historyProcessInstanceVOS = new ArrayList<>();
+        Page<HistoryProcessInstanceVO> page = new Page<>();
+        for (HistoricProcessInstance historicProcessInstance : historicProcessInstances) {
+            Map<String, Object> processVariables = historicProcessInstance.getProcessVariables();
+            HistoryProcessInstanceVO historyProcessInstanceVO = new HistoryProcessInstanceVO();
+            historyProcessInstanceVO.setProcessInstanceId(historicProcessInstance.getId());
+
+            BpmnModel bpmnModel = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());
+
+            String Name= bpmnModel.getMainProcess().getName();
+            historyProcessInstanceVO.setOrderId(MapUtil.getStr(processVariables, ORDER_ID));
+            historyProcessInstanceVO.setOrderType(MapUtil.getStr(processVariables, ORDER_TYPE));
+            historyProcessInstanceVO.setProcessDefinitionName(historicProcessInstance.getProcessDefinitionName());
+            historyProcessInstanceVO.setStartUser(JSONObject.parseObject(MapUtil.getStr(processVariables, START_USER_INFO), new TypeReference<UserInfo>() {
+            }));
+            historyProcessInstanceVO.setStartTime(historicProcessInstance.getStartTime());
+            historyProcessInstanceVO.setEndTime(historicProcessInstance.getEndTime());
+            Boolean flag = historicProcessInstance.getEndTime() == null ? false : true;
+            historyProcessInstanceVO.setCurrentActivityName(getCurrentName(historicProcessInstance.getId(), flag, historicProcessInstance.getProcessDefinitionId()));
+            historyProcessInstanceVO.setBusinessStatus(MapUtil.getStr(processVariables, PROCESS_STATUS));
+
+            long totalTimes = historicProcessInstance.getEndTime() == null ?
+                    (Calendar.getInstance().getTimeInMillis() - historicProcessInstance.getStartTime().getTime()) :
+                    (historicProcessInstance.getEndTime().getTime() - historicProcessInstance.getStartTime().getTime());
+            long dayCount = totalTimes / (1000 * 60 * 60 * 24);//计算天
+            long restTimes = totalTimes % (1000 * 60 * 60 * 24);//剩下的时间用于计于小时
+            long hourCount = restTimes / (1000 * 60 * 60);//小时
+            restTimes = restTimes % (1000 * 60 * 60);
+            long minuteCount = restTimes / (1000 * 60);
+
+            String spendTimes = dayCount + "天" + hourCount + "小时" + minuteCount + "分";
+            historyProcessInstanceVO.setDuration(spendTimes);
+            historyProcessInstanceVOS.add(historyProcessInstanceVO);
+        }
+        pageResult.setRecords(historyProcessInstanceVOS);
+        pageResult.setTotalRows(Long.valueOf(applyDTO.getPageNo()));
+        pageResult.setTotalPage(PageUtil.totalPage((int) count, Convert.toInt(pageResult.getPageSize())));
+        pageResult.setPageSize(Long.valueOf(applyDTO.getPageSize()));
+        pageResult.setPageNo(Long.valueOf(applyDTO.getPageNo()));
+        return  pageResult;
+    }
+
+    /**
+     * 查看我的待办
+     *
+     * @return
+     */
+    @Override
+    public PageResult<TaskVO> toDoList(TaskDTO taskDTO) {
+            SysUser StartUser=new SysUser();
+            if (taskDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+            {
+                StartUser = sysUserService.getById(taskDTO.getCurrentUserInfo().getUserId());
+
+            }
+            else
+            {
+                StartUser= sysUserService.getById(LoginContext.getContext().getLoginUser());
+            }
+
+        List<Task> tasks = taskService.createTaskQuery().taskAssignee(StartUser.getUserId().toString())
+                .includeProcessVariables()
+                .orderByTaskCreateTime().desc()
+                .listPage((taskDTO.getPageNo() - 1) * taskDTO.getPageSize(), taskDTO.getPageSize());
+        long count = taskService.createTaskQuery().taskAssignee(StartUser.getUserId().toString()).count();
+        List<TaskVO> taskVOS= new ArrayList<>();
+        Page<TaskVO> page =new Page<>();
+        for (Task task : tasks) {
+            ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();
+            String startUserId = processInstance.getStartUserId();
+            BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
+            Map<String, Object> processVariables = task.getProcessVariables();
+            TaskVO taskVO=new TaskVO();
+            taskVO.setTaskId(task.getId());
+            taskVO.setProcessInstanceId(task.getProcessInstanceId());
+            taskVO.setProcessDefinitionName(bpmnModel.getMainProcess().getName());
+            SysUser staruser= sysUserService.getById(startUserId);
+            taskVO.setStartUser(this.SetUser(staruser));
+            taskVO.setOrderId(MapUtil.getStr(processVariables, ORDER_ID));
+            taskVO.setOrderType(MapUtil.getStr(processVariables, ORDER_TYPE));
+            taskVO.setStartTime(processInstance.getStartTime());
+            taskVO.setCurrentActivityName(getCurrentName(processInstance.getId(),false,processInstance.getProcessDefinitionId()));
+
+            taskVO.setBusinessStatus(MapUtil.getStr(processVariables,PROCESS_STATUS));
+            taskVO.setTaskCreatedTime(task.getCreateTime());
+            DelegationState delegationState = task.getDelegationState();
+            if(delegationState!=null){
+                taskVO.setDelegationState(delegationState);
+            }
+            taskVOS.add(taskVO);
+        }
+
+        page.setRecords(taskVOS);
+        return PageResultFactory.createPageResult(page);
+
+
+    }
+
+    /**
+     * 查看我的已办
+     *
+     * @return
+     */
+    @Override
+    public PageResult<TaskVO> doneList(TaskDTO taskDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (taskDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(taskDTO.getCurrentUserInfo().getUserId());
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+
+
+        List<HistoricTaskInstance> tasks = historyService.createHistoricTaskInstanceQuery()
+                .taskAssignee(StartUser.getUserId().toString())
+                .finished()
+                .includeProcessVariables()
+                .orderByTaskCreateTime().desc()
+                .listPage((taskDTO.getPageNo() - 1) * taskDTO.getPageSize(), taskDTO.getPageSize());
+        long count = historyService.createHistoricTaskInstanceQuery()
+                .taskAssignee(StartUser.getUserId().toString()).count();
+        List<TaskVO> taskVOS = new ArrayList<>();
+        Page<TaskVO> page = new Page<>();
+        for (HistoricTaskInstance task : tasks) {
+            HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();
+            Boolean flag = historicProcessInstance.getEndTime() == null ? false : true;
+
+            BpmnModel bpmnModel = null;
+            try {
+                bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
+            } catch (Exception e) {
+                // 处理获取BpmnModel异常的情况
+                e.printStackTrace(); // 可以将异常信息打印到日志中
+                // 可以在这里设置默认的BpmnModel或采取其他处理措施
+            }
+
+            Map<String, Object> processVariables = task.getProcessVariables();
+            TaskVO taskVO = new TaskVO();
+            taskVO.setTaskId(task.getId());
+            taskVO.setProcessInstanceId(task.getProcessInstanceId());
+            if (bpmnModel!=null)
+            {
+                taskVO.setProcessDefinitionName(bpmnModel.getMainProcess().getName());
+            }
+
+            taskVO.setStartUser(JSONObject.parseObject(MapUtil.getStr(processVariables, START_USER_INFO), new TypeReference<UserInfo>() {
+            }));
+            taskVO.setOrderId(MapUtil.getStr(processVariables, ORDER_ID));
+            taskVO.setOrderType(MapUtil.getStr(processVariables, ORDER_TYPE));
+            taskVO.setStartTime(historicProcessInstance.getStartTime());
+            taskVO.setCurrentActivityName(getCurrentName(task.getProcessInstanceId(), flag, task.getProcessDefinitionId()));
+            taskVO.setBusinessStatus(MapUtil.getStr(processVariables, PROCESS_STATUS));
+            taskVO.setEndTime(task.getEndTime());
+
+            long totalTimes = task.getEndTime() == null ?
+                    (Calendar.getInstance().getTimeInMillis() - task.getStartTime().getTime()) :
+                    (task.getEndTime().getTime() - task.getStartTime().getTime());
+            long dayCount = totalTimes / (1000 * 60 * 60 * 24);//计算天
+            long restTimes = totalTimes % (1000 * 60 * 60 * 24);//剩下的时间用于计于小时
+            long hourCount = restTimes / (1000 * 60 * 60);//小时
+            restTimes = restTimes % (1000 * 60 * 60);
+            long minuteCount = restTimes / (1000 * 60);
+            String spendTimes = dayCount + "天" + hourCount + "小时" + minuteCount + "分";
+            taskVO.setDuration(spendTimes);
+            taskVOS.add(taskVO);
+        }
+
+        page.setRecords(taskVOS);
+        page.setCurrent(taskDTO.getPageNo());
+        page.setSize(taskDTO.getPageSize());
+        page.setTotal(count);
+
+        return PageResultFactory.createPageResult(page);
+
+    }
+
+
+    @Override
+    public ResponseResult revoke(HandleDataDTO handleDataDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (handleDataDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(Long.valueOf(handleDataDTO.getCurrentUserInfo().getUserId()));
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+        Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        HistoricTaskInstance task = historyService.createHistoricTaskInstanceQuery().taskId(taskId).singleResult();
+        Map<String,Object> map=new HashMap<>();
+        if(formData!=null &&formData.size()>0){
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR,formData);
+        }
+        map.put(PROCESS_STATUS,BUSINESS_STATUS_2);
+        runtimeService.setVariables(task.getProcessInstanceId(),map);
+        if(StringUtils.isNotBlank(comments)){
+            taskService.addComment(task.getId(),task.getProcessInstanceId(),"opinion",comments);
+        }
+        if(attachments!=null && attachments.size()>0){
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option",taskId,task.getProcessInstanceId(),attachment.getName(),attachment.getName(),attachment.getUrl());
+            }
+        }
+
+        if(StringUtils.isNotBlank(handleDataDTO.getSignInfo())){
+            taskService.addComment(task.getId(),task.getProcessInstanceId(),"sign",handleDataDTO.getSignInfo());
+        }
+        runtimeService.deleteProcessInstance(task.getProcessInstanceId(),"撤销");
+        return new ResponseResult(HttpStatus.SUCCESS,ReturnMsg.PASS,"");
+    }
+    @Override
+    public ResponseResult agree(HandleDataDTO handleDataDTO) {
+
+        LoginUser StartUser=new LoginUser();
+        if (handleDataDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(Long.valueOf(handleDataDTO.getCurrentUserInfo().getUserId()));
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        String processInstanceId=handleDataDTO.getProcessInstanceId();
+
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        if (task!=null)//task为空则说明当前任务可能已结束
+        {
+            Map<String, Object> map = new HashMap<>();
+            if (formData != null && formData.size() > 0) {
+                Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+                });
+                map.putAll(formValue);
+                map.put(FORM_VAR, formData);
+            }
+
+            runtimeService.setVariables(task.getProcessInstanceId(), map);//设置进入当前流程
+
+            Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+            if (StringUtils.isNotBlank(comments)) {
+                taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+            }
+            if (attachments != null && attachments.size() > 0) {
+                for (AttachmentDTO attachment : attachments) {
+                    taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+                }
+            }
+
+//            if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+//                taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+//            }
+            taskService.complete(task.getId());
+            HistoricTaskInstance historicTask = historyService
+                    .createHistoricTaskInstanceQuery()
+                    .taskId(taskId)
+                    .singleResult();
+
+            if (historicTask.getEndTime()!=null)//EndTime为空，说明任务已结束，需要往消息队列中进行消息传递
+            {
+                HistoricProcessInstance historicProcessInstance= historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId)
+                        .includeProcessVariables().singleResult();//拿到历史中的表单信息
+                Map<String, Object> processVariables = historicProcessInstance.getProcessVariables();
+                JSONObject jsonObject = (JSONObject) processVariables.get(FORM_VAR);
+
+
+            }
+            return new ResponseResult(HttpStatus.SUCCESS,ReturnMsg.PASS,ReturnMsg.PASS);
+
+        }
+        else {
+            return new ResponseResult(HttpStatus.PROCESS_WAS_END,ReturnMsg.PROCESS_WAS_END,"");
+
+        }
+
+
+    }
+
+    @Override
+    public Result delegateTask(HandleDataDTO handleDataDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (handleDataDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(Long.valueOf(handleDataDTO.getCurrentUserInfo().getUserId()));
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+
+        UserInfo delegateUserInfo = handleDataDTO.getDelegateUserInfo();
+        taskService.delegateTask(task.getId(), delegateUserInfo.getId());
+        return Result.OK();
+    }
+
+    @Override
+    public Result resolveTask(HandleDataDTO handleDataDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (handleDataDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(Long.valueOf(handleDataDTO.getCurrentUserInfo().getUserId()));
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+
+        taskService.resolveTask(taskId);
+        return Result.OK();
+    }
+
+    @Override
+    public ResponseResult refuse(HandleDataDTO handleDataDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (handleDataDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(Long.valueOf(handleDataDTO.getCurrentUserInfo().getUserId()));
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+
+        Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+        map.put(PROCESS_STATUS, BUSINESS_STATUS_3);
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+        runtimeService.deleteProcessInstance(task.getProcessInstanceId(), "拒绝");
+
+        return new ResponseResult(HttpStatus.SUCCESS, ReturnMsg.PASS,ReturnMsg.PASS);
+    }
+
+
+    @Override
+    public Result assignee(HandleDataDTO handleDataDTO) {
+        LoginUser StartUser= LoginContext.getContext().getLoginUser();
+
+        Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+        map.put(PROCESS_STATUS, BUSINESS_STATUS_1);
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+        taskService.setAssignee(taskId, handleDataDTO.getTransferUserInfo().getId());
+        return Result.OK();
+    }
+
+    @Override
+    public Result rollback(HandleDataDTO handleDataDTO) {
+        LoginUser StartUser=new LoginUser();
+        if (handleDataDTO.getCurrentUserInfo().getUserId()!=null)//优先拿接口中的信息，方便调试
+        {
+            StartUser.setUserId(Long.valueOf(handleDataDTO.getCurrentUserInfo().getUserId()));
+        }
+        else
+        {
+            StartUser= LoginContext.getContext().getLoginUser();
+        }
+        Authentication.setAuthenticatedUserId(StartUser.getUserId().toString());
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        String processInstanceId = handleDataDTO.getProcessInstanceId();
+        List<Task> list = taskService.createTaskQuery().processInstanceId(processInstanceId).list();
+        Task task = null;
+        List<String> taskIds = new ArrayList<>();
+
+        for (Task task1 : list) {
+            if (task1.getId().equals(taskId)) {
+                task = task1;
+            }
+            taskIds.add(task1.getTaskDefinitionKey());
+        }
+
+
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+        map.put(PROCESS_STATUS, BUSINESS_STATUS_3);
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+
+
+        runtimeService.createChangeActivityStateBuilder()
+                .processInstanceId(task.getProcessInstanceId())
+                .moveActivityIdsToSingleActivityId(taskIds, handleDataDTO.getRollbackId())
+                .changeState();
+        return Result.OK();
+    }
+
+    @Override
+    public Result addMulti(HandleDataDTO handleDataDTO) {
+        UserInfo currentUserInfo = handleDataDTO.getCurrentUserInfo();
+        Authentication.setAuthenticatedUserId(currentUserInfo.getId());
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+        map.put(PROCESS_STATUS, BUSINESS_STATUS_1);
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "opinion", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+
+        Map<String, Object> variableMap = new HashMap<>();
+        variableMap.put("assigneeName", handleDataDTO.getMultiAddUserInfo().getId());
+        ExecutionEntity execution = (ExecutionEntity) runtimeService.addMultiInstanceExecution(task.getTaskDefinitionKey(), task.getProcessInstanceId(), variableMap);
+        return Result.OK();
+    }
+
+    @Override
+    public Result<List<MultiVO>> queryMultiUsersInfo(Map<String, Object> map) {
+        String taskId = MapUtil.getStr(map, "taskId");
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        List<Task> list = taskService.createTaskQuery()
+                .processInstanceId(task.getProcessInstanceId())
+                .taskDefinitionKey(task.getTaskDefinitionKey()).list();
+        Iterator<Task> iterator = list.iterator();
+        List<MultiVO> multiVOList = new ArrayList<>();
+        while (iterator.hasNext()) {
+            Task next = iterator.next();
+            if (!taskId.equals(next.getId())) {
+                MultiVO multiVO = new MultiVO();
+                multiVO.setTaskId(next.getId());
+                multiVO.setProcessInstanceId(next.getProcessInstanceId());
+                multiVO.setExecutionId(next.getExecutionId());
+                multiVO.setUserId(next.getAssignee());
+                multiVOList.add(multiVO);
+            }
+
+        }
+        return Result.OK(multiVOList);
+    }
+
+    @Override
+    public Result deleteMulti(List<String> executionIds) {
+        for (String executionId : executionIds) {
+            runtimeService.deleteMultiInstanceExecution(executionId, true);
+        }
+        return Result.OK();
+    }
+
+    @Override
+    public Result comments(HandleDataDTO handleDataDTO) {
+        UserInfo currentUserInfo = handleDataDTO.getCurrentUserInfo();
+        Authentication.setAuthenticatedUserId(currentUserInfo.getId());
+        List<AttachmentDTO> attachments = handleDataDTO.getAttachments();
+        String comments = handleDataDTO.getComments();
+        JSONObject formData = handleDataDTO.getFormData();
+        String taskId = handleDataDTO.getTaskId();
+        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
+        Map<String, Object> map = new HashMap<>();
+        if (formData != null && formData.size() > 0) {
+            Map formValue = JSONObject.parseObject(formData.toJSONString(), new TypeReference<Map>() {
+            });
+            map.putAll(formValue);
+            map.put(FORM_VAR, formData);
+        }
+        map.put(PROCESS_STATUS, BUSINESS_STATUS_1);
+        runtimeService.setVariables(task.getProcessInstanceId(), map);
+        if (StringUtils.isNotBlank(comments)) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "comments", comments);
+        }
+        if (attachments != null && attachments.size() > 0) {
+            for (AttachmentDTO attachment : attachments) {
+                taskService.createAttachment("option", taskId, task.getProcessInstanceId(), attachment.getName(), attachment.getName(), attachment.getUrl());
+            }
+        }
+
+        if (StringUtils.isNotBlank(handleDataDTO.getSignInfo())) {
+            taskService.addComment(task.getId(), task.getProcessInstanceId(), "sign", handleDataDTO.getSignInfo());
+        }
+        return Result.OK();
+    }
+
+
+
+    @Override
+    public ApiRes<String> getProcessDefinitionId(String formId) {
+        String defId="";
+        ProcessDefinition ProDef=repositoryService.createProcessDefinitionQuery()
+                .processDefinitionKey("Process_"+formId)
+                .latestVersion()
+                .singleResult();
+        if(ProDef!=null)
+        {
+            defId=ProDef.getId();
+        }
+
+        return ApiRes.success(defId);
+    }
+
+    @Override
+    public ApiRes<HandleDataVO> instanceInfo(HandleDataDTO HandleDataDTO) {
+        String processInstanceId = HandleDataDTO.getProcessInstanceId();
+        HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId)
+                .includeProcessVariables().singleResult();
+        String processDefinitionKey = historicProcessInstance.getProcessDefinitionKey();
+        String pro=processDefinitionKey.replace(PROCESS_PREFIX, "");
+        ProcessTemplates processTemplates = processTemplateService.getById(processDefinitionKey.replace(PROCESS_PREFIX, ""));
+//        processTemplates.setLogo(processTemplates.getIcon());
+        processTemplates.setFormId(processTemplates.getTemplateId());
+        processTemplates.setFormName(processTemplates.getFormName());
+//        processTemplates.setProcessDefinitionId(historicProcessInstance.getProcessDefinitionId());
+
+        HandleDataVO handleDataVO = new HandleDataVO();
+        Map<String, Object> processVariables = historicProcessInstance.getProcessVariables();
+
+        handleDataVO.setProcessInstanceId(historicProcessInstance.getId());
+        JSONObject jsonObject = (JSONObject) processVariables.get(FORM_VAR);
+        handleDataVO.setFormData(jsonObject);
+        String process = processTemplates.getProcessJson();
+        ChildNode childNode = JSONObject.parseObject(process, new TypeReference<ChildNode>() {
+        });
+        SettingsInfo settingsInfo = JSONObject.parseObject(processTemplates.getSettings(), new TypeReference<SettingsInfo>() {
+        });
+//        Boolean sign = settingsInfo.getSign();
+        ChildNode currentNode = null;
+        if (StringUtils.isNotBlank(HandleDataDTO.getTaskId())) {
+            HistoricTaskInstance historicTaskInstance = historyService.createHistoricTaskInstanceQuery().taskId(HandleDataDTO.getTaskId()).singleResult();
+            currentNode = getChildNode(childNode, historicTaskInstance.getTaskDefinitionKey());
+            List<FormOperates> formPerms = currentNode.getProps().getFormPerms();
+            if (CollUtil.isNotEmpty(formPerms)) {
+                Iterator<FormOperates> iterator = formPerms.iterator();
+                while (iterator.hasNext()) {
+                    FormOperates next = iterator.next();
+                    if ("H".equals(next.getPerm())) {
+                        iterator.remove();
+                        if (jsonObject != null) {
+                            jsonObject.remove(next.getId());
+                        }
+                    }
+                }
+            }
+            handleDataVO.setCurrentNode(currentNode);
+            handleDataVO.setTaskId(HandleDataDTO.getTaskId());
+        }
+
+//        if (sign) {
+//            handleDataVO.setSignFlag(true);
+//        }
+//        if (StringUtils.isNotBlank(HandleDataDTO.getTaskId())) {
+//            if (currentNode != null) {
+//                if (currentNode.getProps().getSign()) {
+//                    handleDataVO.setSignFlag(true);
+//                } else {
+//                    handleDataVO.setSignFlag(false);
+//                }
+//            }
+//        }
+
+        List<HistoricActivityInstance> list = historyService.createHistoricActivityInstanceQuery().processInstanceId(historicProcessInstance.getId()).list();
+        Map<String, List<HistoricActivityInstance>> historicActivityInstanceMap = new HashMap<>();
+        for (HistoricActivityInstance historicActivityInstance : list) {
+            List<HistoricActivityInstance> historicActivityInstances = historicActivityInstanceMap.get(historicActivityInstance.getActivityId());
+            if (historicActivityInstances == null) {
+                historicActivityInstances = new ArrayList<>();
+                historicActivityInstances.add(historicActivityInstance);
+                historicActivityInstanceMap.put(historicActivityInstance.getActivityId(), historicActivityInstances);
+            } else {
+                historicActivityInstances.add(historicActivityInstance);
+                historicActivityInstanceMap.put(historicActivityInstance.getActivityId(), historicActivityInstances);
+            }
+        }
+
+        Process mainProcess = repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId()).getMainProcess();
+        Collection<FlowElement> flowElements = mainProcess.getFlowElements();
+
+        List<String> runningList = new ArrayList<>();
+        handleDataVO.setRunningList(runningList);
+        List<String> endList = new ArrayList<>();
+        handleDataVO.setEndList(endList);
+        List<String> noTakeList = new ArrayList<>();
+        handleDataVO.setNoTakeList(noTakeList);
+        Map<String, List<TaskDetailVO>> deatailMap = new HashMap<>();
+        List<Comment> processInstanceComments = taskService.getProcessInstanceComments(historicProcessInstance.getId());
+        List<Attachment> processInstanceAttachments = taskService.getProcessInstanceAttachments(historicProcessInstance.getId());
+        for (FlowElement flowElement : flowElements) {
+            List<TaskDetailVO> detailVOList = new ArrayList<>();
+            List<HistoricActivityInstance> historicActivityInstanceList = historicActivityInstanceMap.get(flowElement.getId());
+            if (CollUtil.isNotEmpty(historicActivityInstanceList)) {
+                for (HistoricActivityInstance historicActivityInstance : historicActivityInstanceList) {
+                    if (historicActivityInstance.getEndTime() != null) {
+                        if ("startEvent".equalsIgnoreCase(historicActivityInstance.getActivityType()) || "endEvent".equalsIgnoreCase(historicActivityInstance.getActivityType())) {
+                            TaskDetailVO taskDetailVO = new TaskDetailVO();
+                            taskDetailVO.setActivityId(historicActivityInstance.getActivityId());
+                            taskDetailVO.setName(historicActivityInstance.getActivityName());
+                            taskDetailVO.setCreateTime(historicActivityInstance.getStartTime());
+                            taskDetailVO.setEndTime(historicActivityInstance.getEndTime());
+                            detailVOList.add(taskDetailVO);
+                            deatailMap.put(historicActivityInstance.getActivityId(), detailVOList);
+                            endList.add(historicActivityInstance.getActivityId());
+                        } else if ("userTask".equalsIgnoreCase(historicActivityInstance.getActivityType())) {
+                            List<TaskDetailVO> voList = deatailMap.get(historicActivityInstance.getActivityId());
+                            List<HistoricActivityInstance> activityInstanceList = list.stream().filter(h -> h.getActivityId().equals(historicActivityInstance.getActivityId()) && h.getEndTime() != null).collect(Collectors.toList());
+                            if (voList != null) {
+                                collectUserTaskInfo(processInstanceComments, processInstanceAttachments, historicActivityInstance, voList, activityInstanceList);
+                            } else {
+                                voList = new ArrayList<>();
+                                collectUserTaskInfo(processInstanceComments, processInstanceAttachments, historicActivityInstance, voList, activityInstanceList);
+                            }
+                            deatailMap.put(historicActivityInstance.getActivityId(), voList);
+                            endList.add(historicActivityInstance.getActivityId());
+                        } else if ("serviceTask".equalsIgnoreCase(historicActivityInstance.getActivityType())) {
+
+                        }
+                    } else {
+                        if ("userTask".equalsIgnoreCase(historicActivityInstance.getActivityType())) {
+                            List<TaskDetailVO> voList = deatailMap.get(historicActivityInstance.getActivityId());
+                            List<HistoricActivityInstance> activityInstanceList = list.stream().filter(h -> h.getActivityId().equals(historicActivityInstance.getActivityId()) && h.getEndTime() == null).collect(Collectors.toList());
+                            if (voList != null) {
+                                collectUserTaskInfo(processInstanceComments, processInstanceAttachments, historicActivityInstance, voList, activityInstanceList);
+                            } else {
+                                voList = new ArrayList<>();
+                                collectUserTaskInfo(processInstanceComments, processInstanceAttachments, historicActivityInstance, voList, activityInstanceList);
+                            }
+                            deatailMap.put(historicActivityInstance.getActivityId(), voList);
+                            if (endList.contains(historicActivityInstance.getActivityId())) {
+                                endList.remove(historicActivityInstance.getActivityId());
+                                runningList.add(historicActivityInstance.getActivityId());
+                            } else {
+                                runningList.add(historicActivityInstance.getActivityId());
+                            }
+                        } else if ("serviceTask".equalsIgnoreCase(historicActivityInstance.getActivityType())) {
+
+                        }
+                    }
+                }
+            } else {
+                noTakeList.add(flowElement.getId());
+            }
+        }
+        handleDataVO.setProcessTemplates(processTemplates);
+        handleDataVO.setDetailVOList(deatailMap);
+        return ApiRes.success(handleDataVO);
+    }
+
+    private void collectUserTaskInfo(List<Comment> processInstanceComments,
+                                     List<Attachment> processInstanceAttachments,
+                                     HistoricActivityInstance historicActivityInstance,
+                                     List<TaskDetailVO> voList,
+                                     List<HistoricActivityInstance> activityInstanceList) {
+        for (HistoricActivityInstance activityInstance : activityInstanceList) {
+            TaskDetailVO taskDetailVO = new TaskDetailVO();
+            taskDetailVO.setTaskId(activityInstance.getTaskId());
+            taskDetailVO.setActivityId(activityInstance.getActivityId());
+            taskDetailVO.setName(activityInstance.getActivityName());
+            taskDetailVO.setCreateTime(activityInstance.getStartTime());
+            taskDetailVO.setEndTime(activityInstance.getEndTime());
+            Comment signComment = processInstanceComments.stream().filter(h -> h.getTaskId().equals(historicActivityInstance.getTaskId()) && h.getType().equals("sign")).findFirst().orElse(null);
+            if (signComment != null) {
+                taskDetailVO.setSignImage(signComment.getFullMessage());
+            }
+            List<Attachment> attachments = processInstanceAttachments.stream().filter(h -> h.getTaskId().equals(historicActivityInstance.getTaskId())).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(attachments)) {
+                List<AttachmentVO> attachmentVOList = new ArrayList<>();
+                for (Attachment attachment : attachments) {
+                    AttachmentVO attachmentVO = new AttachmentVO();
+                    attachmentVO.setId(attachment.getId());
+                    attachmentVO.setName(attachment.getName());
+                    attachmentVO.setUrl(attachment.getUrl());
+                    attachmentVOList.add(attachmentVO);
+                }
+                taskDetailVO.setAttachmentVOList(attachmentVOList);
+            }
+
+            List<Comment> options = processInstanceComments.stream().filter(h -> h.getTaskId().equals(historicActivityInstance.getTaskId()) && h.getType().equals("opinion")).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(options)) {
+                List<OptionVO> optionVOList = new ArrayList<>();
+                for (Comment option : options) {
+                    OptionVO optionVO = new OptionVO();
+                    optionVO.setComments(option.getFullMessage());
+                    optionVO.setUserId(option.getUserId());
+//                                        optionVO.setUserName();
+                    optionVO.setCreateTime(option.getTime());
+                    optionVOList.add(optionVO);
+                }
+                taskDetailVO.setOptionVOList(optionVOList);
+            }
+
+            List<Comment> comments = processInstanceComments.stream().filter(h -> h.getTaskId().equals(historicActivityInstance.getTaskId()) && h.getType().equals("comments")).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(comments)) {
+                List<CommentVO> commentsVOList = new ArrayList<>();
+                for (Comment comment : comments) {
+                    CommentVO commentVO = new CommentVO();
+                    commentVO.setComments(comment.getFullMessage());
+                    commentVO.setUserId(comment.getUserId());
+//                                        commentVO.setUserName();
+                    commentVO.setCreateTime(comment.getTime());
+                    commentsVOList.add(commentVO);
+                }
+                taskDetailVO.setCommentVOList(commentsVOList);
+            }
+
+            voList.add(taskDetailVO);
+
+
+        }
+    }
+    /**
+    * @Author: Zhaojw
+    * @Description: 为用户赋值
+    * @DateTime: 2023/9/27 16:00
+    * @Params:
+    * @Return
+    */
+    private UserInfo SetUser(SysUser sysUser)
+    {
+        UserInfo userInfo=new UserInfo();
+        userInfo.setUserId(sysUser.getUserId());
+        userInfo.setId(sysUser.getUserId().toString());
+        userInfo.setName(sysUser.getRealName());
+        userInfo.setSex(sysUser.getSex());
+     return  userInfo;
+    }
+    private String getCurrentName(String processInstanceId, Boolean flag, String processDefinitionId) {
+        if (flag) {
+            return "流程已结束";
+        }
+        List<ActivityInstance> list = runtimeService.createActivityInstanceQuery().processInstanceId(processInstanceId).activityType("userTask").unfinished().orderByActivityInstanceStartTime().desc().list();
+        if(CollUtil.isEmpty(list)){
+            return "";
+        }
+        else{
+            String activityId = list.get(0).getActivityId();
+            BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
+            FlowElement flowElement = bpmnModel.getMainProcess().getFlowElement(activityId);
+            return flowElement.getName();
+        }
+//        Execution execution = runtimeService.createExecutionQuery().executionId(processInstanceId).singleResult();
+//        String activityId = execution.getActivityId();
+//        if (StringUtils.isBlank(activityId)) {
+//            return "";
+//        } else {
+//            BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
+//            FlowElement flowElement = bpmnModel.getMainProcess().getFlowElement(activityId);
+//            return flowElement.getName();
+//        }
+
+    }
+
+}