检验下单审核进行企业微信推送

zss

2024-11-19 e8d0a2f9375da4d04da4a06a0f9fa8ef448512c4

 inspect-server/src/main/java/com/yuanchu/mom/service/impl/InsOrderPlanServiceImpl.java

@@ -1,53 +1,59 @@
package com.yuanchu.mom.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.deepoove.poi.config.ConfigureBuilder;
import com.yuanchu.mom.common.GetLook;
import com.yuanchu.mom.common.PrintChina;
import com.yuanchu.mom.dto.InsOrderPlanDTO;
import com.yuanchu.mom.dto.InsProductResultDto;
import com.yuanchu.mom.dto.SampleProductDto;
import com.yuanchu.mom.dto.SubmitPlanDto;
import com.yuanchu.mom.exception.ErrorException;
import com.yuanchu.mom.mapper.*;
import com.yuanchu.mom.pojo.*;
import com.yuanchu.mom.exception.ErrorException;
import com.yuanchu.mom.service.InsOrderPlanService;
import com.yuanchu.mom.service.InsOrderService;
import com.yuanchu.mom.service.StandardTemplateService;
import com.yuanchu.mom.utils.GiveCode;
import com.yuanchu.mom.utils.QueryWrappers;
import com.yuanchu.mom.vo.InsOrderPlanVO;
import lombok.AllArgsConstructor;
import com.yuanchu.mom.service.*;
import com.yuanchu.mom.utils.*;
import com.yuanchu.mom.vo.*;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ResourceUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.nio.file.Files;
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.stream.Collectors;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 检验任务-业务实现层
 */
@Service
//@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class InsOrderPlanServiceImpl extends ServiceImpl<InsOrderMapper, InsOrder> implements InsOrderPlanService {

    @Resource
@@ -66,12 +72,26 @@
    private InsOrderStateMapper insOrderStateMapper;
    @Resource
    private InsProductMapper insProductMapper;
    @Resource
    private InsOrderUserMapper insOrderUserMapper;
    @Resource
    private ShiftTimeMapper shiftTimeMapper;
    @Resource
    private PerformanceShiftMapper performanceShiftMapper;
    @Resource
    private WarehouseHistoryMapper warehouseHistoryMapper;

    @Resource
    private WarehouseService warehouseService;

    @Value("${wordUrl}")
    private String wordUrl;

    @Value("${twoCode}")
    private String twoCode;

    @Resource
    private GiveCode giveCode;
    WordUtils wordUtils;

    @Resource
    private InsReportMapper insReportMapper;
@@ -79,20 +99,75 @@
    @Resource
    private InsProductResultMapper insProductResultMapper;

    @Resource
    private InsProductResult2Mapper insProductResult2Mapper;

    @Resource
    private InsProductUserMapper insProductUserMapper;

    @Resource
    private InsUnPassService insUnPassService;

    @Resource
    AuxiliaryOutputWorkingHoursMapper auxiliaryOutputWorkingHoursMapper;

    @Resource
    QYWXApi qywxApi;

    @Resource
    private InformationNotificationService informationNotificationService;

    @Resource
    private UserMapper userMapper;

    @Resource
    private CustomMapper customMapper;

    @Value("${file.path}")
    private String imgUrl;

    @Resource
    private InsOrderFileMapper insOrderFileMapper;

    @Resource
    FuSheUtils fuSheUtils;

    @Override
    public Map<String, Object> selectInsOrderPlanList(Page page, InsOrderPlanDTO insOrderPlanDTO) {
        Map<String, Object> map = new HashMap<>();
        map.put("head", PrintChina.printChina(InsOrderPlanVO.class));
        Map<String, Integer> map1 = getLook.selectPowerByMethodAndUserId(null);
        Integer userId = map1.get("userId");
        String laboratory = null;
        String userName = null;
        if (ObjectUtil.isNotEmpty(insOrderPlanDTO.getUserId())) {
            insOrderPlanDTO.setUserId(userId.longValue());
            userName = userMapper.selectById(map1.get("userId")).getName();
            insOrderPlanDTO.setUserId(null);
        }
        IPage<InsOrderPlanVO> insOrderPage = insSampleMapper.findInsSampleAndOrder(page, QueryWrappers.queryWrappers(insOrderPlanDTO), userId);
        String sonLaboratory = insOrderPlanDTO.getSonLaboratory();//试验室
        insOrderPlanDTO.setSonLaboratory(null);
        IPage<InsOrderPlanVO> insOrderPage = insSampleMapper.findInsSampleAndOrder(page, QueryWrappers.queryWrappers(insOrderPlanDTO), userName, sonLaboratory, laboratory);
        map.put("body", insOrderPage);
        return map;
    }

    @Override
    public Map<String, Object> inspectionOrderDetailsTaskSwitching(Page page, InsOrderPlanDTO insOrderPlanDTO) {
        Map<String, Object> map = new HashMap<>();
        map.put("head", PrintChina.printChina(InsOrderPlanTaskSwitchVo.class));
        Map<String, Integer> map1 = getLook.selectPowerByMethodAndUserId(null);
        Integer userId = map1.get("userId");
        User user = userMapper.selectById(map1.get("userId"));//当前登录的人
        String laboratory = null;
        if (ObjectUtil.isNotEmpty(insOrderPlanDTO.getUserId())) {
            insOrderPlanDTO.setUserId(userId.longValue());
        }
        String sonLaboratory = insOrderPlanDTO.getSonLaboratory();//试验室
        IPage<InsOrderPlanTaskSwitchVo> insOrderPage = insSampleMapper.inspectionOrderDetailsTaskSwitching(page, QueryWrappers.queryWrappers(insOrderPlanDTO), userId, sonLaboratory, laboratory);
        map.put("body", insOrderPage);
        return map;
    }

    //认领任务
    @Override
    public boolean claimInsOrderPlan(InsOrderPlanDTO entity) {
        if (Objects.isNull(entity)) {
@@ -100,7 +175,7 @@
        }
        Map<String, Integer> map1 = getLook.selectPowerByMethodAndUserId(null);
        Integer userId = map1.get("userId");
        InsSampleUser insSampleUser = new InsSampleUser(entity.getInsSampleId().intValue(), userId, 1);
        InsSampleUser insSampleUser = new InsSampleUser(entity.getInsSampleId().intValue(), userId, 0, entity.getSonLaboratory());
        return insSampleUserMapper.insert(insSampleUser) > 0;
    }

@@ -108,116 +183,455 @@
    public Map<String, Object> doInsOrder(Integer id, String laboratory) {
        InsOrder insOrder = new InsOrder();
        insOrder.setId(id);
        insOrder.setInsState(1);
        InsOrder order = insOrderMapper.selectById(id);
        if (BeanUtil.isEmpty(order.getInsTime())) {
            insOrder.setInsTime(LocalDateTime.now());
            insOrderMapper.updateById(insOrder);
            insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                    .eq(InsOrderState::getInsOrderId, id)
                    .eq(InsOrderState::getLaboratory, laboratory)
                    .set(InsOrderState::getInsTime, LocalDateTime.now())
                    .set(InsOrderState::getInsState, 1));
        }
        insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate().eq(InsOrderState::getInsOrderId, id).eq(InsOrderState::getLaboratory, laboratory).set(InsOrderState::getInsTime, LocalDateTime.now()).set(InsOrderState::getInsState, 1));
        Map<String, Object> map = insOrderService.getInsOrderAndSample(id, laboratory);
        Set<Integer> set = new HashSet<>();
        Map<Integer, String> map2 = new HashMap<>();
        List<SampleProductDto> list = JSON.parseArray(JSON.toJSONString(map.get("sampleProduct")), SampleProductDto.class);
        for (SampleProductDto samples : list) {
            if (BeanUtil.isEmpty(samples.getInsProduct())) continue;
            for (InsProduct product : samples.getInsProduct()) {
                if (product.getTemplateId() == null) {
                    product.setTemplate(new ArrayList<>());
                    continue;
                }
                if (set.add(product.getTemplateId())) {
                    map2.put(product.getTemplateId(), standardTemplateService.getStandTempThingById(product.getTemplateId()) + "");
                }
                String thing = map2.get(product.getTemplateId());
                if (StrUtil.isNotEmpty(thing)) {
                    JSONObject sheet = JSON.parseObject(JSON.toJSONString(JSON.parseArray(JSON.toJSONString(JSON.parseObject(thing).get("data"))).get(0)));
                    JSONObject config = JSON.parseObject(JSON.toJSONString(sheet.get("config")));
                    List<JSONObject> cellData = JSON.parseArray(JSON.toJSONString(sheet.get("celldata")), JSONObject.class);
                    List<JSONObject> tableData = new ArrayList<>();
                    Map<String, Object> style = new HashMap<>();
//                    style.put("borderInfo", config.get("borderInfo"));
                    style.put("rowlen", config.get("rowlen"));
                    style.put("columnlen", config.get("columnlen"));
                    int r = -1;
                    if (BeanUtil.isNotEmpty(cellData)) {
                        for (JSONObject o : cellData) {
                            JSONObject v = JSON.parseObject(JSON.toJSONString(o.get("v")));
                            if (BeanUtil.isNotEmpty(v.get("ps"))) {
                                JSONObject ps = JSON.parseObject(JSON.toJSONString(v.get("ps")));
                                if (ps.get("value").equals("检验项") && v.get("v").equals(product.getInspectionItem())) {
                                    tableData.add(o);
                                    r = Integer.parseInt(o.get("r") + "");
                                    continue;
                                }
                            }
                            if (tableData.size() > 0) {
                                if ((Integer.parseInt(o.get("r") + "") == r + 1 || Integer.parseInt(o.get("r") + "") == r) && !(o.get("v") + "").equals("{\"ht\":\"0\"}")) {
                                    r = Integer.parseInt(o.get("r") + "");
                                    tableData.add(o);
                                } else {
                                    break;
                                }
                            }
                        }
                    }
                    product.setTemplate(tableData);
                    product.setStyle(style);
                }
            }
        }
        map.put("sampleProduct", list);
        return map;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveInsContext(Map<String, Object> insContext) {
    public List<InsProduct> getInsProduct(Integer id, Integer type, String laboratory, HttpServletRequest request) {
        List<InsProduct> insProducts = new ArrayList<>();
        switch (type) {
            case 0:
                //样品
                insProducts = insSampleMapper.getInsProduct1(id, laboratory);
                if (insProducts.size() == 0) {
                    insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                            .eq(InsProduct::getInsSampleId, id)
                            .eq(InsProduct::getState, 1)
                            .eq(InsProduct::getSonLaboratory, laboratory));
                    for (InsProduct insProduct : insProducts) {
                        List<InsProductResult2> insProductResult2List = insProductResult2Mapper.selectList(Wrappers.<InsProductResult2>lambdaQuery()
                                .eq(InsProductResult2::getInsProductId, insProduct.getId()).isNull(InsProductResult2::getNum));
                        insProduct.setInsProductResult2(insProductResult2List);
                        InsProductResult insProductResult = insProductResultMapper.selectOne(Wrappers.<InsProductResult>lambdaQuery()
                                .eq(InsProductResult::getInsProductId, insProduct.getId()).isNull(InsProductResult::getNum));
                        insProduct.setInsProductResult(insProductResult);
                    }
                }
                /*if (insProducts.size() == 0) {
                    insProducts = insSampleMapper.getIns2Product1(id, laboratory);
                }*/
                break;
            case 1:
                //光纤带
                break;
            case 2:
                //光纤
                break;
            case 3:
                //套管
                break;
        }
        Set<Integer> set = new HashSet<>();
        Map<Integer, String> map2 = new HashMap<>();
        if (BeanUtil.isEmpty(insProducts)) return null;
        getTemplateThing(set, map2, insProducts);
        return insProducts;
    }

    @Override
    public List<InsProduct> getInsProduct2(Integer id, Integer type, String laboratory, HttpServletRequest request, Integer num) {
        List<InsProduct> insProducts = new ArrayList<>();
        switch (type) {
            case 0:
                //样品
                insProducts = insSampleMapper.get2InsProduct1(id, laboratory, num);
                if (insProducts.size() == 0) {
                    throw new ErrorException("当前检验数据还没有保存,保存之后有数据历史");
                }
                break;
            case 1:
                //光纤带
                break;
            case 2:
                //光纤
                break;
            case 3:
                //套管
                break;
        }
        Set<Integer> set = new HashSet<>();
        Map<Integer, String> map2 = new HashMap<>();
        if (BeanUtil.isEmpty(insProducts)) return null;
        getTemplateThing(set, map2, insProducts);
        return insProducts;
    }

    @Override
    public List<String> checkSubmitPlan(Integer orderId, String laboratory) {
        List<String> collect = new ArrayList<>();
        List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getInsOrderId, orderId).select(InsSample::getId));
        List<Integer> ids = insSamples.stream().map(a -> a.getId()).collect(Collectors.toList());
        List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                .in(InsProduct::getInsSampleId, ids)
                .eq(InsProduct::getSonLaboratory, laboratory)
                .eq(InsProduct::getState, 1)
                .eq(InsProduct::getInsResult, 0));
        if (insProducts.size() > 0) {
            collect = insProducts.stream().map(insProduct -> {
                return insProduct.getInspectionItem() + "-" + insProduct.getInspectionItemSubclass();
            }).collect(Collectors.toList());
        }
        return collect;
    }

    @Override
    public Map<String, Object> getFileList(Page page, InsOrderFile insOrderFile) {
        Map<String, Object> map = new HashMap<>();
        map.put("head", PrintChina.printChina(InsOrderFile.class));
        Integer insOrderId = insOrderFile.getInsOrderId();
        insOrderFile.setInsOrderId(null);
        String sonLaboratory = null;
        if (ObjectUtils.isNotEmpty(insOrderFile.getSonLaboratory())) {
            sonLaboratory = insOrderFile.getSonLaboratory();
            insOrderFile.setSonLaboratory(null);
        }
        IPage<InsOrderFile> insOrderFileIPage = insOrderFileMapper.getFileList(page, QueryWrappers.queryWrappers(insOrderFile), insOrderId, sonLaboratory);
        map.put("body", insOrderFileIPage);
        return map;
    }

    @Override
    public int uploadFile(Integer orderId, MultipartFile file, String sonLaboratory) {
        String urlString;
        String pathName;
        String path;
        String filename = file.getOriginalFilename();
        String contentType = file.getContentType();
        InsOrderFile insOrderFile = new InsOrderFile();
        insOrderFile.setInsOrderId(orderId);
        insOrderFile.setFileName(filename);
        if (contentType != null && contentType.startsWith("image/")) {
            // 是图片
            path = imgUrl;
            insOrderFile.setType(1);
        } else {
            // 是文件
            path = wordUrl;
            insOrderFile.setType(2);
        }
        try {
            File realpath = new File(path);
            if (!realpath.exists()) {
                realpath.mkdirs();
            }
            pathName = file.getOriginalFilename().replace("#", "&");
            urlString = realpath + "/" + pathName;
            file.transferTo(new File(urlString));
            insOrderFile.setFileUrl(pathName);
            if (ObjectUtils.isNotEmpty(sonLaboratory)) {
                insOrderFile.setSonLaboratory(sonLaboratory);
                //删除重复的数据
                insOrderFileMapper.delete(Wrappers.<InsOrderFile>lambdaQuery()
                        .eq(InsOrderFile::getInsOrderId, orderId)
                        .eq(InsOrderFile::getType, insOrderFile.getType())
                        .eq(InsOrderFile::getFileName, insOrderFile.getFileName())
                        .eq(InsOrderFile::getSonLaboratory, insOrderFile.getSonLaboratory())
                        .eq(InsOrderFile::getFileUrl, insOrderFile.getFileUrl()));
            } else {
                //删除重复的数据
                insOrderFileMapper.delete(Wrappers.<InsOrderFile>lambdaQuery()
                        .eq(InsOrderFile::getInsOrderId, orderId)
                        .eq(InsOrderFile::getType, insOrderFile.getType())
                        .eq(InsOrderFile::getFileName, insOrderFile.getFileName())
                        .isNull(InsOrderFile::getSonLaboratory)
                        .eq(InsOrderFile::getFileUrl, insOrderFile.getFileUrl()));
            }
            insOrderFileMapper.insert(insOrderFile);
            //如果是辐射试验(近场/远程上传的csv文件)
            String[] split = filename.split("\\.");
            if (ObjectUtils.isNotEmpty(sonLaboratory) && (sonLaboratory.equals("近场") || sonLaboratory.equals("远场")) &&
                    split[split.length - 1].equals("csv")) {
                //判断是哪种csv文件,是否有——
                if (!file.getOriginalFilename().contains("——")) {
                    fuSheUtils.getFuSheWord1(sonLaboratory, insOrderFile);
                } else {
                    fuSheUtils.getFuSheWord2(sonLaboratory, insOrderFile);
                }
            }
        } catch (Exception e) {
            System.err.println("附件上传错误");
        }
        return 0;
    }

    @Override
    public List<String> upPlanUser2(Integer orderId) {
        List<Integer> sampleId = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getInsOrderId, orderId)).stream().map(InsSample::getId).collect(Collectors.toList());
        List<String> sonLaboratory = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery().eq(InsProduct::getState, 1).in(InsProduct::getInsSampleId, sampleId)).stream().map(InsProduct::getSonLaboratory).distinct().collect(Collectors.toList());
        return sonLaboratory;
    }

    @Override
    public int deleteInsContext(InsProductResultVo insProductResultVo) {
        return insProductResult2Mapper.delete(Wrappers.<InsProductResult2>lambdaQuery()
                .eq(InsProductResult2::getFrequency, insProductResultVo.getFrequency())
                .eq(InsProductResult2::getNum, insProductResultVo.getNum())
                .in(InsProductResult2::getInsProductId, insProductResultVo.getProductIds()));
    }

    //扫码报检
    @Override
    public int scanInsOrderState(String sonLaboratory, String sampleCode, String trees) {
        /*样品入库*/
        warehouseService.inWarehouse(trees, sampleCode);
        /*新增检验任务*/
        //先判断该订单是否有这个站点的项目
        InsSample insSample = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getSampleCode, sampleCode));
        List<Integer> sampleIds = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, insSample.getInsOrderId())).stream().map(InsSample::getId).collect(Collectors.toList());
        List<String> collect = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                .eq(InsProduct::getState, 1)
                .in(InsProduct::getInsSampleId, sampleIds)).stream().map(InsProduct::getSonLaboratory).collect(Collectors.toList());
        if (!collect.contains(sonLaboratory)) {
            throw new ErrorException("该订单没有" + sonLaboratory + "站点的相关项目,请查看下单详情!");
        }
        //判断该订单是否站点任务有结束试验
        List<InsOrderState> orderStates = insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, insSample.getInsOrderId())
                .eq(InsOrderState::getInsState, 5));
        if (CollectionUtils.isNotEmpty(orderStates)) {
            throw new ErrorException("该订单站点的任务已经结束试验,无法再次进行试验!");
        }
        InsOrderState orderState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, insSample.getInsOrderId())
                .eq(InsOrderState::getLaboratory, sonLaboratory));
        if (ObjectUtils.isNotEmpty(orderState)) {
            //继续试验
            if (orderState.getInsState() == 6) {
                orderState.setInsState(0);
                orderState.setNum(orderState.getNum() + 1);//递增
                insOrderStateMapper.updateById(orderState);
            }
        } else {
            InsOrderState insOrderState = new InsOrderState();
            insOrderState.setInsOrderId(insSample.getInsOrderId());
            insOrderState.setLaboratory(sonLaboratory);
            insOrderState.setInsState(0);
            insOrderState.setNum(1);//初始是第一次
            insOrderStateMapper.insert(insOrderState);
        }
        return 1;
    }

    //扫码出库
    @Override
    public int outInsOrderState(String sonLaboratory, String sampleCode) {
        //判断该样品的检验任务是否已经结束(继续试验或者是结束试验)
        //先判断该订单是否有这个站点的项目
        InsSample insSample = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getSampleCode, sampleCode));
        List<Integer> sampleIds = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, insSample.getInsOrderId())).stream().map(InsSample::getId).collect(Collectors.toList());
        List<String> collect = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                .eq(InsProduct::getState, 1)
                .in(InsProduct::getInsSampleId, sampleIds)).stream().map(InsProduct::getSonLaboratory).collect(Collectors.toList());
        if (!collect.contains(sonLaboratory)) {
            throw new ErrorException("该订单没有" + sonLaboratory + "站点的相关项目,请查看下单详情!");
        }
        //判断该订单是否站点任务有(继续试验或者是结束试验)
        List<InsOrderState> orderStates = insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, insSample.getInsOrderId())
                .eq(InsOrderState::getInsState, 5));
        if (CollectionUtils.isEmpty(orderStates)) {
            List<InsOrderState> orderStates1 = insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery()
                    .eq(InsOrderState::getInsOrderId, insSample.getInsOrderId())
                    .eq(InsOrderState::getLaboratory, sonLaboratory)
                    .eq(InsOrderState::getInsState, 6));
            if (CollectionUtils.isEmpty(orderStates1)) {
                throw new ErrorException("该样品的检验任务还没有结束试验或继续试验,暂时无法出库!");
            }
        }
        boolean a = true;
        warehouseService.outWarehouse(sampleCode, a);
        return 0;
    }

    @Override
    public List<InsOrderUser> getInsOrderUserList(Integer insOrderStateId) {
        return insOrderUserMapper.getInsOrderUserList(insOrderStateId);
    }

    private static final String splitIdentifier = "@-@"; // 自定义唯一标识分割符

    //预览文件
    @Override
    public Object preview(Integer id) throws Exception {
        InsOrderFile insOrderFile = insOrderFileMapper.selectById(id);
        File file = new File(wordUrl + "/" + insOrderFile.getFileUrl());
        StringBuilder stringBuilder = new StringBuilder();
        // 创建 reader
        try (BufferedReader br = Files.newBufferedReader(file.toPath())) {
            // CSV文件的分隔符
            String DELIMITER = ",";
            // 按行读取
            String line;
            while ((line = br.readLine()) != null) {
                // 分割
                String[] columns = line.split(DELIMITER);
                // 打印行
                stringBuilder.append(String.join(splitIdentifier, columns)).append("\n");
            }
        } catch (Exception ex) {
            List<Object> list = new ArrayList<>();
            //创建工作簿对象
            XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(file));
            //获取工作簿下sheet的个数 只读取第一个sheet
            int sheetNum = xssfWorkbook.getNumberOfSheets();
            //遍历工作簿中的所有数据
            for (int i = 0; i < sheetNum; i++) {
                Map<String, Object> map = new HashMap<>();
                StringBuilder result = new StringBuilder();
                XSSFSheet sheet = xssfWorkbook.getSheetAt(i);
                //获取最后一行的num，即总行数。此处从0开始
                int maxRow = sheet.getLastRowNum();
                for (int row = 0; row <= maxRow; row++) {
                    //获取最后单元格num，即总单元格数 ***注意：此处从1开始计数***
                    int maxRol = sheet.getRow(row).getLastCellNum();
                    StringBuilder aLine = new StringBuilder();
                    for (int rol = 0; rol < maxRol; rol++) {
                        aLine.append(sheet.getRow(row).getCell(rol)).append(",");
                    }
                    String substring = aLine.substring(0, aLine.length() - 1);
                    result.append(substring).append("\n");
                }
                map.put("sheetName", sheet.getSheetName());
                map.put("content", result.toString());
                list.add(map);
            }
            return list;
        }
        return stringBuilder.toString();
    }

    //模版保存检验内容
    @Override
    public void saveInsContext(Map<String, Object> insContext, Integer num) {
        Integer userId = getLook.selectPowerByMethodAndUserId(null).get("userId");
        CompletableFuture.supplyAsync(() -> {
            AtomicInteger count = new AtomicInteger();
            insContext.forEach((k, v) -> {
                JSONObject jo = JSON.parseObject(JSON.toJSONString(v));
                InsProduct insProduct = new InsProduct();
                insProduct.setId(Integer.parseInt(k));
                InsProductResult result = insProductResultMapper.selectOne(Wrappers.<InsProductResult>lambdaQuery().eq(InsProductResult::getInsProductId, insProduct.getId()));
                if (BeanUtil.isEmpty(result)) {
                List<InsProductResult> results = insProductResultMapper.selectList(Wrappers.<InsProductResult>lambdaQuery()
                        .eq(InsProductResult::getNum, num)
                        .eq(InsProductResult::getInsProductId, insProduct.getId()));
                InsProductResult result;
                if (CollectionUtils.isEmpty(results)) {
                    result = new InsProductResult();
                } else {
                    result = results.get(0);
                }
                result.setInsProductId(Integer.parseInt(k));
                JSONArray jsonArray = JSON.parseArray(JSON.toJSONString(jo.get("insValue")));
                List<Map<String, Object>> iv = new ArrayList<>();
                for (Object o : jsonArray) {
                    JSONObject insValue = JSON.parseObject(JSON.toJSONString(o));
                    Map<String, Object> map = new HashMap<>();
                    map.put("v", JSON.parseObject(JSON.toJSONString(insValue.get("v"))).get("v"));
                    if ((insValue.get("u") == null || insValue.get("u").equals("")) && StrUtil.isNotEmpty(JSON.parseObject(JSON.toJSONString(insValue.get("v"))).get("v").toString())) {
                        map.put("u", userId);
                    }else {
                        map.put("u", insValue.get("u"));
                result.setNum(num);
                //检验值
                if (jo.get("insValue") != null) {
                    JSONArray jsonArray = JSON.parseArray(JSON.toJSONString(jo.get("insValue")));
                    List<Map<String, Object>> iv = new ArrayList<>();
                    for (Object o : jsonArray) {
                        JSONObject insValue = JSON.parseObject(JSON.toJSONString(o));
                        Map<String, Object> map = new HashMap<>();
                        map.put("v", JSON.parseObject(JSON.toJSONString(insValue.get("v"))).get("v"));
                        map.put("r", JSON.toJSONString(insValue.get("r")));
                        map.put("c", JSON.toJSONString(insValue.get("c")));
                        map.put("w", insValue.get("w"));
                        try {
                            if ((insValue.get("u") == null || insValue.get("u").equals("")) && StrUtil.isNotEmpty(JSON.parseObject(JSON.toJSONString(insValue.get("v"))).get("v").toString())) {
                                map.put("u", userId + "");
                            } else {
                                map.put("u", insValue.get("u"));
                            }
                            iv.add(map);
                        } catch (Exception e) {
                        }
                    }
                    iv.add(map);
                    result.setInsValue(JSON.toJSONString(iv));
                }
                result.setInsValue(JSON.toJSONString(iv));
                JSONArray jsonArray2 = JSON.parseArray(JSON.toJSONString(jo.get("comValue")));
                List<Map<String, Object>> cv = new ArrayList<>();
                for (Object o : jsonArray2) {
                    JSONObject comValue = JSON.parseObject(JSON.toJSONString(o));
                    Map<String, Object> map = new HashMap<>();
                    map.put("v", JSON.parseObject(JSON.toJSONString(comValue.get("v"))).get("v"));
                    cv.add(map);
                //计算值
                if (jo.get("comValue") != null && !Objects.equals(jo.get("comValue"), "")) {
                    JSONArray jsonArray2 = JSON.parseArray(JSON.toJSONString(jo.get("comValue")));
                    List<Map<String, Object>> cv = new ArrayList<>();
                    for (Object o : jsonArray2) {
                        JSONObject comValue = JSON.parseObject(JSON.toJSONString(o));
                        Map<String, Object> map = new HashMap<>();
                        map.put("v", JSON.parseObject(JSON.toJSONString(comValue.get("v"))).get("v"));
                        cv.add(map);
                    }
                    result.setComValue(JSON.toJSONString(cv));
                }
                result.setComValue(JSON.toJSONString(cv));
                JSONObject resValue = JSON.parseObject(JSON.toJSONString(jo.get("resValue")));
                insProduct.setLastValue(JSON.parseObject(JSON.toJSONString(resValue.get("v"))).get("v") + "");
                JSONObject equipValue = JSON.parseObject(JSON.toJSONString(jo.get("equipValue")));
                //最终值
                try {
                    result.setEquipValue(JSON.parseObject(JSON.toJSONString(equipValue.get("v"))).get("v") + "");
                }catch (Exception ignored){
                    result.setEquipValue(null);
                    JSONObject resValue = JSON.parseObject(JSON.toJSONString(jo.get("resValue")));
                    if (resValue.get("v") != null) {
                        Object o = JSON.parseObject(JSON.toJSONString(resValue.get("v"))).get("v");
                        insProduct.setLastValue(o.equals("") ? null : (o.toString()));
                    }
                } catch (Exception e) {
                    insProduct.setLastValue("");//''
                }
                JSONObject insResult = JSON.parseObject(JSON.toJSONString(jo.get("insResult")));
                insProduct.setInsResult(Integer.parseInt(JSON.parseObject(JSON.toJSONString(insResult.get("v"))).get("v") + ""));
                //试验前样品检查
                try {
                    JSONObject resValue = JSON.parseObject(JSON.toJSONString(jo.get("beforeCheck")));
                    if (resValue.get("v") != null) {
                        Object o = JSON.parseObject(JSON.toJSONString(resValue.get("v"))).get("v");
                        result.setBeforeCheck(o.equals("") ? null : (o.toString()));
                    }
                } catch (Exception e) {
                    result.setBeforeCheck("");//''
                }
                //试验后样品检查
                try {
                    JSONObject resValue = JSON.parseObject(JSON.toJSONString(jo.get("afterCheck")));
                    if (resValue.get("v") != null) {
                        Object o = JSON.parseObject(JSON.toJSONString(resValue.get("v"))).get("v");
                        result.setAfterCheck(o.equals("") ? null : (o.toString()));
                    }
                } catch (Exception e) {
                    result.setAfterCheck("");//''
                }
                //设备编号
                if (jo.get("equipValue") != null) {
                    JSONArray jsonArray2 = JSON.parseArray(JSON.toJSONString(jo.get("equipValue")));
                    List<Map<String, Object>> ev = new ArrayList<>();
                    for (Object o : jsonArray2) {
                        JSONObject equipValue = JSON.parseObject(JSON.toJSONString(o));
                        Map<String, Object> map = new HashMap<>();
                        map.put("v", JSON.parseObject(JSON.toJSONString(equipValue.get("v"))).get("v"));
                        ev.add(map);
                    }
                    result.setEquipValue(JSON.toJSONString(ev));
                }
                //设备名称
                if (jo.get("equipName") != null) {
                    JSONArray jsonArray2 = JSON.parseArray(JSON.toJSONString(jo.get("equipName")));
                    List<Map<String, Object>> ev = new ArrayList<>();
                    for (Object o : jsonArray2) {
                        JSONObject equipValue = JSON.parseObject(JSON.toJSONString(o));
                        Map<String, Object> map = new HashMap<>();
                        map.put("v", JSON.parseObject(JSON.toJSONString(equipValue.get("v"))).get("v"));
                        ev.add(map);
                    }
                    result.setEquipName(JSON.toJSONString(ev));
                }
                //结论
                try {
                    JSONObject insResult = JSON.parseObject(JSON.toJSONString(jo.get("insResult")));
                    String ir = JSON.parseObject(JSON.toJSONString(insResult.get("v"))).get("v") + "";
                    insProduct.setInsResult(Integer.parseInt(ir));
                } catch (Exception e) {
                    insProduct.setInsResult(2);//待定
                }
                if (BeanUtil.isEmpty(result.getId())) {
                    result.setCreateUser(userId);
                    result.setUpdateUser(userId);
@@ -229,79 +643,600 @@
                }
                insProduct.setUpdateUser(userId);
                insProductMapper.updateById(insProduct);
                if(count.get() == 0){
                    InsSample insSample = insSampleMapper.selectById(insProductMapper.selectById(insProduct.getId()).getInsSampleId());
                    insSample.setInsState(1);
                    count.addAndGet(1);
                insProductUserMapper.insert(new InsProductUser(null, userId, LocalDateTime.now(), insProduct.getId()));
                insProduct = insProductMapper.selectById(insProduct);
                InsSample insSample = insSampleMapper.selectById(insProductMapper.selectById(insProduct.getId()).getInsSampleId());
                insSample.setInsState(1);
                Long l = insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
                        .eq(InsProduct::getInsSampleId, insSample.getId()));
                Long l1 = insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
                        .eq(InsProduct::getInsSampleId, insSample.getId())
                        .and(wrapper -> wrapper
                                .isNotNull(InsProduct::getInsResult)
                                .or()
                                .ne(InsProduct::getInsResult, 2)
                        ));
                if (l == l1) {
                    //如果所有项目都有结论,那么该样品状态已检
                    insSample.setInsState(2);
                }
                insSampleMapper.updateById(insSample);
                /*校验一下result表*/
                List<InsProductResult> insProductResults = insProductResultMapper.selectList(Wrappers.<InsProductResult>lambdaQuery()
                        .eq(InsProductResult::getNum, num)
                        .eq(InsProductResult::getInsProductId, insProduct.getId()));
                if (insProductResults.size() > 1) {
                    for (int i = 1; i < insProductResults.size(); i++) {
                        insProductResultMapper.deleteById(insProductResults.get(i));
                    }
                }
            });
            return null;
            return insContext.keySet().stream().findFirst().orElse(null);
        }).thenAccept(res -> {
            if (res != null) {
                int pId = Integer.parseInt(res.replaceAll("\\D+", ""));
                InsProduct insProduct = insProductMapper.selectById(pId);
                // 通过样本id获取订单id
                int orderId = insSampleMapper.selectById(insProduct.getInsSampleId()).getInsOrderId();
                int count = insProductMapper.selectInsProductCountByOrderId(orderId);
                if (count == 0) {
                    insOrderStateMapper.update(new InsOrderState(), Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getInsOrderId, orderId)
                            .eq(InsOrderState::getLaboratory, insProduct.getSonLaboratory())
                            .set(InsOrderState::getInsState, 2));
                }
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            return null;
        });
    }

    //电路试验的保存检验内容
    @Override
    public int upPlanUser(Integer userId, Integer orderId) {
    public List<Integer> saveInsContext2(InsProductResultDto insProductResultDtos) {
        if (ObjectUtils.isEmpty(insProductResultDtos.getFrequency())) {
            throw new ErrorException("频率不能为空");
        }
        Integer userId = getLook.selectPowerByMethodAndUserId(null).get("userId");
        //查询检验单信息
        InsOrder insOrder = insOrderMapper.selectById(insProductResultDtos.getOrderId());
        InsOrderState orderState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, insProductResultDtos.getOrderId())
                .eq(InsOrderState::getLaboratory, insProductResultDtos.getSonLaboratory())
                .orderByDesc(InsOrderState::getId)
                .last("LIMIT 1"));// 确保只取一条记录
        //查询样品信息
        InsSample insSample = insSampleMapper.selectById(insProductResultDtos.getSampleId());
        List<Integer> list = new ArrayList<>();
        /*新增检验项目检验值记录表(采取先删后增)*/
        insProductResult2Mapper.delete(Wrappers.<InsProductResult2>lambdaQuery()
                .in(InsProductResult2::getInsProductId, insProductResultDtos.getInsProductResult2s().stream().map(InsProductResult2::getInsProductId).distinct().collect(Collectors.toList()))
                .eq(InsProductResult2::getNum, orderState.getNum())
                .eq(InsProductResult2::getFrequency, insProductResultDtos.getFrequency()));
        for (InsProductResult2 insProductResult2 : insProductResultDtos.getInsProductResult2s()) {
            InsProduct insProduct = new InsProduct();
            insProduct.setId(insProductResult2.getInsProductId());//项目id
            InsProductResult2 result2 = new InsProductResult2();
            result2.setNum(orderState.getNum());
            result2.setInsProductId(insProductResult2.getInsProductId());
            //频率
            result2.setFrequency(insProductResultDtos.getFrequency());
            //频点
            if (insProductResult2.getOften() != null) {
                result2.setOften(insProductResult2.getOften());
            }
            //端口
            if (insProductResult2.getPort() != null) {
                result2.setPort(insProductResult2.getPort());
            }
            //角度
            if (insProductResult2.getAngle() != null) {
                result2.setAngle(insProductResult2.getAngle());
            }
            //设备编号
            if (insProductResult2.getEquipValue() != null) {
                result2.setEquipValue(insProductResult2.getEquipValue());
            }
            //设备名称
            if (insProductResult2.getEquipName() != null) {
                result2.setEquipName(insProductResult2.getEquipName());
            }
            insProduct = insProductMapper.selectById(insProduct.getId());
            //值
            if (insProductResult2.getValue() != null) {
                result2.setValue(insProductResult2.getValue());
                //结论
                int ressult = 1;
                String valueStr = insProductResult2.getValue();
                if (!insProduct.getAsk().contains(",")) {
                    if (insProduct.getAsk().equals("/")) {
                        ressult = 3; //不判定
                    } else if (!isValueValid(valueStr, new String[]{insProduct.getAsk()})) {
                        ressult = 0; //不合格
                    }
                } else {
                    // 如果要求值是(2°≥20,7°≥25,12°≥25)这种情况
                    String[] askParts = insProduct.getAsk().split(",");
                    String[] angles = insProductResult2.getAngle().split(",");
                    for (String s : askParts) {
                        String[] askSplit = s.split("°");
                        String angleKey = askSplit[0];
                        String angleValue = askSplit[1];
                        for (int i = 0; i < angles.length; i++) {
                            if (angles[i].split("°")[0].equals(angleKey)) {
                                try {
                                    String s1 = valueStr.substring(1, valueStr.length() - 1).split("\\],\\[")[i];
                                    if (!s1.startsWith("[")) {
                                        s1 = "[" + s1;
                                    }
                                    if (!s1.endsWith("]")) {
                                        s1 = s1 + "]";
                                    }
                                    if (!isValueValid("[" + s1 + "]", new String[]{angleValue})) {
                                        ressult = 0; // 不合格
                                        break;
                                    }
                                } catch (Exception e) {
                                } finally {
                                    continue;
                                }
                            }
                        }
                    }
                }
                result2.setResult(ressult);
                list.add(ressult);
            }
            result2.setCreateUser(userId);
            result2.setUpdateUser(userId);
            insProductResult2Mapper.insert(result2);
            insProduct.setUpdateUser(userId);
            insProductMapper.updateById(insProduct);
            insProductUserMapper.insert(new InsProductUser(null, userId, LocalDateTime.now(), insProduct.getId()));
            /*更新样品的检验状态*/
            insSample.setInsState(1);
            Long l = insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
                    .eq(InsProduct::getInsSampleId, insSample.getId()));
            Long l1 = insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
                    .eq(InsProduct::getInsSampleId, insSample.getId())
                    .and(wrapper -> wrapper
                            .isNotNull(InsProduct::getInsResult)
                            .or()
                            .ne(InsProduct::getInsResult, 2)
                    ));
            if (l == l1) {
                //如果所有项目都有结论,那么该样品状态已检
                insSample.setInsState(2);
            }
            insSampleMapper.updateById(insSample);
        }
        /*判断该站点的检验项目是否全部已检*/
        int count = insProductMapper.selectInsProductCountByOrderId(insProductResultDtos.getOrderId());
        if (count == 0) {
            insOrderStateMapper.update(new InsOrderState(), Wrappers.<InsOrderState>lambdaUpdate()
                    .eq(InsOrderState::getInsOrderId, insProductResultDtos.getOrderId())
                    .eq(InsOrderState::getLaboratory, insProductResultDtos.getSonLaboratory())
                    .set(InsOrderState::getInsState, 2));
        }
        return list;
    }

    //温湿度试验+功率试验的保存检验内容
    @Override
    public int saveInsContext3(InsProductResult insProductResult) {
        //先删后加
        insProductResultMapper.delete(Wrappers.<InsProductResult>lambdaQuery()
                .eq(InsProductResult::getInsProductId, insProductResult.getInsProductId())
                .eq(InsProductResult::getNum, insProductResult.getNum()));
        insProductResult.setEquipValue("[{\"v\":\"" + insProductResult.getEquipValue() + "\"}]");
        insProductResult.setEquipName("[{\"v\":\"" + insProductResult.getEquipName() + "\"}]");
        insProductResultMapper.insert(insProductResult);
        return 0;
    }

    //解析要求值的格式
    private boolean getResult(double s, String ask) {
        // 处理±范围的条件
        if (ask.contains("±")) {
            Pattern pattern = Pattern.compile("(\\d+)±(\\d+)");
            Matcher matcher = pattern.matcher(ask);
            if (matcher.matches()) {
                double center = Double.parseDouble(matcher.group(1));
                double tolerance = Double.parseDouble(matcher.group(2));
                return Math.abs(s - center) <= tolerance;
            }
        }
        // 处理其他比较条件
        if (ask.startsWith(">")) {
            double threshold = Double.parseDouble(ask.substring(1));
            return s > threshold;
        } else if (ask.startsWith("≥")) {
            double threshold = Double.parseDouble(ask.substring(1));
            return s >= threshold;
        } else if (ask.startsWith("<")) {
            double threshold = Double.parseDouble(ask.substring(1));
            return s < threshold;
        } else if (ask.startsWith("≤")) {
            double threshold = Double.parseDouble(ask.substring(1));
            return s <= threshold;
        } else if (ask.equals("=")) {
            double exactValue = Double.parseDouble(ask.substring(1));
            return s == exactValue;
        }
        // 处理不支持的条件
        throw new IllegalArgumentException("未知格式要求值请检查" + ask);
    }

    //将前端传过来的值转换成数组的形式
    private String[] parseValues(String valueStr) {
        String trimmedStr = valueStr.substring(1, valueStr.length() - 1);
        return Arrays.stream(trimmedStr.split("\\],\\["))
                .map(s -> s.substring(1, s.length() - 1).split(","))
                .flatMap(Arrays::stream)
                .map(s -> s.replace("\"", ""))
                .toArray(String[]::new);
    }

    //判读合格与不合格
    private boolean isValueValid(String valueStr, String[] valuesToCheck) {
        for (String s : parseValues(valueStr)) {
            if (ObjectUtils.isEmpty(s)) {
                continue;
            }
            double numericValue = Double.parseDouble(s);
            boolean valid = Arrays.stream(valuesToCheck)
                    .allMatch(v -> getResult(numericValue, v));
            if (!valid) {
                return false;
            }
        }
        return true;
    }

    //交接
    @Override
    public int upPlanUser(Integer userId, Integer orderId, String sonLaboratory) {
        InsSampleUser insSampleUser = new InsSampleUser();
        insSampleUser.setUserId(userId);
        insSampleUser.setInsSampleId(orderId);
        insSampleUser.setState(0);
        insSampleUser.setSonLaboratory(sonLaboratory);
        return insSampleUserMapper.insert(insSampleUser);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int verifyPlan(Integer orderId, String laboratory, Integer type, String tell) {
        Integer num = (type == 1 ? 5 : 4);
        insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate().eq(InsOrderState::getInsOrderId, orderId).eq(InsOrderState::getLaboratory, laboratory).set(InsOrderState::getInsTime, LocalDateTime.now()).set(InsOrderState::getInsState, num).set(InsOrderState::getVerifyTell, tell).set(InsOrderState::getVerifyUser, getLook.selectPowerByMethodAndUserId(null).get("userId")));
        List<InsOrderState> insOrderStates = insOrderStateMapper.selectList(Wrappers.<InsOrderState>lambdaQuery().eq(InsOrderState::getInsOrderId, orderId));
        long count = insOrderStates.stream().filter(a -> a.getInsState() == 5).count();
        if (count == insOrderStates.size() && num == 5) {
            InsOrder insOrder = insOrderMapper.selectById(orderId);
            Map<String, String> user = insProductMapper.selectUserById(insOrder.getUserId());
            List<SampleProductDto> samples = insSampleMapper.selectSampleProductListByOrderId(orderId);
            samples.forEach(System.out::println);
            InsReport insReport = new InsReport();
            insReport.setCode(giveCode.giveCode("JCZX/TX-", "ins_report", "-", "yyMMdd"));
            insReport.setInsOrderId(orderId);
            String url;
            try {
                url = ResourceUtils.getURL("classpath:static/report-template.docx").getPath();
            } catch (FileNotFoundException e) {
                throw new ErrorException("找不到模板文件");
    public int verifyPlan(Integer orderId, String laboratory, Integer type, String tell) throws IOException {
        LocalDateTime now = LocalDateTime.now();
        Integer userId = getLook.selectPowerByMethodAndUserId(null).get("userId");
        List<InsUnPass> insUnPasses = new ArrayList<>();
        /*样品下的项目只要有一个项目不合格则检验结果为0,否则为1*/
        List<InsSample> samples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getInsOrderId, orderId));
        for (InsSample insSample : samples) {
            List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                    .eq(InsProduct::getInsSampleId, insSample.getId())
                    .eq(InsProduct::getSonLaboratory, laboratory)
                    .eq(InsProduct::getState, 1));
            List<Integer> results = insProducts.stream().map(InsProduct::getInsResult).filter(str -> str != null).collect(Collectors.toList());
            if (results.contains(0)) {
                insSample.setInsResult(0);
            } else {
                insSample.setInsResult(1);
            }
            XWPFTemplate template = XWPFTemplate.compile(url).render(
                    new HashMap<String, Object>() {{
                        put("order", insOrder);
                        put("report", insReport);
                        put("user", user);
                        put("samples", samples);
                        put("sampleSize", samples.size() + samples.get(0).getUnit());
                    }});
            try {
                String name = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yy_MM_dd_HH_mm_ss")) + ".docx";
                template.writeAndClose(new FileOutputStream(wordUrl + "/" + name));
                insReport.setUrl("/word/"+ name);
                insReportMapper.insert(insReport);
            } catch (IOException e) {
                throw new RuntimeException(e);
            insSampleMapper.updateById(insSample);
            /*复核后，将不合格的项目信息添加到ins_un_pass表中*/
            for (InsProduct insProduct : insProducts) {
                if (insProduct.getInsResult() == 0) {
                    InsUnPass insUnPass = new InsUnPass();
                    insUnPass.setId(null);
                    insUnPass.setModel(insSample.getModel());
                    insUnPass.setSample(insSample.getSample());
                    insUnPass.setInspectionItem(insProduct.getInspectionItem());
                    insUnPass.setInspectionItemSubclass(insProduct.getInspectionItemSubclass());
                    insUnPass.setLastValue(insProduct.getLastValue());
                    insUnPass.setEntrustCode(insOrderMapper.selectById(orderId).getEntrustCode());
                    List<Integer> userIds = insProductUserMapper.selectList(Wrappers.<InsProductUser>lambdaQuery().eq(InsProductUser::getInsProductId, insProduct.getId())).stream().map(InsProductUser::getCreateUser).distinct().collect(Collectors.toList());
                    String name = userMapper.selectBatchIds(userIds).stream().map(User::getName).collect(Collectors.joining(","));
                    insUnPass.setName(name);
                    insUnPasses.add(insUnPass);
                }
            }
        }
        insUnPassService.saveBatch(insUnPasses);
        /*type=0  再次试验; type=1 继续试验 ; type=2 结束试验*/
        // 查询根据 id 倒序排列的第一条记录
        InsOrderState record = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, orderId)
                .eq(InsOrderState::getLaboratory, laboratory)
                .orderByDesc(InsOrderState::getId)
                .last("LIMIT 1")); // 确保只取一条记录
        if (record != null) {
            //更新记录
            insOrderUserMapper.update(null, Wrappers.<InsOrderUser>lambdaUpdate()
                    .eq(InsOrderUser::getInsOrderStateId, record.getId())
                    .eq(InsOrderUser::getNum, record.getNum())
                    .set(InsOrderUser::getTell, tell));
            switch (type) {
                case 0:
                    //再次试验:该单子退回到检验状态(排序改成当前的最后),次数递增(保留以前的数据)；
                    insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getId, record.getId())
                            .set(InsOrderState::getInsTime, now)
                            .set(InsOrderState::getInsState, 4)
                            .set(InsOrderState::getVerifyTell, tell)
                            .set(InsOrderState::getVerifyUser, userId)
                            .set(InsOrderState::getNum, record.getNum() + 1)//次数加1
                            .set(InsOrderState::getCreateTime, LocalDateTime.now()));
                    break;
                case 1:
                    //继续试验:该站点任务结束(可以再次扫码检验)；
                    insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getInsOrderId, orderId)
                            .eq(InsOrderState::getLaboratory, laboratory)
                            .set(InsOrderState::getInsState, 6)
                            .set(InsOrderState::getVerifyTell, tell)
                            .set(InsOrderState::getVerifyUser, userId));
                    break;
                case 2:
                    //结束试验:此委托单停止试验(无法再次检验)。
                    insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                            .eq(InsOrderState::getInsOrderId, orderId)
                            .eq(InsOrderState::getLaboratory, laboratory)
                            .set(InsOrderState::getInsState, 5)
                            .set(InsOrderState::getVerifyTell, tell)
                            .set(InsOrderState::getVerifyUser, userId));
                    //如果订单类型是原理样机,则该订单直接闭环
                    InsOrder insOrder = insOrderMapper.selectById(orderId);
                    if (insOrder.getFormType().equals("原理样机")) {
                        for (InsSample sample : samples) {
                            //出库
                            try {
                                outInsOrderState(laboratory, sample.getSampleCode());
                            } catch (Exception e) {

                            }
                        }
                        insOrder.setState(4);
                        insOrderMapper.updateById(insOrder);
                    }
                    break;
            }
        }
        return 1;
    }

    @Override
    public int submitPlan(Integer orderId, String laboratory) {
        List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getInsOrderId, orderId).select(InsSample::getId));
        List<Integer> ids = insSamples.stream().map(a -> a.getId()).collect(Collectors.toList());
        List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery().in(InsProduct::getInsSampleId, ids).eq(InsProduct::getSonLaboratory, laboratory).isNotNull(InsProduct::getInsResult));
        if (insProducts.size() == 0) {
            return 0;
    private void getTemplateThing(Set<Integer> set, Map<Integer, String> map2, List<InsProduct> insProducts) {
        for (InsProduct product : insProducts) {
            if (product.getTemplateId() == null) {
                product.setTemplate(new ArrayList<>());
                continue;
            }
            String thing = null;
            if (product.getTemplateId() != null && set.add(product.getTemplateId())) {
                map2.put(product.getTemplateId(), standardTemplateService.getStandTempThingById(product.getTemplateId()) + "");
                thing = map2.get(product.getTemplateId());
            }
            if (StrUtil.isNotEmpty(thing)) {
                JSONObject sheet = JSON.parseObject(JSON.toJSONString(JSON.parseArray(JSON.toJSONString(JSON.parseObject(thing).get("data"))).get(0)));
                JSONObject config = JSON.parseObject(JSON.toJSONString(sheet.get("config")));
                List<JSONObject> cellData = JSON.parseArray(JSON.toJSONString(sheet.get("celldata")), JSONObject.class);
                Map<String, Object> style = new HashMap<>();
                style.put("rowlen", config.get("rowlen"));
                style.put("columnlen", config.get("columnlen"));
                product.setTemplate(cellData);
                product.setStyle(style);
                product.setTemplateName(standardTemplateService.getStandTempNameById(product.getTemplateId()));
            }
        }
        insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate().eq(InsOrderState::getInsOrderId, orderId).eq(InsOrderState::getLaboratory, laboratory).set(InsOrderState::getInsTime, LocalDateTime.now()).set(InsOrderState::getInsState, 3));
    }

    @Override
    public int submitPlan(SubmitPlanDto submitPlanDto) {
        List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
                .eq(InsSample::getInsOrderId, submitPlanDto.getOrderId()).select(InsSample::getId));
        InsOrderState orderState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
                .eq(InsOrderState::getInsOrderId, submitPlanDto.getOrderId())
                .eq(InsOrderState::getLaboratory, submitPlanDto.getLaboratory())
                .orderByDesc(InsOrderState::getId)
                .last("LIMIT 1"));// 确保只取一条记录
        /*记录检验任务每次的备注信息*/
        InsOrderUser insOrderUser = new InsOrderUser();
        insOrderUser.setInsOrderStateId(orderState.getId());
        insOrderUser.setSubmitUser(getLook.selectPowerByMethodAndUserId(null).get("userId"));
        insOrderUser.setSubmitTime(LocalDateTime.now());
        insOrderUser.setNum(orderState.getNum());
        insOrderUser.setNote(ObjectUtils.isNotEmpty(submitPlanDto.getNote()) ? submitPlanDto.getNote() : null);
        insOrderUser.setTerm(ObjectUtils.isNotEmpty(submitPlanDto.getTerm()) ? submitPlanDto.getTerm() : null);
        insOrderUserMapper.insert(insOrderUser);
        List<Integer> ids = insSamples.stream().map(a -> a.getId()).collect(Collectors.toList());
        List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
                .in(InsProduct::getInsSampleId, ids)
                .eq(InsProduct::getSonLaboratory, submitPlanDto.getLaboratory())
                .eq(InsProduct::getState, 1)
                .and(wrapper -> wrapper
                        .isNull(InsProduct::getInsResult)
                        .or()
                        .eq(InsProduct::getInsResult, 2)
                ));
        if (insProducts.size() > 0) {
            String str = "";
            int count = 0;
            for (InsProduct product : insProducts) {
                //辐射试验,温湿度试验,功率试验的检验项目,不需要去手动填写检验值,只需要上传表格文件就可以了,后台提交的时候校验跳过这个检验项目
                if (product.getInspectionItem().equals("辐射试验") || product.getInspectionItem().equals("温湿度试验") || product.getInspectionItem().equals("功率试验")) {
                    product.setInsResult(3);//不判定
                    insProductMapper.updateById(product);
                    continue;
                }
                //电路试验的检验项目,需要在提交的时候再去赋值合格与不合格
                if (product.getInspectionItem().equals("电路试验")) {
                    List<Integer> collect = insProductResult2Mapper.selectList(Wrappers.<InsProductResult2>lambdaQuery()
                            .eq(InsProductResult2::getNum, orderState.getNum())
                            .eq(InsProductResult2::getInsProductId, product.getId())).stream().map(InsProductResult2::getResult).distinct().collect(Collectors.toList());
                    if (collect.contains(0)) {
                        product.setInsResult(0);//不合格
                    } else {
                        product.setInsResult(1);//合格
                    }
                    insProductMapper.updateById(product);
                    continue;
                }
                count++;
                str += "<br/>" + count + "：" + product.getInspectionItem() + " " + product.getInspectionItemSubclass() + "<br/>";
            }
            if (ObjectUtils.isNotEmpty(str)) {
                throw new ErrorException("<strong>存在待检验的项目：</strong><br/>" + str);
            }
        }
        insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
                .eq(InsOrderState::getInsOrderId, submitPlanDto.getOrderId())
                .eq(InsOrderState::getLaboratory, submitPlanDto.getLaboratory())
                .set(InsOrderState::getInsState, 3)
                .set(InsOrderState::getVerifyUser, submitPlanDto.getVerifyUser()));
        InsOrder insOrder = insOrderMapper.selectById(submitPlanDto.getOrderId());
        /*这个情况先关闭----如果是C类订单且是下发到质量部,则直接复核通过(结束试验)*/
//        if (insOrder.getOrderType().equals("C") && insOrder.getDepartmentLims().equals("质量部")) {
//            try {
//                verifyPlan(orderId, laboratory, 2, null);
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        } else {
        Integer userId = getLook.selectPowerByMethodAndUserId(null).get("userId");
        //LIMS系统消息推送
        InformationNotification info = new InformationNotification();
        info.setCreateUser(insProductMapper.selectUserById(userId).get("name"));
        info.setMessageType("2");
        info.setTheme("复核通知");
        info.setContent("您有一条检验任务待复核消息");
        info.setSenderId(userId);
        info.setConsigneeId(submitPlanDto.getVerifyUser());
        info.setViewStatus(false);
        info.setJumpPath("b1-inspect-order-plan");
        informationNotificationService.addInformationNotification(info);
        //  todo 企业微信消息推送@zss
            HashMap<String, Object> map = new HashMap<>();
            String account = userMapper.selectById(submitPlanDto.getVerifyUser()).getAccount();
            map.put("touser", account);//接收消息成员的账号'ZT-031292'这种类型(如果有多个用'|'分隔)
            map.put("toparty", "");//接收部门id
            map.put("totag", "");//消息标签id
            map.put("msgtype", "text");//消息类型 text:文本
            map.put("agentid", 1000517);//应用id
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("content", "您有一条检验任务待复核消息,订单号是："+insOrder.getEntrustCode()+",请前往LIMS系统查看。<a href=\"https://ztwxlims.ztt.cn:7443/enter\">中天通信LIMS系统 </a>");
            map.put("text", hashMap);//消息内容
            map.put("safe", 0);//是否保密消息.0否
            map.put("enable_id_trans", 0);//是否开启id转译.0否
            map.put("enable_duplicate_check", 0);//是否开启重复消息检查.0否
            qywxApi.send(map);
//        }
        //复核人--检验单相关负责人
        InsSampleUser insSampleUser = new InsSampleUser();
        insSampleUser.setUserId(submitPlanDto.getVerifyUser());
        insSampleUser.setInsSampleId(submitPlanDto.getOrderId());
        insSampleUser.setState(1);
        insSampleUser.setSonLaboratory(submitPlanDto.getLaboratory());
        insSampleUserMapper.insert(insSampleUser);
        /*生成电路试验的站点报告并上传到附件中*/
        if (submitPlanDto.getLaboratory().equals("电路试验")) {
            //wordUtils.generateWord(submitPlanDto.getTerm(), orderState);
            //todo 电路站点报告 正式库部署放开
            try {
                wordUtils.generateWord(submitPlanDto.getTerm(), orderState);
            } catch (Exception e) {
                throw new ErrorException("电路试验的站点报告生成有误,请联系开发人员调整!");
            }
        }
        /*// 删除数采采集次数
        String key = "frequency" + ":" + submitPlanDto.getEntrustCode() + ":*";
        RedisUtil.delsLike(key);*/

        /*生成产量工时*/
        //校验如果这个人这个检测项目已经添加过了则不需要再新增
        //首先判断当前人的当前时间是否是排班时间内,如果不是就是加班
        LocalDateTime today = LocalDateTime.of(LocalDate.now(), LocalTime.MIDNIGHT);
        PerformanceShift performanceShift = performanceShiftMapper.selectOne(Wrappers.<PerformanceShift>lambdaQuery()
                .eq(PerformanceShift::getUserId, userId)
                .eq(PerformanceShift::getWorkTime, today));
        if (ObjectUtils.isNotEmpty(performanceShift)) {
            ShiftTime shiftTime = shiftTimeMapper.selectOne(Wrappers.<ShiftTime>lambdaQuery().eq(ShiftTime::getShift, performanceShift.getShift()));
            if (ObjectUtils.isNotEmpty(shiftTime)) {
                DateTimeFormatter forma = DateTimeFormatter.ofPattern("HH:mm");
                LocalTime now = LocalTime.now();
                LocalTime startTime = LocalTime.parse(shiftTime.getStartTime(), forma);
                LocalTime endTime = LocalTime.parse(shiftTime.getEndTime(), forma);
                // 检查当前时间是否在范围内（包括边界）
                boolean isWithinRange;
                if (endTime.isAfter(startTime)) {
                    // 不跨天的情况
                    isWithinRange = !now.isBefore(startTime) && !now.isAfter(endTime);
                } else {
                    // 跨天的情况
                    isWithinRange = !now.isBefore(startTime) || !now.isAfter(endTime);
                }
                for (AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHours : submitPlanDto.getAuxiliaryOutputWorkingHoursList()) {
                    InsProduct insProduct = insProductMapper.selectById(auxiliaryOutputWorkingHours.getInsProductId());
                    if (isWithinRange) {
                        //在时间内就是正常上班
                        auxiliaryOutputWorkingHours.setOrderNo(insOrder.getEntrustCode());//非加班委托单号
                        auxiliaryOutputWorkingHours.setWorkTime(auxiliaryOutputWorkingHours.getOutputWorkTime());//非加班工时
                        auxiliaryOutputWorkingHours.setAmount(1);//非加班数量
                    } else {
                        //加班
                        auxiliaryOutputWorkingHours.setOvertimeOrderNo(insOrder.getEntrustCode());//加班委托单号
                        auxiliaryOutputWorkingHours.setOvertimeWorkTime(auxiliaryOutputWorkingHours.getOutputWorkTime());//加班工时
                        auxiliaryOutputWorkingHours.setOvertimeAmount(1);//加班数量
                    }
                    auxiliaryOutputWorkingHours.setManHourGroup(insProduct.getManHourGroup());//工时分组
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
                    DateTimeFormatter formatters = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                    auxiliaryOutputWorkingHours.setDateTime(LocalDateTime.now().toLocalDate().atStartOfDay().format(formatters));//日期
                    LocalDateTime localDateTime = LocalDateTime.now();
                    DateTime parse = DateUtil.parse(localDateTime.format(formatter));
                    auxiliaryOutputWorkingHours.setWeekDay(getWeek(localDateTime.format(formatters)));//星期
                    auxiliaryOutputWorkingHours.setWeek(String.valueOf(DateUtil.weekOfYear(DateUtil.offsetDay(parse, 1))));//周次
                    auxiliaryOutputWorkingHours.setCheck(userId);//检测人
                    auxiliaryOutputWorkingHoursMapper.insert(auxiliaryOutputWorkingHours);
                }
            }
        }
        return 1;
    }

    public static String getWeek(String dayStr) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date date = sdf.parse(dayStr);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            return getWeekDay(dayOfWeek);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String getWeekDay(int dayOfWeek) {
        switch (dayOfWeek) {
            case Calendar.MONDAY:
                return "周一";
            case Calendar.TUESDAY:
                return "周二";
            case Calendar.WEDNESDAY:
                return "周三";
            case Calendar.THURSDAY:
                return "周四";
            case Calendar.FRIDAY:
                return "周五";
            case Calendar.SATURDAY:
                return "周六";
            case Calendar.SUNDAY:
                return "周日";
            default:
                return "未知";
        }
    }
}