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

jyzb-api/src/main/java/com/junmp/jyzb/api/exception/enums/OrderExceptionEnum.java

@@ -13,6 +13,7 @@ public enum OrderExceptionEnum implements IExceptionEnum {
     ORDERDETAIL_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE,"子单据不存在"),
     ORDERDETAIL_ERROR(CommonConstant.DEFAULT_USER_ERROR_CODE,"子单据不一致，操作失败"),
     ROLE_ERROR(CommonConstant.DEFAULT_USER_ERROR_CODE,"审核组织机构用户配置异常！请检查日志"),
+    ORDER_CREATE_ERROR(CommonConstant.DEFAULT_USER_ERROR_CODE,"单子创建失败"),
     ;
 
     /**

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

@@ -36,6 +36,13 @@ public class InventorySummary implements Serializable {
     @TableField("org_name")
     private String orgName;
 
+
+    /**
+     * 组织机构编码
+     */
+    @ApiModelProperty(value = "组织机构编码")
+    @TableField("org_code")
+    private String orgCode;
     /**
      * 装备类型id
      */

jyzb-biz/src/main/java/com/junmp/jyzb/listener/GlobalEndListener.java

@@ -13,9 +13,11 @@ import com.junmp.jyzb.api.bean.req.UpdateBusFormReq;
 import com.junmp.jyzb.api.bean.req.UpdateOrderDetailReq;
 import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
 import com.junmp.jyzb.api.bean.req.UpdateReassignmentReq;
+import com.junmp.jyzb.api.exception.enums.OrderExceptionEnum;
 import com.junmp.jyzb.entity.*;
 import com.junmp.jyzb.service.*;
 import com.junmp.jyzb.utils.DateTimeUtil;
+import com.junmp.v2.common.exception.base.ServiceException;
 import com.junmp.v2.common.util.BeanPlusUtil;
 import com.rabbitmq.client.Channel;
 import com.rabbitmq.client.Connection;
@@ -81,18 +83,19 @@ import java.util.stream.Collectors;
                     String Type= orderType.get(0).getValue().toString();
                     if (Type.equals("workOrder"))//出入库单据
                     {
-                        OrderMainReq req=new OrderMainReq();
-                        req.setProcessId(processInstanceId);
+//                        OrderMainReq req=new OrderMainReq();
+//                        req.setProcessId(processInstanceId);
                         OrderMain existOrder= orderMainService.getOne(new LambdaQueryWrapper<OrderMain>()
-                                .eq(OrderMain::getProcessId, req.getProcessId()));
+                                .eq(OrderMain::getProcessId, processInstanceId));
+                        existOrder.setExamineState("finished");
+                        existOrder.setOrderState("ready");
                         UpdateOrderReq updateOrderReq = new UpdateOrderReq();
                         BeanPlusUtil.copyProperties(existOrder,updateOrderReq);
                         List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
                                 .eq(OrderDetail::getOrderId, updateOrderReq.getId()));
                         updateOrderReq.setId(existOrder.getId());
-                        updateOrderReq.setExamineState("finished");
-                        updateOrderReq.setOrderState("ready");
-                        orderMainService.ChangeOrderState(updateOrderReq);
+                        orderMainService.updateById(existOrder);
+//                        orderMainService.ChangeOrderState(updateOrderReq);
                         List<UpdateOrderDetailReq> collect = list.stream().map(orderDetail -> {
                             UpdateOrderDetailReq updateOrderDetailReq = new UpdateOrderDetailReq();
                             BeanPlusUtil.copyProperties(orderDetail, updateOrderDetailReq);
@@ -120,52 +123,18 @@ import java.util.stream.Collectors;
 
                     }
                     if (Type.equals("quickOrder")){
-                        //创建快速出库单并且通过快速出库单再去创建入库单(主单)
-                        OrderMain orderMain = new OrderMain();
                         OrderMain existOrder= orderMainService.getOne(new LambdaQueryWrapper<OrderMain>()
                                 .eq(OrderMain::getProcessId, processInstanceId));
                         existOrder.setExamineState("finished");
                         existOrder.setOrderState("ready");
-                        BeanPlusUtil.copyProperties(existOrder,orderMain);
-                        orderMain.setEndOrgId(existOrder.getStartOrgId());
-                        orderMain.setEndOrgName(existOrder.getStartOrgName());
-                        orderMain.setOrderType("in");
-                        orderMain.setId(UUID.randomUUID().toString());
-                        //修改订单编号
-                        UpdateOrderReq req = new UpdateOrderReq();
-                        BeanPlusUtil.copyProperties(orderMain,req);
-                        OrderNum orderNum = orderMainService.setOrderCode(req);
-                        String codeValue=String.format("%04d",orderNum.getNum());
-                        orderMain.setOrderCode(orderNum.getBussinessType()+orderNum.getYear()+
-                                String.format("%02d",LocalDateTime.now().getMonth().getValue())+
-                                String.format("%02d",LocalDateTime.now().getDayOfMonth())+codeValue);
                         orderMainService.updateById(existOrder);
-                        orderMainService.save(orderMain);
-                        //创建子单
-                        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
-                                .eq(OrderDetail::getOrderId, existOrder.getId()));
-                        List<Object[]> searchCriteria=new ArrayList<>();
-                        List<OrderDetail> collect = list.stream().map(orderDetail -> {
-                            OrderDetail orderDetail1 = new OrderDetail();
-                            BeanPlusUtil.copyProperties(orderDetail, orderDetail1);
-                            //修改主单据id
-                            orderDetail1.setOrderId(orderMain.getId());
-                            //修改单据出入状态
-                            orderDetail1.setType("in");
-                            //修改仓库id
-                            orderDetail1.setWarehouseId(orderMain.getLocationId());
-                            orderDetail1.setWarehouseName(orderMain.getLocationName());
-                            //新增创建时间
-                            orderDetail1.setCreateTime(DateTimeUtil.getCurrentDateTime());
-                            Object[] criteria=new Object[]{existOrder.getStartOrgId(),orderDetail.getWarehouseId(),orderDetail.getTypeId(),orderDetail.getSizeId(),orderDetail.getPrice()};
-                            searchCriteria.add(criteria);
-                            return orderDetail1;
-                        }).collect(Collectors.toList());
-                        orderDetailService.saveBatch(collect);
 
-                        //将库存表中的装备的仓库id进行修改
+                        //创建快速出库单并且通过快速出库单再去创建入库单(主单)
+                        boolean b = orderMainService.addQuickOrder(existOrder);
+                        if (!b){
+                            throw new ServiceException(OrderExceptionEnum.ORDER_CREATE_ERROR);
+                        }
 
-                        //将summary汇总表中数据进行修改
 
                     }
                 }

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

@@ -60,4 +60,8 @@ public interface InventoryMapper extends BaseMapper<Inventory> {
 
      //判断epc是否存在
     List<String> checkEPCList(@Param("list") List<String> epcList);
+
+
+    //根据条件查询满足条件的数据（用于快速移库修改装备仓库id）
+    List<Inventory> selectEqsByItem(@Param("list") List<Object[]> searchCriteria);
 }
\ No newline at end of file

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

@@ -35,7 +35,7 @@ public interface InventorySummaryMapper  extends BaseMapper<InventorySummary> {
 
 
     //出入库时无单据查询库存汇总并统计更新或者记账时根据单据查询库存汇总并统计更新
-    List<InventorySummary> selectByItems(@Param("list") List<Object[]> searchCriteria);
+    List<InventorySummary> selectSumByItems(@Param("list") List<Object[]> searchCriteria);
 
     //根据组织机构查询报表中的本级及下一级信息
     List<TjOrgEqsDto> getByOrgId(@Param("orgId") Long orgId);

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

@@ -81,4 +81,7 @@ public interface InventoryService extends IService<Inventory> {
 
     //判断epc是否存在
     List<String> checkEPCList(EpcCheckReq req);
+
+    //根据条件查询满足条件的数据（用于快速移库修改装备仓库id）
+    List<Inventory> selectEqsByItem(List<Object[]> searchCriteria);
 }

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

@@ -39,6 +39,6 @@ public interface InventorySummaryService extends IService<InventorySummary> {
     List<InventorySummary> EquipmentStatistics(InventorySumReq req);
 
     //出入库时无单据查询库存汇总并统计更新或者记账时根据单据查询库存汇总并统计更新
-    List<InventorySummary> selectByItems(List<Object[]> searchCriteria);
+    List<InventorySummary> selectSumByItems(List<Object[]> searchCriteria);
 
 }

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

@@ -53,4 +53,6 @@ public interface OrderMainService extends IService<OrderMain> {
 
      OrderNum setOrderCode(UpdateOrderReq req);
 
+     //快速创建入库单（快速移库内容）
+    boolean addQuickOrder(OrderMain existOrder);
 }

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

@@ -601,6 +601,11 @@ public class InventoryServiceImpl extends ServiceImpl<InventoryMapper, Inventory
         return inventoryMapper.checkEPCList(req.getEpcList());
     }
 
+    //根据条件查询满足条件的数据（用于快速移库修改装备仓库id）
+    @Override
+    public List<Inventory> selectEqsByItem(List<Object[]> searchCriteria) {
+        return inventoryMapper.selectEqsByItem(searchCriteria);
+    }
 
 
 }
\ No newline at end of file

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

@@ -236,8 +236,8 @@ public class InventorySummaryServiceImpl  extends ServiceImpl<InventorySummaryMa
 
     //出入库时无单据查询库存汇总并统计更新或者记账时根据单据查询库存汇总并统计更新
     @Override
-    public List<InventorySummary> selectByItems(List<Object[]> searchCriteria) {
-        return inventorySummaryMapper.selectByItems(searchCriteria);
+    public List<InventorySummary> selectSumByItems(List<Object[]> searchCriteria) {
+        return inventorySummaryMapper.selectSumByItems(searchCriteria);
     }
 
 

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

@@ -157,7 +157,7 @@ public class LogSummaryServiceImpl extends ServiceImpl<LogSummaryMapper, LogSumm
             searchCriteria.add(criteria);
         }
         //满足条件的数据
-        List<InventorySummary> inventorySummaryList = inventorySummaryMapper.selectByItems(searchCriteria);
+        List<InventorySummary> inventorySummaryList = inventorySummaryMapper.selectSumByItems(searchCriteria);
         List<InventorySummary> addList=new ArrayList<>();
         List<InventorySummary> updateList=new ArrayList<>();
         //遍历两者，判断数据库中是否全部存在，如果不存在，则进行增加数据操作，如果存在，则更新数据即可

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

@@ -87,6 +87,9 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
     private InventorySummaryService inventorySummaryService;
 
     @Resource
+    private InventoryService inventoryService;
+
+    @Resource
     private WarehouseService warehouseService;
     @Resource
     private BusFormService busFormService;
@@ -158,43 +161,45 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
         order.setCreateTime(DateTimeUtil.getCurrentDateTime());
         //执行工作流
         String processInstanceId = null;
-        if (req.getExamineState().equals("working") && !req.getBussinessType().equals("quick"))//其他出入库单
-        {
         StartProcessInstanceDTO startProcessInstanceDTO=new StartProcessInstanceDTO();
+        //业务单走审核流
         startProcessInstanceDTO.setProcessDefinitionId(req.getProcessDefinitionId());
         startProcessInstanceDTO.setOrderId(order.getId());
-            startProcessInstanceDTO.setOrderType("workOrder");
         startProcessInstanceDTO.setUserId(req.getUserId());
+
+        if (!req.getBussinessType().equals("quick") && req.getExamineState().equals("working"))//其他出入库单
+        {
+            startProcessInstanceDTO.setOrderType("workOrder");
             processInstanceId= FlowInstanceService.startProcessInstanceById(startProcessInstanceDTO);
 
         }else {//快速移库单
-            StartProcessInstanceDTO startProcessInstanceDTO=new StartProcessInstanceDTO();
-            startProcessInstanceDTO.setProcessDefinitionId(req.getProcessDefinitionId());
-            startProcessInstanceDTO.setOrderId(order.getId());
             startProcessInstanceDTO.setOrderType("quickOrder");
-            startProcessInstanceDTO.setUserId(req.getUserId());
             processInstanceId= FlowInstanceService.startProcessInstanceById(startProcessInstanceDTO);
         }
         //list返回数据
         List<String> list=new ArrayList<>();
-        String assigns= FlowInstanceService.GetNextAssign(processInstanceId);
-        order.setCurrentAssign(assigns);
+        //当前审核是否跳过
         if (processInstanceId.substring(0,2).equals("TG")){
-             processInstanceId = processInstanceId.substring(2);
-            order.setProcessId(processInstanceId);
-            Task currentTask = taskService.createTaskQuery().processInstanceId(processInstanceId).singleResult();
+            String substring = processInstanceId.substring(2);
+            order.setProcessId(substring);
+            if (ObjectUtil.isNotNull(req.getId()) && !req.getId().trim().isEmpty()) {
+                updateById(order);
+            } else {
+                //保存
+                this.save(order);
+            }
+            Task currentTask = taskService.createTaskQuery().processInstanceId(substring).singleResult();
             // 直接完成当前任务
             taskService.complete(currentTask.getId());
         }else {
             order.setProcessId(processInstanceId);
-        }
             if (ObjectUtil.isNotNull(req.getId()) && !req.getId().trim().isEmpty()) {
                 updateById(order);
             } else {
                 //保存
                 this.save(order);
             }
-
+        }
         list.add(order.getId());
         for (OrderDetail orderDetail:detailList) {
             list.add(Long.toString(orderDetail.getId()));
@@ -250,6 +255,7 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
     }
 
 
+
     //新增默认审核通过的任务单（可以没有工作流）
     @Transactional(rollbackFor = Exception.class)
     @Override
@@ -598,7 +604,7 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
             Object[] criteria=new Object[]{orgId,upReq.getWarehouseId(),upReq.getTypeId(),upReq.getSizeId(),upReq.getPrice()};
             searchCriteria.add(criteria);
         }
-        List<InventorySummary> inventorySummaryList = inventorySummaryService.selectByItems(searchCriteria);
+        List<InventorySummary> inventorySummaryList = inventorySummaryService.selectSumByItems(searchCriteria);
         List<InventorySummary> addList=new ArrayList<>();
         List<InventorySummary> updateList=new ArrayList<>();
         for (UpdateOrderDetailReq upReq: orderDetailReqList) {
@@ -830,7 +836,7 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
                     .eq(Stocktake::getProcessId, req.getProcessInstanceId()));
             BeanPlusUtil.copyProperties(one,stocktakeDto);
             processOrderDto.setStocktakeDto(stocktakeDto);
-        } else if (req.getOrderType().equals("reassigmentOrder")) {
+        } else if (req.getOrderType().equals("reassigment")) {
             ReassignmentDto reassignmentDto = new ReassignmentDto();
             Reassignment one = reassignmentService.getOne(new LambdaQueryWrapper<Reassignment>()
                     .eq(Reassignment::getProcessId, req.getProcessInstanceId()));
@@ -841,5 +847,169 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
     }
 
 
+    //快速生成入库单
+    @Override
+    public boolean addQuickOrder(OrderMain existOrder) {
+        //orderMain入库单
+        OrderMain orderMain = new OrderMain();
+        BeanPlusUtil.copyProperties(existOrder,orderMain);
+        orderMain.setEndOrgId(existOrder.getStartOrgId());
+        orderMain.setEndOrgName(existOrder.getStartOrgName());
+        orderMain.setOrderType("in");
+        orderMain.setId(UUID.randomUUID().toString());
+        //修改订单编号
+        UpdateOrderReq req = new UpdateOrderReq();
+        BeanPlusUtil.copyProperties(orderMain,req);
+        OrderNum orderNum = setOrderCode(req);
+        String codeValue=String.format("%04d",orderNum.getNum());
+        orderMain.setOrderCode(orderNum.getBussinessType()+orderNum.getYear()+
+                String.format("%02d",LocalDateTime.now().getMonth().getValue())+
+                String.format("%02d",LocalDateTime.now().getDayOfMonth())+codeValue);
+        //保存入库单
+        save(orderMain);
+        //查询出库子单
+        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
+                .eq(OrderDetail::getOrderId, existOrder.getId()));
+        //查询条件，将所有查询条件放在searchCriteria中，用于修改库存表中的装备的仓库位置
+        //原来出库单的查询条件list
+        List<Object[]> searchCriteria=new ArrayList<>();
+        //新建的入库单查询条件list
+        List<Object[]> updateCriteria=new ArrayList<>();
+        //创建入库单子单
+        List<OrderDetail> collect = list.stream().map(orderDetail -> {
+            OrderDetail orderDetail1 = new OrderDetail();
+            BeanPlusUtil.copyProperties(orderDetail, orderDetail1);
+            //修改主单据id
+            orderDetail1.setOrderId(orderMain.getId());
+            //修改单据出入状态
+            orderDetail1.setType("in");
+            //修改仓库id
+            orderDetail1.setWarehouseId(orderMain.getLocationId());
+            orderDetail1.setWarehouseName(orderMain.getLocationName());
+            //新增创建时间
+            orderDetail1.setCreateTime(DateTimeUtil.getCurrentDateTime());
+            Object[] criteria=new Object[]{existOrder.getStartOrgId(),orderDetail.getWarehouseId(),orderDetail.getTypeId(),orderDetail.getSizeId(),orderDetail.getPrice()};
+            searchCriteria.add(criteria);
+            Object[] update=new Object[]{orderMain.getEndOrgId(),orderDetail1.getWarehouseId(),orderDetail1.getTypeId(),orderDetail1.getSizeId(),orderDetail1.getPrice()};
+            updateCriteria.add(update);
+            return orderDetail1;
+        }).collect(Collectors.toList());
+        orderDetailService.saveBatch(collect);
+
+        //将库存表中的装备的仓库id进行修改
+        List<Inventory> eqsList = inventoryService.selectEqsByItem(searchCriteria);
+        for (Inventory inventory : eqsList) {
+            for (OrderDetail detail2 : collect) {
+                if (inventory.getOrgId().equals(existOrder.getStartOrgId())
+                        && inventory.getSizeId().equals(detail2.getSizeId())
+                        && inventory.getTypeId().equals(detail2.getTypeId())
+                        && inventory.getPrice().equals(detail2.getPrice())) {
+                    // 修改 仓库id
+                    inventory.setLocationId(detail2.getWarehouseId());
+                    break; // 找到匹配的对象后跳出内循环
+                }
+            }
+        }
+        inventoryService.updateBatchById(eqsList);
+        //将summary汇总表中数据进行修改(修改该组织机构下的装备汇总信息将库存信息的在库数，库存总数，总价还有其他数据数量进行修改)
+        //那么首先将原来的仓库下的装备汇总信息进行查询出来，对其进行修改
+        List<InventorySummary> oldSummaryList = inventorySummaryService.selectSumByItems(searchCriteria);
+        //创建删除列表用于将没用的数据汇总信息进行删除
+        List<InventorySummary> deleteList=new ArrayList<>();
+        for (OrderDetail orderDetail: list ) {
+            for (InventorySummary oldSum:oldSummaryList) {
+                //如果组织机构、仓库id、sizeId、typeId、unitPrice相同，那么修改其各项数值（不会存在两个列表长度不对等的情况，一定是一对一的，只不过是顺序问题，所以需要进行遍历）
+                if (orderDetail.getSizeId().equals(oldSum.getSizeId())
+                        && orderDetail.getTypeId().equals(oldSum.getTypeId())
+                        && orderDetail.getPrice().compareTo(oldSum.getUnitPrice())==0){
+                    //直接修改各项数据，并且判断库存总数是否为0，如果为0 ，判断其他数据是否为0，只有当所有数据为0才能将这条信息进行删除，否则装备数据会不准确（销毁数量）
+                    oldSum.setNumber(oldSum.getNumber()-orderDetail.getPlanNum());
+                    oldSum.setPrice(oldSum.getPrice().subtract(orderDetail.getPrice().multiply(BigDecimal.valueOf(orderDetail.getPlanNum()))));
+                    oldSum.setStockNumber(oldSum.getStockNumber()-orderDetail.getPlanNum());
+                    //如果存在删减数量完成之后所有的数量值都是0的情况，那么将这一条数据进行删除操作
+                    if (oldSum.getStockNumber()==0 && oldSum.getNumber()==0 && oldSum.getOutboundNumber()==0 && oldSum.getDestructionNumber()!=0 ){
+                        deleteList.add(oldSum);
+                    }
+                    break;
+                }
+            }
+
+        }
+
+        //其次查询出修改后的仓库下面的汇总信息，判断该仓库下是否已经存在该号型、类型、单价相同的装备数据
+        List<InventorySummary> newSummaryList = inventorySummaryService.selectSumByItems(updateCriteria);
+        // 如果存在那么只需要修改在库数，出库数，库存总数和单价；
+        // 如果不存在那么新增一条该型号，类型和单价的数据，并且对在库数，出库数，库存总数和单价进行赋值添加；
+        //判断查询的汇总表中是否存在数据，如果list为空，那么直接进行新增即可，如果不为空，那么需要遍历哪些满足条件，如果满足条件只需要进行修改更新，如果未找到那么则进行新增
+        //查询组织机构编码
+        String orgCode = pubOrgService.PubOrgExist(orderMain.getEndOrgId()).getOrgCode();
+        //新建list用于存放新的汇总数据
+        List<InventorySummary> newList=new ArrayList<>();
+        if (newSummaryList.size()==0){
+            for (OrderDetail orderDetail1:collect) {
+                InventorySummary newSummary = addNewSum(orderMain, orderDetail1, orgCode);
+                newList.add(newSummary);
+            }
+        }else {
+            //遍历两个list，判断是否存在，如果不存在，那么将新增数据放在newList中最后进行批量新增，如果存在，那么修改数据，还是放在newSummaryList中，之后同老的数据一起进行修改
+            for (OrderDetail orderDetail1:collect) {
+                boolean flag=false;
+                for (InventorySummary newSum:newSummaryList) {
+                    if (orderDetail1.getSizeId().equals(newSum.getSizeId())
+                            && orderDetail1.getTypeId().equals(newSum.getTypeId())
+                            && orderDetail1.getPrice().compareTo(newSum.getUnitPrice())==0){
+                        newSum.setNumber(newSum.getNumber()-orderDetail1.getPlanNum());
+                        newSum.setPrice(newSum.getPrice().subtract(orderDetail1.getPrice().multiply(BigDecimal.valueOf(orderDetail1.getPlanNum()))));
+                        newSum.setStockNumber(newSum.getStockNumber()-orderDetail1.getPlanNum());
+                        //过质保数？临近质保？报废数？
+                        flag=true;
+                        break;
+                    }
+                }
+                if (!flag){
+                    //新增一条数据并且返回
+                    InventorySummary newSummary = addNewSum(orderMain, orderDetail1, orgCode);
+                    newList.add(newSummary);
+                }
+            }
+        }
+        //保存新的inventorySummary数据
+        //如果newList不为空则save
+        if(newList.size()>0){
+            inventorySummaryService.saveBatch(newList);
+        }
+        //如果删除list不为空，那么进行批量删除
+        if (deleteList.size()>0){
+            inventorySummaryService.removeBatchByIds(deleteList);
+        }
+        //将orderSum和newSum两个列表进行拼接，最终得到一个更新的list进行更新
+        List<InventorySummary> totalSumList=new ArrayList<>();
+        totalSumList.addAll(oldSummaryList);
+        totalSumList.addAll(newSummaryList);
+        return inventorySummaryService.updateBatchById(totalSumList);
+    }
+
+    //新增一条inventorysummary数据
+    public InventorySummary addNewSum(OrderMain orderMain,OrderDetail orderDetail1,String orgCode){
+        InventorySummary newSummary = new InventorySummary();
+        newSummary.setOrgId(orderMain.getEndOrgId());
+        newSummary.setOrgName(orderMain.getEndOrgName());
+        newSummary.setOrgCode(orgCode);
+        newSummary.setTypeId(orderDetail1.getTypeId());
+        newSummary.setTypeName(orderDetail1.getTypeName());
+        newSummary.setSizeId(orderDetail1.getSizeId());
+        newSummary.setSizeName(orderDetail1.getSizeName());
+        newSummary.setLocationId(orderMain.getLocationId());
+        newSummary.setLocationName(orderMain.getLocationName());
+        newSummary.setLocationType("0");
+        newSummary.setNumber(orderDetail1.getPlanNum());
+        newSummary.setPrice(orderDetail1.getPrice().multiply(BigDecimal.valueOf(orderDetail1.getPlanNum())));
+        newSummary.setUnitPrice(orderDetail1.getPrice());
+        newSummary.setStockNumber(orderDetail1.getPlanNum());
+        newSummary.setCreateTime(DateTimeUtil.getCurrentDateTime());
+        return newSummary;
+    }
+
+
 
 }

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

@@ -720,7 +720,7 @@ public class PolicemanServiceImpl extends ServiceImpl<PolicemanMapper, Policeman
             StartProcessInstanceDTO startProcessInstanceDTO=new StartProcessInstanceDTO();
             startProcessInstanceDTO.setProcessDefinitionId(req.getProcessDefinitionId());
             startProcessInstanceDTO.setOrderId(reassignment.getId());
-            startProcessInstanceDTO.setOrderType("reassigmentOrder");
+            startProcessInstanceDTO.setOrderType("reassigment");
             startProcessInstanceDTO.setUserId(req.getUserId());
             String ProcessInstanceId= FlowInstanceService.startProcessInstanceById(startProcessInstanceDTO);
             reassignment.setProcessId(ProcessInstanceId);

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

@@ -466,6 +466,14 @@
             #{item}
         </foreach>
     </select>
+    <select id="selectEqsByItem" resultType="com.junmp.jyzb.entity.Inventory">
+        select * from base_inventory where
+        <foreach collection="list" item="item"  separator="or">
+            (
+            location_state = 'in' AND state = 'normal' AND org_id_int = ${item[0]} AND location_id = '${item[1]}' AND type_id = ${item[3]} AND size_id = '${item[2]}' AND unit_price = ${item[4]}
+            )
+        </foreach>
+    </select>
 
 
 </mapper>
\ No newline at end of file

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

@@ -279,7 +279,7 @@
         GROUP BY size_id,type_id
         HAVING stockNumber>0
     </select>
-    <select id="selectByItems" resultType="com.junmp.jyzb.entity.InventorySummary">
+    <select id="selectSumByItems" resultType="com.junmp.jyzb.entity.InventorySummary">
         select * from base_inventory_summary where
         <foreach collection="list" item="item"  separator="or">
             (