1.22

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

@@ -624,6 +624,473 @@ public class BizDayworkController extends BaseController {
         return success(dayworkList);
     }
     @Transactional
+    @GetMapping("/assistList")
+    @Log(title = "获取报工列表", businessType = BusinessType.SELECT)
+    public AjaxResult assistList(BizDaywork bizDaywork) {
+        Long deptId = bizDaywork.getDeptId();
+        String keywords = bizDaywork.getKeywords();
+        startPage();
+        List<BizDaywork> dayworks = bizDayworkService.getAssistDayworkList(bizDaywork);
+//        // 如果关键字不为空，则根据关键字匹配批次，后面会根据批次进行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)
+                .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("status",1).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)
+//                        .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();
+//        }
+
+        // 定义一个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());
+                item.setProductDescription(planDetailslanDetails.stream().filter(v -> v.getId().equals(item.getProductionPlanDetailId())).collect(Collectors.toList()).get(0).getProductDescription());
+                item.setProductionPlanId(planDetailslanDetails.stream().filter(v -> v.getId().equals(item.getProductionPlanDetailId())).collect(Collectors.toList()).get(0).getProductionPlanId());
+                item.setRequisitionDepartmentId(planDetailslanDetails.stream().filter(v -> v.getId().equals(item.getProductionPlanDetailId())).collect(Collectors.toList()).get(0).getRequisitionDepartmentId());
+            }
+            //添加批次单批量
+            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())).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) {
+                // 获取当前操作者自己的报工记录
+                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("dept_id", deptId).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());
+            //查找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);
+                //所有操作者
+                daywork.setAllNickName(tempDayworkItems.stream().filter(item->item.getStatus().compareTo("4")<0).map(BizDayworkItem::getNickName).distinct().collect(Collectors.joining(",")));
+
+                /* ************************** 配置当前工段车间 ************************** */
+                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);
+                }
+
+                /* ************************** 以下是为了获得当前 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;
+
+                    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);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return success(dayworkList);
+    }
+    @Transactional
     @GetMapping("/innerList")
     @Log(title = "获取报工列表", businessType = BusinessType.SELECT)
     public AjaxResult innerList(BizDaywork bizDaywork) {

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

@@ -120,48 +120,6 @@ public class BizDayworkItemController extends BaseController {
     @GetMapping("/list")
     @Log(title = "查询报工记录", businessType = BusinessType.SELECT)
     public TableDataInfo list(BizDayworkItem bizDayworkItem) {
-//        SysUser user = SecurityUtils.getLoginUser().getUser();
-////        startPage();
-//        bizDayworkItem.setUserId(user.getUserId());
-//        List<BizDayworkItem> list = bizDayworkItemService.getList(bizDayworkItem);
-//        //人员只能看到最近的一条报工记录中工序的报工
-//        List<BizDayworkItem> itemList = new ArrayList<>();
-//        Long processId = 0L;
-//        if (list.size() > 0) {
-//            processId = list.get(0).getProcessId();
-//        }
-//        /** 根据当前工序查询下一道工序 */
-//        for (BizDayworkItem item : list) {
-//            for (int i = 0; i < item.getProcessSequence().size(); i++) {
-//                if ((i + 1) < item.getProcessSequence().size()) {
-//                    if (item.getProcessId().equals(item.getProcessSequence().get(i).getId())) {
-//
-//                        item.setNextProcess(item.getProcessSequence().get(i + 1));
-//                        //查询出非本工段的第一道序
-//                        for (BizDeptProcess deptProcess : item.getProcessSequence().get(i + 1).getDeptProcess()) {
-//                            if (!deptProcess.getDeptId().equals(item.getDeptId())) {
-//                                item.setNextDeptProcess(item.getNextProcess().getProcessAlias() + "、" + deptProcess.getProcessAlias());
-//                                break;
-//                            }
-//                        }
-//                    }
-//                }
-//            }
-//            // 设置上一工段,周转用
-//            List<BizDayworkItem> dayworkItemList = bizDayworkItemService.query().lt("status", 4).eq("process_id", item.getProcessId()).list();
-//            for (int i = 0; i < dayworkItemList.size(); i++) {
-//                if (dayworkItemList.get(i).getDeptName() != null && !"".equals(dayworkItemList.get(i).getDeptName())) {
-//                    item.setPreDeptName(dayworkItemList.get(i).getDeptName());
-//                    break;
-//                }
-//            }
-//            //只保留当前工序的报工记录
-//            if (processId.equals(item.getProcessId())) {
-//                itemList.add(item);
-//            }
-//        }
-//
-//        return getDataTable(itemList);
         //0420
         SysUser user = SecurityUtils.getLoginUser().getUser();
 //        startPage();
@@ -245,6 +203,89 @@ public class BizDayworkItemController extends BaseController {
 
         return getDataTable(itemList);
     }
+    @GetMapping("/assistList")
+    @Log(title = "查询报工记录", businessType = BusinessType.SELECT)
+    public TableDataInfo assistList(BizDayworkItem bizDayworkItem) {
+        //0420
+        List<BizDayworkItem> list = bizDayworkItemService.getList(bizDayworkItem);
+        //如果是废品回用，ProcessSequence从新表拿
+        if(bizDayworkItem.getIsAmend() ==1  ||bizDayworkItem.getIsWasteRecycling() ==1 ) {
+            BizLot bizLot = bizLotService.query().eq("id",bizDayworkItem.getLotId()).list().get(0);
+            List<BizLotTechnologicalProcessDetail> bizTechnologicalWasteRecyclingDetails = bizLotTechnologicalProcessDetailService.query().eq("lot_technological_process_id",bizLot.getTechnologicalProcessId()).orderByAsc("process_step_number").list();
+            BizLotTechnologicalProcessDetail lotTechnologicalProcessDetail = bizLotTechnologicalProcessDetailService.query().eq("id", list.get(0).getTechnologicalProcessDetailId()).one();
+            BizTechnologicalProcessDetail bizTechnologicalProcessDetail = new BizTechnologicalProcessDetail();
+            bizTechnologicalProcessDetail.setProcessId(lotTechnologicalProcessDetail.getProcessId());
+            bizTechnologicalProcessDetail.setProcessAlias(lotTechnologicalProcessDetail.getProcessAlias());
+            bizTechnologicalProcessDetail.setProcessStepNumber(lotTechnologicalProcessDetail.getProcessStepNumber());
+            bizTechnologicalProcessDetail.setProcessCode(lotTechnologicalProcessDetail.getProcessCode());
+            bizTechnologicalProcessDetail.setProductId(lotTechnologicalProcessDetail.getProductId());
+
+
+            //查询所有工段下的工序
+            List<BizDeptProcess> deptProcessList = bizDeptProcessService.query().list();
+            List<BizProcess> processList = new ArrayList<>();
+            for(BizLotTechnologicalProcessDetail bizTechnologicalWasteRecyclingDetail : bizTechnologicalWasteRecyclingDetails) {
+                BizProcess process = new BizProcess();
+                process.setId(bizTechnologicalWasteRecyclingDetail.getProcessId());
+                process.setProcessCode(bizTechnologicalWasteRecyclingDetail.getProcessCode());
+                process.setProcessStepNumber(bizTechnologicalWasteRecyclingDetail.getProcessStepNumber());
+                process.setProcessAlias(bizTechnologicalWasteRecyclingDetail.getProcessAlias());
+                process.setTechnologicalProcessDetailId(bizTechnologicalWasteRecyclingDetail.getId());
+                process.setDeptProcess(deptProcessList.stream().filter(deptProcess -> deptProcess.getProcessId().equals(bizTechnologicalWasteRecyclingDetail.getProcessId())).collect(Collectors.toList()));
+                processList.add(process);
+            }
+            list.stream().forEach(item -> {item.setProcessSequence(processList);});
+            if(bizDayworkItem.getProcessStepNumber() != null) {
+                list.forEach(item -> {
+                    item.setProcess(
+                            item.getProcessSequence().stream()
+                                    .filter(process -> process.getProcessStepNumber().equals(bizDayworkItem.getProcessStepNumber()))
+                                    .findFirst()
+                                    .orElse(null) // 如果未找到匹配的 process，则设置为 null
+                    );
+                    item.setTechnologicalProcessDetail(bizTechnologicalProcessDetail);
+                });
+            }
+        }
+        //人员只能看到最近的一条报工记录中工序的报工
+        List<BizDayworkItem> itemList = new ArrayList<>();
+        String processStepNumber = "";
+        if (list.size() > 0) {
+            processStepNumber = list.get(0).getProcessStepNumber();
+        }
+        /** 根据当前工序查询下一道工序 */
+        for (BizDayworkItem item : list) {
+            for (int i = 0; i < item.getProcessSequence().size(); i++) {
+                if ((i + 1) < item.getProcessSequence().size()) {
+                    if (item.getProcessStepNumber().equals(item.getProcessSequence().get(i).getProcessStepNumber())) {
+
+                        item.setNextProcess(item.getProcessSequence().get(i + 1));
+                        //查询出非本工段的第一道序
+                        for (BizDeptProcess deptProcess : item.getProcessSequence().get(i + 1).getDeptProcess()) {
+                            if (!deptProcess.getDeptId().equals(item.getDeptId())) {
+                                item.setNextDeptProcess(item.getNextProcess().getProcessAlias() + "、" + deptProcess.getProcessAlias());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            // 设置上一工段,周转用
+            List<BizDayworkItem> dayworkItemList = bizDayworkItemService.query().lt("status", 4).eq("lot_id",item.getLotId()).eq("process_step_number", item.getProcessStepNumber()).list();
+            for (int i = 0; i < dayworkItemList.size(); i++) {
+                if (dayworkItemList.get(i).getDeptName() != null && !"".equals(dayworkItemList.get(i).getDeptName())) {
+                    item.setPreDeptName(dayworkItemList.get(i).getDeptName());
+                    break;
+                }
+            }
+            //只保留当前工序的报工记录
+            if (processStepNumber.equals(item.getProcessStepNumber())) {
+                itemList.add(item);
+            }
+        }
+
+        return getDataTable(itemList);
+    }
 
 
 
@@ -739,9 +780,9 @@ public class BizDayworkItemController extends BaseController {
         bizDayworkItem.setLotId(daywork.getLotId());
         bizDayworkItem.setLotCode(daywork.getLotCode());
         SysUser user = SecurityUtils.getLoginUser().getUser();
-        bizDayworkItem.setUserId(user.getUserId());
-        bizDayworkItem.setUserName(user.getUserName());
-        bizDayworkItem.setNickName(user.getNickName());
+//        bizDayworkItem.setUserId(user.getUserId());
+//        bizDayworkItem.setUserName(user.getUserName());
+//        bizDayworkItem.setNickName(user.getNickName());
         String[] statusArr = {"0", "4", "5", "7"};
         if (Arrays.asList(statusArr).contains(bizDayworkItem.getStatus())) {
             bizDayworkItem.setWorkingHours(0L);
@@ -1073,6 +1114,38 @@ public class BizDayworkItemController extends BaseController {
         bizDayworkItem.setUserId(user.getUserId());
         bizDayworkItem.setUserName(user.getUserName());
         bizDayworkItem.setNickName(user.getNickName());
+//          bizDayworkItem.setTenantId(Long.valueOf(tenantId));
+        boolean b = bizDayworkItemService.saveOrUpdate(bizDayworkItem);
+        if (!bizDayworkItem.getCollaborationList().isEmpty()) {
+            for (BizDayworkItemCollaboration collaboration : bizDayworkItem.getCollaborationList()) {
+                collaboration.setDayworkId(bizDayworkItem.getDayworkId());
+                collaboration.setDayworkItemId(bizDayworkItem.getId());
+                collaboration.insert();
+            }
+        }
+        // 判断开始报工的批次在不在滚筒,如果在开始报工后制动鼓解绑载具
+        SysDept dept = sysDeptMapper.selectDeptById(bizDayworkItem.getDeptId());
+        if (dept.getAutoUnbind() == 1) {
+            List<BizDayworkCarrier> oldList = bizDayworkCarrierService.query().eq("daywork_id", bizDayworkItem.getDayworkId()).eq("process_inspection_id", 0L).eq("is_changed", 0).list();
+            List<BizDayworkCarrier> newList = oldList.stream().collect(Collectors.toList());
+            newList.forEach(item -> item.setIsChanged(1));
+            saveOrUpdateCarrierBatch(bizDayworkCarrierService, newList, oldList);
+        }
+        return toAjax(b);
+    }
+    @Log(title = "批量新增报工记录", businessType = BusinessType.INSERT)
+    @Transactional
+    @PostMapping("/saveAssistBatch")
+    public AjaxResult saveAssistBatch(@RequestBody BizDayworkItem bizDayworkItem) throws NoSuchFieldException, IllegalAccessException {
+        //        String tenantId = request.getHeader("tenantId");
+        BizDaywork daywork = bizDayworkService.getById(bizDayworkItem.getDayworkId());
+        if(daywork.getIsAmend()==1){
+            bizDayworkItem.setFormDayworkItemId(1l);
+        }
+        SysUser user = SecurityUtils.getLoginUser().getUser();
+        bizDayworkItem.setUserId(user.getUserId());
+        bizDayworkItem.setUserName(user.getUserName());
+        bizDayworkItem.setNickName(user.getNickName());
 //          bizDayworkItem.setTenantId(Long.valueOf(tenantId));
         boolean b = bizDayworkItemService.saveOrUpdate(bizDayworkItem);
         if (!bizDayworkItem.getCollaborationList().isEmpty()) {
@@ -1442,6 +1515,102 @@ public class BizDayworkItemController extends BaseController {
         }
         return success();
     }
+    @Log(title="外协周转申请")
+    @Transactional
+    @PostMapping("/turnoverOutsourceAssist")
+    public AjaxResult turnoverOutsourceAssist(@RequestBody BizDayworkItem bizDayworkItem) throws NoSuchFieldException,IllegalAccessException {
+        //判断当前是否在盘点
+        BizTakeStockPeriod bizTakeStockPeriod = bizTakeStockPeriodService.query().eq("status",1).one();
+        if(bizTakeStockPeriod!=null && bizTakeStockPeriod.getStatus() == 1) {
+            return error("当前在盘点，禁止投产");
+        }
+        // 设置工时
+        // 获取箱子关联的所有批次
+        boolean batch = true;
+        SysDept sysDept = sysDeptMapper.selectDeptByCode(bizDayworkItem.getDeptCode());
+        bizDayworkItem.setDeptId(sysDept.getDeptId());
+        bizDayworkItem.setDeptName(sysDept.getDeptName());
+        List<BizDayworkCarrier> dayworkCarriers = bizDayworkCarrierService.query().eq("process_inspection_id", 0L).eq("is_changed", 0).eq("daywork_id", bizDayworkItem.getDayworkId()).list();
+        List<BizDayworkCarrier> allCarries = bizDayworkCarrierService.query().eq("is_changed", 0).eq("process_inspection_id", 0L).in("carrier_id", dayworkCarriers.isEmpty() ? Collections.singletonList(0L) : dayworkCarriers.stream().map(BizDayworkCarrier::getCarrierId).collect(Collectors.toList())).list();
+        // 关联批次的所有最后一条报工
+        List<BizDayworkItem> bizDayworkItems = bizDayworkItemService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).in("status", Arrays.asList("0", "1", "2", "3")).orderByDesc("status").orderByDesc("create_time").list();
+        List<BizDayworkItem> bizDayworkItemAll = bizDayworkItemService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).orderByDesc("create_time").list();
+        List<BizDayworkItem> bizDayworkItemList = bizDayworkItemService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).list();
+        List<BizDaywork> bizDayworks = bizDayworkService.query().in("id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).list();
+        for (BizDaywork v : bizDayworks) {
+            BizDayworkItem lastItem = bizDayworkItems.stream().filter(l -> l.getDayworkId().equals(v.getId())).findFirst().orElse(null);
+            //不筛选status，当前批次最新一条报工
+            BizDayworkItem lastItemAll = bizDayworkItemAll.stream().filter(l -> l.getDayworkId().equals(v.getId())).findFirst().orElse(null);
+            //为了防止该工序已经周转到下一道序，且已经干了，所以判断如果当前processStepNumber和最新一条的步骤是否相同
+            if(lastItemAll != null && (!lastItemAll.getProcessStepNumber().equals(bizDayworkItem.getProcessStepNumber()) || (lastItemAll.getStatus().equals("4") || lastItemAll.getStatus().equals("5") || lastItemAll.getStatus().equals("7")))) {
+                return error( v.getLotCode()+"批次已周转，请勿重复操作");
+            }
+            if (lastItem != null && lastItem.getStatus().equals("3")) {
+                List<BizDayworkItem> allItem = bizDayworkItemList.stream().filter(l -> l.getDayworkId().equals(v.getId()) && l.getTechnologicalProcessDetailId().equals(lastItem.getTechnologicalProcessDetailId())).collect(Collectors.toList());
+                Integer lot = allItem.stream().mapToInt(BizDayworkItem::getQualifiedNum).sum();
+                BizDayworkItem bizItem = new BizDayworkItem();
+                bizItem.setDayworkId(lastItem.getDayworkId());
+                bizItem.setProcessId(lastItem.getProcessId());
+                bizItem.setTechnologicalProcessDetailId(lastItem.getTechnologicalProcessDetailId());
+                bizItem.setStatus(bizDayworkItem.getStatus());
+                bizItem.setFromDeptId(lastItem.getDeptId());
+                bizItem.setFromDeptName(lastItem.getDeptName());
+                if (bizDayworkItem.getStatus().equals("7")||bizDayworkItem.getStatus().equals("4")) {
+                    v.setDeptId(bizDayworkItem.getDeptId());
+                    v.setProcessQualifiedNum(v.getTemporaryProcessQualifiedNum());
+                    bizDayworkService.updateById(v);
+                }
+                // 周转后如果是车间内的，状态为7，则需要从当前资源组中删除被邀请人
+                if(bizDayworkItem.getStatus().equals("7") || bizDayworkItem.getStatus().equals("5")) {
+                    v.setProtemProcessId(lastItem.getProcessId());
+                    v.setProtemProcessStepNumber(lastItem.getProcessStepNumber());
+                    // 如果被邀请人不是本工段内的人，则需要从当前资源组中删除被邀请人
+                    bizProductionResourceGroupDetailService.deleTemporanyPeople(v);
+                }
+                if(v.getIsAmend()==1){
+                    bizItem.setFormDayworkItemId(1L);
+                }
+                //当前工序第一条报工
+                BizDayworkItem firstDayworkItem = bizDayworkItems.stream().filter(l -> l.getProcessStepNumber().equals(bizDayworkItem.getProcessStepNumber())&& l.getDayworkId().equals(v.getId())).sorted(Comparator.comparing(BizDayworkItem::getCreateTime)).findFirst().orElse(null);
+                bizItem.setProdNum(v.getTemporaryProcessQualifiedNum());
+                bizItem.setLotId(v.getLotId());
+                bizItem.setLotCode(v.getLotCode());
+                SysUser user = SecurityUtils.getLoginUser().getUser();
+                bizItem.setUserId(firstDayworkItem.getUserId());
+                bizItem.setUserName(firstDayworkItem.getUserName());
+                bizItem.setNickName(firstDayworkItem.getNickName());
+                //协作信息
+                bizItem.setAssistNickName(user.getNickName());
+                bizItem.setAssistUserId(user.getUserId());
+                bizItem.setAssistUserName(user.getUserName());
+                bizItem.setIsSpecial(lastItem.getIsSpecial());
+                bizItem.setSpecialIsFirst(lastItem.getSpecialIsFirst());
+                bizItem.setWorkingHours(0L);
+                bizItem.setTenantId(lastItem.getTenantId());
+                bizItem.setProductionPlanDetailId(lastItem.getProductionPlanDetailId());
+                bizItem.setProductionPlanId(lastItem.getProductionPlanId());
+                bizItem.setProductionPlanDetailSubDetailId(lastItem.getProductionPlanDetailSubDetailId());
+                bizItem.setProductionPlanDetailSubDetailEquipmentId(lastItem.getProductionPlanDetailSubDetailEquipmentId());
+                bizItem.setQualifiedNum(lot);
+                bizItem.setTechnologicalProcessId(lastItem.getTechnologicalProcessId());
+                bizItem.setProdNum(lot);
+                bizItem.setEquipmentDetailId(lastItem.getEquipmentDetailId());
+                bizItem.setEquipmentDetailCode(lastItem.getEquipmentDetailCode());
+                bizItem.setDeptId(bizDayworkItem.getDeptId());
+                bizItem.setDeptName(bizDayworkItem.getDeptName());
+                bizItem.setStartTime(bizDayworkItem.getStartTime());
+                bizItem.setTurnoverType(bizDayworkItem.getTurnoverType());
+                bizItem.setTurnoverId(bizDayworkItem.getTurnoverId());
+                bizItem.setTurnoverArea(bizDayworkItem.getTurnoverArea());
+                bizItem.setPlaceId(bizDayworkItem.getPlaceId());
+                bizItem.setPlace(bizDayworkItem.getPlace());
+                bizItem.setProcessStepNumber(lastItem.getProcessStepNumber());
+                batch = batch && bizDayworkItemService.saveOrUpdate(bizItem);
+
+            }
+        }
+        return success();
+    }
 
     // 周转申请都走这个方法，不再走原来的add方法
     @Log(title="周转申请")
@@ -1614,6 +1783,182 @@ public class BizDayworkItemController extends BaseController {
         bizDayworkItemExamineService.saveBatch(needAddList);
         return toAjax(batch);
     }
+    @Log(title="周转申请")
+    @Transactional
+    @PostMapping("/turnoverAssist")
+    public AjaxResult turnoverAssist(@RequestBody BizDayworkItem bizDayworkItem) throws NoSuchFieldException,IllegalAccessException {
+        //判断当前是否在盘点
+        BizTakeStockPeriod bizTakeStockPeriod = bizTakeStockPeriodService.query().eq("status",1).one();
+        if(bizTakeStockPeriod!=null && bizTakeStockPeriod.getStatus() == 1) {
+            return error("当前在盘点，禁止投产");
+        }
+        // 设置工时
+        // 获取箱子关联的所有批次
+        boolean batch = true;
+//        bizDayworkItem.getCarrierId();
+        // 根据 daywork_item 中的 daywork_id，获取到所有未解绑的【daywork 与 箱子】的集合，通过这个集合，可以知道该批次下绑定了多少个箱子
+        List<BizDayworkCarrier> dayworkCarriers = bizDayworkCarrierService.query().eq("is_changed", 0).eq("process_inspection_id", 0L).eq("daywork_id", bizDayworkItem.getDayworkId()).list();
+        // 再根据上面获得到的数据，通过箱子的id（carrier_id），再进行查找，有多少个批次与该箱子绑定，这是因为存在一箱多批的情况。这样就获得到了所有的批次
+        List<BizDayworkCarrier> allCarries = bizDayworkCarrierService.query().eq("process_inspection_id", 0L).eq("is_changed", 0).in("carrier_id", dayworkCarriers.isEmpty() ? Collections.singletonList(0L) : dayworkCarriers.stream().map(BizDayworkCarrier::getCarrierId).collect(Collectors.toList())).list();
+
+        // 根据获取到的所有批次的id，查询出所有批次的报工信息，并且状态是【"0", "1", "2", "3"】，按状态值倒序、创建日期的倒序，对数据进行排序，得到的数据是还未周转的数据。
+        // 后续会通过该集合，获取某批次的最后一条报工信息
+        List<BizDayworkItem> bizDayworkItems = bizDayworkItemService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).in("status", Arrays.asList("0", "1", "2", "3")).orderByDesc("status").orderByDesc("create_time").list();
+        List<BizDayworkItem> bizDayworkItemsAll = bizDayworkItemService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).orderByDesc("create_time").list();
+        // 根据获取到的所有批次的id，查询出所有批次的报工信息，不需要判断状态
+        List<BizDayworkItem> bizDayworkItemList = bizDayworkItemService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).list();
+        // 获取所有的 daywork 数据集合
+        List<BizDaywork> bizDayworks = bizDayworkService.query().in("id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).list();
+        //查询分选-包装的审核申请
+        List<BizDayworkItemExamine> dayworkExamineList = bizDayworkItemExamineService.query().in("daywork_id", allCarries.isEmpty() ? Collections.singletonList(0L) : allCarries.stream().map(BizDayworkCarrier::getDayworkId).collect(Collectors.toList())).list();
+        //需要新增的审核申请集合
+        List<BizDayworkItemExamine> needAddList = new ArrayList<>();
+        // 遍历 daywork 数据集合
+        for (BizDaywork v : bizDayworks) {
+            // 获取该批次的最后一条报工
+            BizDayworkItem lastItem = bizDayworkItems.stream().filter(l -> l.getDayworkId().equals(v.getId())).findFirst().orElse(null);
+            //批次所有报工，判断是否已经周转了，如果周转返回报错信息
+            BizDayworkItem lastItemAll = bizDayworkItemsAll.stream().filter(l -> l.getDayworkId().equals(v.getId())).findFirst().orElse(null);
+            //为了防止该工序已经周转到下一道序，且已经干了，所以判断如果当前processStepNumber和最新一条的步骤是否相同
+            if(lastItemAll != null && (!lastItemAll.getProcessStepNumber().equals(bizDayworkItem.getProcessStepNumber()) || (lastItemAll.getStatus().equals("4") || lastItemAll.getStatus().equals("5") || lastItemAll.getStatus().equals("7")))) {
+                return error( v.getLotCode()+"批次已周转，请勿重复操作");
+            }
+            // 如果最后一条报工信息存在，并且报工状态为：3，则说明该报工已经工序完成
+            if (lastItem != null && lastItem.getStatus().equals("3")) {
+                // 根据当前批次的id，获取该批次下的工序id与最后一条报工的工序id相同的所有报工信息
+                // 因为同一工序可能存在多次报工，所以需要获取该批次下，该工序的所有报工信息，后续会进行合格数的统计
+                List<BizDayworkItem> allItem = bizDayworkItemList.stream().filter(l -> l.getDayworkId().equals(v.getId()) && l.getTechnologicalProcessDetailId().equals(lastItem.getTechnologicalProcessDetailId())).collect(Collectors.toList());
+                // 根据获得到的某工序的报工信息，进行合格数统计
+                Integer lot = allItem.stream().mapToInt(BizDayworkItem::getQualifiedNum).sum();
+
+                // 实例化一个报工信息对象，用于保存【周转】的报工记录
+                BizDayworkItem bizItem = new BizDayworkItem();
+                bizItem.setDayworkId(lastItem.getDayworkId());
+                bizItem.setProcessId(lastItem.getProcessId());
+                bizItem.setTechnologicalProcessDetailId(lastItem.getTechnologicalProcessDetailId());
+                bizItem.setStatus(bizDayworkItem.getStatus());
+                bizItem.setFromDeptId(lastItem.getDeptId());
+                bizItem.setFromDeptName(lastItem.getDeptName());
+                //添加分选-包装的审核申请
+                if(bizDayworkItem.getIsNextPacking()) {
+                    //如果有审核申请，则删除审核申请，重新新增
+                    if(dayworkExamineList.size() > 0) {
+                        //删除多余的审核申请
+                        bizDayworkItemExamineService.removeBatchByIds(dayworkExamineList);
+                    }
+                    //新增审核申请
+                    BizDayworkItemExamine examine = new BizDayworkItemExamine();
+                    examine.setDayworkId(v.getId());
+                    examine.setDayworkItemId(lastItem.getId());
+                    examine.setDeptId(bizDayworkItem.getDeptId());
+                    examine.setProductionPlanDetailId(bizDayworkItem.getProductionPlanDetailId());
+                    examine.setProductDescription(bizDayworkItem.getProductDescription());
+                    examine.setLotId(lastItem.getLotId());
+                    examine.setLotCode(v.getLotCode());
+                    examine.setProductId(v.getProductId());
+                    examine.setTechnologicalProcessId(lastItem.getTechnologicalProcessId());
+                    examine.setTechnologicalProcessDetailId(lastItem.getTechnologicalProcessDetailId());
+                    examine.setProcessId(lastItem.getProcessId());
+                    examine.setProcessAlias(bizDayworkItem.getProcess().getProcessAlias());
+                    examine.setStatus(0);
+                    needAddList.add(examine);
+                }
+                // 如果报工状态为：7（已送达）或者4（待周转），则需要设置对应的daywork的当前部门id，以及合格数
+                // 这里的状态值4/7，是由前端传递过来的。
+                if (bizDayworkItem.getStatus().equals("7") || bizDayworkItem.getStatus().equals("4")) {
+                    v.setDeptId(bizDayworkItem.getDeptId());
+                    int sum = bizDayworkItems.stream()
+                            .filter(l -> l.getProcessStepNumber().equals(bizDayworkItem.getProcessStepNumber()))
+                            .mapToInt(BizDayworkItem::getQualifiedNum) // 假设 getNum 返回一个 int 类型的值
+                            .sum();
+                    v.setTemporaryProcessQualifiedNum(sum);
+                    bizDayworkService.updateById(v);
+                }
+                // 周转后如果是车间内的，状态为7，则需要从当前资源组中删除被邀请人
+                if(bizDayworkItem.getStatus().equals("7") || bizDayworkItem.getStatus().equals("5")) {
+                    v.setProtemProcessId(lastItem.getProcessId());
+                    v.setProtemProcessStepNumber(lastItem.getProcessStepNumber());
+                    // 如果被邀请人不是本工段内的人，则需要从当前资源组中删除被邀请人
+                    bizProductionResourceGroupDetailService.deleTemporanyPeople(v);
+                }
+                // 如果是单批单改换，则设置form_daywork_item_id为1，表示没有原来的报工
+                if(v.getIsAmend()==1){
+                    bizItem.setFormDayworkItemId(1L);
+                }
+                //当前工序第一条报工
+                BizDayworkItem firstDayworkItem = bizDayworkItems.stream().filter(l -> l.getProcessStepNumber().equals(bizDayworkItem.getProcessStepNumber())&& l.getDayworkId().equals(v.getId())).sorted(Comparator.comparing(BizDayworkItem::getCreateTime)).findFirst().orElse(null);
+                bizItem.setLotId(v.getLotId());
+                bizItem.setLotCode(v.getLotCode());
+                SysUser user = SecurityUtils.getLoginUser().getUser();
+                bizItem.setUserId(firstDayworkItem.getUserId());
+                bizItem.setUserName(firstDayworkItem.getUserName());
+                bizItem.setNickName(firstDayworkItem.getNickName());
+                //协作信息
+                bizItem.setAssistNickName(user.getNickName());
+                bizItem.setAssistUserId(user.getUserId());
+                bizItem.setAssistUserName(user.getUserName());
+                bizItem.setIsSpecial(lastItem.getIsSpecial());
+                bizItem.setSpecialIsFirst(lastItem.getSpecialIsFirst());
+                bizItem.setWorkingHours(0L);
+                bizItem.setDeptId(lastItem.getDeptId());
+                bizItem.setTenantId(lastItem.getTenantId());
+                bizItem.setProductionPlanDetailId(lastItem.getProductionPlanDetailId());
+                bizItem.setProductionPlanId(lastItem.getProductionPlanId());
+                bizItem.setProductionPlanDetailSubDetailId(lastItem.getProductionPlanDetailSubDetailId());
+                bizItem.setProductionPlanDetailSubDetailEquipmentId(lastItem.getProductionPlanDetailSubDetailEquipmentId());
+                bizItem.setQualifiedNum(lot);
+                bizItem.setTechnologicalProcessId(lastItem.getTechnologicalProcessId());
+                bizItem.setProdNum(lot);
+                bizItem.setEquipmentDetailId(lastItem.getEquipmentDetailId());
+                bizItem.setEquipmentDetailCode(lastItem.getEquipmentDetailCode());
+                bizItem.setDeptId(bizDayworkItem.getDeptId());
+                bizItem.setDeptName(bizDayworkItem.getDeptName());
+                bizItem.setStartTime(bizDayworkItem.getStartTime());
+                bizItem.setTurnoverId(bizDayworkItem.getTurnoverId());
+                bizItem.setTurnoverType(bizDayworkItem.getTurnoverType());
+                bizItem.setTurnoverArea(bizDayworkItem.getTurnoverArea());
+                bizItem.setTenantId(bizDayworkItem.getTenantId());
+                bizItem.setPlaceId(bizDayworkItem.getPlaceId());
+                bizItem.setPlace(bizDayworkItem.getPlace());
+                bizItem.setProcessStepNumber(lastItem.getProcessStepNumber());
+                batch = batch && bizDayworkItemService.saveOrUpdate(bizItem);
+                // 自动派活
+                SysDept sysDept = sysDeptMapper.selectDeptById(bizDayworkItem.getDeptId());
+                if (sysDept.getAutoAllocation() == 1) {
+                    // 查资源组
+                    List<BizProductionResourceGroup> productionResourceGroupList = bizProductionResourceGroupService.list(new QueryWrapper<BizProductionResourceGroup>().eq("dept_id", bizDayworkItem.getDeptId()).eq("is_deactivate", 0));
+
+                    //查询是否已经分配资源组
+                    BizProductionResourceGroupSubPlan groupSubPlan=new BizProductionResourceGroupSubPlan();
+                    groupSubPlan.setDeptId(bizDayworkItem.getDeptId());
+                    groupSubPlan.setProductionPlanDetailId(bizDayworkItem.getProductionPlanDetailId());
+
+                    List<BizProductionResourceGroupSubPlan> groupSubPlanList = bizProductionResourceGroupSubPlanService.getAotList(groupSubPlan);
+                    //如果没分配
+                    if(groupSubPlanList.isEmpty()){
+                        //查产品id
+                        BizProductionPlanDetail productionPlanDetail = bizProductionPlanDetailService.getOne(new QueryWrapper<BizProductionPlanDetail>().eq("id", bizDayworkItem.getProductionPlanDetailId()));
+                        //存放保存的subPlanList
+                        List<BizProductionResourceGroupSubPlan> subPlanList = new ArrayList<>();
+                        for (BizProductionResourceGroup info : productionResourceGroupList) {
+                            BizProductionResourceGroupSubPlan subPlan = new BizProductionResourceGroupSubPlan();
+                            subPlan.setProductId(productionPlanDetail.getProductId());
+                            subPlan.setProductionPlanDetailId(v.getProductionPlanDetailId());
+                            subPlan.setTechnologicalProcessId(v.getTechnologicalProcessId());
+                            subPlan.setResourceGroupId(info.getId());
+                            subPlan.setDeptId(bizDayworkItem.getDeptId());
+                            subPlan.setResourceGroupCode(info.getCode());
+                            subPlanList.add(subPlan);
+                        }
+                        bizProductionResourceGroupSubPlanService.saveBatch(subPlanList);
+                    }
+                }
+            }
+        }
+
+        bizDayworkItemExamineService.saveBatch(needAddList);
+        return toAjax(batch);
+    }
     @Log(title="内部外协周转申请")
     @Transactional
     @PostMapping("/turnoverInner")

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

@@ -231,4 +231,8 @@ public class BizDaywork extends BaseEntity
     private Long workshopId;
     @TableField(exist =false)
     private Boolean hasFinishOutsource;
+    @TableField(exist =false)
+    private String allNickName;
+    @TableField(exist = false)
+    private Long requisitionDepartmentId;
 }

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

@@ -312,4 +312,7 @@ public class BizDayworkItem extends BaseEntity
     //外协发出明细
     private Long  outsourceDetailId;
     private Integer isWx;
+    private String assistUserName;
+    private String assistNickName;
+    private Long assistUserId;
 }

src/main/java/cn/ezhizao/project/business/product/mapper/BizDayworkMapper.java

@@ -21,6 +21,7 @@ public interface BizDayworkMapper extends BaseMapper<BizDaywork> {
      * @return 报工集合
      */
     public List<BizDaywork> getList(BizDaywork bizDaywork);
+    public List<BizDaywork> getAssistDayworkList(BizDaywork bizDaywork);
     public BizDaywork getDayworkInfoById(BizDaywork bizDaywork);
 
     /**

src/main/java/cn/ezhizao/project/business/product/service/IBizDayworkService.java

@@ -23,6 +23,7 @@ public interface IBizDayworkService extends IService<BizDaywork>
      */
     public List<BizDaywork> getList(BizDaywork bizDaywork);
     public BizDaywork getDayworkInfoById(BizDaywork bizDaywork);
+    public List<BizDaywork> getAssistDayworkList(BizDaywork bizDaywork);
 
     /**
      * 物理删除

src/main/java/cn/ezhizao/project/business/product/service/impl/BizDayworkServiceImpl.java

@@ -41,6 +41,11 @@ public class BizDayworkServiceImpl extends ServiceImpl<BizDayworkMapper, BizDayw
         return bizDayworkMapper.getDayworkInfoById(bizDaywork);
     }
 
+    @Override
+    public List<BizDaywork> getAssistDayworkList(BizDaywork bizDaywork) {
+        return bizDayworkMapper.getAssistDayworkList(bizDaywork);
+    }
+
     /**
      * 物理删除
      * @param bizDaywork

src/main/resources/mybatis/business/product/BizDayworkMapper.xml

@@ -111,6 +111,31 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         </trim>
         ORDER BY create_time DESC
     </select>
+    <select id="getAssistDayworkList" resultType="cn.ezhizao.project.business.product.domain.BizDaywork">
+        SELECT DISTINCT t1.*
+        FROM biz_daywork t1
+        <trim prefix=" WHERE" suffix="" suffixOverrides="AND">
+            t1.status = 1 AND t1.deleted = 0 AND t1.dept_id = #{deptId}
+            AND (
+            SELECT t2.status
+            FROM biz_daywork_item t2
+            WHERE t2.daywork_id = t1.id AND t2.deleted = 0
+            ORDER BY t2.create_time DESC
+            LIMIT 1
+            ) &lt;5
+            AND ( SELECT t2.from_dept_id FROM biz_daywork_item t2 WHERE t2.daywork_id = t1.id AND t2.deleted = 0 ORDER BY t2.create_time DESC LIMIT 1 ) in(0,#{deptId})
+            <if test="keywords != null">
+                AND (
+                (
+                SELECT GROUP_CONCAT(carrier_code SEPARATOR ',')
+                FROM biz_daywork_carrier
+                WHERE deleted = 0 AND is_changed = 0 AND daywork_id = t1.id
+                ) LIKE CONCAT('%', #{keywords}, '%')
+                OR t1.lot_code LIKE CONCAT('%', #{keywords}, '%')
+                )
+            </if>
+        </trim>
+    </select>
 
     <delete id="physicalDelete">
         DELETE FROM biz_daywork