blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
guoyujie
2025-11-24 90de68b8a67ea15091fa3a4223402b4b34a36298 
 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportingWorkService.java


@@ -3,43 +3,54 @@


import com.alibaba.fastjson.JSON;


import com.alibaba.fastjson.JSONArray;


import com.alibaba.fastjson.JSONObject;


import com.baomidou.dynamic.datasource.annotation.DS;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;


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.example.erp.common.AsyncQueryExecutor;


import com.example.erp.common.Constants;


import com.example.erp.common.Result;


import com.example.erp.dto.pp.OrderNumberTransferDTO;


import com.example.erp.dto.sd.OrderProcessSortDTO;


import com.example.erp.entity.pp.*;


import com.example.erp.entity.sd.*;


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.userInfo.Log;


import com.example.erp.entity.userInfo.SysError;


import com.example.erp.exception.ServiceException;


import com.example.erp.mapper.mm.FinishedOperateLogMapper;


import com.example.erp.mapper.pp.*;


import com.baomidou.dynamic.datasource.annotation.DS;


import com.example.erp.mapper.sd.*;


import com.example.erp.mapper.userInfo.LogMapper;


import com.example.erp.service.mm.FinishedGoodsInventoryService;


import com.example.erp.service.sd.OrderProcessDetailService;


import com.example.erp.service.userInfo.LogService;


import com.example.erp.service.userInfo.SysErrorService;


import com.example.erp.tools.JacksonUtil;


import com.fasterxml.jackson.core.JsonProcessingException;


import com.fasterxml.jackson.core.type.TypeReference;


import com.github.yulichang.wrapper.MPJLambdaWrapper;


import lombok.RequiredArgsConstructor;


import org.springframework.http.HttpEntity;


import org.springframework.http.HttpMethod;


import org.springframework.http.HttpStatus;


import org.springframework.http.ResponseEntity;


import org.springframework.data.redis.core.RedisCallback;


import org.springframework.data.redis.core.StringRedisTemplate;


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;


import org.springframework.transaction.interceptor.TransactionAspectSupport;


import org.springframework.web.client.RestTemplate;




import javax.annotation.Resource;


import java.text.SimpleDateFormat;


import java.time.LocalDate;


import java.time.LocalDateTime;


import java.time.LocalTime;


import java.time.format.DateTimeFormatter;


import java.util.*;


import java.util.concurrent.CompletableFuture;


import java.util.concurrent.TimeUnit;


import java.util.stream.Collectors;




@Service


@DS("pp")


@@ -53,13 +64,9 @@


    private final ReportingWorkDetailMapper reportingWorkDetailMapper;


    private final OrderMapper  orderMapper;


    private final OrderDetailMapper orderDetailMapper;




    private final FlowCardMapper flowCardMapper;




    private final OrderProcessDetailService orderProcessDetailService;




    private final LogService logService;




    private final LogMapper logMapper;


    private final OrderGlassDetailMapper orderGlassDetailMapper;


    private final SysErrorService sysErrorService;


@@ -69,8 +76,10 @@


    private final ReworkMapper reworkMapper;


    private final BasicDataMapper basicDataMapper;


    private final FinishedGoodsInventoryService finishedGoodsInventoryService;


    private final StringRedisTemplate stringRedisTemplate;






    @Resource


    private AsyncQueryExecutor asyncExecutor;


    /*public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper, LogService logService, LogMapper logMapper, OrderGlassDetailMapper orderGlassDetailMapper, SysErrorService sysErrorService, OrderDetailMapper orderDetailMapper, FinishedOperateLogMapper finishedOperateLogMapper, ReportingWorkTransferMapper reportingWorkTransferMapper) {


        this.reportingWorkMapper = reportingWorkMapper;


        this.basicDateProduceMapper = basicDateProduceMapper;


@@ -152,6 +161,8 @@


            //工艺流程


            map.put("technologicalProcess", technologicalProcess);




            //获取服务器时间


            map.put("reportingWorkTiem", LocalDateTime.now());


            //设备下拉框


            map.put("device", reportingWorkMapper.SelectWorkBasicDeviceMp(process));


            //班组下拉框


@@ -264,19 +275,7 @@


        List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(


                JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);




        // 报工编号


        Integer maxId = reportingWorkMapper.selectMaxReportingWorkId();


        if (maxId == null) {


            maxId = 0;


        }


        String formattedNumber = String.format("%04d", maxId + 1);




        // 格式化当前日期


        Date currentDate = new Date();


        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");


        String formattedDate = dateFormat.format(currentDate);


        String reportingWorkId = "BG" + formattedDate + formattedNumber;


        reportingWork.setReportingWorkId(reportingWorkId);




        // 处理工序 ID


        String[] processIdStr = reportingWork.getProcessId() != null


@@ -300,9 +299,23 @@


            reportingWork.setReportingWorkTime(LocalDateTime.now());


        }




        // 是否线补 1现补 0未现补


        // 是否现补 1现补 0未现补


        int isPatch = reportingWorkJson.getInteger("isPatch") != null


                ? reportingWorkJson.getInteger("isPatch") : 0;




        // 报工编号


        Integer maxId = reportingWorkMapper.selectMaxReportingWorkId();


        if (maxId == null) {


            maxId = 0;


        }


        String formattedNumber = String.format("%04d", maxId + 1);




        // 格式化当前日期


        Date currentDate = new Date();


        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");


        String formattedDate = dateFormat.format(currentDate);


        String reportingWorkId = "BG" + formattedDate + formattedNumber;


        reportingWork.setReportingWorkId(reportingWorkId);




        // 主表插入


        reportingWorkMapper.insert(reportingWork);


@@ -427,7 +440,7 @@


                reportingWorkDetailMapper.insert(reportingWorkDetail);


            }




            // 更新流程卡报工数量


            // 判断最后一道工序，更新流程卡报工数量


            if (reportingWork.getNextProcess() == null || reportingWork.getNextProcess().isEmpty()) {


                LambdaUpdateWrapper<FlowCard> flowCardLambdaUpdateWrapper = new LambdaUpdateWrapper<>();


                flowCardLambdaUpdateWrapper


@@ -643,22 +656,22 @@


        String nowDate = LocalDate.now().toString();


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


        String laminating = reportingWorkMapper.getProcessLaminating(thisProcess);


//合片工序


if (laminating.indexOf("step")!=-1){


    LambdaUpdateWrapper


                <ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();


        updateWrapper


                .eq(ReportingWork::getProcessId, processIdStr[0])


                .eq(ReportingWork::getThisProcess, reportingWork.get("process"))


                .eq(ReportingWork::getReviewedState, 0)


                .setSql("reviewed_state =1")


                .set(ReportingWork::getReviewed, userName)


                .set(ReportingWork::getExamineTime, nowDate);


        reportingWorkMapper.update(null, updateWrapper);


}else {


    reportingWorkMapper.ReviewReportingWorkMp(processIdStr[0],reportingWork.get("process"),technologyStr,userName);


        //合片工序


        if (laminating.indexOf("step")!=-1){


            LambdaUpdateWrapper


                        <ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();


                updateWrapper


                        .eq(ReportingWork::getProcessId, processIdStr[0])


                        .eq(ReportingWork::getThisProcess, reportingWork.get("process"))


                        .eq(ReportingWork::getReviewedState, 0)


                        .setSql("reviewed_state =1")


                        .set(ReportingWork::getReviewed, userName)


                        .set(ReportingWork::getExamineTime, nowDate);


                reportingWorkMapper.update(null, updateWrapper);


        }else {


            reportingWorkMapper.ReviewReportingWorkMp(processIdStr[0],reportingWork.get("process"),technologyStr,userName);




}


        }


        return true;


    }




@@ -676,7 +689,7 @@








        List<Map<String, Object>> reportingWorkDetails = reportingWorkMapper.selectByReportingWorkId(reportingWorkId, reportingWork.getNextProcess());


        List<Map<String, Object>> reportingWorkDetails = reportingWorkMapper.selectByReportingWorkId(reportingWorkId, reportingWork.getNextProcess(),reportingWork.getOrderId());


        reportingWorkDetails.forEach(reportingWorkDetail -> {


            List<DamageDetails> damageDetailsList = new ArrayList<>();


            damageDetailsList = damageDetailsMapper.selectList(new LambdaQueryWrapper<DamageDetails>()


@@ -735,6 +748,14 @@


        JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);


        ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);


        List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);






        ReportingWork reportingWork1 = reportingWorkMapper.selectOne(new LambdaQueryWrapper<ReportingWork>()


                .eq(ReportingWork::getReportingWorkId, reportingWork.getReportingWorkId()));


        reportingWork.setCreatorId(reportingWork1.getCreatorId());


        reportingWork.setCreator(reportingWork1.getCreator());


        reportingWork.setUpdateTime(LocalDateTime.now());




        //查询该报工是否为报工转移订单


        Integer transferState = reportingWorkMapper.selectReviewedState(reportingWork.getReportingWorkId());


        if (transferState !=3){


@@ -811,30 +832,92 @@


    }




    //报工管理查询


    public Map<String, Object> selectReportingWorkSv(Integer pageNum, Integer pageSize, List<String> selectDate, 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, startDate, endDate, 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;


//    }






    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 = "";


        }




        // 默认时间：最近 3 天


        String endDate = LocalDate.now().toString();


        String startDate = LocalDate.now().minusDays(3).toString();


        if(selectDate !=null && selectDate.size()==2){


            if(!selectDate.get(0).isEmpty()){




        // 如果传入自定义日期


        if (selectDate != null && selectDate.size() == 2) {


            if (!selectDate.get(0).isEmpty()) {


                startDate = selectDate.get(0);


            }


            if(!selectDate.get(1).isEmpty()){


            if (!selectDate.get(1).isEmpty()) {


                endDate = selectDate.get(1);


            }


        }


        Map<String, Object> map = new HashMap<>();


        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, startDate, endDate, orderId, reportingWork));


        List<String> list = new ArrayList<>();


        list.add(startDate);


        list.add(endDate);


        map.put("selectDate",list);


        return map;




        Map<String, Object> result = new HashMap<>();




        try {


            // 并行执行两条 SQL 查询


            String finalStartDate = startDate;


            String finalEndDate = endDate;


            String finalOrderId = orderId;


            CompletableFuture<List<ReportingWork>> dataFuture =


                    asyncExecutor.runAsync(() ->


                            reportingWorkMapper.selectReportingWorkMp(


                                    offset, pageSize, finalStartDate, finalEndDate, finalOrderId, reportingWork));




            CompletableFuture<Map<String, Float>> totalFuture =


                    asyncExecutor.runAsync(() ->


                            reportingWorkMapper.getFootSum(


                                    offset, pageSize, finalStartDate, finalEndDate, finalOrderId, reportingWork));




            // 等待全部完成


            CompletableFuture.allOf(dataFuture, totalFuture).join();




            result.put("data", dataFuture.get());


            result.put("total", totalFuture.get());




            // 日期范围


            List<String> list = new ArrayList<>();


            list.add(startDate);


            list.add(endDate);


            result.put("selectDate", list);




        } catch (Exception e) {


            e.printStackTrace();


            throw new RuntimeException("并行查询报工记录异常：" + e.getMessage(), e);


        }




        return result;


    }




    //删除报工


@@ -1044,7 +1127,9 @@


            List<ReportingWork> ReportingWorks = reportingWorkMapper.selectJoinList(ReportingWork.class,


                    new MPJLambdaWrapper<ReportingWork>()


                            .select(ReportingWork::getReportingWorkId)


                            .leftJoin(ReportingWorkDetail.class, ReportingWorkDetail::getReportingWorkId, ReportingWork::getReportingWorkId)


                            .leftJoin(ReportingWorkDetail.class,


                                    ReportingWorkDetail::getReportingWorkId,


                                    ReportingWork::getReportingWorkId)


                            .eq(ReportingWork::getProcessId,reportingWork.getProcessId())


                            .eq(ReportingWork::getThisProcess,reportingWork.getThisProcess())


                            .eq(ReportingWork::getDeviceName,reportingWork.getDeviceName())


@@ -1059,12 +1144,7 @@


            //判断报工表是否存在，不存在则新增报工主副表数据，存在则修改副表数据


            if(ReportingWorks.isEmpty()){


                //获取当前最大报工单号生成报工单号


                String formattedNumber = String.format("%04d", reportingWorkMapper.selectMaxReportingWorkId() + 1);


                //格式化当前日期


                Date currentDate = new Date();


                SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");


                String formattedDate = dateFormat.format(currentDate);


                String reportingWorkId = "BG" + formattedDate + formattedNumber;


                String reportingWorkId = this.getTodayMaxReportingId();




                reportingWork.setReportingWorkId(reportingWorkId);


                reportingWorkDetail.setReportingWorkId(reportingWorkId);


@@ -1127,7 +1207,7 @@


            //将异常传入数据库


            SysError sysError = new SysError();


            sysError.setError(e +Arrays.toString(e.getStackTrace()));


            sysError.setFunc("汉玻mes报工");


            sysError.setFunc("mes报工");


            sysErrorService.insert(sysError);


            throw new ServiceException(Constants.Code_500, "数据请求异常，请检查");




@@ -1514,4 +1594,206 @@


        map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));


        return map;


    }






    //@Transactional(rollbackFor = Exception.class , noRollbackFor = ServiceException.class)


    public Result mesReportingWorkSvToRedis(Map<String, Object> reportingWorkMap) throws JsonProcessingException, InterruptedException {




        //设置回滚点


        //Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();


            //接收解析主附表信息


        String titleJson = JacksonUtil.writeValueAsString(reportingWorkMap.get("title"));


        String detailJson = JacksonUtil.writeValueAsString(reportingWorkMap.get("detail"));


        ReportingWork reportingWork = JacksonUtil.readValue(titleJson, ReportingWork.class);


        ReportingWorkDetail reportingWorkDetail = JacksonUtil.readValue(detailJson, ReportingWorkDetail.class);


        String Base_KEY = "reportingWork:"+reportingWork.getProcessId()+"/"+reportingWorkDetail.getTechnologyNumber()+":"+reportingWork.getThisProcess()+":"+reportingWork.getDeviceName();


        String reportingWork_KEY = Base_KEY+":title";


        String reportingWorkDetail_KEY = Base_KEY+":detail:"+reportingWorkDetail.getOrderNumber();




        String process_KEY = "reportingWork:"+reportingWork.getProcessId()+"/"+reportingWorkDetail.getTechnologyNumber()+":process";




        //判断锁是否存在，存在等待5秒


        if(Boolean.TRUE.equals(stringRedisTemplate.hasKey("lock:reportingWork"))){


            Thread.sleep(5*1000);


            if(Boolean.TRUE.equals(stringRedisTemplate.hasKey("lock:reportingWork"))){


                throw new ServiceException(Constants.Code_600, "当前服务器正在处理报工数据，请稍后重试！");


            }


        }






        //判断工序是否存在redis中


        if(!Boolean.TRUE.equals(stringRedisTemplate.hasKey(process_KEY+":"+reportingWork.getThisProcess()))){


            List<OrderProcessSortDTO> orderProcessSortDTOList  = orderProcessDetailMapper.selectProcessSort(


                    reportingWork.getOrderId(),


                    reportingWork.getProcessId(),


                    reportingWorkDetail.getOrderNumber(),


                    reportingWorkDetail.getTechnologyNumber()


            );


            if (orderProcessSortDTOList.isEmpty()){


                throw new ServiceException(Constants.Code_600, "未检测到流程卡信息，请检查");


            }




            orderProcessSortDTOList.forEach(orderProcessSortDTO -> {


                Map<String, String> map = new HashMap<>();


                map.put("sort",orderProcessSortDTO.getSort());


                map.put("recombination",orderProcessSortDTO.getRecombination());


                stringRedisTemplate.opsForHash().putAll(process_KEY+":"+orderProcessSortDTO.getProcess(), map);


            });


        }


        String recombination = (String) stringRedisTemplate.opsForHash().get(process_KEY+":"+reportingWork.getThisProcess(),"recombination");




        if (!recombination.isEmpty()){


            throw new ServiceException(Constants.Code_600, "复合工序请到ERP中进行报工");


        }












        //判断是否redis此报工编号key是否存在


        if(Boolean.TRUE.equals(stringRedisTemplate.hasKey(reportingWork_KEY))){


            stringRedisTemplate.opsForHash().increment(


                    reportingWork_KEY,


                    "thisCompletedQuantity",


                    reportingWork.getThisCompletedQuantity()


            );


        }


        else{


            stringRedisTemplate.opsForHash().putAll(


                    reportingWork_KEY,


                    JacksonUtil.readValueObjectToString(reportingWork,new TypeReference<Map<String, String>>() {})


            );


        }


        //获取可报数量




        //判断是否redis此报工明细中key是否存在


        if(Boolean.TRUE.equals(stringRedisTemplate.hasKey(reportingWorkDetail_KEY))){


            stringRedisTemplate.opsForHash().increment(


                    reportingWorkDetail_KEY,


                    "completedQuantity",


                    reportingWorkDetail.getCompletedQuantity()


            );


        }else {


            stringRedisTemplate.opsForHash().putAll(


                    reportingWorkDetail_KEY,


                    JacksonUtil.readValueObjectToString(reportingWorkDetail,new TypeReference<Map<String, String>>() {})


            );


        }


        return Result.success("提交成功");


    }




    public void redisToMysqlReportingWork() throws InterruptedException {


        if(Boolean.TRUE.equals(stringRedisTemplate.hasKey("lock:reportingWork"))){


            throw new ServiceException(Constants.Code_600, "定时任务:当前服务器正在处理报工数据，请稍后重试！");


        }


        //获取所有key


        String pattern = "reportingWork:*";


        Set<String> keys = stringRedisTemplate.keys(pattern);




        //判断redis中是否存在报工数据,存在则添加锁 并且修改key转移到上传mysql的key中


        if (keys != null && !keys.isEmpty()) {


            //添加锁


            stringRedisTemplate.opsForValue().set("lock:reportingWork","1",60, TimeUnit.SECONDS);




            if(Boolean.FALSE.equals(stringRedisTemplate.hasKey("upload:*" ))){


                keys.forEach(key -> {


                    stringRedisTemplate.rename(key, "upload:" + key);


                });


            }


        }else{


            return;


        }


        //添加暂停时间，方式获取map时，redis中数据还在变化


        Thread.sleep(200);






        // 保存日志，把redis中的数据保存到日志中


        Map<String, Map<Object, Object>> map = this.getAllHashesByPattern("upload:reportingWork:*");


        Log log = new Log();


        log.setContent(JacksonUtil.writeValueAsString(map));


        log.setFunction("reportingWorkRedisToMysql");


        log.setOperator("自动定时报工");


        logService.saveLog(log);


        //删除锁，让接口继续接收报工


        stringRedisTemplate.delete("lock:reportingWork");




        //获取到所有参数后清空redis库


        // stringRedisTemplate.getConnectionFactory().getConnection().flushDb();




        //从redis中获取所有报工主表数据


        String titleKeyString = "upload:reportingWork:*:title";


        Set<String> titleKeys = stringRedisTemplate.keys(titleKeyString);


        if (titleKeys != null) {


            titleKeys.forEach(titleKey -> {


                ReportingWork reportingWork = JSON.parseObject(


                        JSONObject.toJSONString(stringRedisTemplate.opsForHash().entries(titleKey))


                        , ReportingWork.class


                );


                //获取当天一共有多少个报工编号


                String reportingWorkId = this.getTodayMaxReportingId();


                //添加报工编号


                reportingWork.setReportingWorkId(reportingWorkId);


                //往主表插入报工主数据


                reportingWorkMapper.insert(reportingWork);




                String detailKeyString = titleKey.replace(":title", ":detail:*");


                Set<String> detailKeys = stringRedisTemplate.keys(detailKeyString);


                if (detailKeys != null) {


                    detailKeys.forEach(detailKey -> {




                        ReportingWorkDetail reportingWorkDetail = JSON.parseObject(


                                JSONObject.toJSONString(stringRedisTemplate.opsForHash().entries(detailKey))


                                , ReportingWorkDetail.class


                        );


                        reportingWorkDetail.setReportingWorkId(reportingWorkId);


                        reportingWorkDetailMapper.insert(reportingWorkDetail);




                        //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量


                        LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();


                        updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())


                                .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())


                                .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())


                                .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())


                                .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())


                                .setSql("reporting_work_num_count = reporting_work_num_count +" + reportingWorkDetail.getCompletedQuantity())


                                .setSql("reporting_work_num =reporting_work_num +" + reportingWorkDetail.getCompletedQuantity());




                        orderProcessDetailMapper.update(null, updateWrapper);


                    });


                }




            });


        }


        Set<String> uploadKeys = stringRedisTemplate.keys("upload:reportingWork:*");


        if (uploadKeys != null) {


            stringRedisTemplate.delete(uploadKeys);


        }




    }




    public String getTodayMaxReportingId() {


        String formattedNumber = String.format("%04d", reportingWorkMapper.selectMaxReportingWorkId() + 1);


        //格式化当前日期


        Date currentDate = new Date();


        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");


        String formattedDate = dateFormat.format(currentDate);


        return "BG" + formattedDate + formattedNumber;




    }






/*获取所有的参数转*/


    public Map<String, Map<Object, Object>> getAllHashesByPattern(String pattern) {


        Set<String> keys = stringRedisTemplate.keys(pattern);


        Map<String, Map<Object, Object>> result = new HashMap<>();




        if (keys != null) {


            for (String key : keys) {


                Map<Object, Object> hashData = stringRedisTemplate.opsForHash().entries(key);


                result.put(key, hashData);


            }


        }




        return result;


    }


}