流程卡查询界面修改表格下方汇总方式

chenlu

2025-09-22 7ee68df04b7a169d51ab95ad9955276c9aff6ee1

 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportingWorkService.java

@@ -10,14 +10,10 @@
import com.example.erp.common.Constants;
import com.example.erp.dto.pp.OrderNumberTransferDTO;
import com.example.erp.entity.pp.*;
import com.example.erp.entity.sd.BasicData;
import com.example.erp.entity.sd.Order;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.sd.OrderProcessDetail;
import com.example.erp.entity.sd.*;
import com.example.erp.entity.userInfo.Log;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.exception.ServiceException;
import com.example.erp.mapper.mm.FinishedGoodsInventoryMapper;
import com.example.erp.mapper.mm.FinishedOperateLogMapper;
import com.example.erp.mapper.pp.*;
import com.baomidou.dynamic.datasource.annotation.DS;
@@ -71,7 +67,7 @@
    private final RestTemplate restTemplate;
    private final PatchLogMapper patchLogMapper;
    private final ReworkMapper reworkMapper;
    private final BasicDateMapper basicDataMapper;
    private final BasicDataMapper basicDataMapper;
    private final FinishedGoodsInventoryService finishedGoodsInventoryService;


@@ -255,6 +251,8 @@
        reportingWork.setReportingWorkId(reportingWorkId);
        String[] processIdStr = reportingWork.getProcessId().split("/");
        reportingWork.setProcessId(processIdStr[0]);
        reportingWork.setThisWornQuantity(0);
        reportingWork.setThisCompletedQuantity(0);

        int reviewState = (int) reportingWorkJson.get("type");
        if (reviewState == 1) {//审核通过
@@ -273,7 +271,13 @@
        //主表插入
        reportingWorkMapper.insert(reportingWork);
        //副表循环插入，并且插入次破信息表。再根据次破信息修改订单玻璃流程表的完工数量与刺破数量
        final Integer[] maxTechnologyNumber = {0,0};
        reportingWorkDetails.forEach(reportingWorkDetail -> {
            //合片数量汇总减少
            if(Integer.parseInt(reportingWorkDetail.getTechnologyNumber()) > maxTechnologyNumber[0]){
                maxTechnologyNumber[0] = Integer.valueOf(reportingWorkDetail.getTechnologyNumber());
                maxTechnologyNumber[1]+=1;
            }
            reportingWork.setThisCompletedQuantity(reportingWork.getThisCompletedQuantity() + reportingWorkDetail.getCompletedQuantity());
            reportingWork.setThisWornQuantity(reportingWork.getThisWornQuantity() + reportingWorkDetail.getBreakageQuantity());
            int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
@@ -382,6 +386,11 @@


        });
        //获取报工工序是否为复合工程

        reportingWork.setThisCompletedQuantity(reportingWork.getThisCompletedQuantity()/maxTechnologyNumber[1]);


        reportingWorkMapper.update(reportingWork, new LambdaUpdateWrapper<ReportingWork>()
                .eq(ReportingWork::getId, reportingWork.getId()));

@@ -437,6 +446,7 @@
                orderMapper.selectOne(new LambdaQueryWrapper<Order>()
                        .eq(Order::getOrderId, reportingWork.getOrderId())));
        reportingWork.setFlowCard(new FlowCard());




@@ -575,15 +585,29 @@
    }

    //报工管理查询
    public Map<String, Object> selectReportingWorkSv(Integer pageNum, Integer pageSize, java.sql.Date selectTime1, java.sql.Date selectTime2, String orderId, ReportingWork reportingWork) {
    public Map<String, Object> selectReportingWorkSv(Integer pageNum, Integer pageSize, List<String> selectDate, String orderId, ReportingWork reportingWork) {
        Integer offset = (pageNum - 1) * pageSize;
        if ("null".equals(orderId)) {
            orderId = "";
        }
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(3).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
            }
            if(!selectDate.get(1).isEmpty()){
                endDate = selectDate.get(1);
            }
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportingWorkMapper.selectReportingWorkMp(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("data", reportingWorkMapper.selectReportingWorkMp(offset, pageSize, startDate, endDate, orderId, reportingWork));
       // map.put("total", reportingWorkMapper.getPageTotal(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("total" ,reportingWorkMapper.getFootSum(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("total" ,reportingWorkMapper.getFootSum(offset, pageSize, startDate, endDate, orderId, reportingWork));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }

@@ -603,6 +627,17 @@
            if (transferState !=3){
                //判断是否有补片返工数据
                if (countStates==0){
                    //当下工序未审核则删除本工序
                    ReportingWork reportingWork = reportingWorkMapper.selectOne(new LambdaQueryWrapper<ReportingWork>()
                            .eq(ReportingWork::getReportingWorkId, reportingWorkId));
                    //保存日志
                    Log log = new Log();
                    log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
                    log.setFunction("deleteWork报工删除");
                    log.setOperatorId(userId);
                    log.setOperator(userName);


                    //判断是否是入库工序
                    if (lastProcess.equals(thisProcess)) {//是入库工序
                        //查询该流程卡数量、可入库数量、已入库数量
@@ -629,12 +664,6 @@
                                }
                                //删除报工，将审核状态改为-1
                                reportingWorkMapper.deleteWork(reportingWorkId);
                                //保存日志
                                Log log = new Log();
                                log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
                                log.setFunction("deleteWork报工入库删除");
                                log.setOperatorId(userId);
                                log.setOperator(userName);
                                logService.saveLog(log);
                                return true;
                            } else {
@@ -643,6 +672,19 @@
                        }

                    } else {//不是入库工序
                        if(reportingWork.getReviewedState()==0){
                            //查询当前报工编号完工次破数量的数据
                            List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
                            for (Map<String, Object> item : workDateList) {
                                //更新报工流程表数据
                                reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
                            }
                            //删除报工，将审核状态改为-1
                            reportingWorkMapper.deleteWork(reportingWorkId);
                            logService.saveLog(log);
                            return true;
                        }

                        if (count == 0) {
                            //查询当前报工编号完工次破数量的数据
                            List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
@@ -653,12 +695,7 @@
                            //删除报工，将审核状态改为-1
                            reportingWorkMapper.deleteWork(reportingWorkId);

                            //保存日志
                            Log log = new Log();
                            log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
                            log.setFunction("deleteWork报工删除");
                            log.setOperatorId(userId);
                            log.setOperator(userName);

                            logService.saveLog(log);
                            return true;
                        } else {
@@ -998,7 +1035,7 @@
                        .eq("order_sort", reportingWork.get("oldOrderNumber"))
                        .eq("review_status",0)
        );
        if (patchLogs.isEmpty()){
        if (!patchLogs.isEmpty()){
            result.put("msg","旧订单存在补片未审核数据");
            result.put("data",false);
            return result;
@@ -1009,7 +1046,7 @@
                    .eq("order_sort", reportingWork.get("oldOrderNumber"))
                    .eq("review_status",0)
        );
        if (patchLogs.isEmpty()){
        if (!patchLogs.isEmpty()){
            result.put("msg","旧订单存在返工未审核数据，请先审核报工后再进行转出");
            result.put("data",false);
            return result;
@@ -1135,7 +1172,7 @@
        //restTemplate.postForObject("http://localhost:8086/order/test",orderNumberTransferList,String.class);

        //向mes发送http请求
        ResponseEntity<OrderNumberTransferDTO> response =restTemplate.exchange(
        /*ResponseEntity<OrderNumberTransferDTO> response =restTemplate.exchange(
                "http://localhost:88/api/loadGlass/order/order/orderChange",
                HttpMethod.POST,
                new HttpEntity<>(orderNumberTransferList),
@@ -1147,7 +1184,9 @@
        }else{
            result.put("msg","连接mes响应超时");
            result.put("data",false);
        }
        }*/

        result.put("data",true);
        return result;

    }
@@ -1169,7 +1208,10 @@
        date.add(endDate);
        Map<String, Object> result = new HashMap<>();
        BasicData basicData = basicDataMapper
                .selectOne(new QueryWrapper<BasicData>().eq("basic_name", reportingWork.get("process")));
                .selectOne(new QueryWrapper<BasicData>()
                        .eq("basic_name", reportingWork.get("process"))
                        .last("limit 1")
                );
        result.put("data",orderProcessDetailMapper.selectShiftQuantitySv(creatorId, startDate, endDate,basicData==null?null:basicData.getNickname()));
        result.put("date",date);
        return result;
@@ -1189,24 +1231,48 @@
        date.add(startDate);
        date.add(endDate);
        Map<String, Object> result = new HashMap<>();
        result.put("data",reportingWorkMapper.selectList(
        List<ReportingWork> reportingWorkList = reportingWorkMapper.selectList(
                new QueryWrapper<ReportingWork>().nested(
                                reportingWork.get("process")!=null,
                                wrapper-> wrapper.eq("creator_id",reportingWork.get("userId"))//当工序为空时，查询所有报工信息
                        )
                        .gt("reviewed_state",-1)
                        .between("date(reporting_work_time)",startDate,endDate)
                        .orderByDesc("id")));
                        .orderByDesc("id"));
        reportingWorkList.forEach(reportingWork1 -> {
            String Plies =  reportingWorkDetailMapper.getGlassPliesCount(reportingWork1.getReportingWorkId());
            reportingWork1.setProcessId(reportingWork1.getProcessId()+'/'+Plies);
        });

        result.put("data",reportingWorkList);
        result.put("date",date);

         return result;

    }

    public List<BasicDataProduce> selectEquipmentByProcessSv(String process) {
           return reportingWorkMapper.SelectWorkBasicDeviceMp(process);
        }

    public String saveWorkStorage(Map<String, Object> object) {
        //List<Map<String, Object>> flowCard = reportingWorkMapper.getStorageData();
        //finishedGoodsInventoryService.addSelectWarehousing(object);
        return null;
            //List<Map<String, Object>> flowCard = reportingWorkMapper.getStorageData();
            //finishedGoodsInventoryService.addSelectWarehousing(object);
            return null;
        }

    public Map<String, Object> mesBasicDataSv() {
        Map<String, Object> map = new HashMap<>();
        //工序
        map.put("process",flowCardMapper.getProcessNameList());
        //设备下拉框
        map.put("device", reportingWorkMapper.mesSelectWorkBasicDeviceMp());
        //班组下拉框
        map.put("teams", reportingWorkMapper.mesSelectWorkBasicTeamsMp());
        //次破类型
        map.put("breakageType", reportingWorkMapper.selectBasicNameByType("breakagetype"));
        //次破原因
        map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));
        return map;
    }
}