【业务功能篇31】重构整改圈复杂度高的代码块

小灰灰 2024-03-16 21:34 9阅读 0赞

> 在前面的文章中，我们设计实现一个告警功能，其中对于一个类，我们在流水线上部署后，有些codecheck问题需要整改，比如圈复杂度问题，有些逻辑嵌套多层判断语句，需要降低复杂度 [【业务功能篇24】Springboot+mybatisPlus基于＞业务功能篇16 持续补充 CRUD+导出+定时任务功能开发\_studyday1的博客-CSDN博客][24_Springboot_mybatisPlus_16 _ CRUD_studyday1_-CSDN]

### 整改实现类： ###

整改思路也比较简单，直接利用idea工具的重构功能，把复杂度高的代码块抽象出来一个方法，这里可以参考我写的另外一篇帖子，大概讲了这个重构的操作 [【业务功能篇30】代码重构--卫语句/idea内置工具抽象方法\_studyday1的博客-CSDN博客][30_--_idea_studyday1_-CSDN]

ProdProblemWarnServiceImpl

package com.xxx.xxx.service.impl.matwarn;
    
    import static com.xxx.xxx.service.impl.dao.iservice.matwarn.ProdProblemWarnMsgServiceImpl.MESSAGE_DO_SEND;
    import static com.xxx.xxx.service.impl.dao.iservice.matwarn.ProdProblemWarnMsgServiceImpl.MESSAGE_NO_SEND;
    
    import com.xxx.xxx.domain.dto.DistributionWarnDto;
    import com.xxx.xxx.domain.dto.xxxDto;
    import com.xxx.xxx.domain.dto.xxxTaskDto;
    import com.xxx.xxx.domain.model.MtProductionProblemLog;
    import com.xxx.xxx.domain.model.MtProductionProblemMessage;
    import com.xxx.xxx.domain.model.MtProductionProblemWarn;
    import com.xxx.xxx.domain.model.QbdReportTopProblem;
    import com.xxx.xxx.domain.model.TxnyProductProblemManage;
    import com.xxx.xxx.domain.model.TxnyQualityIssureFeedF;
    import com.xxx.xxx.qualitybigdata.model.DistributionWarnCol;
    import com.xxx.xxx.qualitybigdata.model.DistributionWarnQueryParam;
    import com.xxx.xxx.qualitybigdata.model.ProdProblemWarnCol;
    import com.xxx.xxx.qualitybigdata.model.ProdProblemWarnQueryParam;
    import com.xxx.xxx.qualitybigdata.model.ProdProblemWarnUpdateParam;
    import com.xxx.xxx.qualitybigdata.model.ResponseVo;
    import com.xxx.xxx.service.UserService;
    import com.xxx.xxx.service.dao.UserAccountService;
    import com.xxx.xxx.service.dao.iservice.QbdReportTopProblemService;
    import com.xxx.xxx.service.dao.iservice.TxnyProductProblemManageService;
    import com.xxx.xxx.service.dao.iservice.matwarn.MatWarnFieldConfigService;
    import com.xxx.xxx.service.dao.iservice.matwarn.ProdProblemWarnMsgService;
    import com.xxx.xxx.service.dao.mapper.TxnyQualityIssureFeedMapper;
    import com.xxx.xxx.service.impl.dao.iservice.matwarn.ProdProblemWarnLogServiceImpl;
    import com.xxx.xxx.service.matwarn.MatWarnService;
    import com.xxx.xxx.service.matwarn.ProdProblemWarnService;
    import com.xxx.xxx.utils.EmailUtil;
    import com.xxx.xxx.utils.JsonUtils;
    import com.xxx.xxx.utils.MsgUtils;
    import com.xxx.xxx.utils.MyBeanUtils;
    import com.xxx.xxx.utils.ResponseUtils;
    import com.xxx.xxx.utils.SpringBeanUtils;
    import com.xxx.xxx.utils.excel.ExcelUtil;
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.google.common.collect.Lists;
    
    import lombok.extern.slf4j.Slf4j;
    
    import org.apache.commons.lang3.StringUtils;
    import org.apache.poi.hssf.usermodel.HSSFCellStyle;
    import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
    import org.apache.poi.hssf.usermodel.HSSFSheet;
    import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    import org.apache.poi.ss.usermodel.Cell;
    import org.apache.poi.ss.usermodel.FillPatternType;
    import org.apache.poi.ss.usermodel.Font;
    import org.apache.poi.ss.usermodel.IndexedColors;
    import org.apache.poi.ss.usermodel.Row;
    import org.jetbrains.annotations.NotNull;
    import org.springframework.beans.BeanUtils;
    import org.springframework.stereotype.Component;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.transaction.support.TransactionSynchronization;
    import org.springframework.transaction.support.TransactionSynchronizationManager;
    
    import java.io.File;
    import java.io.IOException;
    import java.lang.reflect.Field;
    import java.math.BigDecimal;
    import java.math.RoundingMode;
    import java.security.AccessController;
    import java.security.PrivilegedAction;
    import java.text.SimpleDateFormat;
    import java.time.DayOfWeek;
    import java.time.LocalDate;
    import java.time.format.DateTimeFormatter;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Locale;
    import java.util.Map;
    import java.util.Objects;
    import java.util.stream.Collectors;
    
    import javax.annotation.Resource;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletResponse;
    
    
    @Slf4j
    @Component("prodProblemWarnService1")
    public class ProdProblemWarnServiceImpl extends UserAccountService implements ProdProblemWarnService {
    
        @Resource
        private UserService userService;
    
        @Resource
        private MatWarnService matWarnService;
    
        @Resource
        private com.xxx.xxx.service.impl.dao.iservice.matwarn.ProdProblemWarnServiceImpl prodProblemWarnService;
    
        @Resource
        private ProdProblemWarnLogServiceImpl prodProblemWarnLogService;
    
        @Resource
        private ProdProblemWarnMsgService prodProblemWarnMsgService;
    
        @Resource
        private TxnyQualityIssureFeedMapper issureFeedMapper;
    
        @Resource
        private MatWarnFieldConfigService matWarnFieldConfigService;
    
        @Resource
        private QbdReportTopProblemService qbdReportTopProblemService;
    
        @Resource
        private TxnyProductProblemManageService productProblemManageService;
    
        private final static String TASK_URL = "https://"
            + "xxx.xxx.com/xxx/#/productWarning?warnNo=";
    
        private final static String TEST_TASK_URL = "https://"
            + "xxx.xxx.com/xxx/#/productWarning?warnNo=";
    
        /**
         * 测试xxx账号
         */
        private final static String TEST_xxx_ACCOUNT = "xxx";
    
        private final static String WARN_TYPE = "不良数量预警";
    
    
        /**
         * getDropListByType
         * 
         * @param type type
         * @return ResponseVo
         */
        @Override
        public ResponseVo getDropListByType(String type) {
            List<String> result = new ArrayList<>();
            switch (type) {
                // 预警状态
                case "warnStatus":
                    String[] status = new String[] {"未处理", "分析中", "评审中", "已关闭"};
                    result.addAll(Arrays.asList(status));
                    break;
                // 预警级别
                case "warnLev":
                    String[] level = new String[] {"一般", "较重", "严重"};
                    result.addAll(Arrays.asList(level));
                    break;
                // 其他 product,project,category,subCategory,warnRea
                default:
                    result = prodProblemWarnService.getDropListByType(type);
                    break;
            }
            return ResponseUtils.successResponse(result, "获取数据成功");
        }
    
    
        /**
         * downloadPageExcel
         * 
         * @param httpServletResponse httpServletResponse
         * @param queryParam queryParam
         */
        @Override
        public void downloadPageExcel(HttpServletResponse httpServletResponse, ProdProblemWarnQueryParam queryParam) {
            String fileName = "生产问题预警";
            String[] heads = getStrings();
            File newFile = new File(fileName);
            byte[] chartOne = EmailUtil.base64ToByte(queryParam.getChartList().get("1").toString());
            byte[] chartTwo = EmailUtil.base64ToByte(queryParam.getChartList().get("2").toString());
            byte[] chartFive = EmailUtil.base64ToByte(queryParam.getChartList().get("5").toString());
            byte[] chartThree = EmailUtil.base64ToByte(queryParam.getChartList().get("3").toString());
            byte[] chartFour = EmailUtil.base64ToByte(queryParam.getChartList().get("4").toString());
            byte[] chartSeven = EmailUtil.base64ToByte(queryParam.getChartList().get("7").toString());
            byte[] chartSix = EmailUtil.base64ToByte(queryParam.getChartList().get("6").toString());
            List<MtProductionProblemWarn> res1 = prodProblemWarnService.getFilterData(queryParam);
            try (ServletOutputStream out = httpServletResponse.getOutputStream()) {
                HSSFWorkbook wb = new HSSFWorkbook();
                HSSFCellStyle style = wb.createCellStyle();
                Font font = wb.createFont();
                font.setFontHeightInPoints((short) 11);
                font.setBold(true);
                style.setFont(font);
                style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
                style.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
                // 生成一个表格
                HSSFSheet sh = getRows(fileName, heads, res1, wb, style);
                int picStart = getPicStart(res1, sh);
                HSSFClientAnchor anchor1 = new HSSFClientAnchor(0, 0, 0, 0, (short) 0, picStart, (short) 4, picStart + 8);
                ExcelUtil.setPicture(chartOne, wb, sh, 1, 1, anchor1);
                HSSFClientAnchor anchor2 = new HSSFClientAnchor(0, 0, 0, 0, (short) 4, picStart, (short) 10, picStart + 8);
                ExcelUtil.setPicture(chartTwo, wb, sh, 1, 1, anchor2);
                HSSFClientAnchor anchor3 = new HSSFClientAnchor(0, 0, 0, 0, (short) 10, picStart, (short) 15, picStart + 8);
                ExcelUtil.setPicture(chartThree, wb, sh, 1, 1, anchor3);
                HSSFClientAnchor anchor4 = new HSSFClientAnchor(0, 0, 0, 0, (short) 15, picStart, (short) 20, picStart + 8);
                ExcelUtil.setPicture(chartFour, wb, sh, 1, 1, anchor4);
                HSSFClientAnchor anchor5 = new HSSFClientAnchor(0, 0, 0, 0, (short) 0, picStart + 8, (short) 7,
                    picStart + 16);
                ExcelUtil.setPicture(chartFive, wb, sh, 1, 1, anchor5);
                HSSFClientAnchor anchor6 = new HSSFClientAnchor(0, 0, 0, 0, (short) 7, picStart + 8, (short) 14,
                    picStart + 16);
                ExcelUtil.setPicture(chartSix, wb, sh, 1, 1, anchor6);
                HSSFClientAnchor anchor7 = new HSSFClientAnchor(0, 0, 0, 0, (short) 14, picStart + 8, (short) 20,
                    picStart + 16);
                ExcelUtil.setPicture(chartSeven, wb, sh, 1, 1, anchor7);
                wb.write(out);
                newFile = new File(fileName);
            } catch (IOException e) {
                log.error(e.getMessage());
            }
            httpServletResponse.setCharacterEncoding("UTF-8");
            httpServletResponse.setContentType("application/octet-stream");
            httpServletResponse.setHeader("Content-Disposition", "attachment;fileName=" + newFile.getName());
        }
    
        @NotNull
        private String[] getStrings() {
            String[] heads = new String[] {
                "预警单号", "预警状态", "预警时间", "预警原因", "产品", "项目", "品类", "子品类", "产品编码", "物料编码", "预警描述", "mes+问题单号", "供应商", "不良数",
                "分析人", "评审人", "编码累计预警单数", "在制", "在库", "在途", "在网", "围堵措施", "根因分析-产生原因", "纠正措施-针对产生原因", "纠正措施-针对流出原因", "长期措施",
                "横向排查清零", "是否分析完成", "是否有效预警", "无效预警原因", "评审意见", "是否闭环", "闭环时间"
            };
            return heads;
        }
    
        private int getPicStart(List<MtProductionProblemWarn> res1, HSSFSheet sh) {
            int picStart = res1.size() + 1;
            for (int i = picStart; i < picStart + 17; i++) {
                sh.createRow(i).setHeight((short) (200 * 4));
            }
            return picStart;
        }
    
        @NotNull
        private HSSFSheet getRows(String fileName, String[] heads, List<MtProductionProblemWarn> res1,
            HSSFWorkbook workbook, HSSFCellStyle style) {
            HSSFSheet sh = workbook.createSheet(fileName);
            Row xRow0 = sh.createRow(0);
            for (int i = 0; i < heads.length; i++) {
                Cell cell = xRow0.createCell(i);
                cell.setCellStyle(style);
                cell.setCellValue(heads[i]);
                sh.autoSizeColumn(i, true);
                sh.setColumnWidth(i, sh.getColumnWidth(i) * 17 / 10);
            }
            writePageExcelSheetData(res1, sh);
            return sh;
        }
    
        private String writePageExcelSheetProperty(List<Field> fieldList,String pro,List<MtProductionProblemWarn> details
            ,int index) {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            String val = "";
            try {
                Field field = fieldList.stream()
                        .filter(f -> f.getName().toUpperCase(Locale.ROOT).equals(pro))
                        .collect(Collectors.toList())
                        .get(0);
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    field.setAccessible(true);
                    return null;
                });
                Object obj = field.get(details.get(index));
                switch (field.getType().getName()) {
                    case "java.util.Date":
                        val = getString(details, formatter, index, field, obj);
                        break;
                    case "java.lang.Integer":
                    case "int":
                        val = obj == null ? "" : ((Integer) field.get(details.get(index))).toString();
                        break;
                    case "java.lang.Double":
                        val = obj == null ? "" : ((Double) field.get(details.get(index))).toString();
                        break;
                    default:
                        val = obj == null ? "" : (String) field.get(details.get(index));
                        break;
                }
            } catch (IllegalAccessException e) {
                log.error(e.getMessage());
            }
            return val;
        }
    
        /**
         * writePageExcelSheetData
         * 
         * @param details details
         * @param sh sh
         */
        private void writePageExcelSheetData(List<MtProductionProblemWarn> details, HSSFSheet sh) {
    
            String mapStr
                = "{\"warnNo\":\"预警单号\",\"warnStatus\":\"预警状态\",\"warnDate\":\"预警时间\",\"warnRea\":\"预警原因\",\"product\":\"产品\",\"project\":\"项目\",\"category\":\"品类\",\"subCategory\":\"子品类\",\"itemCode\":\"产品编码\",\"failItem\":\"物料编码\",\"warnDesc\":\"预警描述\",\"mesNo\":\"mes+问题单号\",\"supplier\":\"供应商\",\"badQty\":\"不良数\",\"analysisBy\":\"分析人\",\"reviewBy\":\"评审人\",\"codeAccQty\":\"编码累计预警单数\",\"inProcess\":\"在制\",\"inStore\":\"在库\",\"inTransit\":\"在途\",\"inNet\":\"在网\",\"encloseMeasure\":\"围堵措施\",\"occurCause\":\"根因分析-产生原因\",\"occurMeasure\":\"纠正措施-针对产生原因\",\"outflowCause\":\"纠正措施-针对流出原因\",\"solution\":\"长期措施\",\"horizontal\":\"横向排查清零\",\"isAnalyseFinish\":\"是否分析完成\",\"isEffective\":\"是否有效预警\",\"invalidReason\":\"无效预警原因\",\"reviewComment\":\"评审意见\",\"isClosed\":\"是否闭环\",\"closedDate\":\"闭环时间\"}";
            Map<String, String> map = JsonUtils.jsonToObj(mapStr, Map.class);
            List<String> property = new ArrayList<>(map.keySet());
            for (int i = 0; i < details.size(); i++) {
                Field[] fields = details.get(i).getClass().getDeclaredFields();
                List<Field> fieldList = Arrays.asList(fields);
                Row xRow = sh.createRow(i + 1);
                xRow.setHeight((short) (200 * 2));
                for (int j = 0; j < property.size(); j++) {
                    String val = "";
                    Cell cell = xRow.createCell(j);
                    String pro = property.get(j).toUpperCase(Locale.ROOT);
                    val = writePageExcelSheetProperty(fieldList,pro,details,i);
                    cell.setCellValue(val);
                }
            }
        }
    
        @NotNull
        private String getString(List<MtProductionProblemWarn> details, SimpleDateFormat formatter, int num, Field field,
            Object obj) throws IllegalAccessException {
            String val;
            if (obj == null) {
                val = "";
            } else {
                Date date = ((Date) field.get(details.get(num)));
                val = formatter.format(date);
            }
            return val;
        }
    
        /**
         * getUserCol
         * 
         * @param user user
         * @return ResponseVo
         */
        @Override
        public ResponseVo getUserCol(String user) {
            return ResponseUtils.successResponse(matWarnFieldConfigService.getUserCol(user, "1"), "获取数据成功");
        }
    
    
        /**
         * saveUserCol
         * 
         * @param warnCol warnCol
         * @return ResponseVo
         */
        @Override
        public ResponseVo saveUserCol(ProdProblemWarnCol warnCol) {
            DistributionWarnCol param = new DistributionWarnCol();
            MyBeanUtils.shallowCopy(warnCol, param);
            param.setDataType("1");
            matWarnFieldConfigService.saveUserCol(param);
            return ResponseUtils.successResponse(null, "保存数据成功");
        }
    
    
        /**
         * getWarnPage
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getWarnPage(ProdProblemWarnQueryParam queryParam) {
            Page<MtProductionProblemWarn> result = prodProblemWarnService.getPagedFilterData(queryParam);
            return ResponseUtils.successResponse(result, "获取数据成功");
        }
    
    
        /**
         * getWarnInfo
         * 
         * @param warnNo warnNo
         * @return ResponseVo
         */
        @Override
        public ResponseVo getWarnInfo(String warnNo) {
            MtProductionProblemWarn vo = prodProblemWarnService.findOneByWarnNo(warnNo);
            // 查询日志 [存在循环调用SQL问题]
            List<MtProductionProblemLog> logs = prodProblemWarnLogService.findLogsByWarnNo(vo.getWarnNo());
            vo.setLogList(logs);
            // 查询mes+单号跳转
            List<String> mesNo = Arrays.asList(vo.getMesNo().split(","));
            List<Map<String, String>> businessKey = prodProblemWarnService.getBusinessKey(mesNo);
            Map<String, String> mesKey = new HashMap<>();
            for (Map<String, String> item : businessKey) {
                mesKey.put(item.get("issure_no"), item.get("business_key"));
            }
            vo.setBusinessKey(mesKey);
            // 获取文件列表
            vo.setFiles(prodProblemWarnService.findFile(vo.getWarnNo()));
            return ResponseUtils.successResponse(vo, "获取明细成功");
        }
    
    
        /**
         * getBusinessKey
         * 
         * @param issureNo issureNo
         * @return ResponseVo
         */
        @Override
        public ResponseVo getBusinessKey(String issureNo) {
            List<Map<String, String>> businessKey = prodProblemWarnService.getBusinessKey(Lists.newArrayList(issureNo));
            String res = businessKey.isEmpty() ? null : businessKey.get(0).get("business_key");
            return ResponseUtils.successResponse(res, "");
        }
    
    
        /**
         * transProcessed
         * 
         * @param updateParam updateParam
         * @return ResponseVo
         */
        @Override
        @Transactional
        public ResponseVo transProcessed(ProdProblemWarnUpdateParam updateParam) {
            List<String> badWarnNo = null;
            String env = SpringBeanUtils.getActiveProfile();
            String jumpUrl = env.equals("test") ? TEST_TASK_URL : TASK_URL;
            if (updateParam.getWarnNobBatch().isEmpty()) {
                updateParam.setWarnNobBatch(Lists.newArrayList(updateParam.getWarnNo()));
            }
            List<MtProductionProblemWarn> list = prodProblemWarnService.list(
                new QueryWrapper<MtProductionProblemWarn>().in("WARN_NO", updateParam.getWarnNobBatch()));
            badWarnNo = list.stream()
                .filter(item -> !item.getWarnStatus().equals("未处理") && !item.getWarnStatus().equals("分析中"))
                .map(MtProductionProblemWarn::getWarnNo)
                .collect(Collectors.toList());
            if (!badWarnNo.isEmpty()) {
                return ResponseUtils.errorResponse(
                    String.format("转处理人失败，预警单号：【%s】，不是未处理/分析中状态!", String.join(",", badWarnNo)));
            }
            badWarnNo = list.stream().filter(item -> {
                List<String> analysis = Arrays.asList(StringUtils.isNotEmpty(item.getProcessedBy())
                    ? item.getProcessedBy().split(",")
                    : item.getAnalysisBy().split(","));
                analysis = analysis.stream().map(it -> it.toLowerCase(Locale.ROOT)).collect(Collectors.toList());
                return !analysis.contains(updateParam.getOperator().toLowerCase(Locale.ROOT));
            }).map(MtProductionProblemWarn::getWarnNo).collect(Collectors.toList());
            if (!badWarnNo.isEmpty()) {
                return ResponseUtils.errorResponse(String.format("转处理人失败，预警单号：【%s】，你不是分析人!", String.join(",", badWarnNo)));
            }
            for (MtProductionProblemWarn vo : list) {
                // 更新预警单
                updateParam.setWarnNo(vo.getWarnNo());
                prodProblemWarnService.updateIssueWhenTransHandler(updateParam);
                // 日志
                prodProblemWarnLogService.insertLogWhenTransHandler(updateParam.getWarnNo(), updateParam.getOperator(),
                    updateParam.getProcessedBy());
                // 分析人删除待办，转处理人生成待办
                insertProcessedUndoWhenTrans(env, jumpUrl, updateParam);
                xxxDto xxxDto = new xxxDto();
                xxxDto.setTitle("xxx生产问题预警");
                String desc = String.format("当前有一个预警单%s,【编码】%s,【分析人】%s转与%s处理，请%s尽快处理分析", updateParam.getWarnNo(),
                    vo.getFailItem(), updateParam.getOperator(), updateParam.getProcessedBy(),
                    updateParam.getProcessedBy());
                xxxDto.setContent(desc);
                xxxDto.setJumpUrl(jumpUrl + vo.getWarnNo());
                xxxDto.setToUser(
                    env.equals("test") ? getxxxAccount(TEST_xxx_ACCOUNT) : getxxxAccount(updateParam.getProcessedBy()));
                MsgUtils.sendxxxMessage(xxxDto);
                prodProblemWarnMsgService.insertAppNotify(xxxDto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
    
            return ResponseUtils.successResponse("转处理人成功");
        }
    
    
        /**
         * getCountTag
         * 
         * @return ResponseVo
         */
        @Override
        public ResponseVo getCountTag() {
            String xxxAccount = "";
            try {
                xxxAccount = userService.getUser().getxxxAccount();
            } catch (Exception e) {
                log.error(e.getMessage());
            }
            // 前端传过来的xxx账号格式xxx，需要去掉首字母
            xxxAccount = xxxAccount.substring(1);
            List<Map<String, String>> list = prodProblemWarnService.getCountTag(xxxAccount);
            Map<String, String> result = new HashMap<>();
            for (Map<String, String> item : list) {
                result.put(item.get("dataType"), item.get("count"));
            }
            return ResponseUtils.successResponse(result, "获取数据成功！");
    
        }
    
    
        /**
         * getIssureList
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getIssureList(ProdProblemWarnQueryParam queryParam) {
            MtProductionProblemWarn vo = prodProblemWarnService.findOneByWarnNo(queryParam.getWarnNo());
            if (vo == null) {
                return ResponseUtils.errorResponse(Boolean.FALSE, "预警单不存在");
            }
            Page<TxnyQualityIssureFeedF> pageInfo = new Page<>();
            pageInfo.setCurrent(queryParam.getPage() == null ? 1 : queryParam.getPage());
            pageInfo.setSize(queryParam.getPageSize() == null ? 10 : queryParam.getPageSize());
            List<String> mesNos = Arrays.asList(vo.getMesNo().split(","));
            Page<TxnyQualityIssureFeedF> result = issureFeedMapper.getIssureFeedPage(vo.getWarnNo(),
                vo.getWarnType().equals("不良数量预警") ? vo.getFailItem() : null, mesNos, pageInfo);
            return ResponseUtils.successResponse(result, "获取数据成功");
        }
    
    
        /**
         * downloadIssurePageExcel
         * 
         * @param response response
         * @param queryParam queryParam
         */
        @Override
        public void downloadIssurePageExcel(HttpServletResponse response, ProdProblemWarnQueryParam queryParam) {
            MtProductionProblemWarn vo = prodProblemWarnService.findOneByWarnNo(queryParam.getWarnNo());
            List<String> mesNos = Arrays.asList(vo.getMesNo().split(","));
            List<TxnyQualityIssureFeedF> list = issureFeedMapper.getIssureFeedPage(vo.getWarnNo(),
                vo.getWarnType().equals("不良数量预警") ? vo.getFailItem() : null, mesNos);
            matWarnService.handleIssureListExcel(response, list);
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/octet-stream");
            response.setHeader("Content-Disposition", "attachment;fileName=" + "问题明细");
        }
    
    
        /**
         * getIssurePage
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getIssurePage(ProdProblemWarnQueryParam queryParam) {
            Page<TxnyQualityIssureFeedF> pageInfo = new Page<>();
            pageInfo.setCurrent(queryParam.getPage() == null ? 1 : queryParam.getPage());
            pageInfo.setSize(queryParam.getPageSize() == null ? 10 : queryParam.getPageSize());
            DistributionWarnQueryParam param = new DistributionWarnQueryParam();
            BeanUtils.copyProperties(queryParam, param);
            pageInfo = issureFeedMapper.getDetailTable(param, pageInfo);
            return ResponseUtils.successResponse(pageInfo, "获取数据成功！");
    
        }
    
        /**
         * 预警数量趋势    横坐标展示 年月  纵坐标展示 预警单数    海洋图
         *
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getQtyTrends(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getQtyTrends(queryParam);
            Map<String, Object> resMap = new HashMap();
            resMap.put("month", list.stream().map(DistributionWarnDto::getKey).collect(Collectors.toList()));
            resMap.put("count", list.stream().map(DistributionWarnDto::getCount).collect(Collectors.toList()));
            return ResponseUtils.successResponse(resMap, "获取数据成功！");
        }
    
        /**
         * 预警状态分布    饼图 按预警状态 展示多个扇形 饼图 (从大到小顺序排列)
         *
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getQtyStatus(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getQtyStatus(queryParam);
            return ResponseUtils.successResponse(list, "获取数据成功！");
        }
    
        /**
         * 预警根因Top10 横坐标展示预警原因 纵坐标展示预警单数 柱状图（降序从左到右排列）
         *
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getTopTenReason(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getTopTenReason(queryParam);
            Map<String, Object> resMap = new HashMap();
            resMap.put("name", list.stream().map(DistributionWarnDto::getKey).collect(Collectors.toList()));
            resMap.put("data", list.stream().map(DistributionWarnDto::getCount).collect(Collectors.toList()));
            return ResponseUtils.successResponse(resMap, "获取数据成功！");
        }
    
    
        /**
         * getEffectiveRate
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getEffectiveRate(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getEffectiveRate(queryParam);
            return ResponseUtils.successResponse(list, "获取数据成功！");
        }
    
    
        /**
         * getRepQtyTrends
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getRepQtyTrends(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getQtyTrends(queryParam);
            Map<String, Object> resMap = new HashMap();
            resMap.put("key", list.stream().map(DistributionWarnDto::getKey).collect(Collectors.toList()));
            resMap.put("value", list.stream().map(DistributionWarnDto::getCount).collect(Collectors.toList()));
            return ResponseUtils.successResponse(resMap, "获取数据成功！");
        }
    
    
        /**
         * getRepQtyStatus
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getRepQtyStatus(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getQtyStatus(queryParam);
            List<Map<String, Object>> list1 = new LinkedList<>();
            for (DistributionWarnDto item : list) {
                Map<String, Object> map = new HashMap<>();
                map.put("dataType", StringUtils.isEmpty(item.getKey()) ? "" : item.getKey());
                map.put("qty", item.getCount());
                list1.add(map);
            }
            return ResponseUtils.successResponse(list1, "获取数据成功！");
        }
    
    
        /**
         * getRepEffectiveRate
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getRepEffectiveRate(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getEffectiveRate(queryParam);
            List<Map<String, Object>> list1 = new LinkedList<>();
            for (DistributionWarnDto item : list) {
                Map<String, Object> map = new HashMap<>();
                map.put("dataType", StringUtils.isEmpty(item.getKey()) ? "" : item.getKey());
                map.put("qty", item.getCount());
                list1.add(map);
            }
            return ResponseUtils.successResponse(list, "获取数据成功！");
        }
    
    
        /**
         * getRepProcess
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getRepProcess(ProdProblemWarnQueryParam queryParam) {
            List<DistributionWarnDto> list = prodProblemWarnService.getQtyStatus(queryParam);
            int total = list.stream().mapToInt(DistributionWarnDto::getCount).sum();
            int closed = list.stream().filter(f -> f.getKey().equals("已关闭")).mapToInt(DistributionWarnDto::getCount).sum();
            double crate = total == 0
                ? 0d
                : new BigDecimal(Double.valueOf(closed) / Double.valueOf(total)).setScale(4, RoundingMode.HALF_UP)
                    .doubleValue() * 100;
            List<DistributionWarnDto> elist = prodProblemWarnService.getEffectiveRate(queryParam);
            int etotal = elist.stream().mapToInt(DistributionWarnDto::getCount).sum();
            int effect = elist.stream()
                .filter(f -> f.getKey().equals("有效预警单数"))
                .mapToInt(DistributionWarnDto::getCount)
                .sum();
            double erate = etotal == 0
                ? 0d
                : new BigDecimal(Double.valueOf(effect) / Double.valueOf(etotal)).setScale(4, RoundingMode.HALF_UP)
                    .doubleValue() * 100;
            return ResponseUtils.successResponse(
                String.format("预警管理：%s月预警总数%s，预警闭环数量%s，闭环率%s\n预警效果：预警有效数量%s，有效率%s", queryParam.getMonth(), total, closed,
                    crate + "%", effect, erate + "%"));
        }
    
        /**
         * getRepTopProblem
         *
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo getRepTopProblem(ProdProblemWarnQueryParam queryParam) {
            List<String> warnNo = Arrays.asList(queryParam.getWarnNo().split(","));
            List<QbdReportTopProblem> existList = qbdReportTopProblemService.selectDataList(queryParam.getYear(),
                queryParam.getMonth());
            List<String> existWarnNo = existList.stream().map(QbdReportTopProblem::getWarnNo).collect(Collectors.toList());
            List<String> delWarnNo = existWarnNo.stream().filter(f -> !warnNo.contains(f)).collect(Collectors.toList());
            List<String> addWarnNo = warnNo.stream().filter(f -> !existWarnNo.contains(f)).collect(Collectors.toList());
            if (!delWarnNo.isEmpty()) {
                // 删除
                qbdReportTopProblemService.delByWarnNo(delWarnNo, queryParam.getYear(), queryParam.getMonth());
            }
            if (!addWarnNo.isEmpty()) {
                // 新增
                queryParam.setWarnNo(String.join(",", addWarnNo));
                List<QbdReportTopProblem> list = prodProblemWarnService.getRepTopProblem(queryParam);
                list.forEach(item -> {
                    item.setYear(queryParam.getYear());
                    item.setMonth(queryParam.getMonth());
                });
                qbdReportTopProblemService.batchInsert(list);
            }
            List<QbdReportTopProblem> result = qbdReportTopProblemService.selectDataList(queryParam.getYear(),
                queryParam.getMonth());
            return ResponseUtils.successResponse(result, "获取数据成功！");
        }
    
    
        /**
         * saveRepTopProblem
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo saveRepTopProblem(ProdProblemWarnQueryParam queryParam) {
            List<QbdReportTopProblem> list = new ArrayList<>();
            queryParam.getTopProblem().forEach(item -> {
                QbdReportTopProblem target = new QbdReportTopProblem();
                MyBeanUtils.shallowCopy(item, target);
                list.add(target);
            });
            qbdReportTopProblemService.batchUpdate(list, queryParam.getYear(), queryParam.getMonth());
            return ResponseUtils.successResponse("数据更新成功！");
        }
    
    
        /**
         * getWarnCardData
         * 
         * @return ResponseVo
         */
        @Override
        public ResponseVo getWarnCardData() {
            List<Map<String, String>> list = prodProblemWarnService.getWarnCardData();
            Map<String, String> result = new HashMap<>();
            for (Map<String, String> item : list) {
                result.put(item.get("dataType"), item.get("count"));
            }
            return ResponseUtils.successResponse(result, "获取数据成功！");
        }
    
        /**
         * 转处理人生成待办
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param updateParam updateParam
         */
        private void insertProcessedUndoWhenTrans(String env, String jumpUrl, ProdProblemWarnUpdateParam updateParam) {
            String[] processed = updateParam.getProcessedBy().split(",");
            // 查询分析人待办
            List<MtProductionProblemMessage> msgs = prodProblemWarnMsgService.selectAnalystUndo(updateParam.getWarnNo());
            extracted(msgs);
            for (int i = 0; i < processed.length; i++) {
                xxxTaskDto dto = new xxxTaskDto();
                dto.setAppUrl(jumpUrl + updateParam.getWarnNo());
                dto.setTaskDesc(String.format("【%s】【转处理】【分析中】xxx", updateParam.getWarnNo()));
                dto.setTaskURL(jumpUrl + updateParam.getWarnNo());
                dto.setHandler(env.equals("test") ? TEST_xxx_ACCOUNT : processed[i]);
                dto.setApplicant("xxx");
                prodProblemWarnMsgService.insertAnalystUndo(dto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
        }
    
    
        /**
         * saveAnalysis
         * 
         * @param updateParam updateParam
         * @return ResponseVo
         */
        @Override
        @Transactional
        public ResponseVo saveAnalysis(ProdProblemWarnUpdateParam updateParam) {
            String env = SpringBeanUtils.getActiveProfile();
            String jumpUrl = env.equals("test") ? TEST_TASK_URL : TASK_URL;
            MtProductionProblemWarn vo = prodProblemWarnService.findOneByWarnNo(updateParam.getWarnNo());
            // 分析人分析内容，点击提交，且是否分析完成选中了是，应用号推送指定提醒内容给分析人与评审人
            // 更新预警单
            prodProblemWarnService.updateIssueWhenSaveAnalysis(updateParam, vo);
            if (updateParam.getIsAnalyseFinish() != null && updateParam.getIsAnalyseFinish().equals("是")) {
                // 分析人删除待办，评审人生产待办
                insertUndoWhenAnalyseFinish(env, jumpUrl, updateParam, vo);
                // 应用号推送指定提醒内容给分析人与评审人
                // 预警单xxx202105140934024408分析完成，请评审人xxx尽快处理评审
                xxxDto xxxDto = new xxxDto();
                xxxDto.setTitle("xxx生产问题预警");
                String desc = String.format("预警单%s分析完成，请评审人%s尽快处理评审", updateParam.getWarnNo(), vo.getReviewBy());
                xxxDto.setContent(desc);
                xxxDto.setJumpUrl(jumpUrl + vo.getWarnNo());
                xxxDto.setToUser(env.equals("test")
                    ? getxxxAccount(TEST_xxx_ACCOUNT)
                    : (getxxxAccount(StringUtils.isNotEmpty(vo.getProcessedBy()) ? vo.getProcessedBy() : vo.getAnalysisBy())
                        + "," + getxxxAccount(vo.getReviewBy())) + ",xxx");
                MsgUtils.sendxxxMessage(xxxDto);
                prodProblemWarnMsgService.insertAppNotify(xxxDto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
            // 查找最新的日志
            prodProblemWarnLogService.updateAnalyseLog(updateParam);
            // 判断是否生成问题单
            if (updateParam.getIsCreate() != null && updateParam.getIsCreate().equals("是")) {
                // 获取问题单
                TxnyProductProblemManage productProblem = productProblemManageService.selectOneByWarnNo(
                    updateParam.getWarnNo());
                if (Objects.isNull(productProblem)) {
                    // insert
                    productProblem = getTxnyProductProblemManage(updateParam, vo);
                    productProblemManageService.insertOne(productProblem);
                } else {
                    // update
                    extracted(updateParam, vo, productProblem);
                    productProblemManageService.updateProblem(productProblem);
                }
            }
            return ResponseUtils.successResponse("预警单分析成功");
        }
    
        private void extracted(ProdProblemWarnUpdateParam updateParam, MtProductionProblemWarn vo,
            TxnyProductProblemManage productProblem) {
            productProblem.setHappenedTime(DateTimeFormatter.ofPattern("yyyy-MM-dd").format(LocalDate.now()));
            productProblem.setProduct(vo.getProduct());
            productProblem.setBarcode(updateParam.getWarnNo());
            productProblem.setCauseAnalysis(String.format("【%s %s】%s", productProblem.getHappenedTime(), "SYSTEM",
                updateParam.getOccurCause()));
            productProblem.setSolution(String.format("【临时措施】: %s\n【长期措施】: %s\n【改善效果】: ",
                (StringUtils.isEmpty(updateParam.getEncloseMeasure()) ? "" : updateParam.getEncloseMeasure()),
                (StringUtils.isEmpty(updateParam.getSolution())) ? "" : updateParam.getSolution()));
            productProblem.setClosedTime(
                DateTimeFormatter.ofPattern("yyyy-MM-dd").format(LocalDate.now().plusDays(7)));
            productProblem.setLastUpdateDate(new Date());
        }
    
        @NotNull
        private TxnyProductProblemManage getTxnyProductProblemManage(ProdProblemWarnUpdateParam updateParam,
            MtProductionProblemWarn vo) {
            TxnyProductProblemManage productProblem;
            productProblem = new TxnyProductProblemManage();
            productProblem.setHappenedTime(DateTimeFormatter.ofPattern("yyyy-MM-dd").format(LocalDate.now()));
            productProblem.setProduct(vo.getProduct());
            productProblem.setBarcode(updateParam.getWarnNo());
            productProblem.setCauseAnalysis(String.format("【%s %s】%s", productProblem.getHappenedTime(), "SYSTEM",
                updateParam.getOccurCause()));
            productProblem.setSolution(String.format("【临时措施】: %s\n【长期措施】: %s\n【改善效果】: ",
                (StringUtils.isEmpty(updateParam.getEncloseMeasure()) ? "" : updateParam.getEncloseMeasure()),
                (StringUtils.isEmpty(updateParam.getSolution())) ? "" : updateParam.getSolution()));
            productProblem.setStatus("open");
            productProblem.setClosedTime(
                DateTimeFormatter.ofPattern("yyyy-MM-dd").format(LocalDate.now().plusDays(7)));
            productProblem.setLastUpdateDate(new Date());
            return productProblem;
        }
    
        /**
         * canSync
         * 
         * @param queryParam queryParam
         * @return ResponseVo
         */
        @Override
        public ResponseVo canSync(ProdProblemWarnQueryParam queryParam) {
            TxnyProductProblemManage productProblem = productProblemManageService.selectOneByWarnNo(queryParam.getWarnNo());
            return ResponseUtils.successResponse(productProblem != null ? 1 : 0,
                productProblem != null ? "当前预警单已经同步生产问题单 是否还要覆盖同步？" : "");
        }
    
        /**
         * 分析人删除待办，评审人生产待办
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param updateParam updateParam
         * @param vo vo
         */
        private void insertUndoWhenAnalyseFinish(String env, String jumpUrl, ProdProblemWarnUpdateParam updateParam,
            MtProductionProblemWarn vo) {
            String[] review = vo.getReviewBy().split(",");
            // 查询分析人待办
            List<MtProductionProblemMessage> msgs = prodProblemWarnMsgService.selectAnalystUndo(updateParam.getWarnNo());
            extracted(msgs);
            for (int i = 0; i < review.length; i++) {
                xxxTaskDto dto = new xxxTaskDto();
                dto.setAppUrl(jumpUrl + updateParam.getWarnNo());
                dto.setTaskDesc(String.format("【%s】【分析人分析完成】xxx", updateParam.getWarnNo()));
                dto.setTaskURL(jumpUrl + updateParam.getWarnNo());
                dto.setHandler(env.equals("test") ? TEST_xxx_ACCOUNT : review[i]);
                dto.setApplicant("xxx");
                prodProblemWarnMsgService.insertReviewerUndo(dto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
        }
    
    
        /**
         * saveReview
         * 
         * @param updateParam updateParam
         * @return ResponseVo
         */
        @Override
        @Transactional
        public ResponseVo saveReview(ProdProblemWarnUpdateParam updateParam) {
            String env = SpringBeanUtils.getActiveProfile();
            String remark = "";
            String jumpUrl = env.equals("test") ? TEST_TASK_URL : TASK_URL;
            MtProductionProblemWarn vo = prodProblemWarnService.findOneByWarnNo(updateParam.getWarnNo());
            // 更新预警单
            prodProblemWarnService.updateIssueWhenSaveReview(updateParam);
            // 评审人评审内容，点击提交，且是否闭环选中了同意，应用号推送指定提醒内容给该品类团队成员
            if (StringUtils.isNotEmpty(updateParam.getIsClosed()) && updateParam.getIsClosed().equals("同意")) {
                remark = "流程结束";
                // 评审人删除待办
                List<MtProductionProblemMessage> msgs = prodProblemWarnMsgService.selectReviewerUndo(
                    updateParam.getWarnNo());
                extracted(msgs);
                // 预警单xxx202105140934024408评审通过，【评审意见】XXX,请分析人xxx 查看
                xxxDto xxxDto = new xxxDto();
                xxxDto.setTitle("xxx生产问题预警");
                String desc = String.format("预警单%s评审通过，【评审意见】%s,请分析人%s查看", updateParam.getWarnNo(),
                    updateParam.getReviewComment(), getString(vo));
                xxxDto.setJumpUrl(jumpUrl + vo.getWarnNo());
                xxxDto.setContent(desc);
                List<String> members1 = prodProblemWarnService.getMemberList(vo.getCategory());
                members1.replaceAll(this::getxxxAccount);
                String all = String.join(",", members1);
                xxxDto.setToUser(env.equals("test") ? getxxxAccount(TEST_xxx_ACCOUNT) : all);
                MsgUtils.sendxxxMessage(xxxDto);
                prodProblemWarnMsgService.insertAppNotify(xxxDto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
            // 评审人CD评审内容，点击提交，且是否闭环选中了驳回，应用号推送指定提醒内容给分析人
            if (StringUtils.isNotEmpty(updateParam.getIsClosed()) && updateParam.getIsClosed().equals("驳回")) {
                remark = updateParam.getReviewComment();
                // 评审人删除待办，分析人生成待办
                insertUndoWhenReviewClosed(env, jumpUrl, updateParam, vo);
                // 预警单xxx202105140934024408评审不通过，【评审意见】XXX,请分析人xxx 尽快处理分析
                xxxDto xxxDto = new xxxDto();
                xxxDto.setTitle("xxx生产问题预警");
                String desc = String.format("预警单%s评审不通过，【评审意见】%s,请分析人%s尽快处理分析", updateParam.getWarnNo(),
                    updateParam.getReviewComment(), getString(vo));
                xxxDto.setContent(desc);
                xxxDto.setJumpUrl(jumpUrl + vo.getWarnNo());
                xxxDto.setToUser(env.equals("test")
                    ? getxxxAccount(TEST_xxx_ACCOUNT)
                    : getxxxAccount(StringUtils.isNotEmpty(vo.getProcessedBy()) ? vo.getProcessedBy() : vo.getAnalysisBy())
                        + ",xxx,xxx");
                MsgUtils.sendxxxMessage(xxxDto);
                prodProblemWarnMsgService.insertAppNotify(xxxDto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
            // 查找最新的日志
            prodProblemWarnLogService.updateReviewLog(updateParam, remark);
            return ResponseUtils.successResponse("预警单评审成功");
        }
    
        private String getString(MtProductionProblemWarn vo) {
            return StringUtils.isNotEmpty(vo.getProcessedBy()) ? vo.getProcessedBy() : vo.getAnalysisBy();
        }
    
        private void extracted(List<MtProductionProblemMessage> msgs) {
            for (MtProductionProblemMessage msg : msgs) {
                MsgUtils.deletexxxTask(msg.getTaskId());
            }
        }
    
        /**
         * 评审人删除待办，分析人生成待办
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param updateParam updateParam
         * @param vo vo
         */
        private void insertUndoWhenReviewClosed(String env, String jumpUrl, ProdProblemWarnUpdateParam updateParam,
            MtProductionProblemWarn vo) {
            String handler = getString(vo);
            String[] analysis = handler.split(",");
            // 查询评审人待办
            List<MtProductionProblemMessage> msgs = prodProblemWarnMsgService.selectReviewerUndo(updateParam.getWarnNo());
            extracted(msgs);
            for (String analy : analysis) {
                xxxTaskDto dto = new xxxTaskDto();
                dto.setAppUrl(jumpUrl + updateParam.getWarnNo());
                dto.setTaskDesc(String.format("【%s】【评审不通过】xxx", updateParam.getWarnNo()));
                dto.setTaskURL(jumpUrl + updateParam.getWarnNo());
                dto.setHandler(env.equals("test") ? TEST_xxx_ACCOUNT : analy);
                dto.setApplicant("xxx");
                prodProblemWarnMsgService.insertAnalystUndo(dto, updateParam.getWarnNo(), MESSAGE_DO_SEND);
            }
        }
    
    
        /**
         * periodlySyncWarnData
         * 
         */
        @Override
        public void periodlySyncWarnData() {
            String[] period = getPeriodArray();
            List<MtProductionProblemWarn> listToSync = prodProblemWarnService.getToSyncDataList(period[0], period[1]);
            // 需要处理两个周期的数据
            List<MtProductionProblemWarn> listNext = prodProblemWarnService.getToSyncDataList(period[2], period[3]);
            listToSync.addAll(listNext);
            doSyncWarnData(listToSync);
            // 数据commit后处理
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    // 新增超过7天状态还未关闭的应用号信息
                    create7DayMsg();
                    // 查询发送应用号和xxx待办
                    sendMsg();
                }
            });
        }
    
    
        /**
         * resetMatWarnLock
         * 
         */
        @Override
        public void resetMatWarnLock() {
            prodProblemWarnService.resetMatWarnLock();
        }
    
    
        /**
         * getLockCount
         * 
         * @return int
         */
        @Override
        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        public int getLockCount() {
            return prodProblemWarnService.updateMatWarnLock();
        }
    
    
        /**
         * sendMsOnTen
         * 
         */
        @Override
        public void sendMsOnTen() {
            List<MtProductionProblemMessage> list = prodProblemWarnMsgService.getSendOnTen();
            for (MtProductionProblemMessage msg : list) {
                // 应用号
                if (msg.getType().equals("10")) {
                    xxxDto xxxDto = JsonUtils.jsonToObj(msg.getContent(), xxxDto.class);
                    MsgUtils.sendxxxMessage(xxxDto);
                    msg.setIsSend("1");
                    msg.setLastUpdateDate(new Date());
                    prodProblemWarnMsgService.updateOneMsg(msg);
                }
            }
        }
    
        /**
         * 超过7天状态还未关闭，第七天开始往后每天进行一次应用号推送指定提醒内容给分析人AB 评审人CD，直到关闭，则无需再推送
         */
        public void create7DayMsg() {
            String env = SpringBeanUtils.getActiveProfile();
            List<MtProductionProblemWarn> list = prodProblemWarnService.getOpenMoreThanSevenDaysIssues("不良测试预警");
            // 当前有一个预警单xxx202105140934024408超过7天还未关闭，【编码】21750013，【预警状态】XX
            // 请分析人XXX 尽快处理分析（状态在评审中则为：请评审人XXX尽快处理评审）。
            for (MtProductionProblemWarn item : list) {
                String jumpUrl = (env.equals("test") ? TEST_TASK_URL : TASK_URL) + item.getWarnNo();
                insertAppNotifyWhenOpenIssueMoreSeven(env, item, jumpUrl);
            }
        }
    
        /**
         * 超过7天状态还未关闭，第七天开始往后每天进行一次应用号推送指定提醒内容给分析人AB 评审人CD，直到关闭，则无需再推送
         *
         * @param env env
         * @param item item
         * @param jumpUrl jumpUrl
         */
        private void insertAppNotifyWhenOpenIssueMoreSeven(String env, MtProductionProblemWarn item, String jumpUrl) {
            xxxDto xxxDto = new xxxDto();
            xxxDto.setJumpUrl(jumpUrl);
            xxxDto.setTitle("xxx生产问题预警");
            // 分析中请分析人处理，评审中请评审人处理
            String desc = String.format("当前有一个预警单%s超过7天还未关闭，【编码】%s，【预警状态】%s，\n" + "请%s人%s尽快处理%s。", item.getWarnNo(),
                item.getFailItem(), item.getWarnStatus(), item.getWarnStatus().equals("评审中") ? "评审" : "分析",
                item.getWarnStatus().equals("评审中")
                    ? item.getReviewBy()
                    : (org.apache.commons.lang3.StringUtils.isNotEmpty(item.getProcessedBy())
                        ? item.getProcessedBy()
                        : item.getAnalysisBy()), item.getWarnStatus().equals("评审中") ? "评审" : "分析");
            xxxDto.setContent(desc);
            xxxDto.setToUser(env.equals("test")
                ? getxxxAccount(TEST_xxx_ACCOUNT)
                : (item.getWarnStatus().equals("评审中")
                    ? getxxxAccount(item.getReviewBy())
                    : getxxxAccount((org.apache.commons.lang3.StringUtils.isNotEmpty(item.getProcessedBy())
                        ? item.getProcessedBy()
                        : item.getAnalysisBy()))) + ",xxx");
            prodProblemWarnMsgService.insertAppNotify(xxxDto, item.getWarnNo(), MESSAGE_NO_SEND);
        }
    
        /**
         * 发送信息
         */
        private void sendMsg() {
            List<MtProductionProblemMessage> list = prodProblemWarnMsgService.getTodayNotSend();
            for (MtProductionProblemMessage message : list) {
                // 应用号消息
                if (message.getType().equals("0")) {
                    xxxDto xxx = JsonUtils.jsonToObj(message.getContent(), xxxDto.class);
                    MsgUtils.sendxxxMessage(xxx);
                    message.setIsSend("1");
                    message.setLastUpdateDate(new Date());
                    prodProblemWarnMsgService.updateOneMsg(message);
                }
                // 待办消息
                if (message.getType().equals("1") || message.getType().equals("2")) {
                    xxxTaskDto taskDto = JsonUtils.jsonToObj(message.getContent(), xxxTaskDto.class);
                    String taskId = MsgUtils.postxxxTask(taskDto);
                    message.setIsSend("1");
                    message.setTaskId(taskId);
                    message.setLastUpdateDate(new Date());
                    prodProblemWarnMsgService.updateOneMsg(message);
                }
            }
        }
    
    
        /**
         * 获取年月集合
         * 
         * @return 返回String[]
         */
        private String[] getPeriodArray() {
            LocalDate date = LocalDate.now().with(DayOfWeek.MONDAY);
            LocalDate curEndDate = date.plusDays(6);
            LocalDate preStartDate = date.minusDays(7);
            LocalDate preEndDate = date.minusDays(1);
    
            return new String[] {
                    preStartDate.toString(), preEndDate.toString(), date.toString(),
                    curEndDate.toString()
            };
        }
    
    
        /**
         * doSyncWarnData
         * 
         * @param listToSync listToSync
         */
        private void doSyncWarnData(List<MtProductionProblemWarn> listToSync) {
            String env = SpringBeanUtils.getActiveProfile();
            String jumpUrl = env.equals("test") ? TEST_TASK_URL : TASK_URL;
            int maxWarnNo = prodProblemWarnService.getMaxWarnNo(WARN_TYPE);
            int index = 0;
            for (MtProductionProblemWarn toSyncData : listToSync) {
                String startPeriod = parseDateString(toSyncData.getStartPeriod());
                String endPeriod = parseDateString(toSyncData.getEndPeriod());
                // 预警周期内，相同编码，
                MtProductionProblemWarn existedOne = prodProblemWarnService.findOneDataByFailItemAndPeriod(
                    toSyncData.getFailItem(), startPeriod, endPeriod, toSyncData.getWarnType());
                if (existedOne == null) {
                    // 同周期内，同编码2起以上才预警
                    if (toSyncData.getMesCount() < 2) {
                        continue;
                    }
                    // 新增预警单
                    prodProblemWarnService.insertNewIssueWhenSync("ppWarn", listToSync, toSyncData, (maxWarnNo + index++));
                    prodProblemWarnLogService.insertStartLog(toSyncData.getWarnNo());
                    insertAppNotifyWhenAddNewIssue(env, jumpUrl, toSyncData);
                    insertAnalystUndoWhenAddNewIssue(env, jumpUrl, toSyncData);
                    continue;
                }
    
                // 更新已有预警单
                // 预警周期内，已生成预警单（非已关闭），若新增同类预警的MES+问题单，则在原有预警单进行累加，应用号推送指定提醒内容给该品类团队成员
                // 注意：当前状态若为评审中，则需要修改为分析中
                if (existedOne.getWarnStatus() == null) {
                    prodProblemWarnService.updateExistedWarnIssueByStatus(existedOne, toSyncData);
                    continue;
                }
                if (!existedOne.getWarnStatus().equals("已关闭")) {
                    prodProblemWarnService.updateExistedWarnIssueByStatus(existedOne, toSyncData);
                    insertAppNotifyToRemindHandler(env, jumpUrl, toSyncData, existedOne);
                    prodProblemWarnLogService.insertAddMesPlusIssueLog(existedOne.getWarnNo(), toSyncData.getMesNo());
                    continue;
                }
                // 预警周期内，已生成预警单（已关闭），若新增符同类预警的MES+问题单，则在原有预警单进行累加，应用号推送指定提醒内容给分析人AB和评审人CD
                if (existedOne.getWarnStatus().equals("已关闭")) {
                    prodProblemWarnService.updateExistedWarnIssueByStatus(existedOne, toSyncData);
                    insertAppNotifyWhenRestartIssue(env, jumpUrl, toSyncData, existedOne);
                    insertUndoWhenProblemRestart(env, jumpUrl, existedOne);
                    prodProblemWarnLogService.insertReStartWarnIssueLog(existedOne.getWarnNo(), toSyncData.getMesNo());
                }
            }
        }
    
        /**
         * 推送应用号,应用号推送指定提醒内容给该品类团队成员
         *
         * @param env 环境变量
         * @param jumpUrl 跳转url
         * @param tosyncData 同步数据
         */
        private void insertAppNotifyWhenAddNewIssue(String env, String jumpUrl, MtProductionProblemWarn tosyncData) {
            xxxDto xxxDto = new xxxDto();
            xxxDto.setTitle("xxx生产问题预警");
            String desc = String.format("当前有一个预警单%s,【MES+问题单号】%s,【预警编码】%s, 【不良数】%s,该编码触发预警累计%s次,请分析人%s尽快处理分析。",
                tosyncData.getWarnNo(), tosyncData.getMesNo(), tosyncData.getFailItem(), tosyncData.getBadQty(),
                tosyncData.getCodeAccQty(), tosyncData.getAnalysisBy());
            xxxDto.setContent(desc);
            xxxDto.setJumpUrl(jumpUrl + tosyncData.getWarnNo());
            String[] accounts = tosyncData.getMember().split(",");
            for (int i = 0; i < accounts.length; i++) {
                accounts[i] = getxxxAccount(accounts[i]);
            }
            xxxDto.setToUser(env.equals("test") ? getxxxAccount(TEST_xxx_ACCOUNT) : String.join(",", accounts));
            prodProblemWarnMsgService.insertAppNotify(xxxDto, tosyncData.getWarnNo(), MESSAGE_NO_SEND);
        }
    
        /**
         * 分析人生成待办
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param tosyncData tosyncData
         */
        private void insertAnalystUndoWhenAddNewIssue(String env, String jumpUrl, MtProductionProblemWarn tosyncData) {
            String[] analysis = tosyncData.getAnalysisBy().split(",");
            for (int i = 0; i < analysis.length; i++) {
                xxxTaskDto dto = new xxxTaskDto();
                dto.setAppUrl(jumpUrl + tosyncData.getWarnNo());
                dto.setTaskDesc("【" + tosyncData.getWarnNo() + "】【未处理】xxx");
                dto.setTaskURL(jumpUrl + tosyncData.getWarnNo());
                dto.setHandler(env.equals("test") ? TEST_xxx_ACCOUNT : analysis[i]);
                dto.setApplicant("xxx");
                prodProblemWarnMsgService.insertAnalystUndo(dto, tosyncData.getWarnNo(), MESSAGE_NO_SEND);
            }
        }
    
        /**
         * 问题重启评审人生成代办（新增同类问题）
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param vo vo
         */
        private void insertUndoWhenProblemRestart(String env, String jumpUrl, MtProductionProblemWarn vo) {
            String[] review = vo.getReviewBy().split(",");
            for (int i = 0; i < review.length; i++) {
                xxxTaskDto dto = new xxxTaskDto();
                dto.setAppUrl(jumpUrl + vo.getWarnNo());
                dto.setTaskDesc("【" + vo.getWarnNo() + "】【新增同类问题】xxx");
                dto.setTaskURL(jumpUrl + vo.getWarnNo());
                dto.setHandler(env.equals("test") ? TEST_xxx_ACCOUNT : review[i]);
                dto.setApplicant("xxx");
                prodProblemWarnMsgService.insertReviewerUndo(dto, vo.getWarnNo(), MESSAGE_NO_SEND);
            }
        }
    
        /**
         * 应用号推送内容提醒分析人尽快处理分析
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param tosyncData tosyncData
         * @param vo vo
         */
        private void insertAppNotifyToRemindHandler(String env, String jumpUrl, MtProductionProblemWarn tosyncData,
            MtProductionProblemWarn vo) {
            xxxDto xxxDto = new xxxDto();
            xxxDto.setTitle("xxx生产问题预警");
            String desc = String.format("当前有一个预警单%s,【编码】%s 新增同类问题：【问题数新增】%s，【MES+问题单号新增】%s，【不良数新增】%s,请分析人尽快处理分析，评审人重点关注",
                vo.getWarnNo(), vo.getFailItem(), tosyncData.getMesCount(), tosyncData.getMesNo(), tosyncData.getBadQty());
            xxxDto.setContent(desc);
            xxxDto.setJumpUrl(jumpUrl + vo.getWarnNo());
            String[] accounts = tosyncData.getMember().split(",");
            for (int i = 0; i < accounts.length; i++) {
                accounts[i] = getxxxAccount(accounts[i]);
            }
            xxxDto.setToUser(env.equals("test") ? getxxxAccount(TEST_xxx_ACCOUNT) : String.join(",", accounts));
            prodProblemWarnMsgService.insertSentOnTen(xxxDto, vo.getWarnNo(), MESSAGE_NO_SEND);
        }
    
        /**
         * 重开问题后 应用号推送内容
         *
         * @param env env
         * @param jumpUrl jumpUrl
         * @param tosyncData tosyncData
         * @param vo vo
         */
        private void insertAppNotifyWhenRestartIssue(String env, String jumpUrl, MtProductionProblemWarn tosyncData,
            MtProductionProblemWarn vo) {
            xxxDto xxxDto = new xxxDto();
            xxxDto.setTitle("xxx生产问题预警");
            String desc = String.format(
                "当前有一个已关闭的预警单%s，【编码】%s\n" + "新增同类问题：【问题数新增】%s，【MES+问题单号新增】%s，【不良数新增】%s,请分析人尽快处理分析，评审人重点关注", vo.getWarnNo(),
                vo.getFailItem(), tosyncData.getMesCount(), tosyncData.getMesNo(), tosyncData.getBadQty());
            xxxDto.setContent(desc);
            xxxDto.setJumpUrl(jumpUrl + vo.getWarnNo());
            xxxDto.setToUser(env.equals("test")
                ? getxxxAccount(TEST_xxx_ACCOUNT)
                : (getxxxAccount(org.apache.commons.lang3.StringUtils.isNotEmpty(vo.getProcessedBy())
                    ? vo.getProcessedBy()
                    : vo.getAnalysisBy()) + "," + getxxxAccount(vo.getReviewBy())) + ",xxx");
            prodProblemWarnMsgService.insertSentOnTen(xxxDto, vo.getWarnNo(), MESSAGE_NO_SEND);
        }
    
        /**
         * Date类型转字符串
         *
         * @param date date
         * @return String
         */
        private String parseDateString(Date date) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            return sdf.format(date);
        }
    
    }

[24_Springboot_mybatisPlus_16 _ CRUD_studyday1_-CSDN]: https://blog.csdn.net/studyday1/article/details/131173493
[30_--_idea_studyday1_-CSDN]: https://blog.csdn.net/studyday1/article/details/131284311