aps-小卷开工、取消开工相关逻辑增加

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/dao/ApsProcessOperationDao.java

@@ -49,8 +49,8 @@ public interface ApsProcessOperationDao extends BaseMapper<ApsProcessOperationDo
 
     List<ProcessIdRelationVo> getAllNextProcessOperationById(@Param("ids") List<String> ids);
 
-    @Update("update aps_process_operation set STARTINGROLL = STARTINGROLL - 1 ,ACTUALSTARTDATE = if((STARTINGROLL - 1) <= 0,null,ACTUALSTARTDATE) where ID = #{processoperationid}")
-    void updateByCancelRecord(@Param("processoperationid") String processoperationid);
+    @Update("update aps_process_operation set STARTINGROLL = STARTINGROLL - ${reduceNum} ,ACTUALSTARTDATE = if((STARTINGROLL - 1) <= 0,null,ACTUALSTARTDATE) where ID = #{processoperationid}")
+    void updateByCancelRecord(@Param("processoperationid") String processoperationid, @Param("reduceNum") Integer reduceNum);
 
     @Update("update aps_process_operation_process_equ set BACHMATERIALPROCESS = concat(BACHMATERIALPROCESS,',',#{batchnumber}) where DELETED = 0 AND ID = #{processoperationid}")
     void updateBatchNumberByProcessId(@Param("batchnumber") String batchnumber, @Param("processoperationid") String processoperationid);

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/service/ApsReportRecordsService.java

@@ -3,6 +3,7 @@ package com.rongwei.bscommon.sys.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.rongwei.bsentity.domain.ApsReportRecordsDo;
 import com.rongwei.bsentity.vo.SaveReportReq;
+import com.rongwei.bsentity.vo.SmallRollStartReportReq;
 import com.rongwei.bsentity.vo.StartRePortReq;
 import com.rongwei.rwcommon.base.R;
 
@@ -20,4 +21,6 @@ public interface ApsReportRecordsService extends IService<ApsReportRecordsDo> {
     R saveReport(SaveReportReq req);
 
     R checkMergeProcess(ApsReportRecordsDo req);
+
+    R smallRollStartReport(SmallRollStartReportReq req);
 }

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/service/impl/ApsReportRecordsServiceImpl.java

@@ -6,16 +6,17 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.rongwei.bscommon.sys.dao.*;
+import com.rongwei.bscommon.sys.dao.ApsProcessOperationDao;
+import com.rongwei.bscommon.sys.dao.ApsProcessOperationProcessEquDao;
+import com.rongwei.bscommon.sys.dao.ApsProcessOutputProductDao;
+import com.rongwei.bscommon.sys.dao.ApsReportRecordsDao;
 import com.rongwei.bscommon.sys.service.*;
 import com.rongwei.bsentity.domain.*;
-
 import com.rongwei.bsentity.vo.*;
 import com.rongwei.rwadmincommon.system.vo.SysUserVo;
 import com.rongwei.rwcommon.base.R;
 import com.rongwei.rwcommon.base.exception.CustomException;
 import com.rongwei.rwcommon.utils.SecurityUtil;
-import com.rongwei.rwcommon.utils.StringUtils;
 import com.rongwei.rwcommonentity.commonservers.vo.SysSerialVo;
 import com.rongwei.safecommon.fegin.CXAdminFeginClient;
 import com.rongwei.safecommon.utils.CXCommonUtils;
@@ -25,10 +26,7 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
-import java.util.Date;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -100,11 +98,15 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
         //删除报工检查项
         apsReportCheckoutService.remove(new QueryWrapper<ApsReportCheckoutDo>().lambda().eq(ApsReportCheckoutDo::getMainid, recordId));
 
+        //批次号list
+        List<String> batchNumberList = Arrays.asList(recordsDo.getBatchnumber().split(","));
         //更新输入物料在制品：如果输入物料有批次号，并且在制品库存中有输入物料批次号的在制品，则更新该在制品的在制品状态=待加工
         if (ObjectUtil.isNotEmpty(recordsDo.getBatchnumber())) {
             ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = new ApsWorkInProgressInventoryDo();
             apsWorkInProgressInventoryDo.setWorkinprocessstatus("待加工");
-            apsWorkInProgressInventoryService.update(apsWorkInProgressInventoryDo, new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda().eq(ApsWorkInProgressInventoryDo::getBatchnumber, recordsDo.getBatchnumber()));
+            apsWorkInProgressInventoryService.update(apsWorkInProgressInventoryDo, new QueryWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                    .in(ApsWorkInProgressInventoryDo::getBatchnumber, batchNumberList)
+                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0"));
         }
 
         //更新工序作业和作业明细
@@ -118,8 +120,12 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
         //更新该工序作业的作业明细的作业状态字段、已开工卷数、明细的待报工记录ID=（空），加工中批次号=(空)
         apsProcessOperationProcessEquDao.updateByCancelRecord(processequid);
 
-        //更新该工序作业的已开工卷数-1
-        apsProcessOperationDao.updateByCancelRecord(processoperationid);
+        //更新该工序作业的已开工卷数-x(默认为1)
+        int reduceNum = 1;
+        if (batchNumberList.size() > 0) {
+            reduceNum = batchNumberList.size();
+        }
+        apsProcessOperationDao.updateByCancelRecord(processoperationid, reduceNum);
 
         //查询作业明细详情
         ApsProcessOperationProcessEquDo equDo = apsProcessOperationProcessEquDao.selectById(processequid);
@@ -386,6 +392,11 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
 //                String processIds = "'" + collect + "'";
 //                this.baseMapper.updateBatchMaterialProcessBatch(req.getInputBatchNumber(), processIds);
 //            }
+            //更新在制品状态
+            apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                    .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "加工中")
+                    .eq(ApsWorkInProgressInventoryDo::getBatchnumber, req.getInputBatchNumber())
+                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0"));
             /**
              * 如果该工序作业明细有前道工序作业明细，
              * 则将前道工序作业明细的所有后道工序作业明细的待加工料卷批次号去掉“{批次号}，”
@@ -406,7 +417,7 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
 //        if (!r.getCode().equals("200")) {
 //            return R.error(r.getMsg());
 //        }
-        //============保存（报工）时，生成炉号和批次号=============
+        //============开工时，生成炉号和批次号=============
         //获取设备/炉 的炉号（每月、每个设备/炉 更新）
         String heatNumber;//初始化炉号
         //如果存在其他合并工序，并且其他合并工序已开工，则不去生成新的 炉次号 使用其他合并工序的 开工记录的 炉次号
@@ -549,7 +560,7 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
             String inputBatchNumber = req.getInputBatchNumber();
             //查询上一个的报工ID
             String lastReportRecordId = this.baseMapper.selectLastReoprtRecordByBatchNumber(inputBatchNumber);
-            if(ObjectUtil.isNotEmpty(lastReportRecordId)) {
+            if (ObjectUtil.isNotEmpty(lastReportRecordId)) {
                 //查询上一个报工的坯料成分
                 List<ApsReportBlankCompentDo> apsReportBlankCompentDoList = apsReportBlankCompentService.list(new QueryWrapper<ApsReportBlankCompentDo>().lambda().eq(ApsReportBlankCompentDo::getMainid, lastReportRecordId));
                 //复制新增
@@ -899,6 +910,312 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
         return R.ok(res);
     }
 
+    @Override
+    @Transactional
+    public R smallRollStartReport(SmallRollStartReportReq req) {
+        if (ObjectUtil.isEmpty(req.getUseDeviceId())) {
+            return R.error("工序作业明细ID不能为空");
+        }
+        if (ObjectUtil.isEmpty(req.getInputBatchNumberList())) {
+            return R.error("至少要有一个待加工料卷批次号");
+        }
+
+        String useDeviceId = req.getUseDeviceId();
+        ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = apsProcessOperationProcessEquService.getById(useDeviceId);
+        ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(apsProcessOperationProcessEquDo.getProcessid());
+        ApsBlankOrderDo apsBlankOrderDo = apsBlankOrderService.getById(apsProcessOperationDo.getBlankid());
+        ApsProductionOrderDo apsProductionOrderDo = apsProductionOrderService.getById(apsBlankOrderDo.getProductionorderid());
+
+        List<String> inputBatchNumberList = req.getInputBatchNumberList();
+        List<String> needWorkBatchNumberList = Arrays.asList(apsProcessOperationProcessEquDo.getBachmaterialprocess().split(","));
+        //如果选择的批次号不在待加工料卷批次号中
+
+        //错误的待加工料卷批次号集合
+        List<String> withOutBatchNumberList = new LinkedList<>();
+        for (String s : inputBatchNumberList) {
+            if (!needWorkBatchNumberList.contains(s)) {
+                withOutBatchNumberList.add(s);
+            }
+        }
+        //如果有批次号不在待加工料卷批次号中，则错误提示：批次号：{错误批次号逗号拼接}已经被其他作业开工，请重新选择
+        if (withOutBatchNumberList.size() > 0) {
+            return R.error("批次号：" + String.join(",", withOutBatchNumberList) + "已经被其他作业开工，请重新选择");
+        }
+
+        //当前登录用户信息
+        SysUserVo currentUser = CXCommonUtils.getCurrentUser();
+        String tenantId = currentUser.getOrganizationDoList().get(0).getFullpid().split(",")[1];
+
+        //查询此工序对应工艺步骤中，对应设备的设备参数
+        String equparames = "";
+        //查询工序步骤
+        String stepnum = apsProcessOperationDo.getStepnum();
+        ApsCraftStepDo craftStepDo = apsCraftStepService.getOne(new QueryWrapper<ApsCraftStepDo>().lambda().eq(ApsCraftStepDo::getStepnum, stepnum));
+        if (ObjectUtil.isNotEmpty(craftStepDo)) {
+            //查询设备参数子表
+            ApsCraftEquDo apsCraftEquDo = apsCraftEquService.getOne(new QueryWrapper<ApsCraftEquDo>().lambda().eq(ApsCraftEquDo::getMainid, craftStepDo.getId()).eq(ApsCraftEquDo::getResourceid, apsProcessOperationProcessEquDo.getProcessdeviceid()).eq(ApsCraftEquDo::getTenantid, tenantId));
+            if (ObjectUtil.isNotEmpty(apsCraftEquDo)) {
+                equparames = apsCraftEquDo.getEquparames();
+            }
+        }
+
+        //============生成报工记录===============
+        //新增主表报工记录信息
+        ApsReportRecordsDo apsReportRecordsDo = new ApsReportRecordsDo();
+        apsReportRecordsDo.setId(SecurityUtil.getUUID());
+        apsReportRecordsDo.setTenantid(tenantId);
+        //工序作业ID
+        apsReportRecordsDo.setProcessoperationid(apsProcessOperationDo.getId());
+        //作业明细ID
+        apsReportRecordsDo.setProcessequid(apsProcessOperationProcessEquDo.getId());
+        //输入物料的批次号
+        apsReportRecordsDo.setBatchnumber(String.join(",", inputBatchNumberList));
+        //实际输入物料
+        apsReportRecordsDo.setActualinputmaterial(apsProcessOperationDo.getPlaninput());
+        //主操作员
+        apsReportRecordsDo.setChiefoperatorid(currentUser.getId());
+        apsReportRecordsDo.setChiefoperatorname(currentUser.getName());
+        //开工时间
+        apsReportRecordsDo.setStartworktime(DateUtil.date());
+        //报工状态
+        apsReportRecordsDo.setReportworkstatus("已开工");
+        apsReportRecordsDo.setCheckstatus("待检验");
+        //设备参数
+        apsReportRecordsDo.setDeviceparm(equparames);
+        //注意事项
+        apsReportRecordsDo.setAttention(apsProcessOperationDo.getRemark());
+
+        //============开工时，生成炉号和批次号=============
+        //获取设备/炉 的炉号（每月、每个设备/炉 更新）
+        String heatNumber;//初始化炉号
+        //如果存在其他合并工序，并且其他合并工序已开工，则不去生成新的 炉次号 使用其他合并工序的 开工记录的 炉次号
+        List<ApsProcessOperationProcessEquDo> apsProcessEquMergeStartingList = this.baseMapper.selectOtherMergeProcessStarting(apsProcessOperationProcessEquDo.getId(), apsProcessOperationProcessEquDo.getProcessdeviceid(), apsProcessOperationProcessEquDo.getPlanstartdate());
+
+        if (apsProcessEquMergeStartingList.size() > 0) {
+            //合并工序作业明细
+            ApsProcessOperationProcessEquDo equDo = apsProcessEquMergeStartingList.get(0);
+            //查询该合并工序作业明细的待报工记录ID
+            String waitreportid = equDo.getWaitreportid();
+            //待报工记录详情
+            ApsReportRecordsDo aDo = this.getById(waitreportid);
+            heatNumber = aDo.getHeatnumber();
+        } else {
+            //调用通用接口生成炉号
+            SysSerialVo vo = new SysSerialVo();
+            vo.setModulecode("aps_report_output_heat_" + apsProcessOperationProcessEquDo.getProcessdeviceid());
+            vo.setRuleTemplateStr("@{serialNumber:#000}");
+            vo.setResetrule("date:yyyyMM");
+            vo.setIfautomaticreset("y");
+            vo.setInitValue(1L);
+            Map<String, Object> codeData = cxAdminFeginClient.getSerialNumberCode(vo).getData();
+            heatNumber = codeData.get("code").toString();
+        }
+
+        apsReportRecordsDo.setHeatnumber(heatNumber);
+        this.save(apsReportRecordsDo);
+
+        /**
+         * 如果该作业的工序是小卷成退或小卷包装，则每个输入物料的批次号根据工序作业输出物料自动生成报工明细输出物料，例如：有100个输入物料批次号则生成100个输出物料，参见【报工记录字段说明/输出物料字段说明】
+         * 自动填入检验结果字段的默认值，检验等级=B级，是否合格=是，实测卷重=输出物料卷重，实测厚度=输出物料厚度，实测宽度=输出物料宽度，实测长度=输出物料长度，
+         * 自动生成报工记录所有输出物料批次号，参见【自动生成批次号】，以及对应的二维码
+         * 根据工序加工参数设置自动生成该工序所有加工参数明细，参见【报工记录字段说明/加工参数字段说明】
+         * 根据工序检测参数设置自动生成该工序所有检测参数明细，参见【报工记录字段说明/检测参数字段说明】
+         */
+        //========生成输出物料子表===========
+        OrganizationCodeAndDeviceCodeVo organizationCodeAndDeviceCodeVo = this.baseMapper.selectOrganizationCodeAndDeviceCode(apsProcessOperationProcessEquDo.getProcessdeviceid());
+        for (String inputBatchNumber : inputBatchNumberList) {
+            InsertMyReportOutputReq insertMyReportOutputReq = new InsertMyReportOutputReq();
+            insertMyReportOutputReq.setMainId(apsReportRecordsDo.getId());
+            insertMyReportOutputReq.setProcessId(apsProcessOperationDo.getId());
+            insertMyReportOutputReq.setIfBlankProcess(apsProcessOperationDo.getIfblankprocess());
+            insertMyReportOutputReq.setDeviceId(apsProcessOperationProcessEquDo.getProcessdeviceid());
+            insertMyReportOutputReq.setMark(organizationCodeAndDeviceCodeVo.getOrganizationCode());
+            insertMyReportOutputReq.setYearCode((DateUtil.year(DateUtil.date()) % 100) + "");
+            insertMyReportOutputReq.setMonthCode(SaveConstans.MONTH_CODE_LIST.get(DateUtil.month(DateUtil.date())));
+            insertMyReportOutputReq.setEquipmentCode(organizationCodeAndDeviceCodeVo.getDeviceCode());
+            insertMyReportOutputReq.setHeatNumber(heatNumber);
+            insertMyReportOutputReq.setInputBatchNumber(inputBatchNumber);
+            insertMyReportOutputReq.setBlankType(apsBlankOrderDo.getBlanktype());
+            insertMyReportOutputReq.setLevel(apsProcessOperationDo.getLevel());
+
+            R r = apsReportOutputService.insertMyReportOutput(insertMyReportOutputReq);
+            if (!r.getCode().equals("200")) {
+                throw new CustomException(r.getMsg());
+            }
+        }
+        //=============加工参数子表信息、检查项目子表信息================
+        if (ObjectUtil.isNotEmpty(apsProcessOperationDo.getProcess())) {
+            //根据工序查询其工序的加工参数
+            List<ApsParameterDo> parameterDoList = this.baseMapper.selectApsParameterByProcess(apsProcessOperationDo.getProcess());
+            List<ApsReportMachiningDo> needInsertApsReportMachingList = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(parameterDoList)) {
+                for (ApsParameterDo apsParameterDo : parameterDoList) {
+                    if (ObjectUtil.isEmpty(apsParameterDo)) {
+                        continue;
+                    }
+                    ApsReportMachiningDo apsReportMachiningDo = new ApsReportMachiningDo();
+                    apsReportMachiningDo.setId(SecurityUtil.getUUID());
+                    apsReportMachiningDo.setTenantid(tenantId);
+                    apsReportMachiningDo.setMainid(apsReportRecordsDo.getId());
+                    apsReportMachiningDo.setMatching(apsParameterDo.getParameter());
+                    needInsertApsReportMachingList.add(apsReportMachiningDo);
+                }
+                if (ObjectUtil.isNotEmpty(needInsertApsReportMachingList)) {
+                    apsReportMachiningService.saveBatch(needInsertApsReportMachingList);
+                }
+            }
+
+            //根据工序查询其工序的检查项目
+            List<ApsCheckParameterDo> checkParameterDoList = this.baseMapper.selectApsCheckParameterByProcess(apsProcessOperationDo.getProcess());
+            List<ApsReportCheckoutDo> needInsertApsReportCheckList = new LinkedList<>();
+            if (ObjectUtil.isNotEmpty(checkParameterDoList)) {
+                for (ApsCheckParameterDo apsCheckParameterDo : checkParameterDoList) {
+                    if (ObjectUtil.isEmpty(apsCheckParameterDo)) {
+                        continue;
+                    }
+                    ApsReportCheckoutDo apsReportCheckoutDo = new ApsReportCheckoutDo();
+                    apsReportCheckoutDo.setId(SecurityUtil.getUUID());
+                    apsReportCheckoutDo.setTenantid(tenantId);
+                    apsReportCheckoutDo.setMainid(apsReportRecordsDo.getId());
+                    apsReportCheckoutDo.setCheckitem(apsCheckParameterDo.getCheckparameter());
+                    needInsertApsReportCheckList.add(apsReportCheckoutDo);
+                }
+                if (ObjectUtil.isNotEmpty(needInsertApsReportCheckList)) {
+                    apsReportCheckoutService.saveBatch(needInsertApsReportCheckList);
+                }
+            }
+
+        }
+        //=============坯料成分子表信息=============
+        //工序作业的是否坯料工序=是 时，根据客户合金成分设置自动生成
+        if (apsProcessOperationDo.getIfblankprocess().equals("是")) {
+            //工序作业的合金
+            String metal = apsProcessOperationDo.getMetal();
+            //订单的客户ID
+            String customid = apsProductionOrderDo.getCustomid();
+            String alloyId = "";
+            //查询合金对应的所有主表信息
+            List<ApsAlloyDo> apsAlloyDoList = apsAlloyService.list(new QueryWrapper<ApsAlloyDo>().lambda().eq(ApsAlloyDo::getAlloy, metal));
+            if (ObjectUtil.isNotEmpty(apsAlloyDoList)) {
+                //查询客户标准
+                List<ApsAlloyDo> collect = apsAlloyDoList.stream().filter(item -> ObjectUtil.isNotEmpty(item.getCustomerid()) && item.getCustomerid().contains(customid)).collect(Collectors.toList());
+                if (ObjectUtil.isNotEmpty(collect)) {
+                    alloyId = collect.get(0).getId();
+                } else {//查询国标
+                    List<ApsAlloyDo> collect1 = apsAlloyDoList.stream().filter(item -> ObjectUtil.isEmpty(item.getCustomerid())).collect(Collectors.toList());
+                    if (ObjectUtil.isNotEmpty(collect1)) {
+                        alloyId = collect1.get(0).getId();
+                    }
+                }
+            }
+            //查询合金成分要求
+            if (ObjectUtil.isNotEmpty(alloyId)) {
+                List<ApsAlloyCompositionDo> apsAlloyCompositionDoList = apsAlloyCompositionService.list(new QueryWrapper<ApsAlloyCompositionDo>().lambda().eq(ApsAlloyCompositionDo::getAlloyid, alloyId));
+
+                if (ObjectUtil.isNotEmpty(apsAlloyCompositionDoList)) {
+                    List<ApsReportBlankCompentDo> needInsertApsReportBlankCompentList = new LinkedList<>();
+                    for (ApsAlloyCompositionDo apsAlloyCompositionDo : apsAlloyCompositionDoList) {
+                        ApsReportBlankCompentDo apsReportBlankCompentDo = new ApsReportBlankCompentDo();
+                        apsReportBlankCompentDo.setId(SecurityUtil.getUUID());
+                        apsReportBlankCompentDo.setTenantid(tenantId);
+                        apsReportBlankCompentDo.setMainid(apsReportRecordsDo.getId());
+                        apsReportBlankCompentDo.setCompent(apsAlloyCompositionDo.getIngredient());
+                        apsReportBlankCompentDo.setStartproportion(apsAlloyCompositionDo.getLeftproportion());
+                        apsReportBlankCompentDo.setEndproportion(apsAlloyCompositionDo.getRightproportion());
+                        needInsertApsReportBlankCompentList.add(apsReportBlankCompentDo);
+                    }
+                    if (ObjectUtil.isNotEmpty(needInsertApsReportBlankCompentList)) {
+                        apsReportBlankCompentService.saveBatch(needInsertApsReportBlankCompentList);
+                    }
+
+                }
+            }
+        } else {//不是坯料工序，根据输入物料批次号，查询来源报工的坯料成分，copy一份
+            String inputBatchNumber = req.getInputBatchNumberList().get(0);
+            //查询上一个的报工ID
+            String lastReportRecordId = this.baseMapper.selectLastReoprtRecordByBatchNumber(inputBatchNumber);
+            if (ObjectUtil.isNotEmpty(lastReportRecordId)) {
+                //查询上一个报工的坯料成分
+                List<ApsReportBlankCompentDo> apsReportBlankCompentDoList = apsReportBlankCompentService.list(new QueryWrapper<ApsReportBlankCompentDo>().lambda().eq(ApsReportBlankCompentDo::getMainid, lastReportRecordId));
+                //复制新增
+                List<ApsReportBlankCompentDo> needAddList = new LinkedList<>();
+                for (ApsReportBlankCompentDo apsReportBlankCompentDo : apsReportBlankCompentDoList) {
+                    ApsReportBlankCompentDo needAdd = new ApsReportBlankCompentDo();
+                    needAdd.setId(SecurityUtil.getUUID());
+                    needAdd.setTenantid(tenantId);
+                    needAdd.setMainid(apsReportRecordsDo.getId());
+                    needAdd.setCompent(apsReportBlankCompentDo.getCompent());
+                    needAdd.setStartproportion(apsReportBlankCompentDo.getStartproportion());
+                    needAdd.setEndproportion(apsReportBlankCompentDo.getEndproportion());
+                    needAdd.setActualproportion(apsReportBlankCompentDo.getActualproportion());
+                    needAddList.add(needAdd);
+                }
+                apsReportBlankCompentService.saveBatch(needAddList);
+            }
+        }
+
+        /**
+         * 检查每个输入批次号，
+         * 如果在制品库存中有输入物料批次号的在制品，则更新该在制品的在制品状态=加工中
+         * 查找输入物料所有后道作业明细，即前道作业明细的所有后道作业明细中，
+         * 其工序作业的输入物料ID和报工记录的工序作业的输入物料ID相同的所有作业明细，将这些作业明细的待加工料卷批次号去掉“{输入批次号}，”
+         */
+        for (String inputBatchNumber : inputBatchNumberList) {
+            //更新在制品状态
+            apsWorkInProgressInventoryService.update(new UpdateWrapper<ApsWorkInProgressInventoryDo>().lambda()
+                    .set(ApsWorkInProgressInventoryDo::getWorkinprocessstatus, "加工中")
+                    .eq(ApsWorkInProgressInventoryDo::getBatchnumber, inputBatchNumber)
+                    .eq(ApsWorkInProgressInventoryDo::getDeleted, "0"));
+            //更新待加工料卷批次号
+            if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
+                this.baseMapper.updateAllProcessEquBatchNumber(inputBatchNumber, apsProcessOperationProcessEquDo.getPreviousprocessesids());
+            }
+        }
+        //========更新工序作业明细==========
+        ApsProcessOperationProcessEquDo needUpdateProcessEqu = new ApsProcessOperationProcessEquDo();
+        needUpdateProcessEqu.setId(apsProcessOperationProcessEquDo.getId());
+        //该工序作业明细的加工中批次号=“{批次号}-{单个分卷序列号}”逗号拼接
+        needUpdateProcessEqu.setDoingbatchnumber(String.join(",", inputBatchNumberList));
+
+        //如果该作业明细的已开工卷数=0，则该作业明细的实际开工时间=当前时间；作业状态=加工中
+        if (apsProcessOperationProcessEquDo.getStartingroll().equals(0)) {
+            needUpdateProcessEqu.setActualstartdate(DateUtil.date());
+            needUpdateProcessEqu.setWorkstatus("加工中");
+        }
+
+        //更新该作业明细已开工卷数=已开工卷数+输入批次号数量，待报工记录ID=该报工记录ID
+        needUpdateProcessEqu.setStartingroll(apsProcessOperationProcessEquDo.getStartingroll() + inputBatchNumberList.size());
+        needUpdateProcessEqu.setWaitreportid(apsReportRecordsDo.getId());
+
+        apsProcessOperationProcessEquService.updateById(needUpdateProcessEqu);
+        //========更新工序作业=============
+        ApsProcessOperationDo needUpdateProcess = new ApsProcessOperationDo();
+        needUpdateProcess.setId(apsProcessOperationDo.getId());
+        //如果该工序作业已开工卷数=0，则
+        //该工序作业的实际开工时间=当前时间，作业状态=加工中，生产状态=加工中
+
+        if (apsProcessOperationDo.getStartingroll().equals(0)) {
+            needUpdateProcess.setActualstartdate(DateUtil.date());
+            needUpdateProcess.setWorkstatus("加工中");
+            needUpdateProcess.setProcessstatus(SaveConstans.ProductionStatus.PROCESSING);
+        }
+        //更新该工序作业已开工卷数=已开工卷数+输入批次号数量
+        needUpdateProcess.setStartingroll(apsProcessOperationDo.getStartingroll() + inputBatchNumberList.size());
+        apsProcessOperationService.updateById(needUpdateProcess);
+
+        //更新坯料计划状态，参见【订单排程/一键自动排程/更新坯料计划状态】
+        //=========更新生产状态等=============
+        CommonUpdateProductionStatusReq req3 = new CommonUpdateProductionStatusReq();
+        req3.setProcessOperationEquId(apsProcessOperationProcessEquDo.getId());
+        R r2 = apsProcessOperationProcessEquService.updateProductionStatus(req3);
+        if (!r2.getCode().equals("200")) {
+            throw new CustomException(r2.getMsg());
+        }
+
+        return R.ok(apsReportRecordsDo);
+    }
+
+
 }
 
 

cx-aps/cx-aps-entity/src/main/java/com/rongwei/bsentity/vo/SmallRollStartReportReq.java

@@ -0,0 +1,18 @@
+package com.rongwei.bsentity.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @author ：sc
+ * @since ：2024/7/22
+ */
+@Data
+public class SmallRollStartReportReq {
+    //作业明细表ID
+    private String useDeviceId;
+
+    //输入物料的批次号集合
+    private List<String> inputBatchNumberList;
+}

cx-aps/cx-aps-server/src/main/java/com/rongwei/bsserver/controller/ApsReportRecordController.java

@@ -4,6 +4,7 @@ package com.rongwei.bsserver.controller;
 import com.rongwei.bscommon.sys.service.ApsReportRecordsService;
 import com.rongwei.bsentity.domain.ApsReportRecordsDo;
 import com.rongwei.bsentity.vo.SaveReportReq;
+import com.rongwei.bsentity.vo.SmallRollStartReportReq;
 import com.rongwei.bsentity.vo.StartRePortReq;
 import com.rongwei.rwcommon.base.R;
 import lombok.extern.slf4j.Slf4j;
@@ -69,5 +70,13 @@ public class ApsReportRecordController {
     public R checkMergeProcess(@RequestBody ApsReportRecordsDo req){
         return apsReportRecordsService.checkMergeProcess(req);
     }
+
+    /**
+     * 小卷开工
+     */
+    @PostMapping("/smallRollStartReport")
+    public R smallRollStartReport(@RequestBody SmallRollStartReportReq req){
+        return apsReportRecordsService.smallRollStartReport(req);
+    }
 }