Merge remote-tracking branch 'origin/12.31外协分选发出' into 12.31外协分选发出

src/main/java/cn/ezhizao/project/business/outsource/domain/BizOutsourcedOrderDetailProcess.java

@@ -101,4 +101,5 @@ public class BizOutsourcedOrderDetailProcess extends BaseEntity
     private Integer qualifiedNum;
     private BigDecimal loss;
     private Integer productionNum;
+    private Integer status;
 }

src/main/java/cn/ezhizao/project/business/product/controller/BizDayworkController.java

@@ -668,12 +668,13 @@ public class BizDayworkController extends BaseController {
                     .collect(Collectors.toList());
             // 再根据整合后报工明细中对应的 daywork_id 的集合，获取到对应的 daywork 集合
             if (keywords.isEmpty())
-                dayworks = bizDayworkService.query().in("id", dayworkIds).list();
+                dayworks = bizDayworkService.query().in("id", dayworkIds).eq("dept_id", deptId).list();
             else if (!lots.isEmpty()) {
                 List<Long> lotIds = lots.stream().map(BizLot::getId).collect(Collectors.toList());
                 dayworks = bizDayworkService.query()
                         .in("id", dayworkIds)
                         .in("lot_id", lotIds)
+                        .eq("dept_id", deptId)
                         .list();
             }
             if (dayworks.isEmpty())
@@ -1079,7 +1080,7 @@ public class BizDayworkController extends BaseController {
                     daywork.setHasFinishOutsource(false);
                     //如果干完了发往外协的序，则不显示申请周转按钮
                     BizOutsourcedOrderDetailProcess lastOutsourcedOrderDetailProcess = outsourcedDetailProcessList.stream().filter(v -> v.getDayworkId().equals(daywork.getId())).sorted(Comparator.comparing(BizOutsourcedOrderDetailProcess::getProcessStepNumber).reversed()).findFirst().orElse(null);
-                    if(daywork.getDayworkItemList().get(0).getProcessStepNumber().equals(lastOutsourcedOrderDetailProcess.getProcessStepNumber()) && daywork.getDayworkItemList().get(0).getStatus().equals("3")){
+                    if(daywork.getDayworkItemList().get(0).getProcessStepNumber().equals(lastOutsourcedOrderDetailProcess.getProcessStepNumber()) && daywork.getDayworkItemList().stream().filter(v -> v.getProcessStepNumber().equals(lastOutsourcedOrderDetailProcess.getProcessStepNumber())).anyMatch(l->l.getStatus().equals("3"))){
                         daywork.setHasFinishOutsource(true);
                     }
 
@@ -1124,7 +1125,530 @@ public class BizDayworkController extends BaseController {
                 }
             }
         }
-        return success(dayworkList);
+        //如果报工记录最新的记录的isSort是1才返回
+        List<BizDaywork> newList = new ArrayList<>();
+        if(dayworkList.size()>0){
+            dayworkList.stream().forEach(v->{
+                if(v.getDayworkItemList().get(0).getIsSort() == 0){
+                    newList.add(v);
+                }
+            });
+        }
+        return success(newList);
+    }
+
+    @Transactional
+    @GetMapping("/innerSortList")
+    @Log(title = "获取报工列表", businessType = BusinessType.SELECT)
+    public AjaxResult innerSortList(BizDaywork bizDaywork) {
+        SysUser user = SecurityUtils.getLoginUser().getUser();
+        Long userId = user.getUserId();
+        Long productionPlanDetailId = bizDaywork.getProductionPlanDetailId();
+        Long deptId = bizDaywork.getDeptId();
+        String keywords = bizDaywork.getKeywords();
+
+        // 如果关键字不为空，则根据关键字匹配批次，后面会根据批次进行daywork过滤
+        List<BizLot> lots = new ArrayList<>();
+        if (!keywords.isEmpty()) {
+            List<BizLot> lotList1 = bizLotService.query()
+                    .like("lot_code", keywords)
+                    .list();
+            List<Long> dayworkCarrierIds = bizDayworkCarrierService.query().like("carrier_code", keywords).eq("process_inspection_id", 0L).eq("is_changed",0).list().stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList());
+            List<BizDaywork> dayworkByCarriers = bizDayworkService.query().in("id", dayworkCarrierIds.isEmpty() ? Collections.singletonList(0L) : dayworkCarrierIds).list();
+            List<BizLot> lotList2 = bizLotService.query().in("id", dayworkByCarriers.isEmpty() ? Collections.singletonList(0L) : dayworkByCarriers.stream().map(BizDaywork::getLotId).collect(Collectors.toList())).list();
+            Set<BizLot> uniqueSet = Stream.of(lotList1, lotList2)
+                    .flatMap(Collection::stream)
+                    .collect(Collectors.toSet());
+            lots = uniqueSet.stream().collect(Collectors.toList());
+            if (lots.isEmpty()) {
+                return success(new ArrayList<>());
+            }
+        }
+        // 获取当前用户的，针对当前部门以及当前生产计划下的报工集合
+        List<BizDayworkItem> myDayworkItems = bizDayworkItemService.query()
+                .eq("dept_id", deptId)
+                .eq("production_plan_detail_id", productionPlanDetailId)
+                .eq("user_id", userId)
+                .list();
+        List<BizProductionPlanDetail> planDetailslanDetails = new ArrayList<>();
+        List<BizDaywork> dayworks = new ArrayList<>();
+        // 定义一个所有的报工集合，用于后续接收所有的某个批次的报工记录
+        List<BizDayworkItem> allDayworkItems = new ArrayList<>();
+        List<BizLot> lotList = new ArrayList<>();
+        if (!myDayworkItems.isEmpty()) {
+            // 将报工记录中的daywork_id，整个到一个List集合中，用于后续的查询
+            List<Long> dayworkIds = myDayworkItems.stream()
+                    .map(BizDayworkItem::getDayworkId)
+                    .collect(Collectors.toList());
+            // 再根据整合后报工明细中对应的 daywork_id 的集合，获取到对应的 daywork 集合
+            if (keywords.isEmpty())
+                dayworks = bizDayworkService.query().in("id", dayworkIds).eq("dept_id", deptId).list();
+            else if (!lots.isEmpty()) {
+                List<Long> lotIds = lots.stream().map(BizLot::getId).collect(Collectors.toList());
+                dayworks = bizDayworkService.query()
+                        .in("id", dayworkIds)
+                        .in("lot_id", lotIds)
+                        .eq("dept_id", deptId)
+                        .list();
+            }
+            if (dayworks.isEmpty())
+                return success(new ArrayList<>());
+
+            planDetailslanDetails = bizProductionPlanDetailService.query().in("id", dayworks.stream().map(BizDaywork::getProductionPlanDetailId).collect(Collectors.toList())).list();
+            // 根据得到的 daywork 集合，将 daywork_id 整合到集合中
+            List<Long> allDayworkIdList = dayworks.stream().map(BizDaywork::getId).collect(Collectors.toList());
+            // 再根据得到的daywork_id集合，获取所有的报工明细
+            allDayworkItems = bizDayworkItemService.query().in("daywork_id", allDayworkIdList.isEmpty() ? Collections.singletonList(0L) : dayworks.stream().map(BizDaywork::getId).collect(Collectors.toList())).list();
+            // 获取所有lotId
+            List<Long> allLotsIdList = dayworks.stream().map(BizDaywork::getLotId).collect(Collectors.toList());
+            lotList = bizLotService.query().in("id", allLotsIdList.isEmpty() ? Collections.singletonList(0L) : dayworks.stream().map(BizDaywork::getLotId).collect(Collectors.toList())).list();
+        }
+        List<Long> outsourceOrderDetailIds = new ArrayList<>();
+        for (BizDaywork item : dayworks) {
+            BizDayworkItem lastDayworkItem = allDayworkItems.stream().filter(v -> v.getDayworkId().equals(item.getId()))
+                    .sorted(Comparator.comparing(BizDayworkItem::getProcessStepNumber).reversed())
+                    .sorted(Comparator.comparing(BizDayworkItem::getCreateTime).reversed())
+                    .findFirst().orElse(new BizDayworkItem());
+            outsourceOrderDetailIds.add(lastDayworkItem.getOutsourceDetailId());
+        };
+        //收回单明细
+        List<BizReturnReceiptDetail> returnReceiptDetailList = bizReturnReceiptDetailService.query().in("outsource_detail_id", outsourceOrderDetailIds).list();
+        //发出单工序
+        List<BizOutsourcedOrderDetailProcess> outsourcedDetailProcessList = bizOutsourcedOrderDetailProcessService.query().in("detail_id", outsourceOrderDetailIds).list();
+        // 定义一个daywork空的list集合，用于存储符合条件（根据daywork的id，获得到对应的最新一条daywork_item，当该条daywork_item的状态值 < 5时，则添加）的daywork
+        List<BizDaywork> dayworkList = new ArrayList<>();
+        // 对之前获取到的 daywork 集合进行过滤，将符合条件的daywork，添加到dayworkList集合中
+        for (BizDaywork item : dayworks) {
+            if (!planDetailslanDetails.isEmpty()) {
+                //设置尾批量
+                item.setLastLotQuantity(planDetailslanDetails.stream().filter(v -> v.getId().equals(item.getProductionPlanDetailId())).collect(Collectors.toList()).get(0).getLastLotQuantity());
+            }
+            //如果内部外协有收回单，则不展示
+            BizDayworkItem lastDayworkItem = allDayworkItems.stream().filter(v -> v.getDayworkId().equals(item.getId()))
+                    .sorted(Comparator.comparing(BizDayworkItem::getProcessStepNumber).reversed())
+                    .sorted(Comparator.comparing(BizDayworkItem::getCreateTime).reversed())
+                    .findFirst().orElse(new BizDayworkItem());
+            List<BizReturnReceiptDetail> returnReceiptDetail = returnReceiptDetailList.stream().filter(v -> v.getOutsourceDetailId().equals(lastDayworkItem.getOutsourceDetailId())).collect(Collectors.toList());
+            //添加批次单批量
+            item.setOneLotQuantity(lotList.stream().filter(v -> v.getId().equals(item.getLotId())).collect(Collectors.toList()).get(0).getProductionQuantity());
+            //拿到批次是否批废信息
+            item.setIsWaste(lotList.stream().filter(v -> v.getId().equals(item.getLotId())).collect(Collectors.toList()).get(0).getIsWaste());
+            // 根据当前的dayworkId，获取相应的daywork_item集合，并根据创建日期进行倒叙排序
+            // 原代码中对报工进行了按当前登录者user_id的判断，这样，就无法真实获取到当前批次的状态，而是当前登录者的报工状态。
+            // 如果该批次是一个人操作的，则没有问题，如果是多人（邀请报工），通过user_id过滤后，就会出现状态不准的情况。
+            // 所以需要将filter中，user_id过滤去掉
+            /*
+            List<BizDayworkItem> currentDayworkItems = allDayworkItems.stream()
+                    .filter(di -> di.getDayworkId().equals(item.getId()) && di.getUserId().equals(userId))
+                    .sorted(Comparator.comparing(BizDayworkItem::getCreateTime).reversed())
+                    .collect(Collectors.toList());
+             */
+            List<BizDayworkItem> currentDayworkItems = allDayworkItems.stream()
+                    .filter(di -> di.getDayworkId().equals(item.getId()))
+                    .sorted(Comparator.comparing(BizDayworkItem::getCreateTime).reversed())
+                    .collect(Collectors.toList());
+            // 获取最后一条报工明细
+            BizDayworkItem latest = currentDayworkItems.get(0);
+            // 获取最后一条非周转报工，通过过滤掉“4”状态的报工明细，获取到最新的一条非“4”状态的报工明细，避免后续的与 < 5 的条件冲突
+            BizDayworkItem latestNoTurnover = currentDayworkItems.stream().filter(v -> v.getStatus().compareTo("4") < 0)
+                    .max(Comparator.comparing(BizDayworkItem::getCreateTime)).orElse(new BizDayworkItem());
+            BizDayworkItem latestProcess = currentDayworkItems.stream().filter(v -> v.getProcessStepNumber().equals(latestNoTurnover.getProcessStepNumber()) && v.getUserId().equals(userId)).findFirst().orElse(null);
+            String status = currentDayworkItems.stream().filter(v -> v.getTechnologicalProcessDetailId().equals(latest.getTechnologicalProcessDetailId()))
+                    .collect(Collectors.toList())
+                    .get(0)
+                    .getStatus();
+            // 原程序中这里的判断条件是：user_id == 当前登录者user_id && status < 5，但这里不应该判断登录者user_id，而是直接判断状态值，
+            // 因为，如果该批次是多人操作的，那么，该批次的报工状态，应该是所有人的，所以，这里不应该判断user_id
+            // if (latest.getUserId().equals(userId) && Integer.parseInt(status) < 5) {
+
+            // 判断最后一道报工记录的部门id，与当前登录者的部门id相同，并且状态 < 5
+            // 状态 == 5 时，说明已经进入周转中，那么该条daywork，将不再页面中显示，所以，通过对status的值的判断，添加到daywork集合中
+            // 最后一条非周转报工的工段为当前工段。
+            //20240806添加isSpecial!=1将最新一条报工为特殊报工的批次删除
+            if (!latestNoTurnover.getIsSpecial().equals(1) && latestNoTurnover.getDeptId().equals(deptId) && Integer.parseInt(status) < 5 && latestProcess != null && returnReceiptDetail.size() == 0) {
+                // 获取当前操作者自己的报工记录
+                List<BizDayworkItem> currentMyDayworkItems = myDayworkItems.stream()
+                        .filter(di -> di.getDayworkId().equals(item.getId()))
+                        .sorted(Comparator.comparing(BizDayworkItem::getCreateTime))
+                        .collect(Collectors.toList());
+                // 将获取到的 day_work_item 集合，赋值给daywork中的相对应属性
+                item.setDayworkItemList(currentMyDayworkItems);
+                dayworkList.add(item);
+            }
+        }
+
+
+        // 如果有报工数据
+        if (!dayworkList.isEmpty()) {
+            // 将符合条件（需要在页面展示的daywork）的 dayworkList 中的 technologicalProcessId，整合到一个List集合中，需要根据这些technologicalProcessId，获取到相应的工艺工序清单
+            System.out.println("有报工数据:" + dayworkList);
+            List<Long> technologicalProcessIds = dayworkList.stream()
+                    .map(BizDaywork::getTechnologicalProcessId)
+                    .collect(Collectors.toList());
+            // 根据 technologicalProcessIds 获取符合条件的所有工艺工序清单
+            List<BizTechnologicalProcessDetail> technologicalProcessDetails = bizTechnologicalProcessDetailService.query()
+                    .in("technological_process_id", technologicalProcessIds).ne("tenant_id", 9)
+                    .list();
+            // 将符合条件的所有工艺工序清单中的工序id（process_id），整合到一个List集合中
+            List<Long> processIds = technologicalProcessDetails.stream()
+                    .map(BizTechnologicalProcessDetail::getProcessId)
+                    .collect(Collectors.toList());
+            // 根据得到的工序id集合，获得相对应的工序集合
+            List<BizTechnologicalProcessDetail> allTechnologicalProcessDetails = bizTechnologicalProcessDetailService.query().in("technological_process_id", technologicalProcessIds).ne("tenant_id", 9).list();
+            List<Long> finalProcessIds = processIds;
+            List<BizTechnologicalProcessDetail> processList = allTechnologicalProcessDetails.stream().filter(ap -> finalProcessIds.contains(ap.getProcessId())).collect(Collectors.toList());
+
+            // 将最终要显示的daywork集合中的daywork_id整合到一个List集合中，用于后续根据daywork_id获取对应的箱号
+            List<Long> dayworkIdList = dayworkList.stream()
+                    .map(BizDaywork::getId)
+                    .collect(Collectors.toList());
+
+            /* ****************************** 获取daywork 与 箱子 carrier 相关 ****************************** */
+            // 根据daywork_id的集合，获取到所有daywork与箱子关联的中间表 biz_daywork_carrier，用于在循环中精确查询匹配的箱子
+            List<BizDayworkCarrier> dayworkCarriers = bizDayworkCarrierService.query()
+                    .eq("process_inspection_id", 0L)
+                    .in("daywork_id", dayworkIdList)
+                    .eq("is_changed", 0)
+                    .list();
+            // 将箱子的id整合到一个List集合中，用于循环中，进行箱子的查询
+            List<Long> carrierIds = dayworkCarriers.stream()
+                    .map(BizDayworkCarrier::getCarrierId)
+                    .collect(Collectors.toList());
+            // 根据箱子id的集合，获取所有的箱子集合
+            List<BizCarrier> carriers = new ArrayList<>();
+            if (!carrierIds.isEmpty()) {
+                carriers = bizCarrierService.query().in("id", carrierIds).list();
+            }
+
+            /* ****************************** 获取与 daywork 相关的所有批次，为了获取每个批次中的投产数 ****************************** */
+            // 直接通过daywork中的 technological_process_id 组成的集合，获取到对应的批次工艺工序清单，解决【正常】与【异常】冲突的问题
+            List<Long> allTechnologicalProcessIds = dayworkList.stream().map(BizDaywork::getTechnologicalProcessId).collect(Collectors.toList());
+
+            List<BizLotTechnologicalProcessDetail> allLotTechnologicalDetails = bizLotTechnologicalProcessDetailService.query()
+                    .in("lot_technological_process_id", allTechnologicalProcessIds)
+                    .list();
+
+            List<BizLotTechnologicalProcessDetail> technologicalDetailList = new ArrayList<>();
+
+            /* ****************************** 获取 daywork 与 【材质】相关 ****************************** */
+            List<BizFurnaceNoInfo> furnaceNoInfos = bizFurnaceNoInfoService.query()
+                    .in("daywork_id", dayworkIdList)
+                    .list();
+            //查询计划单下所有的报工记录
+            List<BizDayworkItem> totalDayworkItemList = bizDayworkItemService.query().eq("production_plan_detail_id", productionPlanDetailId).list();
+
+            // 循环最终要展示的 daywork 集合，根据每个daywork，精确赋予相关数据
+            List<Long> allLotIds = dayworkList.stream().map(BizDaywork::getLotId).collect(Collectors.toList());
+            List<BizLot> allLots = bizLotService.query().in("id", allLotIds).list();
+            List<Long> allDayworkIds = dayworkList.stream().map(BizDaywork::getId).collect(Collectors.toList());
+            //查找被邀请者的id
+            List<BizProductionResourceGroupDetail> protemResourceGroupDetail = bizProductionResourceGroupDetailService.query().in("protem_daywork_id", allDayworkIds.isEmpty() ? Collections.singletonList(0L) : allDayworkIds)
+                    .eq("common_id", userId).eq("common_type", "person").list();
+            List<Long> protemUserIds = protemResourceGroupDetail.stream().map(BizProductionResourceGroupDetail::getCreatorId).distinct().collect(Collectors.toList());
+            protemUserIds.add(0L);
+            List<SysUser> sysUsers = sysUserService.selectUserListByIds(protemUserIds);
+            //查找dayworkList工段所在的车间
+            List<Long> deptIds = dayworkList.stream().map(BizDaywork::getDeptId).collect(Collectors.toList());
+            SysDept dept = new SysDept();
+            dept.setDeptIds(deptIds);
+            List<SysDept> sysDeptList = sysDeptService.selectDeptList(dept);
+            List<Long> workshopIds = sysDeptList.stream().map(SysDept::getWorkshopId).collect(Collectors.toList());
+            List<BizWorkshop> workshopList = bizWorkshopService.query().in("id", workshopIds).list();
+            for (BizDaywork daywork : dayworkList) {
+                //把批次的lot投产数量加到daywork里
+                allLots.stream().filter(l -> l.getId().equals(daywork.getLotId()))
+                        .findFirst()
+                        .ifPresent(lot -> daywork.setProductionQuantity(lot.getProductionQuantity()));
+
+                // 根据当前的 daywork 的 id，获取到 daywork_item 的集合，并根据 daywork_item 的 create_time 进行倒叙
+                // 之所以通过时间倒叙，目的是在后续过程中，通过get(0)的方式，获得最新的一条报工记录
+                List<BizDayworkItem> tempDayworkItems = totalDayworkItemList.stream()
+                        .filter(di -> di.getDayworkId().equals(daywork.getId()))
+                        .sorted(Comparator.comparing(BizDayworkItem::getCreateTime).reversed())
+                        .collect(Collectors.toList());
+                daywork.setDayworkItemList(tempDayworkItems);
+                /* ************************** 配置当前工段车间 ************************** */
+                SysDept sysDept = sysDeptList.stream().filter(v -> v.getDeptId().equals(daywork.getDeptId())).findFirst().orElse(null);
+                System.out.println("daywork："+daywork);
+                System.out.println("车间列表输出："+sysDeptList);
+                System.out.println("车间输出："+sysDept);
+                System.out.println("workshopList："+workshopList);
+                daywork.setWorkshopName(workshopList.stream().filter(w -> w.getId().equals(sysDept.getWorkshopId())).findFirst().orElse(null).getName());
+                /* ************************** 获取【daywork】所匹配的材质 ************************** */
+                BizFurnaceNoInfo furnaceNoInfo = furnaceNoInfos.stream()
+                        .filter(di -> di.getDayworkId().equals(daywork.getId()))
+                        .findFirst()
+                        .orElse(null);
+                daywork.setFurnaceNoInfo(furnaceNoInfo);
+
+                /* ************************** 以下是获取daywork对应的箱号 ************************** */
+                // 首先获取到该 daywork 对应的箱子的中间表数据
+                List<BizDayworkCarrier> dayworkCarrierList = dayworkCarriers.stream()
+                        .filter(dc -> dc.getDayworkId().equals(daywork.getId()))
+                        .collect(Collectors.toList());
+                // 再将中间表中的箱子id整合到List集合中
+                List<Long> carrierIdList = dayworkCarrierList.stream()
+                        .map(BizDayworkCarrier::getCarrierId)
+                        .collect(Collectors.toList());
+                // 中间表中存储的箱子id（carrier_id），过滤获得到箱子的集合
+                List<BizCarrier> carrierList = carriers.stream()
+                        .filter(c -> carrierIdList.contains(c.getId()))
+                        .collect(Collectors.toList());
+                // 得到箱子的集合后，将所有箱子的编码，整合成一个用中文“，”分割的字符串
+                String carrierCodes = carrierList.stream()
+                        .map(BizCarrier::getCode)
+                        .collect(Collectors.joining("，"));
+                daywork.setCarrierName(carrierCodes);
+
+                /* ************************** 以下是为了获得到所在区域 ************************** */
+                //select  place from biz_daywork_item where deleted =0 and daywork_id = #{id} and status =7 order by create_time desc limit 1
+                tempDayworkItems.stream()
+                        .filter(di -> Integer.parseInt(di.getStatus()) == 7)
+                        .max(Comparator.comparing(BizDayworkItem::getCreateTime))
+                        .ifPresent(tempDayworkItem -> daywork.setPlace(tempDayworkItem.getPlace()));
+
+                /* ************************** 以下是为了获得到上一道工序 ************************** */
+                //获得该批的工序
+                //如果该批是废品回用
+                if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                    //如果是废品回用，则它的工序从biz_technology_waste_recycling表查
+                    //拿到对应工艺id
+                    //废品回用的工序
+                    List<BizLotTechnologicalProcessDetail> lotTechnologicalDetails = allLotTechnologicalDetails.stream()
+                            .filter(twrd -> twrd.getLotTechnologicalProcessId().equals(daywork.getTechnologicalProcessId()))
+                            .collect(Collectors.toList());
+                    // 将符合条件的所有工序清单中的工序id（process_id），整合到一个List集合中
+                    processIds = lotTechnologicalDetails.stream()
+                            .map(BizLotTechnologicalProcessDetail::getProcessId)
+                            .collect(Collectors.toList());
+                    List<Long> tempProcessIds = processIds;
+                    // 根据得到的工序id集合，获得相对应的工序集合
+                    technologicalDetailList = allLotTechnologicalDetails.stream().filter(ap -> daywork.getTechnologicalProcessId().equals(ap.getLotTechnologicalProcessId()) && tempProcessIds.contains(ap.getProcessId())).collect(Collectors.toList());
+                }
+                // daywork_item的status > 4，表示已经离开当前工段，至少是周转中的状态
+                List<BizDayworkItem> finishedTempDayworkItems = tempDayworkItems.stream()
+                        .filter(di -> Integer.parseInt(di.getStatus()) > 4)
+                        .sorted(Comparator.comparing(BizDayworkItem::getCreateTime).reversed())
+                        .collect(Collectors.toList());
+                if (!finishedTempDayworkItems.isEmpty()) {
+                    BizProcess prevProcess = new BizProcess();
+                    if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                        BizLotTechnologicalProcessDetail technologicalDetail = technologicalDetailList.stream()
+                                // 通过get(0)的方式，获得最新的一条报工记录
+                                .filter(tp -> tp.getProcessStepNumber().equals(finishedTempDayworkItems.get(0).getProcessStepNumber()))
+                                .findFirst().orElse(null);
+                        if (technologicalDetail != null) {
+                            prevProcess.setId(technologicalDetail.getProcessId());
+                            prevProcess.setProcessAlias(technologicalDetail.getProcessAlias());
+                            prevProcess.setProcessCode(technologicalDetail.getProcessCode());
+                            prevProcess.setProcessStepNumber(technologicalDetail.getProcessStepNumber());
+                        }
+                    } else {
+                        BizTechnologicalProcessDetail technologicalProcessDetail = processList.stream()
+                                // 通过get(0)的方式，获得最新的一条报工记录
+                                .filter(tp -> tp.getProcessStepNumber().equals(finishedTempDayworkItems.get(0).getProcessStepNumber()))
+                                .findFirst().orElse(null);
+                        if (technologicalProcessDetail != null) {
+                            prevProcess.setId(technologicalProcessDetail.getProcessId());
+                            prevProcess.setProcessAlias(technologicalProcessDetail.getProcessAlias());
+                            prevProcess.setProcessCode(technologicalProcessDetail.getProcessCode());
+                            prevProcess.setProcessStepNumber(technologicalProcessDetail.getProcessStepNumber());
+                        }
+                    }
+                    daywork.setPrevProcess(prevProcess);
+                }
+
+                /* ************************** 以下是为了获得当前 daywork 的当前工序 ************************** */
+                // 如果集合不为空，则获取最后一次报工，对应的工序
+                if (!tempDayworkItems.isEmpty()) {
+                    BizProcess tempProcess = new BizProcess();
+                    if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                        BizLotTechnologicalProcessDetail technologicalDetail = technologicalDetailList.stream()
+                                // 通过get(0)的方式，获得最新的一条报工记录
+                                .filter(tp -> tp.getProcessStepNumber().equals(tempDayworkItems.get(0).getProcessStepNumber()))
+                                .findFirst().orElse(null);
+                        if (technologicalDetail != null) {
+                            tempProcess.setId(technologicalDetail.getProcessId());
+                            tempProcess.setProcessAlias(technologicalDetail.getProcessAlias());
+                            tempProcess.setProcessCode(technologicalDetail.getProcessCode());
+                            tempProcess.setProcessStepNumber(technologicalDetail.getProcessStepNumber());
+                        }
+                    } else {
+                        BizTechnologicalProcessDetail technologicalProcessDetail = processList.stream()
+                                // 通过get(0)的方式，获得最新的一条报工记录
+                                .filter(tp -> tp.getTechnologicalProcessId().equals(tempDayworkItems.get(0).getTechnologicalProcessId()) && tp.getProcessStepNumber().equals(tempDayworkItems.get(0).getProcessStepNumber()))
+                                .findFirst().orElse(null);
+                        if (technologicalProcessDetail != null) {
+                            tempProcess.setId(technologicalProcessDetail.getProcessId());
+                            tempProcess.setProcessAlias(technologicalProcessDetail.getProcessAlias());
+                            tempProcess.setProcessCode(technologicalProcessDetail.getProcessCode());
+                            tempProcess.setProcessStepNumber(technologicalProcessDetail.getProcessStepNumber());
+                        }
+                    }
+                    // 最新的一条报工记录对应的工序，就是当前批次的当前工序
+                    daywork.setCurrentProcess(tempProcess);
+                }
+
+                /* ************************** 以下是为了获得当前 daywork 的工艺工序清单 ************************** */
+                List<BizTechnologicalProcessDetail> currentDayworkProcessDetails = new ArrayList<>();
+                List<BizLotTechnologicalProcessDetail> currentLotDayworkDetails = new ArrayList<>();
+                //该批是废品回用
+                if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                    //如果是废品回用，则它的工序从biz_technology_waste_recycling表查
+                    //拿到对应工艺id
+                    //废品回用的工序(正序排列
+                    currentLotDayworkDetails = allLotTechnologicalDetails.stream()
+                            .filter(twrd -> twrd.getLotTechnologicalProcessId().equals(daywork.getTechnologicalProcessId()))
+                            .sorted(Comparator.comparing((BizLotTechnologicalProcessDetail::getProcessStepNumber)))
+                            .collect(Collectors.toList());
+                } else {
+                    // 将上面获得到的工艺数据，通过当前工艺主表的id，获得到当前的工艺列表，并根据工序序号，进行正序排列
+                    currentDayworkProcessDetails = technologicalProcessDetails.stream()
+                            .filter(pd -> pd.getTechnologicalProcessId().equals(daywork.getTechnologicalProcessId()) && pd.getTenantId() != 9)
+                            .sorted(Comparator.comparing((BizTechnologicalProcessDetail::getProcessStepNumber)))
+                            .collect(Collectors.toList());
+                }
+
+                /* ************************** 以下是为了获得当前 daywork 的 processSequence ************************** */
+                List<BizProcess> processSequence = new ArrayList<>();
+                //废品回用
+                if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                    for (BizLotTechnologicalProcessDetail detail : currentLotDayworkDetails) {
+                        BizProcess newProcess = new BizProcess();
+                        newProcess.setId(detail.getProcessId());
+                        newProcess.setProcessCode(detail.getProcessCode());
+                        newProcess.setProcessAlias(detail.getProcessAlias());
+                        newProcess.setTechnologicalProcessDetailId(detail.getId());
+                        newProcess.setProcessStepNumber(detail.getProcessStepNumber());
+                        processSequence.add(newProcess);
+                    }
+                    daywork.setProcessSequence(processSequence);
+                } else {
+                    for (BizTechnologicalProcessDetail detail : currentDayworkProcessDetails) {
+                        BizProcess newProcess = new BizProcess();
+                        newProcess.setId(detail.getProcessId());
+                        newProcess.setProcessCode(detail.getProcessCode());
+                        newProcess.setProcessAlias(detail.getProcessAlias());
+                        newProcess.setProcessStepNumber(detail.getProcessStepNumber());
+                        newProcess.setTechnologicalProcessDetailId(detail.getId());
+                        processSequence.add(newProcess);
+                    }
+                    daywork.setProcessSequence(processSequence);
+                }
+                /* ************************** 以下是为了获得当前登录这资源组信息，判断邀请报工 ************************** */
+                if (!sysUsers.isEmpty()) {
+                    List<BizProductionResourceGroupDetail> protemDetailList = protemResourceGroupDetail.stream().filter(item -> item.getProtemDayworkId().equals(daywork.getId())).collect(Collectors.toList());
+                    protemDetailList.forEach(item -> {
+                        item.setProtemCreatorName(sysUsers.stream().filter(label -> label.getUserId().equals(item.getCreatorId())).collect(Collectors.toList()).get(0).getNickName());
+                    });
+                    daywork.setProtemResourceGroupDetailList(protemDetailList);
+                }
+
+                /* ************************** 以下是为了获得当前 daywork 的下一道工序 ************************** */
+                // 判断当前工段
+                if (daywork.getCurrentProcess() != null) {
+                    //废品回用
+                    if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                        for (int i = 0; i < currentLotDayworkDetails.size(); i++) {
+                            if ((currentLotDayworkDetails.get(i).getProcessId().equals(daywork.getCurrentProcess().getId())
+                                    && currentLotDayworkDetails.get(i).getProcessStepNumber().equals(daywork.getCurrentProcess().getProcessStepNumber()))
+                                    && (i + 1) < currentLotDayworkDetails.size()) {
+                                // 根据工艺单查询下一道工序
+                                BizLotTechnologicalProcessDetail tempDetail = currentLotDayworkDetails.get(i + 1);
+                                BizProcess nextProcess = new BizProcess();
+                                nextProcess.setId(tempDetail.getProcessId());
+                                nextProcess.setProcessCode(tempDetail.getProcessCode());
+                                nextProcess.setProcessAlias(tempDetail.getProcessAlias());
+                                nextProcess.setProcessStepNumber(tempDetail.getProcessStepNumber());
+                                daywork.setNextProcess(nextProcess);
+                                // 先给一个默认的下道序
+                                daywork.setNextDeptProcess(daywork.getNextProcess().getProcessAlias());
+                            }
+                        }
+                    } else {
+                        for (int i = 0; i < currentDayworkProcessDetails.size(); i++) {
+                            if (currentDayworkProcessDetails.get(i).getProcessId().equals(daywork.getCurrentProcess().getId())
+                                    &&
+                                    (i + 1) < currentDayworkProcessDetails.size()) {
+                                // 根据工艺单查询下一道工序
+                                BizTechnologicalProcessDetail tempDetail = currentDayworkProcessDetails.get(i + 1);
+                                BizProcess nextProcess = new BizProcess();
+                                nextProcess.setId(tempDetail.getProcessId());
+                                nextProcess.setProcessCode(tempDetail.getProcessCode());
+                                nextProcess.setProcessAlias(tempDetail.getProcessAlias());
+                                nextProcess.setProcessStepNumber(tempDetail.getProcessStepNumber());
+                                daywork.setNextProcess(nextProcess);
+                                // 先给一个默认的下道序
+                                daywork.setNextDeptProcess(daywork.getNextProcess().getProcessAlias());
+                            }
+                        }
+                    }
+                }
+
+                /* ************************** 以下是为了获得当前 daywork 的状态，用于前端显示 ************************** */
+                //查询工段下工序有没有未周转的批次
+                if (!daywork.getDayworkItemList().isEmpty()) {
+                    boolean foundStatus3 = false;
+                    boolean foundStatus2 = false;
+                    boolean foundStatus1 = false;
+                    daywork.setHasFinishOutsource(false);
+                    //如果干完了发往外协的序，则不显示申请周转按钮
+                    BizOutsourcedOrderDetailProcess lastOutsourcedOrderDetailProcess = outsourcedDetailProcessList.stream().filter(v -> v.getDayworkId().equals(daywork.getId())).sorted(Comparator.comparing(BizOutsourcedOrderDetailProcess::getProcessStepNumber).reversed()).findFirst().orElse(null);
+                    if(daywork.getDayworkItemList().get(0).getProcessStepNumber().equals(lastOutsourcedOrderDetailProcess.getProcessStepNumber()) && daywork.getDayworkItemList().stream().filter(v -> v.getProcessStepNumber().equals(lastOutsourcedOrderDetailProcess.getProcessStepNumber())).anyMatch(l->l.getStatus().equals("3"))){
+                        daywork.setHasFinishOutsource(true);
+                    }
+
+                    for (BizDayworkItem item : daywork.getDayworkItemList()) {
+                        if (daywork.getCurrentProcess() != null && item.getProcessStepNumber().equals(daywork.getCurrentProcess().getProcessStepNumber())) {
+                            // 最后一道工序的工序步骤序号
+                            String lastProcessStepNumber = "";
+                            if (daywork.getIsAmend() == 1 || daywork.getIsWasteRecycling() == 1) {
+                                lastProcessStepNumber = currentLotDayworkDetails.get(currentLotDayworkDetails.size() - 1).getProcessStepNumber();
+                            } else {
+                                lastProcessStepNumber = currentDayworkProcessDetails.get(currentDayworkProcessDetails.size() - 1).getProcessStepNumber();
+                            }
+                            // 如果工序为工艺最后一道工序且工序完成 ，那么状态为4 工序完成
+                            if ("3".equals(item.getStatus()) && item.getProcessStepNumber().equals(lastProcessStepNumber)) {
+                                daywork.setStatus(4);
+                                break;
+                            }
+                            //如果item状态为待周转那么批次报工状态为周转中
+                            else if ("4".equals(item.getStatus())) {
+                                daywork.setStatus(3);
+                                foundStatus3 = true;
+                            }
+                            //如果item状态为3待周转那么批次报工状态为待周转
+                            else if ("3".equals(item.getStatus()) && !foundStatus3) {
+                                daywork.setStatus(2);
+                                foundStatus2 = true;
+                            }
+                            //如果item状态为1,2进行中那么批次报工状态为进行中
+                            else if (("1".equals(item.getStatus()) || "2".equals(item.getStatus())) && !foundStatus3 && !foundStatus2) {
+                                daywork.setStatus(1);
+                                foundStatus1 = true;
+                            }
+                        }
+
+                        if (!foundStatus3 && !foundStatus2 && !foundStatus1) {
+                            // 如果最新的 item 只有一条且状态是未开始，那么整个批次报工为未开始状态
+                            if (daywork.getDayworkItemList().size() == 1 && daywork.getDayworkItemList().get(0).getStatus().equals("0")) {
+                                daywork.setStatus(0);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        //如果报工记录最新的记录的isSort是1才返回
+        List<BizDaywork> newList = new ArrayList<>();
+        if(dayworkList.size()>0){
+            dayworkList.stream().forEach(v->{
+                if(v.getDayworkItemList().get(0).getIsSort() == 1){
+                    newList.add(v);
+                }
+            });
+        }
+        return success(newList);
     }
 
     private void setAllDayworkItemsAndLots(List<BizDayworkItem> myDayworkItems, String keywords, List<BizDaywork> dayworks, List<BizDayworkItem> allDayworkItems, List<BizLot> lotList, List<BizLot> lots) {
@@ -1887,6 +2411,7 @@ public class BizDayworkController extends BaseController {
             bizDayworkItem.setDeptName(l.getDeptName());
             bizDayworkItem.setLotId(l.getDaywork().getLotId());
             bizDayworkItem.setOutsourceDetailId(l.getOutsourceDetailId());
+            bizDayworkItem.setIsWx(1);
             adds.add(bizDayworkItem);
         });
 

src/main/java/cn/ezhizao/project/business/product/controller/BizDayworkItemController.java

@@ -912,6 +912,7 @@ public class BizDayworkItemController extends BaseController {
             outsourcedOrderDetailProcess.setQualifiedNum(sum);
             float percent = ((outsourcedOrderDetailProcess.getProductionNum() - outsourcedOrderDetailProcess.getQualifiedNum()) / (float) outsourcedOrderDetailProcess.getProductionNum()) * 100;
             outsourcedOrderDetailProcess.setLoss(BigDecimal.valueOf(percent));
+            outsourcedOrderDetailProcess.setStatus(1);
             bizOutsourcedOrderDetailProcessService.updateById(outsourcedOrderDetailProcess);
         }
         //如果没有合格数，则投产数量为总数量，上道序的合格数为下到序的投产数
@@ -1709,6 +1710,7 @@ public class BizDayworkItemController extends BaseController {
                 bizItem.setProdNum(lot);
                 bizItem.setEquipmentDetailId(lastItem.getEquipmentDetailId());
                 bizItem.setEquipmentDetailCode(lastItem.getEquipmentDetailCode());
+                bizItem.setIsSort(lastItem.getIsSort());
                 bizItem.setDeptId(bizDayworkItem.getDeptId());
                 bizItem.setDeptName(bizDayworkItem.getDeptName());
                 bizItem.setStartTime(bizDayworkItem.getStartTime());
@@ -1725,6 +1727,7 @@ public class BizDayworkItemController extends BaseController {
 
                 bizItem.setProcessStepNumber(lastItem.getProcessStepNumber());
                 bizItem.setOutsourceDetailId(lastItem.getOutsourceDetailId());
+                bizItem.setIsWx(1);
                 batch = batch && bizDayworkItemService.saveOrUpdate(bizItem);
                 // 自动派活
                 SysDept sysDept = sysDeptMapper.selectDeptById(bizDayworkItem.getDeptId());

src/main/java/cn/ezhizao/project/business/product/controller/BizProductionPlanDetailController.java

@@ -264,9 +264,11 @@ public class BizProductionPlanDetailController extends BaseController {
                 .list();
         //内部外协已经收回的批次，则不展示收回单
             SysDept sysDept = sysDeptService.selectDeptById(bizProductionPlanDetail.getDeptId());
-                List<BizOutsourcedOrderDetail> outsourcedOrderDetailList = bizOutsourcedOrderDetailService.query()
+        List<BizOutsourcedOrder> outsourceOrderList = bizOutsourcedOrderService.query().eq("outsource_dept_id", sysDept.getDeptId()).list();
+        List<BizOutsourcedOrderDetail> outsourcedOrderDetailList = bizOutsourcedOrderDetailService.query()
                         .in("production_plan_detail_id", tempPlanDetailIds.isEmpty() ? Collections.singletonList(0L):tempPlanDetailIds)
                         .eq("supplier_id", sysDept.getSupplierId())
+                .in("master_id", outsourceOrderList.isEmpty() ? Collections.singletonList(0L): outsourceOrderList.stream().map(BizOutsourcedOrder::getId).collect(Collectors.toList()))
                     .list();
                 List<BizReturnReceiptDetail> returnReceiptDetail = bizReturnReceiptDetailService.query()
                         .in("outsource_detail_id", outsourcedOrderDetailList.isEmpty() ? Collections.singletonList(0L) : outsourcedOrderDetailList.stream().map(BizOutsourcedOrderDetail::getId).collect(Collectors.toList()))
@@ -277,16 +279,12 @@ public class BizProductionPlanDetailController extends BaseController {
                if(!collect.isEmpty()){
                    //该计划单有发出单
                   for(BizOutsourcedOrderDetail v:collect){
-                      if(!returnReceiptDetail.stream().filter(l-> l.getOutsourceDetailId().equals(v.getId())).collect(Collectors.toList()).isEmpty()){
+                      if(returnReceiptDetail.stream().filter(l-> l.getOutsourceDetailId().equals(v.getId())).collect(Collectors.toList()).isEmpty()){
                           if(!newList.contains(item)) {
                               newList.add(item);
                           }
                       }
                   }
-               }else{
-                   if(!newList.contains(item)) {
-                       newList.add(item);
-                   }
                }
             }
 

src/main/java/cn/ezhizao/project/business/product/controller/SortDayworkController.java

@@ -417,10 +417,11 @@ public class SortDayworkController extends BaseController {
         BizDayworkItem item = bizDayworkItemService.getById(bizDayworkItem.getId());
         //修改发出单报工合格数，投产数及折损率
         BizOutsourcedOrderDetailProcess outsourcedOrderDetailProcess = bizOutsourcedOrderDetailProcessService.query().eq("daywork_id", item.getDayworkId()).eq("process_step_number", item.getProcessStepNumber()).one();
-        outsourcedOrderDetailProcess.setProductionNum(item.getProdNum());
-        outsourcedOrderDetailProcess.setQualifiedNum(item.getQualifiedNum());
+        outsourcedOrderDetailProcess.setProductionNum(bizDayworkItem.getProdNum());
+        outsourcedOrderDetailProcess.setQualifiedNum(bizDayworkItem.getQualifiedNum());
         float percent = ((outsourcedOrderDetailProcess.getProductionNum() - outsourcedOrderDetailProcess.getQualifiedNum()) / (float) outsourcedOrderDetailProcess.getProductionNum()) * 100;
         outsourcedOrderDetailProcess.setLoss(BigDecimal.valueOf(percent));
+        outsourcedOrderDetailProcess.setStatus(1);
         bizOutsourcedOrderDetailProcessService.updateById(outsourcedOrderDetailProcess);
         BizDayworkItemReject delCondition = new BizDayworkItemReject();
         delCondition.setDayworkItemId(item.getId());
@@ -671,10 +672,11 @@ public class SortDayworkController extends BaseController {
             bizDayworkItem.setProcessId(l.getDaywork().getProcessId());
             bizDayworkItem.setTechnologicalProcessDetailId(l.getDaywork().getTechnologicalProcessDetailId());
             bizDayworkItem.setDeptId(l.getDeptId());
-            bizDayworkItem.setIsSort(l.getIsSort());
+            bizDayworkItem.setIsSort(1);
             bizDayworkItem.setDeptName(l.getDeptName());
             bizDayworkItem.setLotId(l.getDaywork().getLotId());
             bizDayworkItem.setOutsourceDetailId(l.getOutsourceDetailId());
+            bizDayworkItem.setIsWx(1);
             adds.add(bizDayworkItem);
         });
 

src/main/java/cn/ezhizao/project/business/product/domain/BizDayworkItem.java

@@ -311,4 +311,5 @@ public class BizDayworkItem extends BaseEntity
     private Long fromDeptId;
     //外协发出明细
     private Long  outsourceDetailId;
+    private Integer isWx;
 }