package com.ruoyi.inspect.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.date.DateTime;
|
import cn.hutool.core.date.DateUtil;
|
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.aspose.words.License;
|
import com.aspose.words.SaveFormat;
|
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.deepoove.poi.data.*;
|
import com.deepoove.poi.data.style.BorderStyle;
|
import com.deepoove.poi.data.style.Style;
|
import com.deepoove.poi.data.style.TableStyle;
|
import com.deepoove.poi.util.TableTools;
|
import com.deepoove.poi.util.UnitUtils;
|
import com.ruoyi.basic.mapper.IfsInventoryQuantityMapper;
|
import com.ruoyi.basic.pojo.IfsInventoryQuantity;
|
import com.ruoyi.basic.pojo.StandardTemplate;
|
import com.ruoyi.basic.service.StandardTemplateService;
|
import com.ruoyi.common.constant.DictDataConstants;
|
import com.ruoyi.common.constant.InsOrderTypeConstants;
|
import com.ruoyi.common.constant.MenuJumpPathConstants;
|
import com.ruoyi.common.core.domain.entity.Custom;
|
import com.ruoyi.common.core.domain.entity.InformationNotification;
|
import com.ruoyi.common.core.domain.entity.User;
|
import com.ruoyi.common.enums.OrderType;
|
import com.ruoyi.common.utils.*;
|
import com.ruoyi.framework.exception.ErrorException;
|
import com.ruoyi.inspect.dto.*;
|
import com.ruoyi.inspect.mapper.*;
|
import com.ruoyi.inspect.pojo.*;
|
import com.ruoyi.inspect.service.*;
|
import com.ruoyi.inspect.util.HackLoopTableRenderPolicy;
|
import com.ruoyi.inspect.util.PreserveReportPicturePlaceholderHandler;
|
import com.ruoyi.inspect.vo.InsOrderPlanTaskSwitchVo;
|
import com.ruoyi.inspect.vo.InsOrderPlanVO;
|
import com.ruoyi.inspect.vo.InsSampleUserVO;
|
import com.ruoyi.performance.mapper.AuxiliaryOutputWorkingHoursMapper;
|
import com.ruoyi.performance.pojo.AuxiliaryOutputWorkingHours;
|
import com.ruoyi.performance.service.AuxiliaryOutputWorkingHoursService;
|
import com.ruoyi.system.mapper.CustomMapper;
|
import com.ruoyi.system.mapper.UserMapper;
|
import com.ruoyi.system.service.ISysDictTypeService;
|
import com.ruoyi.system.service.InformationNotificationService;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.poi.xwpf.usermodel.*;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.core.io.ClassPathResource;
|
import org.springframework.mock.web.MockMultipartFile;
|
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.annotation.Resource;
|
import java.io.*;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.nio.file.Files;
|
import java.nio.file.Paths;
|
import java.text.DecimalFormat;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
import java.util.stream.Stream;
|
|
/**
|
* 检验任务-业务实现层
|
*/
|
@Service
|
public class InsOrderPlanServiceImpl extends ServiceImpl<InsOrderMapper, InsOrder> implements InsOrderPlanService {
|
|
private static final int DETECTION_REPORT = 0;
|
private static final int INSPECTION_REPORT = 1;
|
private static final String DIRECT_TEMPLATE_LABORATORY = "新聚";
|
|
@Resource
|
private InsSampleMapper insSampleMapper;
|
@Resource
|
private InsSampleUserMapper insSampleUserMapper;
|
@Resource
|
private InsOrderMapper insOrderMapper;
|
@Resource
|
private InsOrderService insOrderService;
|
@Resource
|
private StandardTemplateService standardTemplateService;
|
@Resource
|
private InsOrderStateMapper insOrderStateMapper;
|
@Resource
|
private InsProductMapper insProductMapper;
|
|
@Value("${wordUrl}")
|
private String wordUrl;
|
@Resource
|
private InsReportMapper insReportMapper;
|
@Resource
|
private InsProductResultMapper insProductResultMapper;
|
@Resource
|
private InsProductUserMapper insProductUserMapper;
|
@Resource
|
private AuxiliaryOutputWorkingHoursService auxiliaryOutputWorkingHoursService;
|
@Resource
|
private AuxiliaryOutputWorkingHoursMapper auxiliaryOutputWorkingHoursMapper;
|
@Resource
|
private InformationNotificationService informationNotificationService;
|
@Resource
|
private UserMapper userMapper;
|
@Resource
|
private CustomMapper customMapper;
|
@Value("${file.path}")
|
private String imgUrl;
|
@Resource
|
private InsOrderFileMapper insOrderFileMapper;
|
@Resource
|
private IfsInventoryQuantityMapper ifsInventoryQuantityMapper;
|
@Resource
|
private IfsPartPropsRecordMapper ifsPartPropsRecordMapper;
|
@Resource
|
private InsReportService insReportService;
|
@Resource
|
private InsUnqualifiedRetestProductMapper insUnqualifiedRetestProductMapper;
|
@Resource
|
private InsUnqualifiedRetestProductService insUnqualifiedRetestProductService;
|
@Resource
|
private InsUnqualifiedRetestResultMapper insUnqualifiedRetestResultMapper;
|
@Resource
|
private ThreadPoolTaskExecutor threadPoolTaskExecutor;
|
@Resource
|
private InsOrderFactoryVerifyMapper insOrderFactoryVerifyMapper;
|
@Resource
|
private InsOrderFactoryVerifyItemService insOrderFactoryVerifyItemService;
|
|
@Resource
|
private SpotCheckQuarterItemMapper spotCheckQuarterItemMapper;
|
@Resource
|
private InsOrderStandardTemplateService insOrderStandardTemplateService;
|
@Resource
|
private InsOrderDeviceRecordMapper insOrderDeviceRecordMapper;
|
@Resource
|
private InsOrderTemplateDeviceMapper insOrderTemplateDeviceMapper;
|
@Resource
|
private InsOrderDeviceRecordService insOrderDeviceRecordService;
|
@Resource
|
private ISysDictTypeService iSysDictTypeService;
|
@Resource
|
private InsOrderRatesService insOrderRatesService;
|
@Resource
|
private InsProductDeviationWarningService insProductDeviationWarningService;
|
@Resource
|
private InsProductDeviationWarningDetailService insProductDeviationWarningDetailService;
|
|
|
@Override
|
public IPage<InsOrderPlanVO> selectInsOrderPlanList(Page page, InsOrderPlanDTO insOrderPlanDTO) {
|
// todo: 仅看自己或者实验室
|
//获取当前人所属实验室id
|
String laboratory = null;
|
String userName = null;
|
Integer userId = null;
|
if (ObjectUtil.isNotEmpty(insOrderPlanDTO.getUserId())) {
|
userId = SecurityUtils.getUserId().intValue();
|
userName = userMapper.selectById(userId).getName();
|
insOrderPlanDTO.setUserId(null);
|
}
|
Integer isCheck = insOrderPlanDTO.getIsCheck();
|
insOrderPlanDTO.setIsCheck(null);
|
String sonLaboratory = insOrderPlanDTO.getSonLaboratory();//试验室
|
IPage<InsOrderPlanVO> insOrderPage = insSampleMapper.findInsSampleAndOrder(page,
|
QueryWrappers.queryWrappers(insOrderPlanDTO),
|
userName,
|
userId,
|
sonLaboratory,
|
laboratory,
|
isCheck);
|
return insOrderPage;
|
}
|
|
@Override
|
public IPage<InsOrderPlanTaskSwitchVo> inspectionOrderDetailsTaskSwitching(Page page, InsOrderPlanDTO insOrderPlanDTO) {
|
|
Integer userId = SecurityUtils.getUserId().intValue();
|
User user = userMapper.selectById(userId);//当前登录的人
|
// todo: 仅看自己或者实验室
|
//获取当前人所属实验室id
|
String departLimsId = user.getDepartLimsId();
|
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);
|
return insOrderPage;
|
}
|
|
//认领任务
|
@Override
|
public boolean claimInsOrderPlan(InsOrderPlanDTO entity) {
|
if (Objects.isNull(entity)) {
|
return false;
|
}
|
Integer userId = SecurityUtils.getUserId().intValue();
|
InsSampleUser insSampleUser = new InsSampleUser(entity.getInsSampleId().intValue(), userId, 0, entity.getSonLaboratory());
|
return insSampleUserMapper.insert(insSampleUser) > 0;
|
}
|
|
@Override
|
public Map<String, Object> doInsOrder(Integer id, String laboratory) {
|
ensureDirectTemplateOrderState(id);
|
InsOrder order = insOrderMapper.selectById(id);
|
Map<String, Object> map = insOrderService.getInsOrderAndSample(id, laboratory);
|
List<SampleProductDto> list = JSON.parseArray(JSON.toJSONString(map.get("sampleProduct")), SampleProductDto.class);
|
map.put("sampleProduct", list);
|
|
// 查询厂家密度
|
String supplierDensity = "";
|
if (CollectionUtils.isNotEmpty(list)) {
|
SampleProductDto sampleProductDto = list.get(0);
|
|
// 判断有没有绑定型号
|
String modelValue = insSampleMapper.selectSupplierDensityModel(sampleProductDto.getSample(),
|
order.getProduction(),
|
sampleProductDto.getModel());
|
if (StringUtils.isNotBlank(modelValue)) {
|
supplierDensity = modelValue;
|
} else {
|
supplierDensity = insSampleMapper.selectSupplierDensity(sampleProductDto.getSample(),
|
order.getProduction());
|
}
|
}
|
map.put("supplierDensity", supplierDensity);
|
return map;
|
}
|
|
@Override
|
public List<InsProduct> getInsProduct(InsOrderPlanProductDto dto) {
|
List<InsProduct> insProducts = new ArrayList<>();
|
switch (dto.getType()) {
|
case 0:
|
case 4:
|
//委托
|
insProducts = insSampleMapper.getInsProduct1(dto.getId(), dto.getLaboratory(), dto.getCableTag(), dto.getRepetitionTag());
|
break;
|
case 5:
|
//原材料下单
|
insProducts = insSampleMapper.getInsProduct6(dto.getId(), dto.getLaboratory(), dto.getRawMaterialTag());
|
break;
|
}
|
// 查询订单Id
|
InsOrder order = insOrderMapper.selectFirstSubmit(dto.getId());
|
if (order == null) {
|
return BeanUtil.isEmpty(insProducts) ? null : insProducts;
|
}
|
insProducts = mergeDirectTemplateSnapshots(order, dto.getId(), dto.getLaboratory(), insProducts);
|
if (BeanUtil.isEmpty(insProducts)) {
|
return null;
|
}
|
getTemplateThing(order, insProducts, dto.getLaboratory());
|
return insProducts;
|
}
|
|
/**
|
* 直绑模板订单的页签来源是订单模板快照，而不是已生成的检验项。
|
*
|
* 仍保留每个模板下已有的检验项记录；如果某个模板没有“检验项”标记，补一条仅用于
|
* 承载模板内容的返回对象，使前端也能展示、填写该模板。
|
*/
|
private List<InsProduct> mergeDirectTemplateSnapshots(InsOrder order, Integer sampleId,
|
String laboratory, List<InsProduct> products) {
|
List<InsProduct> source = products == null ? new ArrayList<>() : products;
|
List<InsOrderStandardTemplate> snapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, order.getId())
|
.orderByAsc(InsOrderStandardTemplate::getSort, InsOrderStandardTemplate::getId));
|
if (snapshots.isEmpty()) {
|
return source;
|
}
|
InsSample sample = insSampleMapper.selectById(sampleId);
|
boolean directTemplateOrder = source.stream()
|
.anyMatch(product -> product.getTemplateRowIndex() != null)
|
|| isDirectTemplateSample(order, sample);
|
if (!directTemplateOrder) {
|
return source;
|
}
|
|
Map<Integer, List<InsProduct>> productsByTemplate = source.stream()
|
.filter(product -> product.getTemplateId() != null)
|
.collect(Collectors.groupingBy(InsProduct::getTemplateId, LinkedHashMap::new, Collectors.toList()));
|
List<InsProduct> result = new ArrayList<>();
|
for (InsOrderStandardTemplate snapshot : snapshots) {
|
List<InsProduct> templateProducts = productsByTemplate.remove(snapshot.getTemplateId());
|
if (CollectionUtils.isNotEmpty(templateProducts)) {
|
templateProducts.forEach(product -> product.setTemplateSort(snapshot.getSort()));
|
result.addAll(templateProducts);
|
continue;
|
}
|
InsProduct templateCarrier = new InsProduct();
|
templateCarrier.setInsSampleId(sampleId);
|
templateCarrier.setTemplateId(snapshot.getTemplateId());
|
templateCarrier.setSonLaboratory(laboratory);
|
templateCarrier.setState(1);
|
templateCarrier.setSort(snapshot.getSort());
|
templateCarrier.setTemplateSort(snapshot.getSort());
|
result.add(templateCarrier);
|
}
|
// 兼容历史异常数据：订单快照以外的检验项仍然返回，但放在快照页签之后。
|
for (List<InsProduct> remaining : productsByTemplate.values()) {
|
result.addAll(remaining);
|
}
|
source.stream().filter(product -> product.getTemplateId() == null).forEach(result::add);
|
return result;
|
}
|
|
private boolean isDirectTemplateSample(InsOrder order, InsSample sample) {
|
return sample != null
|
&& Objects.equals(sample.getInsOrderId(), order.getId())
|
&& sample.getStandardMethodListId() == null
|
&& StringUtils.isBlank(sample.getFactory())
|
&& StringUtils.isBlank(sample.getSampleType())
|
&& StringUtils.isBlank(sample.getModel())
|
&& StringUtils.isBlank(order.getFactory())
|
&& StringUtils.isBlank(order.getSampleType());
|
}
|
|
@Override
|
public Map<String,Object> checkSubmitPlan(Integer orderId, String laboratory) {
|
Map<String, Object> map = new HashMap<>();
|
List<String> collect = new ArrayList<>();
|
if (isDirectTemplateOrder(orderId)) {
|
List<InsOrderStandardTemplate> snapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.orderByAsc(InsOrderStandardTemplate::getSort,
|
InsOrderStandardTemplate::getId));
|
for (InsOrderStandardTemplate snapshot : snapshots) {
|
String templateName = StringUtils.defaultIfBlank(snapshot.getName(),
|
"模板ID " + snapshot.getTemplateId());
|
if (snapshot.getDetectionTime() == null) {
|
collect.add("请选择“" + templateName + "”的检测时间");
|
}
|
if (StringUtils.isBlank(snapshot.getDetectionPlace())) {
|
collect.add("请填写“" + templateName + "”的检测地点");
|
}
|
}
|
map.put("errorMsg", collect);
|
map.put("missingExportItems", getMissingTemplateExportValues(orderId));
|
map.put("unInsOrderCount", 0L);
|
return map;
|
}
|
map.put("errorMsg", collect);
|
map.put("unInsOrderCount", 0L);
|
return map;
|
}
|
|
@Override
|
public IPage<InsOrderFile> getFileList(Page page, InsOrderFile insOrderFile) {
|
Integer insOrderId = insOrderFile.getInsOrderId();
|
insOrderFile.setInsOrderId(null);
|
IPage<InsOrderFile> insOrderFileIPage = insOrderFileMapper.getFileList(page, QueryWrappers.queryWrappers(insOrderFile), insOrderId);
|
return insOrderFileIPage;
|
}
|
|
@Override
|
public int uploadFile(Integer orderId, MultipartFile file) {
|
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 = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyMMddHHmmss")) + "_" + file.getOriginalFilename();
|
urlString = realpath + "/" + pathName;
|
file.transferTo(new File(urlString));
|
insOrderFile.setFileUrl(pathName);
|
return insOrderFileMapper.insert(insOrderFile);
|
} catch (Exception e) {
|
e.printStackTrace();
|
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
|
@Transactional(rollbackFor = Exception.class)
|
public void saveInsContext(SaveInsContextDto saveInsContextDto) {
|
Map<String, Object> insContext = JSON.parseObject(saveInsContextDto.getParam(), Map.class);
|
Integer userId = SecurityUtils.getUserId().intValue();
|
InsSample insSample = insSampleMapper.selectById(saveInsContextDto.getSampleId());
|
insContext.forEach((k, v) -> {
|
JSONObject jo = JSON.parseObject(JSON.toJSONString(v));
|
InsProduct insProduct = new InsProduct();
|
insProduct.setId(Integer.parseInt(k));
|
InsProduct product = insProductMapper.selectById(insProduct.getId());
|
if (saveInsContextDto.getCurrentTable().equals(product.getTemplateId()) && saveInsContextDto.getSampleId().equals(product.getInsSampleId())) {
|
List<InsProductResult> oldResults = insProductResultMapper.selectList(Wrappers.<InsProductResult>lambdaQuery()
|
.eq(InsProductResult::getInsProductId, insProduct.getId()));
|
InsProductResult newResult = new InsProductResult();
|
if (CollectionUtils.isNotEmpty(oldResults)) {
|
BeanUtil.copyProperties(oldResults.get(0), newResult);
|
}
|
newResult.setInsProductId(Integer.parseInt(k));
|
/*校验一下result表*/
|
if (oldResults.size() > 1) {
|
for (int i = 1; i < oldResults.size(); i++) {
|
insProductResultMapper.deleteById(oldResults.get(i));
|
}
|
}
|
//检验值
|
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) {
|
}
|
}
|
newResult.setInsValue(JSON.toJSONString(iv));
|
}
|
//计算值
|
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("r", JSON.toJSONString(comValue.get("r")));
|
map.put("c", JSON.toJSONString(comValue.get("c")));
|
map.put("v", JSON.parseObject(JSON.toJSONString(comValue.get("v"))).get("v"));
|
cv.add(map);
|
}
|
newResult.setComValue(JSON.toJSONString(cv));
|
}
|
//最终值
|
try {
|
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("");//''
|
}
|
//设备编号
|
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);
|
}
|
newResult.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);
|
}
|
newResult.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 (Objects.isNull(newResult.getId())) {
|
newResult.setCreateUser(userId);
|
newResult.setUpdateUser(userId);
|
insProductResultMapper.insert(newResult);
|
} else {
|
newResult.setUpdateUser(userId);
|
newResult.setUpdateTime(LocalDateTime.now());
|
insProductResultMapper.updateById(newResult);
|
}
|
|
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 (Objects.equals(l, l1)) {
|
insSample.setInsState(2);
|
}
|
insSampleMapper.updateById(insSample);
|
/*校验一下result表*/
|
List<InsProductResult> insProductResults = insProductResultMapper.selectList(Wrappers.<InsProductResult>lambdaQuery()
|
.eq(InsProductResult::getInsProductId, product.getId()));
|
if (insProductResults.size() > 1) {
|
for (int i = 1; i < insProductResults.size(); i++) {
|
insProductResultMapper.deleteById(insProductResults.get(i));
|
}
|
}
|
|
// 添加工时
|
// 判断是否只是参与计算值, 参与计算值实际没有填写
|
InsProduct finalInsProduct = insProductMapper.selectById(product.getId());
|
InsOrder insOrder = insOrderMapper.selectById(insSample.getInsOrderId());
|
if (StringUtils.isNotBlank(newResult.getInsValue()) && !newResult.getInsValue().equals("[]")) {
|
threadPoolTaskExecutor.execute(() -> {
|
this.addAuxiliary(userId, finalInsProduct, insOrder);
|
});
|
} else {
|
// 判断是否是没有检验值的内容
|
if (saveInsContextDto.getIsNoTestValue() != null && saveInsContextDto.getIsNoTestValue() == 1) {
|
threadPoolTaskExecutor.execute(() -> {
|
this.addAuxiliary(userId, finalInsProduct, insOrder);
|
});
|
}
|
}
|
|
}
|
});
|
String sampleIdStr = insContext.keySet().stream().findFirst().orElse(null);
|
if (sampleIdStr != null) {
|
int count = insProductMapper.selectInsProductCountByOrderId(saveInsContextDto.getOrderId());
|
if (count == 0) {
|
insOrderStateMapper.update(new InsOrderState(), Wrappers.<InsOrderState>lambdaUpdate()
|
.eq(InsOrderState::getInsOrderId, saveInsContextDto.getOrderId())
|
.eq(InsOrderState::getLaboratory, saveInsContextDto.getSonLaboratory())
|
.set(InsOrderState::getInsState, 2));
|
}
|
}
|
|
|
// 添加设备记录
|
threadPoolTaskExecutor.execute(() -> {
|
// 添加设备使用记录
|
addDeviceRecord(insSample, userId);
|
});
|
}
|
|
/**
|
* 新聚订单的外层 key 是 templateId，不是 ins_product.id；因此单独按模板快照保存。
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void saveTemplateContext(SaveTemplateContextDto dto) {
|
if (dto.getOrderId() == null || dto.getSampleId() == null || dto.getTemplateId() == null) {
|
throw new ErrorException("订单、样品和模板不能为空");
|
}
|
InsSample sample = insSampleMapper.selectById(dto.getSampleId());
|
if (sample == null || !Objects.equals(sample.getInsOrderId(), dto.getOrderId())) {
|
throw new ErrorException("样品不属于当前检验单");
|
}
|
InsOrderStandardTemplate snapshot = insOrderStandardTemplateService.getOne(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, dto.getOrderId())
|
.eq(InsOrderStandardTemplate::getTemplateId, dto.getTemplateId())
|
.last("limit 1"));
|
if (snapshot == null) {
|
throw new ErrorException("未找到当前订单的原始记录模板快照");
|
}
|
ensureDirectTemplateOrderState(dto.getOrderId());
|
List<InsProduct> products = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
|
.eq(InsProduct::getInsSampleId, dto.getSampleId())
|
.eq(InsProduct::getTemplateId, dto.getTemplateId())
|
.isNotNull(InsProduct::getTemplateRowIndex)
|
.eq(InsProduct::getState, 1));
|
|
JSONObject values = JSON.parseObject(JSON.toJSONString(dto.getValues() == null
|
? Collections.emptyMap() : dto.getValues()));
|
List<String> exportValueCoordinates = getExportValueCoordinates(snapshot.getThing()).values().stream()
|
.flatMap(Collection::stream)
|
.distinct()
|
.collect(Collectors.toList());
|
if (exportValueCoordinates.isEmpty()) {
|
throw new ErrorException("模板必须至少配置一个导出值批注");
|
}
|
|
// 导出值按模板配置，不再要求每个检验项区块分别配置。一个模板取第一个导出值作为结果。
|
String exportValueCoordinate = exportValueCoordinates.get(0);
|
JSONObject exportValueCell = values.getJSONObject(exportValueCoordinate);
|
String exportValue = exportValueCell == null || exportValueCell.get("v") == null
|
? "" : String.valueOf(exportValueCell.get("v"));
|
Integer userId = SecurityUtils.getUserId().intValue();
|
for (InsProduct product : products) {
|
InsProduct update = new InsProduct();
|
update.setId(product.getId());
|
update.setLastValue(exportValue);
|
update.setUpdateUser(userId);
|
insProductMapper.updateById(update);
|
insProductUserMapper.insert(new InsProductUser(null, userId, LocalDateTime.now(), product.getId()));
|
}
|
snapshot.setRecordValues(values.toJSONString());
|
insOrderStandardTemplateService.updateById(snapshot);
|
|
if (hasSavedTemplateValue(values)) {
|
markInspectionStarted(dto.getOrderId(), products);
|
}
|
|
Long unfinished = insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
|
.eq(InsProduct::getInsSampleId, dto.getSampleId())
|
.isNotNull(InsProduct::getTemplateRowIndex)
|
.eq(InsProduct::getState, 1)
|
.and(w -> w.isNull(InsProduct::getLastValue).or().eq(InsProduct::getLastValue, "")));
|
sample.setInsState(unfinished == 0 ? 2 : 1);
|
insSampleMapper.updateById(sample);
|
}
|
|
/**
|
* 第一次成功保存任意非空模板值时，记录真实检验开始时间并将任务从待检改为在检。
|
*/
|
private void markInspectionStarted(Integer orderId, List<InsProduct> products) {
|
LocalDateTime now = LocalDateTime.now();
|
insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
|
.eq(InsOrder::getId, orderId)
|
.isNull(InsOrder::getFirstInspectDate)
|
.set(InsOrder::getFirstInspectDate, now)
|
// 保留原字段供检验任务列表中的“检验开始时间”继续展示。
|
.set(InsOrder::getInsTime, now));
|
|
Set<String> laboratories = products.stream()
|
.map(InsProduct::getSonLaboratory)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toSet());
|
if (laboratories.isEmpty() && isDirectTemplateOrder(orderId)) {
|
laboratories.add(DIRECT_TEMPLATE_LABORATORY);
|
}
|
if (!laboratories.isEmpty()) {
|
insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
|
.eq(InsOrderState::getInsOrderId, orderId)
|
.in(InsOrderState::getLaboratory, laboratories)
|
.eq(InsOrderState::getInsState, 0)
|
.set(InsOrderState::getInsTime, now)
|
.set(InsOrderState::getInsState, 1));
|
}
|
}
|
|
private boolean hasSavedTemplateValue(JSONObject values) {
|
if (values == null || values.isEmpty()) {
|
return false;
|
}
|
for (Object rawCell : values.values()) {
|
JSONObject cell = rawCell instanceof JSONObject
|
? (JSONObject) rawCell
|
: JSON.parseObject(JSON.toJSONString(rawCell));
|
if (cell != null && hasMeaningfulValue(cell.get("v"))) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private boolean hasMeaningfulValue(Object value) {
|
if (value == null) {
|
return false;
|
}
|
if (value instanceof CharSequence) {
|
return StringUtils.isNotBlank(value.toString());
|
}
|
if (value instanceof Collection) {
|
return ((Collection<?>) value).stream().anyMatch(this::hasMeaningfulValue);
|
}
|
if (value instanceof Map) {
|
return ((Map<?, ?>) value).values().stream().anyMatch(this::hasMeaningfulValue);
|
}
|
return true;
|
}
|
|
private NavigableMap<Integer, List<String>> getExportValueCoordinates(String compressedThing) {
|
if (StrUtil.isBlank(compressedThing)) {
|
throw new ErrorException("原始记录模板为空");
|
}
|
String thing;
|
try {
|
thing = GZipUtil.uncompress(compressedThing);
|
} catch (Exception ignored) {
|
thing = compressedThing;
|
}
|
JSONArray cellData = JSON.parseObject(thing).getJSONArray("data").getJSONObject(0).getJSONArray("celldata");
|
NavigableMap<Integer, List<String>> result = new TreeMap<>();
|
Integer inspectionResultColumn = null;
|
for (Object item : cellData) {
|
JSONObject cell = JSON.parseObject(JSON.toJSONString(item));
|
Integer column = cell.getInteger("c");
|
JSONObject value = cell.getJSONObject("v");
|
String displayValue = value == null ? null : value.getString("v");
|
if (inspectionResultColumn == null && "检验结果".equals(StringUtils.trim(displayValue))) {
|
inspectionResultColumn = column;
|
}
|
}
|
for (Object item : cellData) {
|
JSONObject cell = JSON.parseObject(JSON.toJSONString(item));
|
JSONObject value = cell.getJSONObject("v");
|
JSONObject ps = value == null ? null : value.getJSONObject("ps");
|
if (ps == null || !"导出值".equals(ps.getString("value"))) {
|
continue;
|
}
|
Integer row = cell.getInteger("r");
|
Integer column = cell.getInteger("c");
|
if (row != null && column != null) {
|
// “导出值”标在检测项目标题单元格时，真正导出的值是同一行“检验结果”列的单元格。
|
String coordinate = row + "-" + column;
|
String resultCoordinate = row + "-" + inspectionResultColumn;
|
if (inspectionResultColumn != null && !Objects.equals(column, inspectionResultColumn)) {
|
coordinate = resultCoordinate;
|
}
|
result.computeIfAbsent(row, ignored -> new ArrayList<>()).add(coordinate);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* 直绑模板订单只校验模板中标记为“导出值”的单元格，不使用检验项状态或 last_value 判定。
|
*/
|
private List<String> getMissingTemplateExportValues(Integer orderId) {
|
List<InsOrderStandardTemplate> snapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.orderByAsc(InsOrderStandardTemplate::getSort, InsOrderStandardTemplate::getId));
|
List<String> missing = new ArrayList<>();
|
if (snapshots.isEmpty()) {
|
missing.add("当前订单未找到原始记录模板快照");
|
return missing;
|
}
|
for (InsOrderStandardTemplate snapshot : snapshots) {
|
Integer templateId = snapshot.getTemplateId();
|
List<String> coordinates = getExportValueCoordinates(snapshot.getThing()).values().stream()
|
.flatMap(Collection::stream)
|
.distinct()
|
.collect(Collectors.toList());
|
String templateName = StringUtils.defaultIfBlank(snapshot.getName(), "模板ID " + templateId);
|
if (coordinates.isEmpty()) {
|
missing.add(templateName + "（未配置导出值）");
|
continue;
|
}
|
|
JSONObject recordValues = StrUtil.isBlank(snapshot.getRecordValues())
|
? new JSONObject() : JSON.parseObject(snapshot.getRecordValues());
|
// 保存时同样只取模板中的第一个导出值，提交校验与保存口径保持一致。
|
String coordinate = coordinates.get(0);
|
JSONObject cell = recordValues.getJSONObject(coordinate);
|
Object value = cell == null ? null : cell.get("v");
|
if (value == null || StringUtils.isBlank(String.valueOf(value))) {
|
missing.add(templateName + "（" + coordinate + "）");
|
}
|
}
|
return missing;
|
}
|
|
@Override
|
public List<Integer> getOrderDeviceIds(Integer orderId) {
|
return insOrderDeviceRecordMapper.selectList(Wrappers.<InsOrderDeviceRecord>lambdaQuery()
|
.eq(InsOrderDeviceRecord::getInsOrderId, orderId))
|
.stream().map(InsOrderDeviceRecord::getDeviceId).filter(Objects::nonNull).distinct()
|
.collect(Collectors.toList());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void saveOrderDevices(SaveOrderDevicesDto dto) {
|
if (dto.getOrderId() == null || insOrderMapper.selectById(dto.getOrderId()) == null) {
|
throw new ErrorException("检验单不存在");
|
}
|
Set<Integer> deviceIds = dto.getDeviceIds() == null ? Collections.emptySet() : dto.getDeviceIds().stream()
|
.filter(Objects::nonNull).collect(Collectors.toSet());
|
List<InsOrderDeviceRecord> oldRecords = insOrderDeviceRecordMapper.selectList(
|
Wrappers.<InsOrderDeviceRecord>lambdaQuery().eq(InsOrderDeviceRecord::getInsOrderId, dto.getOrderId()));
|
Set<Integer> oldIds = oldRecords.stream().map(InsOrderDeviceRecord::getDeviceId).collect(Collectors.toSet());
|
if (!oldIds.isEmpty()) {
|
insOrderDeviceRecordMapper.delete(Wrappers.<InsOrderDeviceRecord>lambdaQuery()
|
.eq(InsOrderDeviceRecord::getInsOrderId, dto.getOrderId())
|
.notIn(!deviceIds.isEmpty(), InsOrderDeviceRecord::getDeviceId, deviceIds));
|
}
|
InsOrder order = insOrderMapper.selectById(dto.getOrderId());
|
User user = userMapper.selectById(SecurityUtils.getUserId().intValue());
|
List<InsOrderDeviceRecord> additions = deviceIds.stream().filter(id -> !oldIds.contains(id)).map(id -> {
|
InsOrderDeviceRecord record = new InsOrderDeviceRecord();
|
record.setInsOrderId(dto.getOrderId());
|
record.setDeviceId(id);
|
record.setSampleCode(order.getEntrustCode());
|
record.setUseBefore(1);
|
record.setUseAfter(1);
|
record.setUsePersonId(user.getId());
|
record.setUsePerson(user.getName());
|
return record;
|
}).collect(Collectors.toList());
|
if (!additions.isEmpty()) {
|
insOrderDeviceRecordService.saveBatch(additions);
|
}
|
}
|
|
private synchronized void addDeviceRecord(InsSample insSample, Integer userId) {
|
InsOrder order = insOrderMapper.selectById(insSample.getInsOrderId());
|
User user = userMapper.selectById(userId);
|
// 查询设备使用记录查询该订单的使用记录
|
List<InsOrderDeviceRecordDto> deviceRecordDtoList = insOrderDeviceRecordMapper.selectDeviceNumber(insSample.getInsOrderId());
|
Set<String> recordCodeset = deviceRecordDtoList.stream().map(InsOrderDeviceRecordDto::getManagementNumber).collect(Collectors.toSet());
|
|
// 获取订单设备编号
|
List<InsProductResult> resultList = insProductResultMapper.selectResultByOrderId(insSample.getInsOrderId());
|
Set<String> deviceCodeSet = new HashSet<>();
|
for (InsProductResult result : resultList) {
|
// 添加设备编号
|
List<JSONObject> jsonObjects = JSON.parseArray(result.getEquipValue(), JSONObject.class);
|
for (JSONObject jsonObject : jsonObjects) {
|
if (!"".equals(jsonObject.get("v") + "")) {
|
List<String> v = StrUtil.split(jsonObject.get("v") + "", "，");
|
deviceCodeSet.addAll(v);
|
}
|
}
|
}
|
// 1.判断是否有没有添加的使用记录
|
Set<String> orderDeviceNumbers = getDeviceDifference(deviceCodeSet, recordCodeset);
|
// 添加使用记录, 根据编号查询设备id
|
if (CollectionUtils.isNotEmpty(orderDeviceNumbers)) {
|
List<Integer> orderDeviceIds = insOrderDeviceRecordMapper.selectDeviceIdsByNumbers(orderDeviceNumbers);
|
List<InsOrderDeviceRecord> collect = orderDeviceIds.stream().map(deviceId -> {
|
InsOrderDeviceRecord insOrderDeviceRecord = new InsOrderDeviceRecord();
|
insOrderDeviceRecord.setInsOrderId(insSample.getInsOrderId());
|
insOrderDeviceRecord.setDeviceId(deviceId);
|
insOrderDeviceRecord.setSampleCode(order.getEntrustCode());
|
insOrderDeviceRecord.setUseBefore(1);
|
insOrderDeviceRecord.setUseAfter(1);
|
insOrderDeviceRecord.setUsePerson(user.getName());
|
insOrderDeviceRecord.setUsePersonId(user.getId());
|
return insOrderDeviceRecord;
|
}).collect(Collectors.toList());
|
|
insOrderDeviceRecordService.saveBatch(collect);
|
|
}
|
|
// 2.判断是否取消了设备使用
|
Set<String> repoprNumbers = getDeviceDifference(recordCodeset, deviceCodeSet);
|
if (CollectionUtils.isNotEmpty(repoprNumbers)) {
|
List<Integer> reportDeviceIds = insOrderDeviceRecordMapper.selectDeviceIdsByNumbers(repoprNumbers);
|
insOrderDeviceRecordMapper.delete(Wrappers.<InsOrderDeviceRecord>lambdaQuery()
|
.in(InsOrderDeviceRecord::getDeviceId, reportDeviceIds)
|
.eq(InsOrderDeviceRecord::getInsOrderId, insSample.getInsOrderId()));
|
}
|
}
|
|
private static Set<String> getDeviceDifference(Set<String> number1, Set<String> number2) {
|
return number1.stream().filter(s1 -> number2.stream().noneMatch(s2 -> s1.equals(s2)))
|
.collect(Collectors.toSet());
|
}
|
|
|
//交接
|
@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);
|
}
|
|
/**
|
* 查询模板内容
|
* @param order
|
* @param insProducts
|
*/
|
private void getTemplateThing(InsOrder order, List<InsProduct> insProducts, String laboratory) {
|
Set<Integer> set = new HashSet<>();
|
Map<Integer, String> recordValuesByTemplate = new HashMap<>();
|
for (InsOrderStandardTemplate snapshot : insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, order.getId()))) {
|
// record_values 在首次填写前允许为空；Collectors.toMap 不接受 null value。
|
if (snapshot.getTemplateId() != null && snapshot.getRecordValues() != null) {
|
recordValuesByTemplate.putIfAbsent(snapshot.getTemplateId(), snapshot.getRecordValues());
|
}
|
}
|
boolean directTemplateOrder = insProducts.stream()
|
.anyMatch(product -> product.getTemplateRowIndex() != null);
|
Long snapshotCount = insOrderStandardTemplateService.count(Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, order.getId()));
|
InsOrderState insOrderState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
|
.eq(InsOrderState::getInsOrderId, order.getId())
|
.eq(StringUtils.isNotBlank(laboratory), InsOrderState::getLaboratory, laboratory)
|
.last("limit 1"));
|
Integer insState = insOrderState == null ? null : insOrderState.getInsState();
|
boolean hasSnapshot = snapshotCount > 0 && (directTemplateOrder
|
|| Objects.equals(order.getIsFirstSubmit(), 1));
|
// 待检验、检验中使用基础配置的最新模板；已检验及后续状态使用订单快照。
|
boolean useSnapshot = hasSnapshot && insState != null && insState >= 2;
|
if (useSnapshot) {
|
for (InsProduct product : insProducts) {
|
if (product.getTemplateId() == null) {
|
product.setTemplate(new ArrayList<>());
|
continue;
|
}
|
if (set.add(product.getTemplateId())) {
|
InsOrderStandardTemplate one = insOrderStandardTemplateService.getOne(Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getTemplateId, product.getTemplateId())
|
.eq(InsOrderStandardTemplate::getInsOrderId, order.getId()));
|
if (one == null || StrUtil.isEmpty(one.getThing())) {
|
// 快照不完整时允许后面的最新模板查询兜底。
|
set.remove(product.getTemplateId());
|
continue;
|
}
|
String thing = GZipUtil.uncompress(one.getThing());
|
JSONObject sheet = JSON.parseObject(thing).getJSONArray("data").getJSONObject(0);
|
JSONObject config = sheet.getJSONObject("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(one.getName());
|
}
|
}
|
}
|
for (InsProduct product : insProducts) {
|
if (product.getTemplateId() == null) {
|
product.setTemplate(new ArrayList<>());
|
continue;
|
}
|
String thing = null;
|
if (product.getTemplateId() != null && set.add(product.getTemplateId())) {
|
thing = standardTemplateService.getStandTempThingById(product.getTemplateId());
|
}
|
if (StrUtil.isNotEmpty(thing)) {
|
JSONObject sheet = JSON.parseObject(thing).getJSONArray("data").getJSONObject(0);
|
JSONObject config = sheet.getJSONObject("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()));
|
}
|
product.setRecordValues(recordValuesByTemplate.get(product.getTemplateId()));
|
}
|
}
|
|
/**
|
* todo: 原始记录模板清除没有使用的检验项(暂时有bug无法使用)
|
* @param sheet
|
* @param itemNameList
|
*/
|
private static void eliminateItem(JSONObject sheet, List<String> itemNameList) {
|
// 获取到 检验项分类+检验项+检验子项的拼接,如果模板里的信息跟接口返回的检验项信息能够匹配则展示出来
|
|
// 循环行数判断是否
|
JSONArray dataListJSONArray = sheet.getJSONArray("data");
|
|
// 添加坐标map
|
Map<String, String> coordinatesMap = new HashMap<>();
|
|
// 需要移除的索引
|
List<Integer> deleteIndex = new ArrayList<>();
|
// 循环列
|
for (int r = 0; r < dataListJSONArray.size(); r++) {
|
JSONArray dataList = dataListJSONArray.getJSONArray(r);
|
// 循环行
|
String itemName = "";
|
// 判断是否显示
|
boolean isShow = false;
|
|
for (int c = 0; c < dataList.size(); c++) {
|
// 查询批注
|
JSONObject jsonObject = dataList.getJSONObject(c);
|
try {
|
if (jsonObject.getJSONObject("ps").getString("value").equals("检验项分类")) {
|
String value = jsonObject.getString("v").trim();
|
itemName += value;
|
// 添加坐标
|
String coordinates = coordinatesJoint(r, c);
|
coordinatesMap.put(coordinates, value);
|
isShow = true;
|
} else if (jsonObject.getJSONObject("ps").getString("value").equals("检验项")) {
|
String value = jsonObject.getString("v").trim();
|
itemName += value;
|
// 添加坐标
|
String coordinates = coordinatesJoint(r, c);
|
coordinatesMap.put(coordinates, value);
|
isShow = true;
|
} else if (jsonObject.getJSONObject("ps").getString("value").equals("检验子项")) {
|
String value = jsonObject.getString("v").trim();
|
itemName += value;
|
// 添加坐标
|
String coordinates = coordinatesJoint(r, c);
|
coordinatesMap.put(coordinates, value);
|
isShow = true;
|
}
|
} catch (Exception e) {
|
// 判断是否有mc合并单元格
|
if (jsonObject != null && jsonObject.getJSONObject("mc") != null) {
|
// 查询坐标进行添加
|
String value = coordinatesMap.get(coordinatesJoint(jsonObject.getJSONObject("mc").getInteger("r"), jsonObject.getJSONObject("mc").getInteger("c")));
|
if (StringUtils.isNotBlank(value) && !itemName.contains(value)) {
|
itemName += value;
|
}
|
}
|
}
|
}
|
// 判断该订单是否有改检验项, 没有剔除
|
if (isShow) {
|
if (!itemNameList.contains(itemName)) {
|
dataListJSONArray.remove(r);
|
r--;
|
}
|
}
|
}
|
}
|
|
|
/**
|
* 坐标拼接
|
* @param r 横坐标
|
* @param c 纵坐标
|
* @return
|
*/
|
private static String coordinatesJoint(int r, int c) {
|
String coordinates = "";
|
coordinates = "r:" + r + ",c:" + c;
|
return coordinates;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int submitPlan(Integer orderId, String laboratory, Integer verifyUser, String entrustCode, Boolean registerInsResults) {
|
ensureDirectTemplateOrderState(orderId);
|
int reportType = DETECTION_REPORT;
|
InsOrder order = insOrderMapper.selectOne(Wrappers.<InsOrder>lambdaQuery()
|
.eq(InsOrder::getId, orderId)
|
.last("FOR UPDATE"));
|
boolean isInspectionReport = Objects.equals(INSPECTION_REPORT, reportType);
|
registerInsResults = isInspectionReport && Boolean.TRUE.equals(registerInsResults);
|
// 1. 判断是否有重复编号, 有重复编号做提醒
|
Long codeCount = insOrderMapper.selectCount(Wrappers.<InsOrder>lambdaQuery()
|
.ne(InsOrder::getState, -1)
|
.ne(InsOrder::getIfsInventoryId, order.getIfsInventoryId())
|
.eq(InsOrder::getEntrustCode, order.getEntrustCode()));
|
if (codeCount > 0) {
|
throw new ErrorException("当前编号有重复, 请先去修改重复编号");
|
}
|
|
// 2. 判断该订单是否是第一次生产(后续报告生成只取第一次提交时间)
|
boolean firstSubmit = !Objects.equals(order.getIsFirstSubmit(), 1);
|
if (firstSubmit) {
|
insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
|
.eq(InsOrder::getId, orderId)
|
.set(InsOrder::getIsFirstSubmit, 1)
|
.set(InsOrder::getFirstSubmitDate, LocalDateTime.now()));
|
}
|
|
// 3. 直绑模板仅校验“导出值”；普通订单沿用原检验项校验。
|
List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, orderId).select(InsSample::getId));
|
List<Integer> InsSampleIds = insSamples.stream().map(InsSample::getId).collect(Collectors.toList());
|
boolean directTemplateOrder = isDirectTemplateOrder(orderId);
|
List<InsProduct> insProducts;
|
if (directTemplateOrder) {
|
List<String> missingExportValues = getMissingTemplateExportValues(orderId);
|
if (!missingExportValues.isEmpty()) {
|
throw new ErrorException("模板中的导出值不能为空：\n" + String.join("\n", missingExportValues));
|
}
|
insProducts = Collections.emptyList();
|
} else {
|
insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
|
.in(InsProduct::getInsSampleId, InsSampleIds)
|
.eq(InsProduct::getSonLaboratory, laboratory)
|
.eq(InsProduct::getState, 1)
|
.and(wrapper -> {
|
if (Objects.equals(reportType, DETECTION_REPORT)) {
|
wrapper.isNull(InsProduct::getLastValue).or().eq(InsProduct::getLastValue, "");
|
} else {
|
wrapper.isNull(InsProduct::getInsResult).or().eq(InsProduct::getInsResult, 2);
|
}
|
})
|
.ne(InsProduct::getIsBinding, 1));
|
}
|
if (!directTemplateOrder && Objects.equals(reportType, INSPECTION_REPORT)) {
|
List<InsProduct> insProducts1 = insProductMapper.selectFiberInsProduct(InsSampleIds, laboratory);
|
insProducts.addAll(insProducts1);
|
}
|
if (insProducts.size() > 0) {
|
String str = "";
|
int count = 0;
|
for (InsProduct product : insProducts) {
|
count++;
|
str += (count != 0 ? "\n" : "") + count + "：" +
|
product.getInspectionItemClass() + " " +
|
product.getInspectionItem() + " " +
|
product.getInspectionItemSubclass();
|
}
|
if (ObjectUtils.isNotEmpty(str)) {
|
throw new ErrorException("存在待检验的项目：" + str);
|
}
|
}
|
|
// 4.修改检测结果
|
insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate().eq(InsOrderState::getInsOrderId, orderId)
|
.eq(InsOrderState::getLaboratory, laboratory)
|
.set(InsOrderState::getInsTime, LocalDateTime.now())
|
.set(InsOrderState::getInsState, 3)
|
.set(InsOrderState::getVerifyUser, verifyUser));
|
|
|
// 5.发送消息通知给复核人
|
// 查询当前人信息
|
Integer userId = SecurityUtils.getUserId().intValue();
|
String userName = insProductMapper.selectUserById(userId).get("name");
|
// 查询发送人信息
|
String sendUserAccount = insProductMapper.selectUserById(verifyUser).get("account");
|
InformationNotification info = new InformationNotification();
|
info.setCreateUser(userName);
|
info.setMessageType("2");
|
info.setTheme("复核通知");
|
info.setContent("您有一条检验任务待复核消息, 编号:" + order.getEntrustCode());
|
info.setSenderId(userId);
|
info.setConsigneeId(verifyUser);
|
info.setViewStatus(false);
|
info.setJumpPath(MenuJumpPathConstants.INSPECTION_REVIEW);
|
informationNotificationService.addInformationNotification(info);
|
|
// 6.复核人--新增检验单相关负责人
|
InsSampleUser insSampleUser = new InsSampleUser();
|
insSampleUser.setUserId(verifyUser);
|
insSampleUser.setInsSampleId(orderId);
|
insSampleUser.setState(1);
|
insSampleUser.setSonLaboratory(laboratory);
|
insSampleUserMapper.insert(insSampleUser);
|
|
// 7.校验一下result表(避免出现多个检验项结果)
|
threadPoolTaskExecutor.execute(() -> {
|
List<Integer> ips = insProducts.stream().map(InsProduct::getId).distinct().collect(Collectors.toList());
|
for (Integer ip : ips) {
|
List<InsProductResult> insProductResults = insProductResultMapper.selectList(Wrappers.<InsProductResult>lambdaQuery()
|
.eq(InsProductResult::getInsProductId, ip));
|
if (insProductResults.size() > 1) {
|
for (int i = 1; i < insProductResults.size(); i++) {
|
insProductResultMapper.deleteById(insProductResults.get(i));
|
}
|
}
|
}
|
});
|
|
// 8.首次提交时将本次检验使用的最新模板冻结为订单快照。
|
Long snapshotCount = insOrderStandardTemplateService.count(Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId));
|
if (firstSubmit || snapshotCount == 0) {
|
this.templateCopy(orderId, InsSampleIds);
|
}
|
|
// 9. 检测报告仅在全部复核通过时生成，提交复核阶段不生成报告。
|
|
// 10.成品抽样添加合格状态
|
// 判断是否有抽样信息
|
if (isInspectionReport && order.getQuarterItemId() != null) {
|
// 判断是否有不合格
|
this.addProductSpotCheck(insSamples, order);
|
}
|
|
|
// 11.添加订单费用统计信息
|
List<InsProduct> productList = insProductMapper.selectProductByOrderId(orderId);
|
// 删除原本费用信息
|
insOrderRatesService.remove(Wrappers.<InsOrderRates>lambdaQuery()
|
.eq(InsOrderRates::getInsOrderId, orderId));
|
List<InsOrderRates> orderRatesList = productList.stream().map(insProduct -> {
|
InsOrderRates insOrderRates = new InsOrderRates();
|
insOrderRates.setInsOrderId(orderId);
|
insOrderRates.setInsSampleId(insProduct.getInsSampleId());
|
insOrderRates.setInsProductId(insProduct.getId());
|
insOrderRates.setSampleCode(insProduct.getSampleCode());
|
insOrderRates.setEntrustCode(order.getEntrustCode());
|
insOrderRates.setInspectionItemClass(insProduct.getInspectionItemClass());
|
insOrderRates.setInspectionItem(insProduct.getInspectionItem());
|
insOrderRates.setInspectionItemSubclass(insProduct.getInspectionItemSubclass());
|
insOrderRates.setCableTag(insProduct.getCableTag());
|
insOrderRates.setRates(insProduct.getRates());
|
insOrderRates.setManHourGroup(insProduct.getManHourGroup());
|
return insOrderRates;
|
}).collect(Collectors.toList());
|
insOrderRatesService.saveBatch(orderRatesList);
|
|
|
// 12.发送企业微信通知
|
// 查询原材料
|
IfsInventoryQuantity ifsInventoryQuantity = ifsInventoryQuantityMapper.selectById(order.getIfsInventoryId());
|
// 查询样品信息
|
InsSample insSample = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, orderId)
|
.last("limit 1"));
|
threadPoolTaskExecutor.execute(() -> {
|
String message = "";
|
message += "检验任务复核通知";
|
message += "\n提交人: " + userName;
|
message += "\n委托编号: " + order.getEntrustCode();
|
message += "\n样品名称: " + insSample.getModel();
|
message += "\n规格型号: " + order.getPartDetail();
|
if (ifsInventoryQuantity != null) {
|
message += "\n批次号: " + ifsInventoryQuantity.getUpdateBatchNo();
|
}
|
//发送企业微信消息通知 提交复核
|
try {
|
// WxCpUtils.inform(sendUserAccount, message, null);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
});
|
|
// 13.ifs移库(原材料需要进行移库操作) --> 最后执行,因为失败无法回滚
|
if (ifsInventoryQuantity != null && isInspectionReport) {
|
// 登记检验结果
|
// 判断是否有不合格, 有不合格不能移库
|
// todo: ifs移库
|
insReportService.isRawMaterial(order,registerInsResults,false);
|
|
// 14 判断当前样品是否为原材料, 原材料需要进行数据分析, 判断之前10条数据同一个供应商, 同一个检验项的偏差是否超过10%
|
// 查询ifs信息获取获取前10个供应商一样的, 检验项一样信息
|
threadPoolTaskExecutor.execute(() -> {
|
// 添加分析数据
|
addAnalysis(productList, ifsInventoryQuantity, order, sendUserAccount);
|
});
|
|
|
} else if (isInspectionReport && !directTemplateOrder) {
|
// 修改成品状态
|
// 判断是否有不合格
|
Long unqualifiedCount = insReportService.getUnqualifiedCount(order);
|
if (unqualifiedCount.equals(0L)) {
|
insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
|
.eq(InsOrder::getId, order.getId())
|
.set(InsOrder::getInsResult, 1));
|
} else {
|
insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
|
.eq(InsOrder::getId, order.getId())
|
.set(InsOrder::getInsResult, 0));
|
}
|
}
|
|
return 1;
|
}
|
|
/**
|
* *****添加分析数据******
|
* @param productList
|
* @param ifsInventoryQuantity
|
* @param order
|
*/
|
private void addAnalysis(List<InsProduct> productList, IfsInventoryQuantity ifsInventoryQuantity, InsOrder order, String sendUserAccount) {
|
for (InsProduct insProduct : productList) {
|
// 判断是否是数值类型
|
if ("1".equals(insProduct.getInspectionValueType()) && Objects.equals(insProduct.getInsResult(), 1)) {
|
List<InsProductDeviationWarningDetail> insProductAnalysisDtoList = insProductMapper.selectAnalysis(insProduct, ifsInventoryQuantity.getSupplierName());
|
|
if (CollectionUtils.isEmpty(insProductAnalysisDtoList)) {
|
continue;
|
}
|
|
// 判断当前检测项是否偏差超过10%
|
List<String> laseValueList = insProductAnalysisDtoList.stream().map(InsProductDeviationWarningDetail::getTestValue)
|
.collect(Collectors.toList());
|
|
double deviation = isDeviationOverTenPercent(laseValueList, insProduct.getLastValue());
|
// 判断要求值是否偏差超过10%
|
double asked = isDeviationOverTenPercentByAsked(insProduct.getAsk(), insProduct.getLastValue());
|
// 判断偏差是否大于10
|
if (deviation > 10 || asked > 10) {
|
// 判断之前是否添加过, 添加过不需要添加
|
long count = insProductDeviationWarningService.count(Wrappers.<InsProductDeviationWarning>lambdaQuery()
|
.eq(InsProductDeviationWarning::getInsProductId, insProduct.getId()));
|
if (count == 0L) {
|
// 发送通知, 并且添加数据
|
// 添加主表信息
|
InsProductDeviationWarning deviationWarning = new InsProductDeviationWarning();
|
deviationWarning.setInsOrderId(order.getId());
|
deviationWarning.setInsSampleId(insProduct.getInsSampleId());
|
deviationWarning.setInsProductId(insProduct.getId());
|
deviationWarning.setEntrustCode(order.getEntrustCode());
|
deviationWarning.setSampleCode(insProduct.getSampleCode());
|
deviationWarning.setSupplierName(ifsInventoryQuantity.getSupplierName());
|
deviationWarning.setDeviationValue(Double.toString(deviation));
|
deviationWarning.setDetectionTime(insProduct.getUpdateTime());
|
insProductDeviationWarningService.save(deviationWarning);
|
|
// 添加详情数据
|
InsProductDeviationWarningDetail deviationWarningDetail = new InsProductDeviationWarningDetail();
|
deviationWarningDetail.setInsOrderId(order.getId());
|
deviationWarningDetail.setInsSampleId(insProduct.getInsSampleId());
|
deviationWarningDetail.setInsProductId(insProduct.getId());
|
deviationWarningDetail.setEntrustCode(order.getEntrustCode());
|
deviationWarningDetail.setSampleCode(insProduct.getSampleCode());
|
deviationWarningDetail.setSupplierName(ifsInventoryQuantity.getSupplierName());
|
deviationWarningDetail.setTestValue(insProduct.getLastValue());
|
deviationWarningDetail.setDetectionTime(insProduct.getCreateTime());
|
deviationWarningDetail.setIsIssue(deviation > 10 ? 1 : 0);
|
deviationWarningDetail.setIsIssueAsked(asked > 10 ? 1 : 0);
|
|
insProductAnalysisDtoList.add(deviationWarningDetail);
|
|
// 添加id
|
for (InsProductDeviationWarningDetail warningDetail : insProductAnalysisDtoList) {
|
warningDetail.setDeviationWarningId(deviationWarning.getDeviationWarningId());
|
}
|
|
insProductDeviationWarningDetailService.saveBatch(insProductAnalysisDtoList);
|
|
//发送企业微信消息通知 检验项预警预警通知
|
try {
|
String message = "";
|
message += "检验项预警预警通知";
|
message += "\n委托编号: " + order.getEntrustCode();
|
message += "\n样品名称: " + order.getSample();
|
message += "\n规格型号: " + order.getPartDetail();
|
message += "\n批次号: " + ifsInventoryQuantity.getUpdateBatchNo();
|
message += "\n供应商名称: " + ifsInventoryQuantity.getSupplierName();
|
message += "\n检验项: " + insProduct.getInspectionItem() + insProduct.getInspectionItemSubclass();
|
message += "\n偏差超过了 10%";
|
// 发送给提交人
|
// WxCpUtils.inform(sendUserAccount, message, null);
|
//
|
// // todo: 发送给检测中心主任(固定死)
|
// WxCpUtils.inform("ZT-004704", message, null);
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("偏差预警企业微信通知报错");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* *****计算偏差****
|
* @param data
|
* @param targetStr
|
* @return
|
*/
|
public static double isDeviationOverTenPercent(List<String> data, String targetStr) {
|
if (data.isEmpty()) {
|
return 0;
|
}
|
List<Double> doubleData = data.stream()
|
.map(Double::parseDouble)
|
.collect(Collectors.toList());
|
double sum = doubleData.stream().mapToDouble(Double::doubleValue).sum();
|
double average = sum / doubleData.size();
|
|
double target = Double.parseDouble(targetStr);
|
double deviationPercent = Math.abs(target - average) / average * 100;
|
|
// 保留两位小数
|
DecimalFormat df = new DecimalFormat("#.00");
|
String formatted = df.format(deviationPercent);
|
return Double.parseDouble(formatted);
|
}
|
|
/**
|
* *****计算偏差（要求值）****
|
* @param asked
|
* @param targetStr
|
* @return
|
*/
|
public static double isDeviationOverTenPercentByAsked(String asked, String targetStr) {
|
if(!isNumeric(asked)) return 0;
|
double average = Double.parseDouble(asked);
|
double target = Double.parseDouble(targetStr);
|
double deviationPercent = Math.abs(target - average) / average * 100;
|
|
// 保留两位小数
|
DecimalFormat df = new DecimalFormat("#.00");
|
String formatted = df.format(deviationPercent);
|
return Double.parseDouble(formatted);
|
}
|
|
/**
|
* ******原始记录模板复制*****
|
* @param orderId
|
* @param ids
|
*/
|
private void templateCopy(Integer orderId, List<Integer> ids) {
|
// 保留模板页签顺序，并在首次提交复核时用检验期间采用的最新模板刷新快照。
|
// 直绑模板订单必须以原订单快照为模板清单，不能只按 ins_product 重建：
|
// 没有“检验项”标记的模板不会生成 ins_product，否则提交后会被错误删除。
|
List<InsOrderStandardTemplate> oldSnapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.orderByAsc(InsOrderStandardTemplate::getSort, InsOrderStandardTemplate::getId));
|
Map<Integer, Integer> templateSortMap = new HashMap<>();
|
Map<Integer, String> templateRecordValuesMap = new HashMap<>();
|
Map<Integer, String> templateTemperatureMap = new HashMap<>();
|
Map<Integer, String> templateHumidityMap = new HashMap<>();
|
Map<Integer, InsOrderStandardTemplate> oldSnapshotMap = new LinkedHashMap<>();
|
int nextTemplateSort = 0;
|
for (InsOrderStandardTemplate snapshot : oldSnapshots) {
|
if (snapshot.getTemplateId() != null) {
|
oldSnapshotMap.putIfAbsent(snapshot.getTemplateId(), snapshot);
|
if (snapshot.getSort() != null) {
|
templateSortMap.putIfAbsent(snapshot.getTemplateId(), snapshot.getSort());
|
nextTemplateSort = Math.max(nextTemplateSort, snapshot.getSort() + 1);
|
}
|
if (snapshot.getRecordValues() != null) {
|
templateRecordValuesMap.putIfAbsent(snapshot.getTemplateId(), snapshot.getRecordValues());
|
}
|
if (snapshot.getTemperature() != null) {
|
templateTemperatureMap.putIfAbsent(snapshot.getTemplateId(), snapshot.getTemperature());
|
}
|
if (snapshot.getHumidity() != null) {
|
templateHumidityMap.putIfAbsent(snapshot.getTemplateId(), snapshot.getHumidity());
|
}
|
}
|
}
|
|
LinkedHashSet<Integer> templateIds = new LinkedHashSet<>();
|
if (isDirectTemplateOrder(orderId)) {
|
// 先加入订单原来绑定的全部模板，包括不生成检验项记录的模板。
|
templateIds.addAll(oldSnapshotMap.keySet());
|
}
|
List<InsProduct> insProductList = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
|
.in(InsProduct::getInsSampleId, ids)
|
.select(InsProduct::getTemplateId));
|
insProductList.stream()
|
.map(InsProduct::getTemplateId)
|
.filter(Objects::nonNull)
|
.forEach(templateIds::add);
|
|
List<InsOrderStandardTemplate> refreshedSnapshots = new ArrayList<>();
|
for (Integer templateId : templateIds) {
|
StandardTemplate standardTemplate = standardTemplateService.getById(templateId);
|
InsOrderStandardTemplate oldSnapshot = oldSnapshotMap.get(templateId);
|
if (standardTemplate == null && oldSnapshot == null) {
|
continue;
|
}
|
InsOrderStandardTemplate refreshed = new InsOrderStandardTemplate();
|
refreshed.setInsOrderId(orderId);
|
refreshed.setTemplateId(templateId);
|
refreshed.setNumber(standardTemplate == null ? oldSnapshot.getNumber() : standardTemplate.getNumber());
|
refreshed.setName(standardTemplate == null ? oldSnapshot.getName() : standardTemplate.getName());
|
refreshed.setRemark(standardTemplate == null ? oldSnapshot.getRemark() : standardTemplate.getRemark());
|
refreshed.setThing(standardTemplate == null ? oldSnapshot.getThing() : standardTemplate.getThing());
|
refreshed.setRecordValues(templateRecordValuesMap.get(templateId));
|
refreshed.setTemperature(templateTemperatureMap.get(templateId));
|
refreshed.setHumidity(templateHumidityMap.get(templateId));
|
Integer templateSort = templateSortMap.get(templateId);
|
refreshed.setSort(templateSort == null ? nextTemplateSort++ : templateSort);
|
refreshedSnapshots.add(refreshed);
|
}
|
|
// 新快照已完整组装后再替换；事务失败时会整体回滚。
|
insOrderStandardTemplateService.remove(Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId));
|
if (!refreshedSnapshots.isEmpty()) {
|
insOrderStandardTemplateService.saveBatch(refreshedSnapshots);
|
}
|
}
|
|
|
/**
|
* 检验任务复核
|
* @param orderId
|
* @param laboratory
|
* @param type
|
* @param tell
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int rawMaterialVerifyPlan(Integer orderId, String laboratory, Integer type, String tell, Integer userId) {
|
VerifyPlanDto dto = new VerifyPlanDto();
|
dto.setOrderId(orderId);
|
dto.setLaboratory(laboratory);
|
dto.setType(type);
|
dto.setTell(tell);
|
dto.setUserId(userId);
|
return rawMaterialVerifyPlan(dto);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int rawMaterialVerifyPlan(VerifyPlanDto dto) {
|
Integer orderId = dto.getOrderId();
|
String laboratory = dto.getLaboratory();
|
Integer type = dto.getType();
|
String tell = dto.getTell();
|
Integer userId = dto.getUserId();
|
if (orderId == null || laboratory == null || type == null) {
|
throw new ErrorException("复核参数不完整");
|
}
|
ensureDirectTemplateOrderState(orderId);
|
InsOrderState currentState = insOrderStateMapper.selectOne(Wrappers.<InsOrderState>lambdaQuery()
|
.eq(InsOrderState::getInsOrderId, orderId)
|
.eq(InsOrderState::getLaboratory, laboratory)
|
.last("limit 1"));
|
InsReport existingReport = insReportMapper.selectOne(Wrappers.<InsReport>lambdaQuery()
|
.eq(InsReport::getInsOrderId, orderId)
|
.last("limit 1"));
|
if (currentState != null && Objects.equals(currentState.getInsState(), 5)
|
&& existingReport != null && StringUtils.isNotBlank(existingReport.getUrl())) {
|
// 防止复核页面重复点击或网络重试重复生成报告、重复发起报告审批。
|
return 1;
|
}
|
boolean directTemplateOrder = isDirectTemplateOrder(orderId);
|
if (directTemplateOrder && Objects.equals(type, 1)
|
&& !Objects.equals(dto.getInsResult(), 0) && !Objects.equals(dto.getInsResult(), 1)) {
|
throw new ErrorException("请选择检验单结论");
|
}
|
Integer num = (type == 1 ? 5 : 4);
|
LocalDateTime now = LocalDateTime.now();
|
insOrderStateMapper.update(null, Wrappers.<InsOrderState>lambdaUpdate()
|
.eq(InsOrderState::getInsOrderId, orderId)
|
.eq(InsOrderState::getLaboratory, laboratory)
|
.set(InsOrderState::getInsTime, now)
|
.set(InsOrderState::getInsState, num)
|
.set(InsOrderState::getVerifyTell, tell)
|
.set(InsOrderState::getVerifyUser, SecurityUtils.getUserId().intValue()));
|
Long count = insOrderStateMapper.selectCount(Wrappers.<InsOrderState>lambdaQuery()
|
.eq(InsOrderState::getInsOrderId, orderId)
|
.ne(InsOrderState::getInsState, 5));
|
InsReport report = insReportMapper.selectOne(Wrappers.<InsReport>lambdaQuery()
|
.eq(InsReport::getInsOrderId, orderId)
|
.last("limit 1"));
|
Integer writeUserId = report != null && report.getWriteUserId() != null
|
? report.getWriteUserId() : resolveInspectionUserId(orderId, laboratory);
|
// 查询订单
|
InsOrder order = insOrderMapper.selectById(orderId);
|
if (directTemplateOrder && Objects.equals(type, 1)) {
|
List<Integer> templateResults = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.select(InsOrderStandardTemplate::getInsResult))
|
.stream().map(InsOrderStandardTemplate::getInsResult)
|
.collect(Collectors.toList());
|
if (templateResults.isEmpty()
|
|| templateResults.stream().anyMatch(result -> !Objects.equals(result, 0)
|
&& !Objects.equals(result, 1))) {
|
throw new ErrorException("请先填写全部模板的检验结论");
|
}
|
Integer aggregateResult = templateResults.stream().allMatch(result -> Objects.equals(result, 1))
|
? 1 : 0;
|
insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
|
.eq(InsOrder::getId, orderId)
|
.set(InsOrder::getInsResult, aggregateResult));
|
order.setInsResult(aggregateResult);
|
}
|
if (count == 0 && num == 5) {
|
// 修改订单状态
|
insOrderMapper.update(null, Wrappers.<InsOrder>lambdaUpdate()
|
.eq(InsOrder::getId, orderId)
|
.set(InsOrder::getInsState, 5));
|
|
// 检验人员提交复核时不再生成报告；仅在全部试验室复核通过后生成检测报告。
|
if (report == null || StringUtils.isBlank(report.getUrl())) {
|
this.generateReport(orderId, DETECTION_REPORT, writeUserId);
|
report = insReportMapper.selectOne(Wrappers.<InsReport>lambdaQuery()
|
.eq(InsReport::getInsOrderId, orderId)
|
.last("limit 1"));
|
}
|
if (report == null || StringUtils.isBlank(report.getUrl())) {
|
throw new ErrorException("检测报告生成失败");
|
}
|
if (report.getTempUrlPdf() == null) {
|
String tempUrlPdf = this.wordToPdfTemp(report.getUrl().replace("/word", wordUrl));
|
report.setTempUrlPdf("/word/" + tempUrlPdf);
|
}
|
report.setIsPass(1);
|
insReportMapper.updateById(report);
|
|
//生成原材料进货验证原始记录到附件里
|
if (order.getTypeSource() != null && order.getTypeSource().equals(1)) {
|
this.reportFactoryVerify(orderId, userId, writeUserId);
|
}
|
|
// 查询检验任务的检验任务
|
// 报告盖上批准人
|
insReportService.writeReport(report.getId(), userId, writeUserId);
|
|
// 检验人
|
String userName = insProductMapper.selectUserById(writeUserId).get("name");
|
|
// 复核人
|
Integer checkUserId = SecurityUtils.getUserId().intValue();
|
String chenkUserName = insProductMapper.selectUserById(checkUserId).get("name");
|
|
// 审核人
|
String sendUserAccount = insProductMapper.selectUserById(userId).get("account");
|
|
// 发送企业微信通知(通知审核人审批)
|
threadPoolTaskExecutor.execute(() -> {
|
|
InsSample insSample = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, orderId)
|
.last("limit 1"));
|
// 查询原材料
|
IfsInventoryQuantity ifsInventoryQuantity = ifsInventoryQuantityMapper.selectById(order.getIfsInventoryId());
|
|
String message = "";
|
message += "报告编制审批通知";
|
message += "\n检验人: " + userName;
|
message += "\n复核人: " + chenkUserName;
|
message += "\n委托编号: " + order.getEntrustCode();
|
message += "\n样品名称: " + insSample.getModel();
|
message += "\n规格型号: " + order.getPartDetail();
|
if (ifsInventoryQuantity != null) {
|
message += "\n生产厂家: " + ifsInventoryQuantity.getSupplierName();
|
message += "\n批次号: " + ifsInventoryQuantity.getUpdateBatchNo();
|
}
|
//发送企业微信消息通知 提交复核
|
try {
|
WxCpUtils.inform(sendUserAccount, message, null);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
});
|
|
|
} else {
|
//复核不通过将把复核的负责人去掉
|
Integer id = insSampleUserMapper.selectOne(Wrappers.<InsSampleUser>lambdaQuery().eq(InsSampleUser::getInsSampleId, orderId).orderByDesc(InsSampleUser::getId).last("limit 1")).getId();
|
insSampleUserMapper.deleteById(id);
|
|
// 当前审核人
|
Integer currentUserId = SecurityUtils.getUserId().intValue();
|
String userName = insProductMapper.selectUserById(currentUserId).get("name");
|
|
// 发送消息的人
|
// 查询发送人信息
|
String sendUserAccount = insProductMapper.selectUserById(writeUserId).get("account");
|
|
// 发送企业微信通知(检验任务退回)
|
threadPoolTaskExecutor.execute(() -> {
|
// 查询订单
|
InsSample insSample = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, orderId)
|
.last("limit 1"));
|
// 查询原材料
|
IfsInventoryQuantity ifsInventoryQuantity = ifsInventoryQuantityMapper.selectById(order.getIfsInventoryId());
|
|
String message = "";
|
message += "检验任务复核退回通知";
|
message += "\n复核人: " + userName;
|
message += "\n委托编号: " + order.getEntrustCode();
|
message += "\n样品名称: " + insSample.getModel();
|
message += "\n规格型号: " + order.getPartDetail();
|
if (ifsInventoryQuantity != null) {
|
message += "\n批次号: " + ifsInventoryQuantity.getUpdateBatchNo();
|
}
|
message += "\n退回原因: " + tell;
|
//发送企业微信消息通知 提交复核
|
try {
|
WxCpUtils.inform(sendUserAccount, message, null);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
});
|
}
|
return 1;
|
}
|
|
private boolean isDirectTemplateOrder(Integer orderId) {
|
List<InsSample> samples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, orderId));
|
if (samples.isEmpty()) {
|
return false;
|
}
|
Long snapshotCount = insOrderStandardTemplateService.count(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId));
|
InsOrder order = snapshotCount == 0 ? null : insOrderMapper.selectById(orderId);
|
if (order != null && samples.stream().anyMatch(sample -> isDirectTemplateSample(order, sample))) {
|
return true;
|
}
|
// 兼容已经生成了模板行号、但订单基础字段不完整的历史直绑订单。
|
return insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
|
.in(InsProduct::getInsSampleId, samples.stream().map(InsSample::getId).collect(Collectors.toList()))
|
.isNotNull(InsProduct::getTemplateRowIndex)) > 0;
|
}
|
|
/**
|
* 兼容修复上线前已经下发、但因没有 ins_product 而缺少任务状态的直绑模板订单。
|
*/
|
private void ensureDirectTemplateOrderState(Integer orderId) {
|
if (!isDirectTemplateOrder(orderId)) {
|
return;
|
}
|
Long stateCount = insOrderStateMapper.selectCount(Wrappers.<InsOrderState>lambdaQuery()
|
.eq(InsOrderState::getInsOrderId, orderId)
|
.eq(InsOrderState::getLaboratory, DIRECT_TEMPLATE_LABORATORY));
|
if (stateCount > 0) {
|
return;
|
}
|
InsOrderState state = new InsOrderState();
|
state.setInsOrderId(orderId);
|
state.setLaboratory(DIRECT_TEMPLATE_LABORATORY);
|
state.setInsState(0);
|
insOrderStateMapper.insert(state);
|
}
|
|
private Integer resolveInspectionUserId(Integer orderId, String laboratory) {
|
InsSampleUser inspector = insSampleUserMapper.selectOne(Wrappers.<InsSampleUser>lambdaQuery()
|
.eq(InsSampleUser::getInsSampleId, orderId)
|
.eq(InsSampleUser::getState, 0)
|
.eq(StringUtils.isNotBlank(laboratory), InsSampleUser::getSonLaboratory, laboratory)
|
.orderByDesc(InsSampleUser::getId)
|
.last("limit 1"));
|
if (inspector == null || inspector.getUserId() == null) {
|
throw new ErrorException("找不到当前检验任务的检验人，无法生成检测报告");
|
}
|
return inspector.getUserId();
|
}
|
|
/**
|
* 生成报告
|
* @param orderId
|
*/
|
private void generateReport(Integer orderId, Integer reportType, Integer writeUserId) {
|
/*样品下的项目只要有一个项目不合格则检验结果为0,否则为1*/
|
//这里的insSamples是订单下的所有样品包括("/")
|
List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery().eq(InsSample::getInsOrderId, orderId));
|
if (Objects.equals(reportType, INSPECTION_REPORT)) {
|
for (InsSample insSample : insSamples) {
|
List<InsProduct> insProducts = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
|
.eq(InsProduct::getInsSampleId, insSample.getId())
|
.eq(InsProduct::getState, 1)
|
.ne(InsProduct::getIsBinding, 1));
|
List<Integer> results = insProducts.stream().map(InsProduct::getInsResult).filter(Objects::nonNull).collect(Collectors.toList());
|
if (results.contains(0)) {
|
insSample.setInsResult(0);
|
} else {
|
insSample.setInsResult(1);
|
}
|
insSampleMapper.updateById(insSample);
|
}
|
}
|
InsOrder insOrder = insOrderMapper.selectById(orderId);
|
// 抽检变成委托检验
|
if (insOrder.getOrderType().equals(InsOrderTypeConstants.SPOT_CHECK)) {
|
insOrder.setOrderType(InsOrderTypeConstants.CUSTOMER_ORDERED);
|
}
|
|
// 判断是大报告还是小报告 进厂小报告, 其他都是大报告
|
if (insOrder.getOrderType().equals(InsOrderTypeConstants.ENTER_THE_FACTORY)) {
|
// 生成小报告
|
addSmallReport(orderId, insOrder, insSamples, reportType, writeUserId);
|
} else {
|
//生成大报告
|
addBitReport(orderId, insOrder, reportType, writeUserId);
|
}
|
|
}
|
|
|
/**
|
* 电缆配置, 查看配置标识
|
* @param id
|
* @param laboratory
|
* @return
|
*/
|
@Override
|
public List<Map<String, Object>> getCableTag(Integer id, String laboratory) {
|
return insSampleMapper.getCableTag(id, laboratory);
|
}
|
|
/**
|
* 原材料查看标识
|
* @param id
|
* @param laboratory
|
* @return
|
*/
|
@Override
|
public List<Map<String, Object>> getRawMaterialTag(Integer id, String laboratory) {
|
return insSampleMapper.getRawMaterialTag(id, laboratory);
|
}
|
|
/**
|
* 查看重复标识
|
* @param id
|
* @param laboratory
|
* @return
|
*/
|
@Override
|
public List<Map<String, Object>> getRepetitionTag(Integer id, String laboratory, String cableTag) {
|
return insSampleMapper.getRepetitionTag(id, laboratory, cableTag);
|
}
|
|
/**
|
* 新增不合格复测内容
|
* @return
|
*/
|
@Override
|
public boolean addDisqualificationRetest(List<InsProduct> insProductsList) {
|
List<Integer> ids = insProductsList.stream().map(InsProduct::getId).collect(Collectors.toList());
|
|
// 判断之前是否添加过
|
Long count = insUnqualifiedRetestProductMapper.selectCount(Wrappers.<InsUnqualifiedRetestProduct>lambdaQuery()
|
.in(InsUnqualifiedRetestProduct::getInsProductId, ids));
|
if (count > 0) {
|
throw new ErrorException("有检验项检添加过复测信息");
|
}
|
|
// 查询不合格内容
|
List<InsUnqualifiedRetestProduct> list = insUnqualifiedRetestProductMapper.selectRetestProduct(ids);
|
// 循环判断是否是绑定值, 绑定值修改检验要求
|
for (InsUnqualifiedRetestProduct insUnqualifiedRetestProduct : list) {
|
for (InsProduct insProduct : insProductsList) {
|
if (insProduct.getIsBinding().equals(1)) {
|
insUnqualifiedRetestProduct.setIsBinding(1);
|
insUnqualifiedRetestProduct.setAsk(null);
|
insUnqualifiedRetestProduct.setTell(null);
|
insUnqualifiedRetestProduct.setPrice(null);
|
insUnqualifiedRetestProduct.setManHour(null);
|
insUnqualifiedRetestProduct.setSection(null);
|
}
|
}
|
}
|
|
// 新增不合格内容
|
insUnqualifiedRetestProductService.saveBatch(list);
|
list.forEach(insUnqualifiedRetestProduct -> {
|
insUnqualifiedRetestProduct.setRetestTag("2");
|
insUnqualifiedRetestProduct.setId(null);
|
});
|
insUnqualifiedRetestProductService.saveBatch(list);
|
return true;
|
}
|
|
@Override
|
public List<InsProduct> getInsProductUnqualifiedRetest(InsOrderPlanProductDto dto) {
|
|
List<InsProduct> insProducts = new ArrayList<>();
|
switch (dto.getType()) {
|
case 0:
|
case 4:
|
//委托
|
insProducts = insUnqualifiedRetestProductMapper.getInsProductUnqualifiedRetest1(dto.getId(), dto.getLaboratory(), dto.getCableTag(), dto.getRepetitionTag(), dto.getRetestTag());
|
break;
|
case 5:
|
//原材料下单
|
insProducts = insUnqualifiedRetestProductMapper.getInsProductUnqualifiedRetest6(dto.getId(), dto.getLaboratory(), dto.getRawMaterialTag(), dto.getRetestTag());
|
break;
|
}
|
if (BeanUtil.isEmpty(insProducts)) {
|
return null;
|
}
|
InsOrder order = insOrderMapper.selectFirstSubmit(dto.getId());
|
getTemplateThing(order, Collections.unmodifiableList(insProducts), dto.getLaboratory());
|
return insProducts;
|
}
|
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void saveUnqualifiedContext(Map<String, Object> insContext, Integer currentTable, Integer currentSampleId, Integer orderId, String sonLaboratory) {
|
Integer userId = SecurityUtils.getUserId().intValue();
|
insContext.forEach((k, v) -> {
|
JSONObject jo = JSON.parseObject(JSON.toJSONString(v));
|
InsUnqualifiedRetestProduct insProduct = new InsUnqualifiedRetestProduct();
|
insProduct.setId(Integer.parseInt(k));
|
InsUnqualifiedRetestProduct product = insUnqualifiedRetestProductMapper.selectById(insProduct.getId());
|
if (currentTable.equals(product.getTemplateId()) && currentSampleId.equals(product.getInsSampleId())) {
|
List<InsUnqualifiedRetestResult> oldResults = insUnqualifiedRetestResultMapper.selectList(Wrappers.<InsUnqualifiedRetestResult>lambdaQuery()
|
.eq(InsUnqualifiedRetestResult::getRetestProductId, insProduct.getId()));
|
InsUnqualifiedRetestResult newResult = new InsUnqualifiedRetestResult();
|
if (CollectionUtils.isNotEmpty(oldResults)) {
|
BeanUtil.copyProperties(oldResults.get(0), newResult);
|
}
|
newResult.setRetestProductId(Integer.parseInt(k));
|
/*校验一下result表*/
|
if (oldResults.size() > 1) {
|
for (int i = 1; i < oldResults.size(); i++) {
|
insUnqualifiedRetestResultMapper.deleteById(oldResults.get(i));
|
}
|
}
|
//检验值
|
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) {
|
}
|
}
|
newResult.setInsValue(JSON.toJSONString(iv));
|
}
|
//计算值
|
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("r", JSON.toJSONString(comValue.get("r")));
|
map.put("c", JSON.toJSONString(comValue.get("c")));
|
map.put("v", JSON.parseObject(JSON.toJSONString(comValue.get("v"))).get("v"));
|
cv.add(map);
|
}
|
newResult.setComValue(JSON.toJSONString(cv));
|
}
|
//最终值
|
try {
|
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("");//''
|
}
|
//设备编号
|
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);
|
}
|
newResult.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);
|
}
|
newResult.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 (Objects.isNull(newResult.getId())) {
|
newResult.setCreateUser(userId);
|
newResult.setUpdateUser(userId);
|
insUnqualifiedRetestResultMapper.insert(newResult);
|
} else {
|
newResult.setUpdateUser(userId);
|
newResult.setUpdateTime(LocalDateTime.now());
|
insUnqualifiedRetestResultMapper.updateById(newResult);
|
}
|
|
insProduct.setUpdateUser(userId);
|
insUnqualifiedRetestProductMapper.updateById(insProduct);
|
insProductUserMapper.insert(new InsProductUser(null, userId, LocalDateTime.now(), insProduct.getId()));
|
|
|
/*校验一下result表*/
|
List<InsUnqualifiedRetestResult> insProductResults = insUnqualifiedRetestResultMapper.selectList(Wrappers.<InsUnqualifiedRetestResult>lambdaQuery()
|
.eq(InsUnqualifiedRetestResult::getRetestProductId, product.getId()));
|
if (insProductResults.size() > 1) {
|
for (int i = 1; i < insProductResults.size(); i++) {
|
insUnqualifiedRetestResultMapper.deleteById(insProductResults.get(i));
|
}
|
}
|
|
}
|
});
|
|
}
|
|
/**
|
* 查询进货原始记录
|
* @param insOrderId
|
* @return
|
*/
|
@Override
|
public InsOrderFactoryVerify getFactoryVerify(Integer insOrderId) {
|
InsOrderFactoryVerify insOrderFactoryVerify = insOrderFactoryVerifyMapper.selectOne(Wrappers.<InsOrderFactoryVerify>lambdaQuery()
|
.eq(InsOrderFactoryVerify::getInsOrderId, insOrderId)
|
.last("limit 1"));
|
// 判断查询查询是否为空
|
if (insOrderFactoryVerify == null) {
|
insOrderFactoryVerify = new InsOrderFactoryVerify();
|
// 查询下单
|
InsOrder order = insOrderMapper.selectById(insOrderId);
|
// 查询检验项目表
|
List<InsSample> insSamples = insSampleMapper.selectList(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, insOrderId));
|
|
//查询规格信号
|
List<String> insSamplemodel = insSamples.stream().map(insSample -> insSample.getModel()).collect(Collectors.toList());
|
String model = CollUtil.join(insSamplemodel, ",");
|
|
// 查询原材料信息
|
IfsInventoryQuantity ifsInventoryQuantity = ifsInventoryQuantityMapper.selectById(order.getIfsInventoryId());
|
if (ifsInventoryQuantity == null) {
|
throw new ErrorException("缺少原材料信息");
|
}
|
|
// 检验编号
|
insOrderFactoryVerify.setEntrustCode(order.getEntrustCode());
|
// 材料厂家
|
insOrderFactoryVerify.setSupplierName(ifsInventoryQuantity.getSupplierName());
|
// 到货日期
|
insOrderFactoryVerify.setDeclareDate(ifsInventoryQuantity.getDeclareDate());
|
// 材料名称
|
insOrderFactoryVerify.setSample(order.getSample());
|
// 规格型号
|
insOrderFactoryVerify.setModel(model);
|
// 材料批号
|
insOrderFactoryVerify.setUpdateBatchNo(ifsInventoryQuantity.getUpdateBatchNo());
|
|
insOrderFactoryVerify.setInsOrderId(insOrderId);
|
|
return insOrderFactoryVerify;
|
}
|
|
// 查询验证项目
|
List<InsOrderFactoryVerifyItem> verifyItems = insOrderFactoryVerifyItemService.list(Wrappers.<InsOrderFactoryVerifyItem>lambdaQuery()
|
.eq(InsOrderFactoryVerifyItem::getFactoryVerifyId, insOrderFactoryVerify.getFactoryVerifyId())
|
.orderByAsc(InsOrderFactoryVerifyItem::getSort));
|
insOrderFactoryVerify.setFactoryVerifyItemList(verifyItems);
|
return insOrderFactoryVerify;
|
}
|
|
/**
|
* 保存原材料进货验证
|
* @param factoryVerify
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public boolean addFactoryVerify(InsOrderFactoryVerify factoryVerify) {
|
if (factoryVerify.getInsOrderId() == null) {
|
throw new ErrorException("缺少订单Id");
|
}
|
|
// 判断是新增还是修改
|
if (factoryVerify.getFactoryVerifyId() == null) {
|
// 判断之前是否添加过
|
Long count = insOrderFactoryVerifyMapper.selectCount(Wrappers.<InsOrderFactoryVerify>lambdaQuery()
|
.eq(InsOrderFactoryVerify::getInsOrderId, factoryVerify.getInsOrderId()));
|
if (count > 0) {
|
throw new ErrorException("原材料进货验证记录重复添加");
|
}
|
|
// 新增
|
insOrderFactoryVerifyMapper.insert(factoryVerify);
|
|
for (InsOrderFactoryVerifyItem item : factoryVerify.getFactoryVerifyItemList()) {
|
item.setFactoryVerifyId(factoryVerify.getFactoryVerifyId());
|
}
|
|
// 批量添加
|
insOrderFactoryVerifyItemService.saveBatch(factoryVerify.getFactoryVerifyItemList());
|
|
} else {
|
// 编辑
|
insOrderFactoryVerifyMapper.updateById(factoryVerify);
|
|
// 删除原本验证项目
|
insOrderFactoryVerifyItemService.remove(Wrappers.<InsOrderFactoryVerifyItem>lambdaQuery()
|
.eq(InsOrderFactoryVerifyItem::getFactoryVerifyId, factoryVerify.getFactoryVerifyId()));
|
|
for (InsOrderFactoryVerifyItem item : factoryVerify.getFactoryVerifyItemList()) {
|
item.setFactoryVerifyId(factoryVerify.getFactoryVerifyId());
|
}
|
|
insOrderFactoryVerifyItemService.saveBatch(factoryVerify.getFactoryVerifyItemList());
|
}
|
|
return true;
|
}
|
|
/***************************************************** 小报告 ***************************************************************************/
|
|
/**
|
* 设置表格样式
|
* @param max 标识最大个数
|
* @return
|
*/
|
private TableStyle setTableStyle(int max, boolean showResult){
|
//设置样式
|
TableStyle tableStyle = new TableStyle();
|
if (!showResult) {
|
switch (max) {
|
case 1: tableStyle.setColWidths(new int[]{650, 3000, 850, 2400, 3100}); break;
|
case 2: tableStyle.setColWidths(new int[]{650, 2800, 850, 2200, 1750, 1750}); break;
|
case 3: tableStyle.setColWidths(new int[]{650, 2600, 850, 1800, 1400, 1400, 1400}); break;
|
case 4: tableStyle.setColWidths(new int[]{650, 2400, 850, 1600, 1125, 1125, 1125, 1125}); break;
|
case 5: tableStyle.setColWidths(new int[]{650, 2200, 850, 1500, 960, 960, 960, 960, 960}); break;
|
default: break;
|
}
|
} else if(max<=5){
|
for (int i = 1; i <= max; i++) {
|
// 根据检验结果个数修改长度
|
switch (i) {
|
case 1:
|
tableStyle.setColWidths(new int[]{650, 2900, 850, 2300, 2100, 1200});
|
break;
|
case 2:
|
tableStyle.setColWidths(new int[]{650, 2700, 850, 2200, 1200, 1200, 1200});
|
break;
|
case 3:
|
tableStyle.setColWidths(new int[]{650, 2700, 850, 1600, 1000, 1000, 1000, 1200});
|
break;
|
case 4:
|
tableStyle.setColWidths(new int[]{650, 2400, 850, 1500, 850, 850, 850, 850, 1200});
|
break;
|
case 5:
|
tableStyle.setColWidths(new int[]{650, 2200, 850, 1350, 770, 770, 770, 770, 770, 1100});
|
break;
|
}
|
}
|
}
|
|
tableStyle.setWidth("10000");
|
tableStyle.setAlign(TableRowAlign.CENTER);
|
BorderStyle borderStyle = new BorderStyle();
|
borderStyle.setColor("000000");
|
borderStyle.setType(XWPFTable.XWPFBorderType.SINGLE);
|
borderStyle.setSize(4);
|
tableStyle.setLeftBorder(borderStyle);
|
tableStyle.setRightBorder(borderStyle);
|
tableStyle.setInsideHBorder(borderStyle); // 设置水平内边框
|
tableStyle.setInsideVBorder(borderStyle);
|
return tableStyle;
|
}
|
|
|
/**
|
* 处理有电缆颜色标识的检测项
|
* @param cableTags 电缆颜色标识
|
* @param collect 检测项列表
|
* @param startIndex 起始下标
|
* @param endIndex 结束下标
|
* @return
|
*/
|
private List<SampleProductExportDto> transformSampleProduct(List<String> cableTags,Map<String, List<SampleProductExportDto>> collect,int startIndex,int endIndex){
|
List<SampleProductExportDto> sampleProductExportDtos = new ArrayList<>();
|
for (String s : collect.keySet()) {
|
List<String> lastValueList = new ArrayList<>();
|
SampleProductExportDto dto = new SampleProductExportDto();
|
BeanUtil.copyProperties(collect.get(s).get(0),dto);
|
Set<String> tellSet = new HashSet<>();
|
for (int i = startIndex; i < endIndex; i++) {
|
String cableTag = cableTags.get(i);
|
for (SampleProductExportDto sDto : collect.get(s)) {
|
tellSet.add(sDto.getTell());
|
if(sDto.getCableTag().equals(cableTag)){
|
lastValueList.add(sDto.getLastValue());
|
}
|
}
|
}
|
//切割电缆配置项
|
dto.setTell(String.join("\n",tellSet));
|
dto.setLastValueList(lastValueList);
|
sampleProductExportDtos.add(dto);
|
}
|
return sampleProductExportDtos;
|
}
|
|
/**
|
* 检测项排序
|
* @param sourceMap
|
* @param targetMap
|
*/
|
private void sortSampleProduct(Map<String, List<SampleProductExportDto>> sourceMap,Map<String, List<SampleProductExportDto>> targetMap){
|
List<Map.Entry<String, List<SampleProductExportDto>>> entries = new ArrayList<>(sourceMap.entrySet());
|
entries.sort(Comparator.comparingInt(o -> (o.getValue().get(0).getSort() == null ? 0 : o.getValue().get(0).getSort())));
|
for (Map.Entry<String, List<SampleProductExportDto>> entry : entries) {
|
targetMap.put(entry.getKey(), entry.getValue());
|
}
|
}
|
|
/**
|
* 小报告生成
|
* @param orderId
|
* @param insOrder
|
* @param insSamples
|
*/
|
private void addSmallReport(Integer orderId, InsOrder insOrder, List<InsSample> insSamples, Integer reportType, Integer writeUserId) {
|
InsReport insReport = new InsReport();
|
AtomicReference<String> resultCh = new AtomicReference<>("");
|
boolean showResult = Objects.equals(reportType, INSPECTION_REPORT);
|
insReport.setCode(insOrder.getEntrustCode());
|
insReport.setInsOrderId(orderId);
|
insReport.setReportType(reportType);
|
InsSample insSample = insSamples.get(0);
|
// 填充基础数据
|
EnterFactoryReport enterFactoryReport = new EnterFactoryReport();
|
enterFactoryReport.setCode(insOrder.getEntrustCode());
|
enterFactoryReport.setSample(insOrder.getSample());
|
// 获取ifs数据
|
IfsInventoryQuantity ifsInventoryQuantity = ifsInventoryQuantityMapper.selectById(insOrder.getIfsInventoryId());
|
//查询零件属性
|
IfsPartPropsRecord ifsPartPropsRecord = ifsPartPropsRecordMapper.selectOne(Wrappers.<IfsPartPropsRecord>lambdaQuery()
|
.eq(IfsPartPropsRecord::getIfsInventoryId, ifsInventoryQuantity.getId()));
|
if(Objects.nonNull(ifsPartPropsRecord)){
|
enterFactoryReport.setOuterColor(ifsPartPropsRecord.getOuterColor());
|
}
|
enterFactoryReport.setQtyArrived(ifsInventoryQuantity.getQtyArrived() == null ? "" :
|
ifsInventoryQuantity.getQtyArrived().stripTrailingZeros().toPlainString() + ifsInventoryQuantity.getBuyUnitMeas());
|
enterFactoryReport.setQuantity(insOrder.getTestQuantity());
|
enterFactoryReport.setPartDesc(insOrder.getPartDetail());
|
enterFactoryReport.setSupplierName(ifsInventoryQuantity.getSupplierName());
|
enterFactoryReport.setLotBatchNo(ifsInventoryQuantity.getUpdateBatchNo());
|
|
// 检测依据
|
Set<String> standardMethod = new HashSet<>();
|
StringBuilder standardMethod2 = new StringBuilder();
|
standardMethod.add(baseMapper.getStandardMethodCode(insSample.getStandardMethodListId()));
|
for (String s : standardMethod) {
|
standardMethod2.append("、").append(s);
|
}
|
standardMethod2.replace(0, 1, "");
|
|
// 样品类型
|
String orderType = iSysDictTypeService.selectLabelByDict(DictDataConstants.CHECK_TYPE, insOrder.getOrderType());
|
|
List<RowRenderData> rows = new ArrayList<>();
|
List<TextRenderData> text = new ArrayList<>();
|
RowRenderData rowRenderData = null;
|
List<Map<String,Object>> cableTagEnclosureTables = new ArrayList<>();
|
|
// 查询检验内容
|
List<SampleProductExportDto> sampleProductDto2s = insOrderMapper.selectSampleBySampleId(insSamples.stream()
|
.map(InsSample::getId).collect(Collectors.toList()));
|
|
// 格式化修改检验项
|
this.formatProducts(sampleProductDto2s);
|
|
List<SampleProductExportDto> sampleList = new ArrayList<>();
|
Integer max = insSamples.stream().mapToInt(InsSample::getQuantity).sum();
|
TableRenderData tableRenderData = new TableRenderData();
|
String templateName;
|
if(StringUtils.equals(OrderType.WG.getValue(),ifsInventoryQuantity.getOrderType())){
|
//过滤不判定的检测项
|
List<SampleProductExportDto> filterItems = sampleProductDto2s.stream()
|
.filter(f -> !showResult || f.getInsResult() != 3)
|
.collect(Collectors.toList());
|
int maxCableTag = 5;//单个表格，电缆颜色标识最大个数
|
templateName = showResult ? "/static/small-wg-report-template.docx" : "/static/small-wg-detection-template.docx";
|
//查询检验单消息
|
InsSampleUserVO insSampleUser = insSampleUserMapper.selectUserNameByOrderId(orderId);
|
if(Objects.nonNull(insSampleUser)){
|
enterFactoryReport.setPartDesc(insSampleUser.getModel());
|
enterFactoryReport.setInspector(insSampleUser.getInspector());
|
enterFactoryReport.setInspectDate(insSampleUser.getInspectDate());
|
}
|
|
Map<String, List<SampleProductExportDto>> totalItem = new LinkedHashMap<>();//检测项列表
|
Map<String, List<SampleProductExportDto>> cableTagItem = new LinkedHashMap<>();//电缆配置检测项
|
Map<String, List<SampleProductExportDto>> cableTagEnclosureItem = new LinkedHashMap<>();//电缆配置检测项附件
|
|
AtomicInteger finalIndex = new AtomicInteger(1);
|
List<String> cableTags = insOrderMapper.selectSampleCableTag(insSample.getId());
|
max = Math.max(cableTags.size(),1);
|
//处理电缆配置检测项
|
Map<String, List<SampleProductExportDto>> tempMap = new HashMap<>();
|
Map<String, List<SampleProductExportDto>> tempMap2 = new HashMap<>();
|
Map<String, List<SampleProductExportDto>> listMap2 = filterItems.stream()
|
.filter(f -> StringUtils.isNotBlank(f.getCableTag()) && StringUtils.isNotBlank(f.getInspectionItem()))
|
.collect(Collectors.groupingBy(SampleProductExportDto::getInspectionItem));
|
for (String key : listMap2.keySet()) {
|
List<SampleProductExportDto> sampleProductExportDtos;
|
List<SampleProductExportDto> sampleProductExportDtos2;
|
//处理电缆配置项
|
Map<String, List<SampleProductExportDto>> collect = listMap2.get(key).stream().collect(Collectors.groupingBy(SampleProductExportDto::getInspectionItemSubclass));
|
if(cableTags.size()>maxCableTag){
|
sampleProductExportDtos = transformSampleProduct(cableTags,collect,0,maxCableTag);
|
sampleProductExportDtos2 = transformSampleProduct(cableTags,collect,maxCableTag,cableTags.size());
|
tempMap2.put(key,sampleProductExportDtos2);
|
}else{
|
sampleProductExportDtos = transformSampleProduct(cableTags,collect,0,cableTags.size());
|
}
|
cableTagItem.put(key,sampleProductExportDtos);
|
}
|
//处理非电缆配置检测项
|
Map<String, List<SampleProductExportDto>> listMap = filterItems.stream()
|
.filter(f -> StringUtils.isBlank(f.getCableTag()) && StringUtils.isNotBlank(f.getInspectionItem()))
|
.collect(Collectors.groupingBy(s->s.getInspectionItem()+"&"));
|
//合并检测项列表
|
tempMap.putAll(cableTagItem);
|
tempMap.putAll(listMap);
|
sortSampleProduct(tempMap,totalItem);
|
int tagNum = Math.min(max,maxCableTag);
|
List<String> tagList = cableTags.isEmpty()?new ArrayList<>():cableTags.subList(0,tagNum);
|
handlerSampleItems(OrderType.WG.getValue(), totalItem, finalIndex, sampleList, tagNum, text, rows, rowRenderData, resultCh, tagList, true, showResult);
|
|
if(CollectionUtil.isNotEmpty(tempMap2)){
|
sortSampleProduct(tempMap2,cableTagEnclosureItem);
|
//生成附件电缆表格
|
TableRenderData tableRenderData2 = new TableRenderData();
|
List<String> newCableTags = cableTags.subList(maxCableTag,cableTags.size());
|
AtomicInteger finalIndex2 = new AtomicInteger(1);
|
List<TextRenderData> newText = new ArrayList<TextRenderData>();
|
List<RowRenderData> newRows = new ArrayList<>();
|
RowRenderData newRowRenderData = null;
|
handlerSampleItems(OrderType.WG.getValue(), cableTagEnclosureItem, finalIndex2, new ArrayList<>(), newCableTags.size(), newText, newRows, newRowRenderData, resultCh, newCableTags, true, showResult);
|
tableRenderData2.setRows(newRows);
|
tableRenderData2.setTableStyle(setTableStyle(newCableTags.size(), showResult));
|
HashMap<String, Object> tableMap = new HashMap<>();
|
tableMap.put("enclosureTable",tableRenderData2);
|
tableMap.put("resultCh", resultCh);
|
tableMap.put("writeUrl", null);
|
tableMap.put("examineUrl", null);
|
tableMap.put("ratifyUrl", null);
|
tableMap.put("writeDateUrl", null);
|
tableMap.put("examineDateUrl", null);
|
tableMap.put("ratifyDateUrl", null);
|
tableMap.put("seal1", null);
|
cableTagEnclosureTables.add(tableMap);
|
}
|
|
tableRenderData.setRows(rows);
|
tableRenderData.setTableStyle(setTableStyle(tagNum, showResult));
|
if (showResult && !resultCh.get().isEmpty()) {
|
resultCh.set("经检验，" + resultCh.get() + "所检项目不合格，其余所检项目均合格。（盖章有效）");
|
} else if (showResult) {
|
resultCh.set("本产品符合相关标准要求，经检验合格准予出厂（盖章有效）");
|
}
|
|
}else{
|
templateName = showResult ? "/static/small-report-template.docx" : "/static/small-detection-template.docx";
|
// 转成Mpa进行排序
|
Map<String, List<SampleProductExportDto>> sortedMap = sampleProductDto2s.stream()
|
.filter(sampleProductDto2 -> StringUtils.isNotBlank(sampleProductDto2.getInspectionItem()))
|
.collect(Collectors.groupingBy(SampleProductExportDto::getInspectionItem));
|
// // 创建一个 LinkedHashMap 来保持插入顺序
|
Map<String, List<SampleProductExportDto>> item = new LinkedHashMap<>();
|
sortSampleProduct(sortedMap,item);
|
|
|
AtomicInteger finalIndex = new AtomicInteger(1);
|
handlerSampleItems(OrderType.RAW.getValue(), item, finalIndex, sampleList, max, text, rows, rowRenderData, resultCh, null, true, showResult);
|
tableRenderData.setRows(rows);
|
tableRenderData.setTableStyle(setTableStyle(max, showResult));
|
|
if (showResult && !resultCh.get().equals("")) {
|
resultCh.set("经检验，" + resultCh.get() + "所检项目不合格，其余所检项目均合格。");
|
} else if (showResult) {
|
resultCh.set("经检验此批" + enterFactoryReport.getSample() + "各项目均符合检验规范要求。");
|
}
|
}
|
|
ConfigureBuilder builder = Configure.builder();
|
builder.useSpringEL(true);
|
|
InputStream inputStream = this.getClass().getResourceAsStream(templateName);
|
XWPFTemplate template = XWPFTemplate.compile(inputStream, builder.build()).render(
|
new HashMap<String, Object>() {{
|
put("report", enterFactoryReport);
|
put("standardMethod", standardMethod2.toString().equals("null") ? "" : standardMethod2);
|
put("orderType", orderType);
|
put("table", tableRenderData);
|
put("enclosureTables", cableTagEnclosureTables.isEmpty()?null:cableTagEnclosureTables);
|
put("resultCh", resultCh);
|
put("writeUrl", null);
|
put("examineUrl", null);
|
put("ratifyUrl", null);
|
put("writeDateUrl", null);
|
put("examineDateUrl", null);
|
put("ratifyDateUrl", null);
|
put("seal1", null);
|
}});
|
try {
|
// 修改换行和合并问题
|
updaeMerge(template.getXWPFDocument(), true);
|
String name = insReport.getCode().replace("/", "") + (showResult ? "-J.docx" : "-C.docx");
|
Files.createDirectories(Paths.get(wordUrl));
|
template.writeAndClose(Files.newOutputStream(Paths.get(wordUrl, name)));
|
insReport.setUrl("/word/" + name);
|
insReport.setIsPass(0);
|
insReport.setWriteUserId(writeUserId);//编制人（检验人）
|
insReport.setWriteTime(LocalDateTime.now());//提交时间
|
saveGeneratedReport(insReport);
|
inputStream.close();
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
/**
|
* 处理常规检测项
|
* @param item
|
* @param finalIndex
|
* @param sampleList
|
* @param max
|
* @param text
|
* @param rows
|
* @param rowRenderData
|
* @param resultCh
|
*/
|
private static void handlerSampleItems(String orderType, Map<String, List<SampleProductExportDto>> item, AtomicInteger finalIndex, List<SampleProductExportDto> sampleList, Integer max, List<TextRenderData> text, List<RowRenderData> rows, RowRenderData rowRenderData, AtomicReference<String> resultCh, List<String> cableTagList, Boolean hasAddHead, boolean showResult) {
|
item.forEach((s, sampleProductDtoInside) -> {
|
// 添加检验项
|
SampleProductExportDto dto2 = new SampleProductExportDto();
|
// 判断是否有英文名称
|
SampleProductExportDto temp = sampleProductDtoInside.get(0);
|
|
// 判断是否有检验子项,没有就把检验参数填充
|
dto2.setIndex(Integer.toString(finalIndex.get()));
|
if (StringUtils.isBlank(temp.getInspectionItemSubclass())) {
|
// 处理集合
|
Map<String, SampleProductExportDto> map = new LinkedHashMap<>();
|
for (SampleProductExportDto productDto2 : sampleProductDtoInside) {
|
String productName = productDto2.getInspectionItemClass() + productDto2.getInspectionItem() + productDto2.getCableTag();
|
if (map.containsKey(productName)) {
|
// 如果名称已经存在，添加 lastValue 值到 lastValueList 列表
|
if(CollectionUtil.isEmpty(map.get(productName).getLastValueList()) || StringUtils.equals(OrderType.RAW.getValue(),orderType)){
|
map.get(productName)
|
.getLastValueList()
|
.add(productDto2.getLastValue());
|
}
|
map.get(productName)
|
.getInsResultList()
|
.add(productDto2.getInsResult());
|
} else {
|
// 如果名称不存在，直接放入 map
|
if(CollectionUtil.isEmpty(productDto2.getLastValueList()) || StringUtils.equals(OrderType.RAW.getValue(),orderType)){
|
productDto2.setLastValueList(new ArrayList<>()); // 检验内容
|
productDto2.getLastValueList().add(productDto2.getLastValue());
|
}
|
productDto2.setInsResultList(new ArrayList<>()); // 结果
|
productDto2.getInsResultList().add(productDto2.getInsResult());
|
|
map.put(productName, productDto2);
|
}
|
}
|
List<SampleProductExportDto> result = new ArrayList<>(map.values());
|
|
//添加检验子项
|
SampleProductExportDto temp2 = result.get(0);
|
if (StringUtils.isNotBlank(temp2.getRadius())) {
|
s = s + "(" + temp2.getRadius() + ")";
|
}
|
// 判断有没有条件字段有需要拼接到名称后面
|
temp2.setInspectionName(s);
|
temp2.setIndex(Integer.toString(finalIndex.get()));
|
sampleList.add(temp2);
|
} else {
|
dto2.setInspectionName(s);
|
// 填充到要求
|
if (StringUtils.isNotBlank(temp.getRadius())) {
|
dto2.setTell("(" + temp.getRadius() + ")");
|
}
|
sampleList.add(dto2);
|
|
// 处理集合
|
Map<String, SampleProductExportDto> map = new LinkedHashMap<>();
|
for (SampleProductExportDto productDto2 : sampleProductDtoInside) {
|
String productName = productDto2.getInspectionItemClass() + productDto2.getInspectionItem() + productDto2.getInspectionItemSubclass() + productDto2.getCableTag();
|
if (map.containsKey(productName)) {
|
// 如果名称已经存在，添加 lastValue 值到 lastValueList 列表
|
if(CollectionUtil.isEmpty(map.get(productName).getLastValueList()) || StringUtils.equals(OrderType.RAW.getValue(),orderType)){
|
map.get(productName)
|
.getLastValueList()
|
.add(productDto2.getLastValue());
|
}
|
map.get(productName)
|
.getInsResultList()
|
.add(productDto2.getInsResult());
|
} else {
|
// 如果名称不存在，直接放入 map
|
if(CollectionUtil.isEmpty(productDto2.getLastValueList()) || StringUtils.equals(OrderType.RAW.getValue(),orderType)){
|
productDto2.setLastValueList(new ArrayList<>()); // 检验内容
|
productDto2.getLastValueList().add(productDto2.getLastValue());
|
}
|
productDto2.setInsResultList(new ArrayList<>()); // 结果
|
productDto2.getInsResultList().add(productDto2.getInsResult());
|
|
map.put(productName, productDto2);
|
}
|
}
|
List<SampleProductExportDto> result = new ArrayList<>(map.values());
|
//添加检验子项
|
for (SampleProductExportDto productDto2 : result) {
|
productDto2.setInspectionName("--" + productDto2.getInspectionItemSubclass());
|
sampleList.add(productDto2);
|
}
|
}
|
finalIndex.incrementAndGet();
|
});
|
|
// 添加小报告表头
|
if(hasAddHead){
|
text = addSmallHead(text, max, rows, cableTagList, showResult);
|
}
|
|
// 中间检测值添加
|
for (int i = 0; i < sampleList.size(); i++) {
|
SampleProductExportDto sample = sampleList.get(i);
|
|
// 序号
|
TextRenderData middleRenderData1 = new TextRenderData();
|
middleRenderData1.setText(sample.getIndex());
|
Style middleStyle1 = new Style();
|
middleStyle1.setFontFamily("宋体");
|
middleStyle1.setColor("000000");
|
middleRenderData1.setStyle(middleStyle1);
|
text.add(middleRenderData1);
|
|
// 检验项目
|
TextRenderData middleRenderData2 = new TextRenderData();
|
String[] split = sample.getInspectionName().split("&");
|
String itemName = split.length>0?split[0]:sample.getInspectionName();
|
middleRenderData2.setText(itemName+"∑"+itemName+i+"_"+finalIndex);
|
Style middleStyle2 = new Style();
|
middleStyle2.setFontFamily("宋体");
|
middleStyle2.setColor("000000");
|
middleRenderData2.setStyle(middleStyle2);
|
text.add(middleRenderData2);
|
|
// 单位
|
TextRenderData middleRenderData4 = new TextRenderData();
|
middleRenderData4.setText(sample.getUnit());
|
Style middleStyle4 = new Style();
|
middleStyle4.setFontFamily("宋体");
|
middleStyle4.setColor("000000");
|
middleRenderData4.setStyle(middleStyle4);
|
text.add(middleRenderData4);
|
|
//标准要求
|
TextRenderData middleRenderData5 = new TextRenderData();
|
middleRenderData5.setText(sample.getTell());
|
Style middleStyle5 = new Style();
|
middleStyle5.setFontFamily("宋体");
|
middleStyle5.setColor("000000");
|
middleRenderData5.setStyle(middleStyle5);
|
text.add(middleRenderData5);
|
|
// 检验结果
|
boolean isMore = false;
|
if (CollectionUtils.isNotEmpty(sample.getLastValueList())
|
&& sample.getLastValueList().size() == max) {
|
// 判断是否是外观, 外观全部合格的话需要合并
|
if (showResult && sample.getInspectionItem().contains("外观")) {
|
// 判定结果
|
boolean falg = false;
|
if (CollectionUtils.isNotEmpty(sample.getLastValueList())) {
|
// 判断是否有一个错误
|
if (sample.getInsResultList().stream().anyMatch(s -> Objects.equals(s, 2))) {
|
falg = true;
|
} else {
|
boolean error = sample.getInsResultList().stream().anyMatch(s -> Objects.equals(s, 0));
|
if (!error) {
|
falg = true;
|
}
|
}
|
} else {
|
if (!Objects.equals(sample.getInsResult(), 2)) {
|
falg = true;
|
}
|
}
|
if (falg) {
|
for (int j = 0; j < max; j++) {
|
TextRenderData middleRenderData6 = new TextRenderData();
|
middleRenderData6.setText((StringUtils.isNotEmpty(sample.getLastValue()) ?
|
sample.getLastValue() : "")
|
+ "∑" + (50 + i));
|
Style middleStyle6 = new Style();
|
middleStyle6.setFontFamily("宋体");
|
middleStyle6.setColor("000000");
|
middleRenderData6.setStyle(middleStyle6);
|
text.add(middleRenderData6);
|
}
|
} else {
|
for (String s : sample.getLastValueList()) {
|
TextRenderData middleRenderData6 = new TextRenderData();
|
middleRenderData6.setText(s);
|
Style middleStyle6 = new Style();
|
middleStyle6.setFontFamily("宋体");
|
middleStyle6.setColor("000000");
|
middleRenderData6.setStyle(middleStyle6);
|
text.add(middleRenderData6);
|
}
|
}
|
} else {
|
for (String s : sample.getLastValueList()) {
|
TextRenderData middleRenderData6 = new TextRenderData();
|
middleRenderData6.setText(s);
|
Style middleStyle6 = new Style();
|
middleStyle6.setFontFamily("宋体");
|
middleStyle6.setColor("000000");
|
middleRenderData6.setStyle(middleStyle6);
|
text.add(middleRenderData6);
|
}
|
}
|
} else {
|
for (int j = 0; j < max; j++) {
|
TextRenderData middleRenderData6 = new TextRenderData();
|
middleRenderData6.setText((StringUtils.isNotEmpty(sample.getLastValue()) ?
|
sample.getLastValue() : "")
|
+ "∑" + (finalIndex.get() +"_"+ i));
|
Style middleStyle6 = new Style();
|
middleStyle6.setFontFamily("宋体");
|
middleStyle6.setColor("000000");
|
middleRenderData6.setStyle(middleStyle6);
|
text.add(middleRenderData6);
|
}
|
}
|
|
|
// 判定结果
|
String result = "";
|
if (showResult && sample.getInsResult() != null) {
|
switch (sample.getInsResult()) {
|
case 1:
|
result = "√";
|
break;
|
case 2:
|
result = "×";
|
break;
|
case 3:
|
result = "-";
|
break;
|
}
|
}
|
if (showResult && CollectionUtils.isNotEmpty(sample.getLastValueList())) {
|
// 判断是否有一个错误
|
if (sample.getInsResultList().stream().anyMatch(s -> Objects.equals(s, 3))) {
|
result = "-";
|
} else {
|
boolean error = sample.getInsResultList().stream().anyMatch(s -> Objects.equals(s, 0));
|
if (error) {
|
List<String> collect = new ArrayList<>();
|
int index = 1;
|
for (Integer count : sample.getInsResultList()) {
|
String type;
|
if (Objects.equals(count, 0)) {
|
// 添加不合格描述
|
String item1 = (max == 1 ? "" : "第" + index + "次")
|
+ sample.getInspectionItem()
|
+ (StringUtils.isBlank(sample.getInspectionItemSubclass()) ? "" : "" + sample.getInspectionItemSubclass());
|
if (resultCh.get().equals("")) {
|
resultCh.set(resultCh.get() + item1);
|
} else {
|
resultCh.set(resultCh.get() + "、" + item1);
|
}
|
type = "×";
|
} else {
|
type = "√";
|
}
|
collect.add(type);
|
index++;
|
}
|
result = CollUtil.join(collect, " ");
|
} else {
|
result = "√";
|
}
|
}
|
}
|
|
if (showResult) {
|
TextRenderData middleRenderData7 = new TextRenderData();
|
middleRenderData7.setText(result);
|
Style middleStyle7 = new Style();
|
middleStyle7.setFontFamily("宋体");
|
middleStyle7.setColor("000000");
|
middleRenderData7.setStyle(middleStyle7);
|
text.add(middleRenderData7);
|
}
|
|
TextRenderData[] text2 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text2).center().rowAtleastHeight(1).create();
|
// 0.8厘米
|
double centimeters = 0.8;
|
int twips = UnitUtils.cm2Twips(centimeters);
|
rowRenderData.getRowStyle().setHeight(twips);
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
}
|
|
}
|
|
/**
|
* 添加小报告表头
|
* @param text
|
* @param max
|
* @param rows
|
* @return
|
*/
|
private static List<TextRenderData> addSmallHead(List<TextRenderData> text, Integer max, List<RowRenderData> rows, List<String> cableTagList, boolean showResult) {
|
RowRenderData rowRenderData;
|
// // 头
|
TextRenderData headRenderData1 = new TextRenderData();
|
headRenderData1.setText("序号");
|
Style headStyle1 = new Style();
|
headStyle1.setFontFamily("宋体");
|
headStyle1.setColor("000000");
|
headRenderData1.setStyle(headStyle1);
|
text.add(headRenderData1);
|
|
TextRenderData headRenderData2 = new TextRenderData();
|
headRenderData2.setText("检验项目");
|
Style headStyle2 = new Style();
|
headStyle2.setFontFamily("宋体");
|
headStyle2.setColor("000000");
|
headRenderData2.setStyle(headStyle2);
|
text.add(headRenderData2);
|
|
TextRenderData headRenderData4 = new TextRenderData();
|
headRenderData4.setText("单位");
|
Style headStyle4 = new Style();
|
headStyle4.setFontFamily("宋体");
|
headStyle4.setColor("000000");
|
headRenderData4.setStyle(headStyle4);
|
text.add(headRenderData4);
|
|
TextRenderData headRenderData5 = new TextRenderData();
|
headRenderData5.setText("标准要求");
|
Style headStyle5 = new Style();
|
headStyle5.setFontFamily("宋体");
|
headStyle5.setColor("000000");
|
headRenderData5.setStyle(headStyle5);
|
text.add(headRenderData5);
|
|
for (int i = 0; i < max; i++) {
|
TextRenderData headRenderData6 = new TextRenderData();
|
headRenderData6.setText(showResult ? "检验结果∑6" : "检测数据∑6");
|
Style headStyle6 = new Style();
|
headStyle6.setFontFamily("宋体");
|
headStyle6.setColor("000000");
|
headRenderData6.setStyle(headStyle6);
|
text.add(headRenderData6);
|
}
|
if (showResult) {
|
TextRenderData headRenderData7 = new TextRenderData();
|
headRenderData7.setText("单项判断");
|
Style headStyle7 = new Style();
|
headStyle7.setFontFamily("宋体");
|
headStyle7.setColor("000000");
|
headRenderData7.setStyle(headStyle7);
|
text.add(headRenderData7);
|
}
|
|
TextRenderData[] text3 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text3).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
|
// 第二行(可能没有)
|
if (max > 1 && CollectionUtil.isEmpty(cableTagList)) {
|
TextRenderData tagRenderData1 = new TextRenderData();
|
tagRenderData1.setText("");
|
Style tagStyle1 = new Style();
|
tagStyle1.setFontFamily("宋体");
|
tagStyle1.setColor("000000");
|
tagRenderData1.setStyle(tagStyle1);
|
text.add(tagRenderData1);
|
|
TextRenderData tagRenderData2 = new TextRenderData();
|
tagRenderData2.setText("标识");
|
Style tagStyle2 = new Style();
|
tagStyle2.setFontFamily("宋体");
|
tagStyle2.setColor("000000");
|
tagRenderData2.setStyle(tagStyle2);
|
text.add(tagRenderData2);
|
|
TextRenderData tagRenderData4 = new TextRenderData();
|
tagRenderData4.setText("");
|
Style tagStyle4 = new Style();
|
tagStyle4.setFontFamily("宋体");
|
tagStyle4.setColor("000000");
|
tagRenderData4.setStyle(tagStyle4);
|
text.add(tagRenderData4);
|
|
TextRenderData tagRenderData5 = new TextRenderData();
|
tagRenderData5.setText("");
|
Style tagStyle5 = new Style();
|
tagStyle5.setFontFamily("宋体");
|
tagStyle5.setColor("000000");
|
tagRenderData5.setStyle(tagStyle5);
|
text.add(tagRenderData5);
|
|
for (int i = 0; i < max; i++) {
|
TextRenderData tagRenderData6 = new TextRenderData();
|
tagRenderData6.setText("标识" + (i + 1));
|
Style tagStyle6 = new Style();
|
tagStyle6.setFontFamily("宋体");
|
tagStyle6.setColor("000000");
|
tagRenderData6.setStyle(tagStyle6);
|
text.add(tagRenderData6);
|
}
|
if (showResult) {
|
TextRenderData tagRenderData7 = new TextRenderData();
|
tagRenderData7.setText("");
|
Style tagStyle7 = new Style();
|
tagStyle7.setFontFamily("宋体");
|
tagStyle7.setColor("000000");
|
tagRenderData7.setStyle(tagStyle7);
|
text.add(tagRenderData7);
|
}
|
|
TextRenderData[] text4 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text4).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
|
|
}
|
//如果有电缆颜色，生成颜色标识行
|
if(CollectionUtil.isNotEmpty(cableTagList)){
|
TextRenderData tagRenderData1 = new TextRenderData();
|
tagRenderData1.setText("");
|
Style tagStyle1 = new Style();
|
tagStyle1.setFontFamily("宋体");
|
tagStyle1.setColor("000000");
|
tagRenderData1.setStyle(tagStyle1);
|
text.add(tagRenderData1);
|
|
TextRenderData tagRenderData2 = new TextRenderData();
|
tagRenderData2.setText("绝缘线芯颜色和标志");
|
Style tagStyle2 = new Style();
|
tagStyle2.setFontFamily("宋体");
|
tagStyle2.setColor("000000");
|
tagRenderData2.setStyle(tagStyle2);
|
text.add(tagRenderData2);
|
|
TextRenderData tagRenderData4 = new TextRenderData();
|
tagRenderData4.setText("/");
|
Style tagStyle4 = new Style();
|
tagStyle4.setFontFamily("宋体");
|
tagStyle4.setColor("000000");
|
tagRenderData4.setStyle(tagStyle4);
|
text.add(tagRenderData4);
|
|
TextRenderData tagRenderData5 = new TextRenderData();
|
tagRenderData5.setText("/");
|
Style tagStyle5 = new Style();
|
tagStyle5.setFontFamily("宋体");
|
tagStyle5.setColor("000000");
|
tagRenderData5.setStyle(tagStyle5);
|
text.add(tagRenderData5);
|
|
for (String cableTag : cableTagList) {
|
TextRenderData tagRenderData6 = new TextRenderData();
|
tagRenderData6.setText(cableTag);
|
Style tagStyle6 = new Style();
|
tagStyle6.setFontFamily("宋体");
|
tagStyle6.setColor("000000");
|
tagRenderData6.setStyle(tagStyle6);
|
text.add(tagRenderData6);
|
}
|
if (showResult) {
|
TextRenderData tagRenderData7 = new TextRenderData();
|
tagRenderData7.setText("/");
|
Style tagStyle7 = new Style();
|
tagStyle7.setFontFamily("宋体");
|
tagStyle7.setColor("000000");
|
tagRenderData7.setStyle(tagStyle7);
|
text.add(tagRenderData7);
|
}
|
|
TextRenderData[] text4 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text4).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
}
|
return text;
|
}
|
|
/***************************************************** 大报告 ***************************************************************************/
|
|
/**
|
* 创建大报告
|
* @param orderId
|
* @param insOrder
|
* @param
|
*/
|
private void addBitReport(Integer orderId, InsOrder insOrder, Integer reportType, Integer writeUserId) {
|
//samples是不包括带有"/"的样品
|
List<SampleProductDto> samples = insSampleMapper.selectSampleProductListByOrderId(orderId);
|
InsReport insReport = new InsReport();
|
insReport.setCode(insOrder.getEntrustCode());
|
insReport.setInsOrderId(orderId);
|
insReport.setReportType(reportType);
|
boolean showResult = Objects.equals(reportType, INSPECTION_REPORT);
|
List<Map<String, Object>> tables = new ArrayList<>();
|
Set<String> standardMethod = new HashSet<>();
|
Set<String> deviceSet = new HashSet<>();
|
Set<String> models = new HashSet<>();
|
// 查询检验项数量
|
AtomicInteger productSize = new AtomicInteger();
|
String[] monthNames = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
|
List<String> resultChList = new ArrayList<>();
|
List<String> resultEnList = new ArrayList<>();
|
// 判断是否是只有一个样品
|
boolean isOneSample = samples.size() == 1;
|
/*基础报告(根据绘制的原始记录模版形成)*/
|
samples.forEach(a -> {
|
models.add(a.getModel());
|
String standardMethodCode = baseMapper.getStandardMethodCode(a.getStandardMethodListId());
|
if (StrUtil.isNotBlank(a.getSpecialStandardMethod())) {
|
standardMethodCode = standardMethodCode + "+" + a.getSpecialStandardMethod();
|
}
|
standardMethod.add(standardMethodCode);
|
for (InsProduct b : a.getInsProduct()) {
|
if (b.getInsProductResult() != null) {
|
List<JSONObject> jsonObjects = JSON.parseArray(b.getInsProductResult().getEquipValue(), JSONObject.class);
|
for (JSONObject jsonObject : jsonObjects) {
|
if (!"".equals(jsonObject.get("v") + "")) {
|
List<String> v = StrUtil.split(jsonObject.get("v") + "", "，");
|
deviceSet.addAll(v);
|
}
|
}
|
}
|
}
|
// 新版检测报告直接使用固定四列结果行，不再构造旧版可变列 TableRenderData。
|
// 检验报告仍沿用下方原有的大表格逻辑。
|
if (!showResult) {
|
return;
|
}
|
// 收样日期
|
List<RowRenderData> rows = new ArrayList<>();
|
List<TextRenderData> text = new ArrayList<>();
|
RowRenderData rowRenderData = null;
|
|
InsSample insSamples = null;
|
int max = 1;
|
List<String> cableTags = new ArrayList<>();
|
// 判断是否为原材料
|
if (insOrder.getTypeSource() != null && insOrder.getTypeSource().equals(1)) {
|
|
InsOrder one = insOrderService.getOne(Wrappers.<InsOrder>lambdaQuery()
|
.eq(InsOrder::getIfsInventoryId, insOrder.getIfsInventoryId())
|
.eq(InsOrder::getOrderType, InsOrderTypeConstants.ENTER_THE_FACTORY)
|
.ne(InsOrder::getState, -1)
|
.last("limit 1"));
|
// 判断之前是否有进厂检验
|
if (one != null) {
|
insSamples = insSampleMapper.selectOne(Wrappers.<InsSample>lambdaQuery()
|
.eq(InsSample::getInsOrderId, one.getId())
|
.last("limit 1"));
|
}
|
|
max = a.getQuantity();
|
// 季度检验需要进厂检验的设备
|
// 查询是否有进厂检验
|
InsOrder order = insOrderMapper.selectOne(Wrappers.<InsOrder>lambdaQuery()
|
.eq(InsOrder::getIfsInventoryId, insOrder.getIfsInventoryId())
|
.ne(InsOrder::getState, -1)
|
.eq(InsOrder::getOrderType, InsOrderTypeConstants.ENTER_THE_FACTORY)
|
.ne(InsOrder::getId, insOrder.getId())
|
.last("limit 1"));
|
if (order != null) {
|
List<SampleProductDto> sampleProductDtos = insSampleMapper.selectSampleProductListByOrderId(order.getId());
|
for (InsProduct b : sampleProductDtos.get(0).getInsProduct()) {
|
if (b.getInsProductResult() != null) {
|
List<JSONObject> jsonObjects = JSON.parseArray(b.getInsProductResult().getEquipValue(), JSONObject.class);
|
for (JSONObject jsonObject : jsonObjects) {
|
if (!"".equals(jsonObject.get("v") + "")) {
|
List<String> v = StrUtil.split(jsonObject.get("v") + "", "，");
|
deviceSet.addAll(v);
|
}
|
}
|
}
|
}
|
}
|
if (StringUtils.isBlank(insOrder.getSampleView())) {
|
insOrder.setSampleView(insOrder.getSample());
|
}
|
if (StringUtils.isBlank(insOrder.getSampleViewEn())) {
|
String sampleViewEn = insSampleMapper.getSampleEn(insOrder.getSample());
|
if (StringUtils.isBlank(sampleViewEn)) {
|
sampleViewEn = insSampleMapper.getSampleEnByObject(insOrder.getSample());
|
}
|
insOrder.setSampleViewEn(sampleViewEn);
|
}
|
} else {
|
// 获得批量检验的总数
|
max = insOrderMapper.selectSampleMax(a.getId());
|
cableTags = insOrderMapper.selectSampleCableTag(a.getId());
|
}
|
|
// 表头添加
|
addHead(a, text, rowRenderData, rows, max, cableTags, showResult);
|
text = new ArrayList<>();
|
|
// 添加检测值
|
productSize.set(addTestValue(a, text, rowRenderData, rows, max, resultChList, resultEnList, insSamples, cableTags, isOneSample, showResult));
|
text = new ArrayList<>();
|
|
// 结尾添加
|
addEnding(text, rowRenderData, rows, max, showResult);
|
text = new ArrayList<>();
|
|
List<TableRenderData> tables1 = new ArrayList<>();
|
TableRenderData tableRenderData = new TableRenderData();
|
tableRenderData.setRows(new ArrayList<>());
|
double totalHeight = 0.0; // 用于跟踪当前表格的总行高
|
double heightThreshold = 9300.0; // 阈值，
|
List<RowRenderData> firstTwoRows = new ArrayList<>(); // 保存前两行以便复制到新表格
|
List<RowRenderData> endTwoRows = new ArrayList<>(); // 保存最后一行以便复制到新表格
|
// 保存前两行以便复制到新表格
|
firstTwoRows.add(rows.get(0));
|
firstTwoRows.add(rows.get(1));
|
// 保存最后一行
|
endTwoRows.add(rows.get(rows.size() - 1));
|
for (RowRenderData row : rows) {
|
double rowHeight = row.getRowStyle().getHeight(); // 获取当前行的行高
|
// // 判断字体内容是否有多的, 多的行高乘倍数
|
RowRenderData lastRaw = rows.get(rows.size() - 1);
|
// 排除最后一行
|
if (rows.get(0) != row && rows.get(1) != row && lastRaw != row) {
|
// 调整高度
|
rowHeight = adjustRowHeight(row, rowHeight, max);
|
}
|
totalHeight += rowHeight; // 更新总行高
|
if (totalHeight >= heightThreshold) {
|
// 创建新表格并复制前两行
|
TableRenderData newTableRenderData = new TableRenderData();
|
newTableRenderData.setRows(new ArrayList<>(firstTwoRows));
|
//设置样式
|
TableStyle tableStyle = new TableStyle();
|
// for (int i = 1; i <= max; i++) {
|
// }
|
// 根据检验结果个数修改长度
|
tableStyle.setColWidths(calcTableColWidths(max, showResult));
|
// switch (max) {
|
// case 1:
|
// tableStyle.setColWidths(new int[]{650, 2000, 2000, 850, 2200, 2100, 1200});
|
// break;
|
// case 2:
|
// tableStyle.setColWidths(new int[]{650, 1400, 1400, 850, 2100, 1200, 1200, 1200});
|
// break;
|
// case 3:
|
// tableStyle.setColWidths(new int[]{650, 1400, 1400, 850, 1500, 1000, 1000, 1000, 1200});
|
// break;
|
// case 4:
|
// tableStyle.setColWidths(new int[]{650, 1200, 1200, 850, 1400, 850, 850, 850, 850, 1200});
|
// break;
|
// case 5:
|
// tableStyle.setColWidths(new int[]{650, 1100, 1100, 850, 1350, 750, 750, 750, 750, 750, 1200});
|
// break;
|
// }
|
tableStyle.setWidth("10000");
|
tableStyle.setAlign(TableRowAlign.CENTER);
|
BorderStyle borderStyle = new BorderStyle();
|
borderStyle.setColor("000000");
|
borderStyle.setType(XWPFTable.XWPFBorderType.THICK);
|
borderStyle.setSize(14);
|
tableStyle.setLeftBorder(borderStyle);
|
tableStyle.setTopBorder(borderStyle);
|
tableStyle.setRightBorder(borderStyle);
|
tableStyle.setBottomBorder(borderStyle);
|
tableRenderData.setTableStyle(tableStyle);
|
newTableRenderData.setTableStyle(tableStyle);
|
|
// 添加最后一行
|
tableRenderData.addRow(rows.get(rows.size() - 1));
|
|
tables1.add(tableRenderData);
|
tableRenderData = newTableRenderData;
|
totalHeight = rowHeight;
|
}
|
tableRenderData.getRows().add(row);
|
}
|
TableStyle tableStyle = new TableStyle();
|
if (tableRenderData.getRows().size() != 3) {
|
//设置样式
|
// for (int i = 1; i <= max; i++) {
|
// }
|
// 根据检验结果个数修改长度
|
tableStyle.setColWidths(calcTableColWidths(max, showResult));
|
// switch (max) {
|
// case 1:
|
// tableStyle.setColWidths(new int[]{650, 2000, 2000, 850, 2200, 2100, 1200});
|
// break;
|
// case 2:
|
// tableStyle.setColWidths(new int[]{650, 1400, 1400, 850, 2100, 1200, 1200, 1200});
|
// break;
|
// case 3:
|
// tableStyle.setColWidths(new int[]{650, 1400, 1400, 850, 1500, 1000, 1000, 1000, 1200});
|
// break;
|
// case 4:
|
// tableStyle.setColWidths(new int[]{650, 1200, 1200, 850, 1400, 850, 850, 850, 850, 1200});
|
// break;
|
// case 5:
|
// tableStyle.setColWidths(new int[]{650, 1100, 1100, 850, 1350, 750, 750, 750, 750, 750, 1200});
|
// break;
|
// }
|
}
|
tableStyle.setWidth("10000");
|
tableStyle.setAlign(TableRowAlign.CENTER);
|
BorderStyle borderStyle = new BorderStyle();
|
borderStyle.setColor("000000");
|
borderStyle.setType(XWPFTable.XWPFBorderType.THICK);
|
borderStyle.setSize(14);
|
tableStyle.setLeftBorder(borderStyle);
|
tableStyle.setTopBorder(borderStyle);
|
tableStyle.setRightBorder(borderStyle);
|
tableStyle.setBottomBorder(borderStyle);
|
tableRenderData.setTableStyle(tableStyle);
|
tables1.add(tableRenderData);
|
tables1.forEach(table -> {
|
Map<String, Object> tableMap = new HashMap<>();
|
tableMap.put("table", table);
|
tableMap.put("report", insReport);
|
tables.add(tableMap);
|
});
|
|
});
|
|
StringBuilder standardMethod2 = new StringBuilder();
|
for (String s : standardMethod) {
|
standardMethod2.append("、").append(s);
|
}
|
if (standardMethod2.length() > 0) {
|
standardMethod2.deleteCharAt(0);
|
}
|
tables.forEach(table -> {
|
table.put("tableSize", tables.size() + 1);
|
});
|
// 新订单按模板选择设备；旧订单没有模板设备关系时回退到订单级设备记录。
|
Set<String> reportDeviceNumbers = insOrderTemplateDeviceMapper
|
.selectManagementNumbersByOrderId(orderId).stream()
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toCollection(LinkedHashSet::new));
|
if (reportDeviceNumbers.isEmpty()) {
|
reportDeviceNumbers.addAll(insOrderDeviceRecordMapper.selectDeviceNumber(orderId).stream()
|
.map(InsOrderDeviceRecordDto::getManagementNumber)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toList()));
|
}
|
reportDeviceNumbers.addAll(deviceSet);
|
List<Map<String, String>> deviceList = reportDeviceNumbers.isEmpty()
|
? new ArrayList<>() : insOrderMapper.selectDeviceList(reportDeviceNumbers);
|
if (CollectionUtils.isNotEmpty(deviceList)) {
|
int count = 1;
|
for (Map<String, String> stringMap : deviceList) {
|
stringMap.put("index", String.valueOf(count));
|
count++;
|
}
|
}
|
|
Map<String, String> codeStr = new HashMap<>();
|
codeStr.put("报告编号", insReport.getCode());
|
codeStr.put("样品名称", defaultReportText(insOrder.getSampleView(), insOrder.getSample()));
|
codeStr.put("规格型号", samples.get(0).getModel());
|
codeStr.put("发放日期", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
|
|
String modelStr = CollUtil.join(models, "\n");
|
|
// 检测类型
|
String orderType = null;
|
orderType = iSysDictTypeService.selectLabelByDict(DictDataConstants.CHECK_TYPE, insOrder.getOrderType());
|
// 判断第一个字典是否为空
|
if (StringUtils.isBlank(orderType)) {
|
orderType = iSysDictTypeService.selectLabelByDict(DictDataConstants.CHECK_TYPE1, insOrder.getOrderType());
|
}
|
|
// 来样方式
|
String formType = iSysDictTypeService.selectLabelByDict(DictDataConstants.FORM_TYPE, insOrder.getFormType());
|
|
// 样品外观优先展示字典名称；历史数据或直接保存文本时，回退展示订单原值。
|
String sampleStatus = defaultReportText(
|
iSysDictTypeService.selectLabelByDict(
|
DictDataConstants.SAMPLE_STATUS_LIST, insOrder.getSampleStatus()),
|
insOrder.getSampleStatus());
|
|
// 公司信息
|
Custom custom = customMapper.selectById(insOrder.getCompanyId());
|
|
// 查询判断是否有不判定项目,和全都是判定项
|
int judgeType = showResult ? insProductMapper.selectNoJudge(insOrder.getId()) : 0;
|
String resultCh = "";
|
String resultEn = "";
|
for (String reference : resultChList) {
|
resultCh = resultCh + reference;
|
}
|
for (String reference : resultEnList) {
|
resultEn = resultEn + reference;
|
}
|
switch (judgeType) {
|
// 没有不判定项目
|
case 1:
|
if (StringUtils.isNotBlank(resultCh)) {
|
resultCh = "依据委托要求，" + resultCh + "所检项目不合格，其余所检项目均合格。";
|
resultEn = "According to commissioned requirements," + resultEn + " these inspected items do not meet the requirements, all other inspected items meet the requirements.";
|
} else {
|
resultCh = "依据委托要求，所检项目均符合要求。";
|
resultEn = "According to commissioned requirements, all the tested items meet the requirements.";
|
}
|
break;
|
// 存在不判定项目
|
case 2:
|
if (StringUtils.isNotBlank(resultCh)) {
|
resultCh = "依据委托要求，" + resultCh + "所检项目不合格，其余所检项目除不判定外均符合要求。";
|
resultEn = "According to commissioned requirements," + resultEn + " these inspected items do not meet the requirements, all the inspected items meet the requirements except that they are not judged.";
|
} else {
|
resultCh = "依据委托要求，所检项目除不判定外均符合要求。";
|
resultEn = "According to commissioned requirements, all the tested items meet the requirements.";
|
}
|
break;
|
// 都是不判定项目
|
case 3:
|
resultCh = "依据委托要求，所检项目均不判定。";
|
resultEn = "According to commissioned requirements, the items examined are not judged.";
|
break;
|
}
|
|
/*获取附件图片类型*/
|
List<Map<String, Object>> images = new ArrayList<>();
|
List<InsOrderFile> insOrderFiles = insOrderFileMapper.selectList(Wrappers.<InsOrderFile>lambdaQuery().eq(InsOrderFile::getType, 1).eq(InsOrderFile::getInsOrderId, orderId));
|
if (CollectionUtils.isNotEmpty(insOrderFiles)) {
|
insOrderFiles.forEach(insOrderFile -> {
|
Map<String, Object> image = new HashMap<>();
|
PictureRenderData pictureRenderData = Pictures.ofLocal(imgUrl + "/" + insOrderFile.getFileUrl()).sizeInCm(17, 20).create();
|
image.put("url", pictureRenderData);
|
image.put("report", insReport);
|
images.add(image);
|
});
|
}
|
//委托人和电话字段判断
|
if (ObjectUtils.isEmpty(insOrder.getPrepareUser())) {
|
insOrder.setPrepareUser("/");
|
}
|
if (ObjectUtils.isEmpty(insOrder.getPhone())) {
|
insOrder.setPhone("/");
|
}
|
|
// 抽样日期
|
// 成品是抽样时间
|
LocalDateTime sendTime = insOrder.getSendTime();
|
IfsInventoryQuantity reportInventory = null;
|
if (insOrder.getIfsInventoryId() != null) {
|
reportInventory = ifsInventoryQuantityMapper.selectById(insOrder.getIfsInventoryId());
|
}
|
if (insOrder.getTypeSource() != null && insOrder.getTypeSource().equals(1) && reportInventory != null) {
|
// 原材料收样日期是报检日期
|
sendTime = reportInventory.getDeclareDate();
|
}
|
|
// 检测日期：首次保存模板值时间-首次提交时间
|
LocalDateTime now = LocalDateTime.now();
|
// 提交时间
|
LocalDateTime submitTime = LocalDateTime.now();
|
// 判断是否有提交时间
|
if (insOrder.getFirstSubmitDate() != null) {
|
submitTime = insOrder.getFirstSubmitDate();
|
}
|
|
LocalDateTime firstInspectDate = insOrder.getFirstInspectDate();
|
// 字段上线前的历史订单沿用原来的下发时间，避免改变既有报告口径。
|
if (firstInspectDate == null) {
|
firstInspectDate = insOrder.getSendTime();
|
}
|
|
String insTime = firstInspectDate.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")) + "-"
|
+ submitTime.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
|
|
String insTimeEn = monthNames[firstInspectDate.getMonthValue() - 1] + " " + firstInspectDate.format(DateTimeFormatter.ofPattern("dd, yyyy")) + "-"
|
+ monthNames[submitTime.getMonthValue() - 1] + " " + submitTime.format(DateTimeFormatter.ofPattern("dd, yyyy"));
|
|
// 检验环境：优先汇总各模板填写的温湿度，报告展示全部模板的最小值到最大值。
|
String environment = buildReportEnvironment(orderId, insOrder);
|
String finalEnvironment = environment;
|
LocalDateTime finalSendTime = sendTime;
|
String finalResultCh = resultCh;
|
String finalResultEn = resultEn;
|
String finalOrderType = orderType;
|
List<Map<String, String>> finalDeviceList = deviceList;
|
String finalModelStr = modelStr;
|
|
List<Map<String, String>> detectionResultRows = buildDetectionResultRows(orderId, samples);
|
String productName = defaultReportText(insOrder.getSampleView(), insOrder.getSample());
|
String customerName = defaultReportText(custom == null ? null : custom.getCompany(), insOrder.getCompany());
|
String detectionCategory = defaultReportText(finalOrderType, "委托检测");
|
String sampleCode = samples.stream()
|
.map(SampleProductDto::getSampleCode)
|
.filter(StringUtils::isNotBlank)
|
.distinct()
|
.collect(Collectors.joining("、"));
|
String productAndModel = productName;
|
if (StringUtils.isNotBlank(finalModelStr) && !Objects.equals(productName, finalModelStr)) {
|
productAndModel = productName + " " + finalModelStr;
|
}
|
String standardMethodText = "null".equals(standardMethod2.toString()) ? "" : standardMethod2.toString();
|
String productionDate = "/";
|
String batchNo = "/";
|
if (reportInventory != null) {
|
if (reportInventory.getProductDate() != null) {
|
productionDate = reportInventory.getProductDate().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
|
}
|
batchNo = defaultReportText(reportInventory.getUpdateBatchNo(), reportInventory.getLotBatchNo());
|
}
|
// 新聚直绑模板订单：报告信息取委托信息和订单模板快照，不再取能力范围标准方法。
|
List<InsOrderStandardTemplate> templateSnapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.orderByAsc(InsOrderStandardTemplate::getSort, InsOrderStandardTemplate::getId));
|
boolean newJuTemplateOrder = !templateSnapshots.isEmpty() && isDirectTemplateOrder(orderId);
|
if (newJuTemplateOrder) {
|
productName = defaultReportText(insOrder.getSampleView(), insOrder.getSample());
|
finalModelStr = "/";
|
productAndModel = productName;
|
if (insOrder.getSampleDate() != null) {
|
finalSendTime = insOrder.getSampleDate().atStartOfDay();
|
}
|
if (insOrder.getProductionDate() != null) {
|
productionDate = insOrder.getProductionDate().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
|
}
|
batchNo = defaultReportText(insOrder.getProductionBatch(), "/");
|
standardMethodText = templateSnapshots.stream()
|
.map(InsOrderStandardTemplate::getRemark)
|
.filter(StringUtils::isNotBlank)
|
.distinct()
|
.collect(Collectors.joining("；"));
|
}
|
boolean containsOrganicChlorine = detectionResultRows.stream()
|
.map(row -> row.get("itemName"))
|
.filter(Objects::nonNull)
|
.anyMatch(name -> name.contains("有机氯"));
|
String resultRemark = containsOrganicChlorine
|
? "微库仑法，有机氯含量小于0.005%时，以未检出报出。"
|
: defaultReportText(insOrder.getRemark(), "/");
|
|
// 检测报告和检验报告统一使用新版报告模板
|
String templateName = "/static/detection-report-template-v2.docx";
|
InputStream inputStream = this.getClass().getResourceAsStream(templateName);
|
if (inputStream == null) {
|
throw new RuntimeException("找不到报告模板: " + templateName);
|
}
|
Configure configure = Configure.builder()
|
.bind("deviceList", new HackLoopTableRenderPolicy())
|
.bind("r", new HackLoopTableRenderPolicy(true))
|
.setValidErrorHandler(new PreserveReportPicturePlaceholderHandler())
|
.useSpringEL(true)
|
.build();
|
|
String finalProductAndModel = productAndModel;
|
String finalProductName = productName;
|
String finalCustomerName = customerName;
|
String finalDetectionCategory = detectionCategory;
|
String finalSampleCode = defaultReportText(sampleCode, "/");
|
String finalStandardMethodText = defaultReportText(standardMethodText, "/");
|
String finalProductionDate = productionDate;
|
String finalBatchNo = batchNo;
|
String finalResultRemark = resultRemark;
|
String equipmentText = buildEquipmentText(finalDeviceList);
|
String issueDate = now.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
|
String finalReportModelStr = finalModelStr;
|
LocalDateTime finalReportSendTime = finalSendTime;
|
XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
|
new HashMap<String, Object>() {{
|
put("order", insOrder);
|
put("report", insReport);
|
put("environment", finalEnvironment);
|
put("custom", custom);
|
put("sampleSize", insOrder.getTestQuantity());
|
put("tables", tables);
|
put("tableSize", tables.size() + 1);
|
put("standardMethod", finalStandardMethodText);
|
put("deviceList", finalDeviceList);
|
put("twoCode", null);
|
put("models", finalReportModelStr);
|
put("productSize", productSize.get());
|
put("createTime", now.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));
|
put("createTimeEn", monthNames[now.getMonthValue() - 1] + " " + now.format(DateTimeFormatter.ofPattern("dd, yyyy")));
|
put("insTime", insTime);
|
put("insTimeEn", insTimeEn);
|
put("writeUrl", null);
|
put("insUrl", null);
|
put("images", images);
|
put("examineUrl", null);
|
put("ratifyUrl", null);
|
put("orderType", finalOrderType);
|
put("getTime", finalReportSendTime.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));
|
put("getTimeEn", monthNames[finalReportSendTime.getMonthValue() - 1] + " " + finalReportSendTime.format(DateTimeFormatter.ofPattern("dd, yyyy")));
|
put("seal1", null);
|
put("seal2", null);
|
put("formTypeCh", formType);
|
put("formTypeEn", insOrder.getFormType());
|
put("resultCh", finalResultCh);
|
put("resultEn", finalResultEn);
|
put("sampleStatus", sampleStatus);
|
// 新版检测报告模板（参照《有机氯检测报告》）使用的扁平字段。
|
put("no", insReport.getCode());
|
put("cover", finalProductAndModel);
|
put("product", finalProductName);
|
put("model", defaultReportText(finalReportModelStr, "/"));
|
put("customer", finalCustomerName);
|
put("category", finalDetectionCategory);
|
put("date", issueDate);
|
put("maker", defaultReportText(insOrder.getProduction(), "/"));
|
put("env", finalEnvironment);
|
put("qty", defaultReportText(insOrder.getTestQuantity(), "/"));
|
put("receive", finalReportSendTime.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));
|
put("sampleNo", finalSampleCode);
|
put("appearance", defaultReportText(sampleStatus, "/"));
|
put("sender", defaultReportText(insOrder.getPrepareUser(), "/"));
|
put("produced", finalProductionDate);
|
put("batch", finalBatchNo);
|
put("phone", defaultReportText(insOrder.getPhone(), "/"));
|
put("testDate", insTime);
|
put("entrustNo", defaultReportText(insOrder.getEntrustCode(), "/"));
|
put("sampling", "/");
|
put("standard", finalStandardMethodText);
|
put("equipment", equipmentText);
|
put("conclusion", "样品按委托方要求进行检测，数据见检测结果。");
|
put("remark", "本报告检测结果仅对当日所接收样品负责。");
|
put("r", detectionResultRows);
|
put("resultNote", finalResultRemark);
|
}});
|
try {
|
String name = insReport.getCode().replace("/", "") + (showResult ? ".docx" : "-C.docx");
|
Files.createDirectories(Paths.get(wordUrl));
|
template.writeAndClose(Files.newOutputStream(Paths.get(wordUrl, name)));
|
insReport.setUrl("/word/" + name);
|
insReport.setWriteUserId(writeUserId);//编制人（检验人）
|
insReport.setWriteTime(LocalDateTime.now());//提交时间
|
saveGeneratedReport(insReport);
|
inputStream.close();
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
private void saveGeneratedReport(InsReport report) {
|
InsReport existing = insReportMapper.selectOne(Wrappers.<InsReport>lambdaQuery()
|
.eq(InsReport::getInsOrderId, report.getInsOrderId())
|
.last("limit 1"));
|
if (existing == null) {
|
insReportMapper.insert(report);
|
return;
|
}
|
report.setId(existing.getId());
|
insReportMapper.updateById(report);
|
}
|
|
/**
|
* 新版检测报告的结果表固定为四列：序号、检测项目、单位、检测结果。
|
*/
|
private List<Map<String, String>> buildDetectionResultRows(Integer orderId, List<SampleProductDto> samples) {
|
if (isDirectTemplateOrder(orderId)) {
|
return buildTemplateDetectionResultRows(orderId);
|
}
|
List<Map<String, String>> rows = new ArrayList<>();
|
if (CollectionUtils.isEmpty(samples)) {
|
return rows;
|
}
|
|
boolean multipleSamples = samples.size() > 1;
|
int sequence = 1;
|
for (SampleProductDto sample : samples) {
|
if (CollectionUtils.isEmpty(sample.getInsProduct())) {
|
continue;
|
}
|
for (InsProduct product : sample.getInsProduct()) {
|
// 绑定项目仅参与计算，不应出现在报告中。
|
if (product == null || Objects.equals(product.getIsBinding(), 1)) {
|
continue;
|
}
|
|
String itemName = defaultReportText(
|
product.getInspectionItemSubclass(),
|
defaultReportText(product.getInspectionItem(), product.getInspectionItemClass()));
|
if (multipleSamples && StringUtils.isNotBlank(sample.getSampleCode())) {
|
itemName = sample.getSampleCode() + " - " + itemName;
|
}
|
|
Map<String, String> row = new LinkedHashMap<>();
|
row.put("seq", String.valueOf(sequence++));
|
row.put("itemName", itemName);
|
row.put("unit", defaultReportText(product.getUnit(), "/"));
|
row.put("result", defaultReportText(product.getLastValue(), "/"));
|
rows.add(row);
|
}
|
}
|
return rows;
|
}
|
|
/**
|
* 新聚直绑模板订单：一个模板页签在报告中只对应一条检测项目。
|
*/
|
private List<Map<String, String>> buildTemplateDetectionResultRows(Integer orderId) {
|
List<InsOrderStandardTemplate> snapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.orderByAsc(InsOrderStandardTemplate::getSort, InsOrderStandardTemplate::getId));
|
List<Map<String, String>> rows = new ArrayList<>();
|
int sequence = 1;
|
for (InsOrderStandardTemplate snapshot : snapshots) {
|
TemplateExportCell exportCell = getFirstTemplateExportCell(snapshot.getThing());
|
JSONObject recordValues = StrUtil.isBlank(snapshot.getRecordValues())
|
? new JSONObject() : JSON.parseObject(snapshot.getRecordValues());
|
String result = readTemplateCellText(recordValues, exportCell.resultCoordinate, exportCell.templateValues);
|
if (StringUtils.isBlank(result)) {
|
throw new ErrorException("模板“" + defaultReportText(snapshot.getName(), "模板ID " + snapshot.getTemplateId())
|
+ "”的导出值不能为空");
|
}
|
String unit = exportCell.unitCoordinate == null ? null
|
: readTemplateCellText(recordValues, exportCell.unitCoordinate, exportCell.templateValues);
|
String itemName = exportCell.itemCoordinate == null ? null
|
: readTemplateCellText(recordValues, exportCell.itemCoordinate, exportCell.templateValues);
|
|
Map<String, String> row = new LinkedHashMap<>();
|
row.put("seq", String.valueOf(sequence++));
|
String reportItemName = defaultReportText(itemName,
|
defaultReportText(snapshot.getName(), "模板ID " + snapshot.getTemplateId()));
|
row.put("itemName", formatExportItemName(reportItemName));
|
row.put("unit", defaultReportText(unit, "/"));
|
row.put("result", result);
|
rows.add(row);
|
}
|
if (rows.isEmpty()) {
|
throw new ErrorException("当前订单未找到可生成报告的原始记录模板");
|
}
|
return rows;
|
}
|
|
private TemplateExportCell getFirstTemplateExportCell(String compressedThing) {
|
if (StrUtil.isBlank(compressedThing)) {
|
throw new ErrorException("原始记录模板为空");
|
}
|
String thing;
|
try {
|
thing = GZipUtil.uncompress(compressedThing);
|
} catch (Exception ignored) {
|
thing = compressedThing;
|
}
|
JSONArray cellData = JSON.parseObject(thing).getJSONArray("data").getJSONObject(0).getJSONArray("celldata");
|
Integer resultColumn = null;
|
Integer itemColumn = null;
|
Integer unitColumn = null;
|
List<int[]> exportCells = new ArrayList<>();
|
Map<String, String> templateValues = new HashMap<>();
|
for (Object item : cellData) {
|
JSONObject cell = JSON.parseObject(JSON.toJSONString(item));
|
Integer row = cell.getInteger("r");
|
Integer column = cell.getInteger("c");
|
JSONObject value = cell.getJSONObject("v");
|
if (row == null || column == null || value == null) {
|
continue;
|
}
|
String displayValue = value.get("v") == null ? null : String.valueOf(value.get("v"));
|
templateValues.put(row + "-" + column, displayValue);
|
if (resultColumn == null && "检验结果".equals(StringUtils.trim(displayValue))) {
|
resultColumn = column;
|
}
|
if (itemColumn == null && ("检测项目".equals(StringUtils.trim(displayValue))
|
|| "检验项目".equals(StringUtils.trim(displayValue)))) {
|
itemColumn = column;
|
}
|
if (unitColumn == null && "单位".equals(StringUtils.trim(displayValue))) {
|
unitColumn = column;
|
}
|
JSONObject ps = value.getJSONObject("ps");
|
if (ps != null && "导出值".equals(ps.getString("value"))) {
|
exportCells.add(new int[]{row, column});
|
}
|
}
|
if (exportCells.isEmpty()) {
|
throw new ErrorException("模板必须至少配置一个导出值批注");
|
}
|
exportCells.sort(Comparator.comparingInt((int[] cell) -> cell[0]).thenComparingInt(cell -> cell[1]));
|
int[] firstExport = exportCells.get(0);
|
int resultColumnForRow = resultColumn == null ? firstExport[1] : resultColumn;
|
// 通常“导出值”批注配置在项目名称单元格；若配置在结果单元格，则回到“检测项目”列取名称。
|
Integer itemColumnForRow = !Objects.equals(firstExport[1], resultColumnForRow)
|
? firstExport[1] : itemColumn;
|
TemplateExportCell result = new TemplateExportCell();
|
result.resultCoordinate = firstExport[0] + "-" + resultColumnForRow;
|
result.itemCoordinate = itemColumnForRow == null ? null : firstExport[0] + "-" + itemColumnForRow;
|
result.unitCoordinate = unitColumn == null ? null : firstExport[0] + "-" + unitColumn;
|
result.templateValues = templateValues;
|
return result;
|
}
|
|
private String readTemplateCellText(JSONObject recordValues, String coordinate, Map<String, String> templateValues) {
|
JSONObject recordCell = recordValues == null ? null : recordValues.getJSONObject(coordinate);
|
if (recordCell != null && recordCell.get("v") != null) {
|
String value = String.valueOf(recordCell.get("v"));
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
}
|
return templateValues.get(coordinate);
|
}
|
|
private static class TemplateExportCell {
|
private String itemCoordinate;
|
private String resultCoordinate;
|
private String unitCoordinate;
|
private Map<String, String> templateValues;
|
}
|
|
private static String buildEquipmentText(List<Map<String, String>> deviceList) {
|
if (CollectionUtils.isEmpty(deviceList)) {
|
return "/";
|
}
|
Set<String> lines = new LinkedHashSet<>();
|
int sequence = 1;
|
for (Map<String, String> device : deviceList) {
|
String name = getMapText(device, "deviceName", "device_name");
|
String managementNumber = getMapText(device, "managementNumber", "management_number");
|
String line = sequence++ + ". " + defaultReportText(name, "/");
|
if (StringUtils.isNotBlank(managementNumber)) {
|
line += "：" + managementNumber;
|
}
|
lines.add(line);
|
}
|
return String.join("\n", lines);
|
}
|
|
private String buildReportEnvironment(Integer orderId, InsOrder order) {
|
List<InsOrderStandardTemplate> snapshots = insOrderStandardTemplateService.list(
|
Wrappers.<InsOrderStandardTemplate>lambdaQuery()
|
.eq(InsOrderStandardTemplate::getInsOrderId, orderId)
|
.select(InsOrderStandardTemplate::getTemperature,
|
InsOrderStandardTemplate::getHumidity));
|
List<String> temperatures = snapshots.stream()
|
.map(InsOrderStandardTemplate::getTemperature)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toList());
|
List<String> humidities = snapshots.stream()
|
.map(InsOrderStandardTemplate::getHumidity)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toList());
|
|
String temperature = formatConditionRange(temperatures, order.getTemperature(), "℃");
|
String humidity = formatConditionRange(humidities, order.getHumidity(), "%");
|
return Stream.of(temperature, humidity)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.joining(" "));
|
}
|
|
private static String formatConditionRange(List<String> values, String fallback, String unit) {
|
List<BigDecimal> numbers = new ArrayList<>();
|
List<String> candidates = CollectionUtils.isEmpty(values)
|
? Collections.singletonList(fallback) : values;
|
Pattern numberPattern = Pattern.compile("-?\\d+(?:\\.\\d+)?");
|
for (String value : candidates) {
|
if (StringUtils.isBlank(value)) {
|
continue;
|
}
|
java.util.regex.Matcher matcher = numberPattern.matcher(value);
|
while (matcher.find()) {
|
numbers.add(new BigDecimal(matcher.group()));
|
}
|
}
|
if (numbers.isEmpty()) {
|
// “/”表示模板明确填写了不适用，不能再按空值处理或追加单位。
|
return candidates.stream()
|
.filter(StringUtils::isNotBlank)
|
.map(String::trim)
|
.distinct()
|
.collect(Collectors.joining("~"));
|
}
|
BigDecimal minimum = Collections.min(numbers);
|
BigDecimal maximum = Collections.max(numbers);
|
String minimumText = minimum.stripTrailingZeros().toPlainString();
|
if (minimum.compareTo(maximum) == 0) {
|
return minimumText + unit;
|
}
|
return minimumText + "~" + maximum.stripTrailingZeros().toPlainString() + unit;
|
}
|
|
/** 报告项目名称不展示模板计算过程中的“平均值”字样及其后的分隔逗号。 */
|
private static String formatExportItemName(String itemName) {
|
if (StringUtils.isBlank(itemName)) {
|
return itemName;
|
}
|
return itemName.replaceAll("平均值\\s*[，,]?\\s*", "");
|
}
|
|
private static String getMapText(Map<String, String> map, String... keys) {
|
if (map == null) {
|
return null;
|
}
|
for (String key : keys) {
|
String value = map.get(key);
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
for (Map.Entry<String, String> entry : map.entrySet()) {
|
if (entry.getKey() != null && entry.getKey().equalsIgnoreCase(key)
|
&& StringUtils.isNotBlank(entry.getValue())) {
|
return entry.getValue();
|
}
|
}
|
}
|
return null;
|
}
|
|
private static String defaultReportText(String value, String fallback) {
|
if (StringUtils.isNotBlank(value)) {
|
return value;
|
}
|
return StringUtils.isNotBlank(fallback) ? fallback : "/";
|
}
|
|
/**
|
* 计算表格列宽度
|
* @param max 最大检验个数
|
* @return
|
*/
|
private static int[] calcTableColWidths(int max, boolean showResult){
|
if (!showResult) {
|
switch (max) {
|
case 1: return new int[]{650, 2200, 2200, 850, 2300, 1800};
|
case 2: return new int[]{650, 1600, 1600, 850, 1900, 1700, 1700};
|
case 3: return new int[]{650, 1400, 1400, 850, 1600, 1375, 1375, 1375};
|
case 4: return new int[]{650, 1250, 1250, 850, 1450, 1140, 1140, 1140, 1140};
|
case 5: return new int[]{650, 1150, 1150, 850, 1300, 980, 980, 980, 980, 980};
|
default: return new int[0];
|
}
|
}
|
int[] colWidths = null;
|
switch (max) {
|
case 1:
|
colWidths = new int[]{650, 2000, 2000, 850, 2200, 2100, 1200};
|
break;
|
case 2:
|
colWidths = new int[]{650, 1400, 1400, 850, 2100, 1200, 1200, 1200};
|
break;
|
case 3:
|
colWidths = new int[]{650, 1400, 1400, 850, 1500, 1000, 1000, 1000, 1200};
|
break;
|
case 4:
|
colWidths = new int[]{650, 1200, 1200, 850, 1400, 850, 850, 850, 850, 1200};
|
break;
|
case 5:
|
colWidths = new int[]{650, 1100, 1100, 850, 1350, 750, 750, 750, 750, 750, 1200};
|
break;
|
}
|
if(ObjectUtils.isNull(colWidths)){
|
List<Integer> defaultColWidths = new ArrayList<>(Arrays.asList(650, 1100, 1100, 850, 1350));
|
int totalWidth = 3000;//总宽度
|
int byOneWidth = totalWidth/max;//每一个的宽度
|
int realWidth = 0;//实际宽度
|
for (int i = 0; i < max; i++) {
|
realWidth+=byOneWidth;
|
defaultColWidths.add(byOneWidth);
|
}
|
defaultColWidths.add(1200+(totalWidth-realWidth));
|
return defaultColWidths.stream().mapToInt(Integer::intValue).toArray();
|
}
|
return colWidths;
|
}
|
|
/**
|
* 调整高度
|
* @param row
|
* @param rowHeight
|
* @return
|
*/
|
private static double adjustRowHeight(RowRenderData row, double rowHeight, int max) {
|
// 根据检验项目名称进行高度调整
|
TextRenderData renderData = (TextRenderData) row.getCells().get(1).getParagraphs().get(0).getContents().get(0);
|
String dataText = renderData.getText();
|
TextRenderData valueData = (TextRenderData) row.getCells().get(5).getParagraphs().get(0).getContents().get(0);
|
String valueText = valueData.getText();
|
// 获取检测内容判断是否超出
|
if (StringUtils.isNotBlank(dataText) && dataText.contains("@")) {
|
double number = 1;
|
double chinaLength = 14;
|
double englishLength = 28;
|
double valueLength = 6;
|
// 根据线芯个数判断距离
|
switch (max) {
|
case 1:
|
chinaLength = 15;
|
englishLength = 30;
|
valueLength = 8;
|
break;
|
case 2:
|
chinaLength = 13;
|
englishLength = 25;
|
valueLength = 6;
|
break;
|
case 3:
|
chinaLength = 13;
|
englishLength = 25;
|
valueLength = 4;
|
break;
|
case 4:
|
chinaLength = 13;
|
englishLength = 23;
|
valueLength = 3;
|
break;
|
case 5:
|
chinaLength = 12;
|
englishLength = 22;
|
valueLength = 2;
|
break;
|
}
|
// 根据@符号截取中英文
|
String[] split = dataText.split("@");
|
// 文字倍数
|
double chinaMultiple = (Math.ceil(split[0].length() / chinaLength)) - 1;
|
|
// 英文倍数
|
double englishMultiple = (Math.ceil(split[1].length() / englishLength)) - 1;
|
double multiple = number + chinaMultiple * 0.5 + englishMultiple * 0.5;
|
|
if (StringUtils.isNotBlank(valueText)) {
|
double valueMultiple = (Math.ceil(valueText.length() / valueLength)) - 1;
|
if (multiple < number + valueMultiple * 0.4) {
|
multiple = number + valueMultiple * 0.4;
|
}
|
}
|
rowHeight = rowHeight * multiple;
|
}
|
return rowHeight;
|
}
|
|
/**
|
* 合并单元格
|
*/
|
private void updaeMerge(XWPFDocument document, boolean isSmall) {
|
// 处理合并单元格的问题
|
// 获取文档中的所有表格
|
List<XWPFTable> xwpfTables = document.getTables();
|
// 遍历表格
|
for (int i = 1; i < xwpfTables.size(); i++) {
|
// 创建一个HashSet来存储唯一的字符串（这里基于"∑"分割后的第二部分）
|
Set<String> set1 = new HashSet<>();
|
// 创建一个HashMap来存储每个唯一字符串及其对应的单元格位置信息
|
Map<String, Map<String, Integer>> maps = new HashMap<>();
|
// 遍历当前表格的所有行
|
for (int j = 0; j < xwpfTables.get(i).getRows().size(); j++) {
|
// 遍历当前行的所有单元格
|
for (int k = 0; k < xwpfTables.get(i).getRows().get(j).getTableCells().size(); k++) {
|
// 检查单元格文本中是否包含"∑"
|
if (xwpfTables.get(i).getRows().get(j).getTableCells().get(k).getText().indexOf("∑") > -1) {
|
String[] split = xwpfTables.get(i).getRows().get(j).getTableCells().get(k).getText().split("∑");
|
// 如果分割后的第二部分是新的（即之前未出现过），则添加到set1并创建位置信息map
|
if (set1.add(split[1])) {
|
Map<String, Integer> map = new HashMap<>();
|
// 存储起始行、起始列、结束行（当前行）、结束列（当前列）
|
map.put("sr", j);
|
map.put("sc", k);
|
map.put("er", j + 0);
|
map.put("ec", k + 0);
|
maps.put(split[1], map);
|
} else {
|
// 如果已存在，则更新结束行或结束列
|
Map<String, Integer> map1 = maps.get(split[1]);
|
if (j == map1.get("sr")) {
|
map1.put("ec", map1.get("ec") + 1);
|
} else if (k == map1.get("sc")) {
|
map1.put("er", map1.get("er") + 1);
|
}
|
}
|
// 判断小高报告还是大报告
|
if (isSmall) {
|
// 获取单元格
|
XWPFTableCell cell = xwpfTables.get(i).getRows().get(j).getTableCells().get(k);
|
XWPFParagraph paragraph = cell.getParagraphArray(0);
|
String originalText = paragraph.getText();
|
String newText = originalText.split("∑")[0];
|
List<XWPFRun> runs = paragraph.getRuns();
|
for (XWPFRun run : runs) {
|
run.setText("", 0); // 清空 run 中的文本
|
}
|
if (!runs.isEmpty()) {
|
XWPFRun run = runs.get(0);
|
run.setText(newText);
|
|
// 复制样式
|
run.setFontFamily(paragraph.getRuns().get(0).getFontFamily());
|
run.setFontSize(paragraph.getRuns().get(0).getFontSize());
|
run.setBold(paragraph.getRuns().get(0).isBold());
|
run.setItalic(paragraph.getRuns().get(0).isItalic());
|
run.setUnderline(paragraph.getRuns().get(0).getUnderline());
|
run.setColor(paragraph.getRuns().get(0).getColor());
|
}
|
|
cell.setVerticalAlignment(XWPFTableCell.XWPFVertAlign.CENTER);
|
paragraph.setAlignment(ParagraphAlignment.CENTER);
|
} else {
|
// 移除包含"∑"的段落，并重新设置单元格文本和样式
|
String str = xwpfTables.get(i).getRows().get(j).getTableCells().get(k).getText().split("∑")[0];
|
xwpfTables.get(i).getRows().get(j).getTableCells().get(k).removeParagraph(0);
|
xwpfTables.get(i).getRows().get(j).getTableCells().get(k).setText(str);
|
xwpfTables.get(i).getRows().get(j).getTableCells().get(k).setVerticalAlignment(XWPFTableCell.XWPFVertAlign.CENTER);
|
xwpfTables.get(i).getRows().get(j).getTableCells().get(k).getParagraphArray(0).setAlignment(ParagraphAlignment.CENTER);
|
}
|
}
|
}
|
}
|
|
// 单元格排序, 避免格式错乱
|
List<Map.Entry<String, Map<String, Integer>>> entries = new ArrayList<>(maps.entrySet());
|
entries.sort((o1, o2) -> o1.getValue().get("sc") - o2.getValue().get("sc"));
|
|
// 按照顺序添加进集合
|
List<String> list = new ArrayList<>();
|
for (Map.Entry<String, Map<String, Integer>> entry : entries) {
|
list.add(entry.getKey());
|
}
|
|
for (int a = list.size() - 1; a >= 0; a--) {
|
Map<String, Integer> v = maps.get(list.get(a));
|
for (int j = 0; j < v.get("er") - v.get("sr") + 1; j++) {
|
if (v.get("ec") > v.get("sc")) {
|
try {
|
TableTools.mergeCellsHorizonal(xwpfTables.get(i), v.get("sr") + j, v.get("sc"), v.get("ec"));
|
} catch (Exception e) {
|
}
|
}
|
}
|
if (v.get("er") > v.get("sr")) {
|
try {
|
TableTools.mergeCellsVertically(xwpfTables.get(i), v.get("sc"), v.get("sr"), v.get("er"));
|
} catch (Exception e) {
|
}
|
}
|
}
|
}
|
|
//处理中英文换行的问题
|
|
List<XWPFTable> xwpfTables1 = document.getTables();
|
for (int i = 1; i < xwpfTables1.size(); i++) {
|
for (int j = 0; j < xwpfTables1.get(i).getRows().size(); j++) {
|
for (int k = 0; k < xwpfTables1.get(i).getRows().get(j).getTableCells().size(); k++) {
|
if (xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).getText().contains("@")) {
|
if (isSmall) {
|
// 获取原有段落的第一个 XWPFRun
|
String text = xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).getText();
|
XWPFParagraph oldParagraph = xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).getParagraphs().get(0);
|
XWPFRun oldRun = oldParagraph.getRuns().get(0);
|
// 保存原有样式
|
String fontFamily = oldRun.getFontFamily();
|
int fontSize = oldRun.getFontSize();
|
boolean isBold = oldRun.isBold();
|
boolean isItalic = oldRun.isItalic();
|
boolean isUnderline = oldRun.getUnderline() != UnderlinePatterns.NONE;
|
// 删除原有段落
|
xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).removeParagraph(0);
|
// 添加新段落
|
XWPFParagraph newParagraph = xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).addParagraph();
|
XWPFRun newRun = newParagraph.createRun();
|
// 应用保存的样式
|
newRun.setFontFamily(fontFamily);
|
newRun.setFontSize(fontSize);
|
newRun.setBold(isBold);
|
newRun.setItalic(isItalic);
|
if (isUnderline) {
|
newRun.setUnderline(UnderlinePatterns.SINGLE);
|
}
|
// 设置新文本
|
String[] split = text.split("@");
|
newRun.setText(split[0]);
|
if (split.length > 1) {
|
newRun.addBreak();
|
newRun.setText(split[1]);
|
}
|
// 设置段落对齐方式
|
newParagraph.setAlignment(ParagraphAlignment.CENTER);
|
} else {
|
String text = xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).getText();
|
String[] split = text.split("@");
|
xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).removeParagraph(0);
|
XWPFParagraph xwpfParagraph = xwpfTables1.get(i).getRows().get(j).getTableCells().get(k).addParagraph();
|
XWPFRun run = xwpfParagraph.createRun();
|
run.setText(split[0]);
|
if (ObjectUtils.isNotNull(split[1])) {
|
run.addBreak();
|
run.setText(split[1]);
|
}
|
xwpfParagraph.setAlignment(ParagraphAlignment.CENTER);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/**
|
* 添加报告表头
|
* @param sample
|
* @param text
|
* @param rowRenderData
|
* @param rows
|
* @param max
|
* @param cableTags 线芯颜色
|
*/
|
private static void addHead(SampleProductDto sample, List<TextRenderData> text, RowRenderData rowRenderData, List<RowRenderData> rows, int max, List<String> cableTags, boolean showResult) {
|
// 第一行
|
TextRenderData firstRenderData1 = new TextRenderData();
|
firstRenderData1.setText("样品编号@Sample No.∑1");
|
Style firstStyle1 = new Style();
|
firstStyle1.setFontFamily("宋体");
|
firstStyle1.setColor("000000");
|
firstRenderData1.setStyle(firstStyle1);
|
text.add(firstRenderData1);
|
|
TextRenderData firstRenderData2 = new TextRenderData();
|
firstRenderData2.setText("样品编号@Sample No.∑1");
|
Style firstStyle2 = new Style();
|
firstStyle2.setFontFamily("宋体");
|
firstStyle2.setColor("000000");
|
firstRenderData2.setStyle(firstStyle2);
|
text.add(firstRenderData2);
|
|
TextRenderData firstRenderData3 = new TextRenderData();
|
firstRenderData3.setText(sample.getSampleCode() + "∑2");
|
Style firstStyle3 = new Style();
|
firstStyle3.setFontFamily("宋体");
|
firstStyle3.setColor("000000");
|
firstRenderData3.setStyle(firstStyle3);
|
text.add(firstRenderData3);
|
|
TextRenderData firstRenderData4 = new TextRenderData();
|
firstRenderData4.setText(sample.getSampleCode() + "∑2");
|
Style firstStyle4 = new Style();
|
firstStyle4.setFontFamily("宋体");
|
firstStyle4.setColor("000000");
|
firstRenderData4.setStyle(firstStyle4);
|
text.add(firstRenderData4);
|
|
|
// 判断循环条件
|
|
if (max <= 2) {
|
for (int i = 0; i < max; i++) {
|
TextRenderData firstRenderData5 = new TextRenderData();
|
firstRenderData5.setText("规格型号@Type∑3");
|
Style firstStyle5 = new Style();
|
firstStyle5.setFontFamily("宋体");
|
firstStyle5.setColor("000000");
|
firstRenderData4.setStyle(firstStyle5);
|
text.add(firstRenderData5);
|
}
|
for (int i = 0; i < 2; i++) {
|
TextRenderData firstRenderData6 = new TextRenderData();
|
firstRenderData6.setText(sample.getModel() + "∑4");
|
Style firstStyle6 = new Style();
|
firstStyle6.setFontFamily("宋体");
|
firstStyle6.setColor("000000");
|
firstRenderData6.setStyle(firstStyle6);
|
text.add(firstRenderData6);
|
}
|
} else {
|
for (int i = 0; i < 2; i++) {
|
TextRenderData firstRenderData5 = new TextRenderData();
|
firstRenderData5.setText("规格型号@Type∑3");
|
Style firstStyle5 = new Style();
|
firstStyle5.setFontFamily("宋体");
|
firstStyle5.setColor("000000");
|
firstRenderData4.setStyle(firstStyle5);
|
text.add(firstRenderData5);
|
}
|
for (int i = 0; i < max; i++) {
|
TextRenderData firstRenderData6 = new TextRenderData();
|
firstRenderData6.setText(sample.getModel() + "∑4");
|
Style firstStyle6 = new Style();
|
firstStyle6.setFontFamily("宋体");
|
firstStyle6.setColor("000000");
|
firstRenderData6.setStyle(firstStyle6);
|
text.add(firstRenderData6);
|
}
|
|
}
|
// 检测报告不展示“结论”列，首行也要同步减少一个单元格，
|
// 否则首行为 max + 6 列、其余行为 max + 5 列，poi-tl 无法渲染表格。
|
if (!showResult && !text.isEmpty()) {
|
text.remove(text.size() - 1);
|
}
|
TextRenderData[] text2 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text2).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
|
// 第二行
|
TextRenderData headRenderData1 = new TextRenderData();
|
headRenderData1.setText("序号@NO.");
|
Style headStyle1 = new Style();
|
headStyle1.setFontFamily("宋体");
|
headStyle1.setColor("000000");
|
headRenderData1.setStyle(headStyle1);
|
text.add(headRenderData1);
|
|
TextRenderData headRenderData2 = new TextRenderData();
|
headRenderData2.setText("检验项目@Test item∑5");
|
Style headStyle2 = new Style();
|
headStyle2.setFontFamily("宋体");
|
headStyle2.setColor("000000");
|
headRenderData2.setStyle(headStyle2);
|
text.add(headRenderData2);
|
|
TextRenderData headRenderData3 = new TextRenderData();
|
headRenderData3.setText("检验项目@Test item∑5");
|
Style headStyle3 = new Style();
|
headStyle3.setFontFamily("宋体");
|
headStyle3.setColor("000000");
|
headRenderData3.setStyle(headStyle3);
|
text.add(headRenderData3);
|
|
TextRenderData headRenderData4 = new TextRenderData();
|
headRenderData4.setText("单位@Unit");
|
Style headStyle4 = new Style();
|
headStyle4.setFontFamily("宋体");
|
headStyle4.setColor("000000");
|
headRenderData4.setStyle(headStyle4);
|
text.add(headRenderData4);
|
|
TextRenderData headRenderData5 = new TextRenderData();
|
headRenderData5.setText("标准要求@Requirement");
|
Style headStyle5 = new Style();
|
headStyle5.setFontFamily("宋体");
|
headStyle5.setColor("000000");
|
headRenderData5.setStyle(headStyle5);
|
text.add(headRenderData5);
|
|
for (int i = 0; i < max; i++) {
|
TextRenderData headRenderData6 = new TextRenderData();
|
headRenderData6.setText(showResult ? "检验结果@Test result∑6" : "检测数据@Test data∑6");
|
Style headStyle6 = new Style();
|
headStyle6.setFontFamily("宋体");
|
headStyle6.setColor("000000");
|
headRenderData6.setStyle(headStyle6);
|
text.add(headRenderData6);
|
}
|
if (showResult) {
|
TextRenderData headRenderData7 = new TextRenderData();
|
headRenderData7.setText("结论@Conclusion");
|
Style headStyle7 = new Style();
|
headStyle7.setFontFamily("宋体");
|
headStyle7.setColor("000000");
|
headRenderData7.setStyle(headStyle7);
|
text.add(headRenderData7);
|
}
|
|
TextRenderData[] text3 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text3).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
|
// 线芯颜色
|
if (CollectionUtils.isNotEmpty(cableTags)) {
|
TextRenderData cableRenderData1 = new TextRenderData();
|
cableRenderData1.setText("");
|
Style cableStyle1 = new Style();
|
cableStyle1.setFontFamily("宋体");
|
cableStyle1.setColor("000000");
|
cableRenderData1.setStyle(cableStyle1);
|
text.add(cableRenderData1);
|
|
TextRenderData cableRenderData2 = new TextRenderData();
|
cableRenderData2.setText("绝缘线芯颜色和标志@Insulation core color and mark∑200");
|
Style cableStyle2 = new Style();
|
cableStyle2.setFontFamily("宋体");
|
cableStyle2.setColor("000000");
|
cableRenderData2.setStyle(cableStyle2);
|
text.add(cableRenderData2);
|
|
TextRenderData cableRenderData3 = new TextRenderData();
|
cableRenderData3.setText("绝缘线芯颜色和标志@Insulation core color and mark∑200");
|
Style cableStyle3 = new Style();
|
cableStyle3.setFontFamily("宋体");
|
cableStyle3.setColor("000000");
|
cableRenderData3.setStyle(cableStyle3);
|
text.add(cableRenderData3);
|
|
TextRenderData cableRenderData4 = new TextRenderData();
|
cableRenderData4.setText("");
|
Style cableStyle4 = new Style();
|
cableStyle4.setFontFamily("宋体");
|
cableStyle4.setColor("000000");
|
cableRenderData4.setStyle(cableStyle4);
|
text.add(cableRenderData4);
|
|
TextRenderData cableRenderData5 = new TextRenderData();
|
cableRenderData5.setText("");
|
Style cableStyle5 = new Style();
|
cableStyle5.setFontFamily("宋体");
|
cableStyle5.setColor("000000");
|
cableRenderData5.setStyle(cableStyle5);
|
text.add(cableRenderData5);
|
|
for (String cableTag : cableTags) {
|
TextRenderData cableRenderData6 = new TextRenderData();
|
cableRenderData6.setText(cableTag);
|
Style cableStyle6 = new Style();
|
cableStyle6.setFontFamily("宋体");
|
cableStyle6.setColor("000000");
|
cableRenderData6.setStyle(cableStyle6);
|
text.add(cableRenderData6);
|
}
|
if (showResult) {
|
TextRenderData cableRenderData7 = new TextRenderData();
|
cableRenderData7.setText("-");
|
Style cableStyle7 = new Style();
|
cableStyle7.setFontFamily("宋体");
|
cableStyle7.setColor("000000");
|
cableRenderData7.setStyle(cableStyle7);
|
text.add(cableRenderData7);
|
}
|
|
TextRenderData[] text4 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text4).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
}
|
|
|
}
|
|
|
/**
|
* 添加检测值
|
* @param a 当前样品
|
* @param text
|
* @param rowRenderData
|
* @param rows
|
* @param max 检验数量
|
* @param resultChList 不符合信息中文
|
* @param resultEhList 不符合信息英文
|
* @param insSamples
|
* @param cableTags 线芯颜色
|
* @param isOneSample 判断是否是只有一个样品
|
*/
|
private int addTestValue(SampleProductDto a,
|
List<TextRenderData> text,
|
RowRenderData rowRenderData,
|
List<RowRenderData> rows,
|
int max,
|
List<String> resultChList,
|
List<String> resultEhList,
|
InsSample insSamples, List<String> cableTags,
|
boolean isOneSample, boolean showResult) {
|
// 检验项总数
|
AtomicInteger productSize = new AtomicInteger(1);
|
// 不合格信息
|
AtomicReference<String> resultCh = new AtomicReference<>("");
|
AtomicReference<String> resultEn = new AtomicReference<>("");
|
// 查询检验结果
|
List<Integer> ids = new ArrayList<>();
|
ids.add(a.getId());
|
List<SampleProductExportDto> sampleProductDto2s = insOrderMapper.selectSampleBySampleId(ids);
|
|
// 判断是否是季度检验, 且有没有进厂检验, 有进厂检验进厂检验的信息赋值到季度上
|
if (insSamples != null) {
|
// 查询检验内容
|
List<SampleProductExportDto> enterDto = insOrderMapper.selectSampleBySampleIdOne(insSamples.getId());
|
// 排除掉进厂报告重复的
|
enterDto = enterDto.stream().filter(sampleProductDto2 -> {
|
// 判断检验项检验子项是否一样, 一样就直接返回false排除
|
return !sampleProductDto2s.stream().anyMatch(dto -> {
|
String quarter = sampleProductDto2.getInspectionItem() + sampleProductDto2.getInspectionItemSubclass();
|
String enter = dto.getInspectionItem() + dto.getInspectionItemSubclass();
|
return quarter.equals(enter);
|
});
|
}).collect(Collectors.toList());
|
sampleProductDto2s.addAll(enterDto);
|
}
|
|
// 格式化修改检验项
|
this.formatProducts(sampleProductDto2s);
|
|
List<SampleProductExportDto> sampleList = new ArrayList<>();
|
|
// 获取检验项分类的
|
Map<String, List<SampleProductExportDto>> itemClassMap = sampleProductDto2s.stream().filter(sampleProductDto2 -> StringUtils.isNotBlank(sampleProductDto2.getInspectionItemClass()))
|
.collect(Collectors.groupingBy(SampleProductExportDto::getInspectionItemClass));
|
|
List<Map.Entry<String, List<SampleProductExportDto>>> itemClassEntries = new ArrayList<>(itemClassMap.entrySet());
|
itemClassEntries.sort((o1, o2) -> {
|
// 再比较 sort
|
Integer sort1 = o1.getValue().get(0).getSort();
|
Integer sort2 = o2.getValue().get(0).getSort();
|
sort1 = sort1 == null ? 0 : sort1;
|
sort2 = sort2 == null ? 0 : sort2;
|
return sort1.compareTo(sort2);
|
});
|
// 创建一个 LinkedHashMap 来保持插入顺序
|
Map<String, List<SampleProductExportDto>> itemClassList = new LinkedHashMap<>();
|
for (Map.Entry<String, List<SampleProductExportDto>> entry : itemClassEntries) {
|
itemClassList.put(entry.getKey(), entry.getValue());
|
}
|
|
if (CollectionUtils.isNotEmpty(itemClassList)) {
|
AtomicInteger finalIndex = new AtomicInteger(1);
|
|
// 获取检验项分类相同的
|
itemClassList.forEach((s, sampleClass) -> {
|
// 添加检验分类
|
SampleProductExportDto classDto = new SampleProductExportDto();
|
// 判断是否有英文名称
|
SampleProductExportDto temp = sampleClass.get(0);
|
if (StringUtils.isNotBlank(temp.getInspectionItemClassEN())) {
|
classDto.setInspectionName(temp.getInspectionItemClass() + "@" + temp.getInspectionItemClassEN());
|
} else {
|
classDto.setInspectionName(temp.getInspectionItemClass());
|
}
|
classDto.setIndex(Integer.toString(finalIndex.get()));
|
sampleList.add(classDto);
|
|
// 添加检验项
|
Map<String, List<SampleProductExportDto>> sortedMap = sampleClass.stream()
|
.filter(sampleProductDto2 -> StringUtils.isNotBlank(sampleProductDto2.getInspectionItem()))
|
.collect(Collectors.groupingBy(SampleProductExportDto::getInspectionItemRadius));
|
|
List<Map.Entry<String, List<SampleProductExportDto>>> entries = new ArrayList<>(sortedMap.entrySet());
|
entries.sort((o1, o2) -> {
|
// 再比较 sort
|
Integer sort1 = o1.getValue().get(0).getSort();
|
Integer sort2 = o2.getValue().get(0).getSort();
|
sort1 = sort1 == null ? 0 : sort1;
|
sort2 = sort2 == null ? 0 : sort2;
|
return sort1.compareTo(sort2);
|
});
|
// 创建一个 LinkedHashMap 来保持插入顺序
|
Map<String, List<SampleProductExportDto>> item = new LinkedHashMap<>();
|
for (Map.Entry<String, List<SampleProductExportDto>> entry : entries) {
|
item.put(entry.getKey(), entry.getValue());
|
}
|
|
AtomicInteger belowIndex = new AtomicInteger(1);
|
item.forEach((s2, sampleProductDtoInside) -> {
|
// 添加检验项
|
SampleProductExportDto dto2 = new SampleProductExportDto();
|
// 判断是否有英文名称
|
SampleProductExportDto temp2 = sampleProductDtoInside.get(0);
|
if (StringUtils.isNotBlank(temp2.getInspectionItemEn())) {
|
dto2.setInspectionName(temp2.getInspectionItem() + "@" + temp2.getInspectionItemEn());
|
} else {
|
dto2.setInspectionName(temp2.getInspectionItem());
|
}
|
// 判断有没有条件字段填充到要求
|
if (StringUtils.isNotBlank(temp2.getRadius())) {
|
dto2.setTell("(" + temp2.getRadius() + ")");
|
}
|
// 判断是否有检验子项,没有就把检验参数填充
|
dto2.setIndex(finalIndex.get() + "." + belowIndex.get());
|
if (StringUtils.isBlank(temp2.getInspectionItemSubclass())) {
|
// 处理集合
|
Map<String, SampleProductExportDto> map = new LinkedHashMap<>();
|
for (SampleProductExportDto productDto2 : sampleProductDtoInside) {
|
String productName = productDto2.getInspectionItemClass() + productDto2.getInspectionItem();
|
if (map.containsKey(productName)) {
|
// 如果名称已经存在，添加 lastValue 值到 lastValueList 列表
|
map.get(productName)
|
.getLastValueList()
|
.add(productDto2.getLastValue());
|
map.get(productName)
|
.getInsResultList()
|
.add(productDto2.getInsResult());
|
// 添加颜色对应的值和结果
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
map.get(productName)
|
.getCableTagValueMap()
|
.put(productDto2.getCableTag(), productDto2.getLastValue());
|
map.get(productName)
|
.getCableTagResultMap()
|
.put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
// 添加标准要求来确定唯一性
|
map.get(productName).getTellSet().add(productDto2.getTell());
|
} else {
|
// 如果名称不存在，直接放入 map
|
productDto2.setLastValueList(new ArrayList<>()); // 检验内容
|
productDto2.getLastValueList().add(productDto2.getLastValue());
|
productDto2.setInsResultList(new ArrayList<>()); // 结果
|
productDto2.getInsResultList().add(productDto2.getInsResult());
|
productDto2.setTellSet(new LinkedHashSet<>());
|
productDto2.getTellSet().add(productDto2.getTell());// 标准要求
|
|
// 判断是否有线芯颜色, 添加颜色对应的值和结果
|
productDto2.setCableTagValueMap(new TreeMap<>());
|
productDto2.setCableTagResultMap(new TreeMap<>());
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
productDto2.getCableTagValueMap().put(productDto2.getCableTag(), productDto2.getLastValue());
|
productDto2.getCableTagResultMap().put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
|
map.put(productName, productDto2);
|
}
|
}
|
List<SampleProductExportDto> result = new ArrayList<>(map.values());
|
|
|
//添加检验项
|
SampleProductExportDto temp3 = result.get(0);
|
String itemName = temp3.getInspectionItem();
|
if (StringUtils.isNotBlank(temp3.getRadius())) {
|
itemName = itemName + "(" + temp3.getRadius() + ")";
|
}
|
// 判断有没有条件字段有需要拼接到名称后面
|
if (StringUtils.isNotBlank(temp3.getInspectionItemEn())) {
|
temp3.setInspectionName(itemName + "@" + temp3.getInspectionItemEn());
|
} else {
|
temp3.setInspectionName(itemName);
|
}
|
// 判断有没有条件字段有需要拼接到名称后面
|
// 判断有没有条件字段填充到要求
|
if (StringUtils.isNotBlank(temp3.getRadius())) {
|
temp3.setTell("(" + temp3.getRadius() + ")");
|
}
|
temp3.setIndex(finalIndex.get() + "." + belowIndex.get());
|
sampleList.add(temp3);
|
} else {
|
sampleList.add(dto2);
|
// 现在需要根据子项去重累加检验结果
|
// 处理集合
|
Map<String, SampleProductExportDto> map = new LinkedHashMap<>();
|
for (SampleProductExportDto productDto2 : sampleProductDtoInside) {
|
String productName = productDto2.getInspectionItemClass() + productDto2.getInspectionItem() + productDto2.getInspectionItemSubclass();
|
if (map.containsKey(productName)) {
|
// 如果名称已经存在，添加 lastValue 值到 lastValueList 列表
|
map.get(productName)
|
.getLastValueList()
|
.add(productDto2.getLastValue());
|
map.get(productName)
|
.getInsResultList()
|
.add(productDto2.getInsResult());
|
// 添加颜色对应的值和结果
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
map.get(productName)
|
.getCableTagValueMap()
|
.put(productDto2.getCableTag(), productDto2.getLastValue());
|
map.get(productName)
|
.getCableTagResultMap()
|
.put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
// 添加标准要求来确定唯一性
|
map.get(productName).getTellSet().add(productDto2.getTell());
|
} else {
|
// 如果名称不存在，直接放入 map
|
productDto2.setLastValueList(new ArrayList<>()); // 检验内容
|
productDto2.getLastValueList().add(productDto2.getLastValue());
|
productDto2.setInsResultList(new ArrayList<>()); // 结果
|
productDto2.getInsResultList().add(productDto2.getInsResult());
|
productDto2.setTellSet(new LinkedHashSet<>());
|
productDto2.getTellSet().add(productDto2.getTell());// 标准要求
|
|
// 判断是否有线芯颜色, 添加颜色对应的值和结果
|
productDto2.setCableTagValueMap(new TreeMap<>());
|
productDto2.setCableTagResultMap(new TreeMap<>());
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
productDto2.getCableTagValueMap().put(productDto2.getCableTag(), productDto2.getLastValue());
|
productDto2.getCableTagResultMap().put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
|
map.put(productName, productDto2);
|
}
|
}
|
List<SampleProductExportDto> result = new ArrayList<>(map.values());
|
|
//添加检验子项
|
for (SampleProductExportDto productDto2 : result) {
|
if (StringUtils.isNotBlank(productDto2.getInspectionItemSubclassEn())) {
|
productDto2.setInspectionName("--" + productDto2.getInspectionItemSubclass() + "@"
|
+ "--" + productDto2.getInspectionItemSubclassEn());
|
} else {
|
productDto2.setInspectionName("--" + productDto2.getInspectionItemSubclass());
|
}
|
sampleList.add(productDto2);
|
}
|
}
|
belowIndex.incrementAndGet();
|
productSize.incrementAndGet();
|
});
|
finalIndex.incrementAndGet();
|
});
|
} else {
|
// 转成Mpa进行排序
|
Map<String, List<SampleProductExportDto>> sortedMap = sampleProductDto2s.stream()
|
.filter(sampleProductDto2 -> StringUtils.isNotBlank(sampleProductDto2.getInspectionItem()))
|
.collect(Collectors.groupingBy(SampleProductExportDto::getInspectionItemRadius));
|
List<Map.Entry<String, List<SampleProductExportDto>>> entries = new ArrayList<>(sortedMap.entrySet());
|
entries.sort((o1, o2) -> {
|
Integer sort1 = o1.getValue().get(0).getSort();
|
Integer sort2 = o2.getValue().get(0).getSort();
|
sort1 = sort1 == null ? 0 : sort1;
|
sort2 = sort2 == null ? 0 : sort2;
|
return sort1.compareTo(sort2);
|
});
|
// 创建一个 LinkedHashMap 来保持插入顺序
|
Map<String, List<SampleProductExportDto>> item = new LinkedHashMap<>();
|
for (Map.Entry<String, List<SampleProductExportDto>> entry : entries) {
|
item.put(entry.getKey(), entry.getValue());
|
}
|
|
AtomicInteger finalIndex = new AtomicInteger(1);
|
item.forEach((s, sampleProductDtoInside) -> {
|
// 添加检验项
|
SampleProductExportDto dto2 = new SampleProductExportDto();
|
// 判断是否有英文名称
|
SampleProductExportDto temp = sampleProductDtoInside.get(0);
|
|
// 判断是否有检验子项,没有就把检验参数填充
|
dto2.setIndex(Integer.toString(finalIndex.get()));
|
if (StringUtils.isBlank(temp.getInspectionItemSubclass())) {
|
// 处理集合
|
Map<String, SampleProductExportDto> map = new LinkedHashMap<>();
|
for (SampleProductExportDto productDto2 : sampleProductDtoInside) {
|
String productName = productDto2.getInspectionItemClass() + productDto2.getInspectionItem();
|
if (map.containsKey(productName)) {
|
// 如果名称已经存在，添加 lastValue 值到 lastValueList 列表
|
map.get(productName)
|
.getLastValueList()
|
.add(productDto2.getLastValue());
|
map.get(productName)
|
.getInsResultList()
|
.add(productDto2.getInsResult());
|
// 添加颜色对应的值和结果
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
map.get(productName)
|
.getCableTagValueMap()
|
.put(productDto2.getCableTag(), productDto2.getLastValue());
|
map.get(productName)
|
.getCableTagResultMap()
|
.put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
// 添加标准要求来确定唯一性
|
map.get(productName).getTellSet().add(productDto2.getTell());
|
} else {
|
// 如果名称不存在，直接放入 map
|
productDto2.setLastValueList(new ArrayList<>()); // 检验内容
|
productDto2.getLastValueList().add(productDto2.getLastValue());
|
productDto2.setInsResultList(new ArrayList<>()); // 结果
|
productDto2.getInsResultList().add(productDto2.getInsResult());
|
productDto2.setTellSet(new LinkedHashSet<>());
|
productDto2.getTellSet().add(productDto2.getTell());// 标准要求
|
|
// 判断是否有线芯颜色, 添加颜色对应的值和结果
|
productDto2.setCableTagValueMap(new TreeMap<>());
|
productDto2.setCableTagResultMap(new TreeMap<>());
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
productDto2.getCableTagValueMap().put(productDto2.getCableTag(), productDto2.getLastValue());
|
productDto2.getCableTagResultMap().put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
|
map.put(productName, productDto2);
|
}
|
}
|
List<SampleProductExportDto> result = new ArrayList<>(map.values());
|
|
//添加检验子项
|
SampleProductExportDto temp2 = result.get(0);
|
String itemName = temp2.getInspectionItem();
|
if (StringUtils.isNotBlank(temp2.getRadius())) {
|
itemName = itemName + "(" + temp2.getRadius() + ")";
|
}
|
// 判断有没有条件字段有需要拼接到名称后面
|
if (StringUtils.isNotBlank(temp2.getInspectionItemEn())) {
|
temp2.setInspectionName(itemName + "@" + temp2.getInspectionItemEn());
|
} else {
|
temp2.setInspectionName(itemName);
|
}
|
// 判断有没有条件字段有需要拼接到名称后面
|
temp2.setIndex(Integer.toString(finalIndex.get()));
|
sampleList.add(temp2);
|
} else {
|
if (StringUtils.isNotBlank(temp.getInspectionItemEn())) {
|
dto2.setInspectionName(temp.getInspectionItem() + "@" + temp.getInspectionItemEn());
|
} else {
|
dto2.setInspectionName(temp.getInspectionItem());
|
}
|
// 填充到要求
|
if (StringUtils.isNotBlank(temp.getRadius())) {
|
dto2.setTell("(" + temp.getRadius() + ")");
|
}
|
sampleList.add(dto2);
|
|
// 现在需要根据子项去重累加检验结果
|
// 处理集合
|
Map<String, SampleProductExportDto> map = new LinkedHashMap<>();
|
for (SampleProductExportDto productDto2 : sampleProductDtoInside) {
|
// 名字取三层唯一
|
String productName = productDto2.getInspectionItemClass() + productDto2.getInspectionItem() + productDto2.getInspectionItemSubclass();
|
if (map.containsKey(productName)) {
|
// 如果名称已经存在，添加 lastValue 值到 lastValueList 列表
|
map.get(productName)
|
.getLastValueList()
|
.add(productDto2.getLastValue());
|
map.get(productName)
|
.getInsResultList()
|
.add(productDto2.getInsResult());
|
// 添加颜色对应的值和结果
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
map.get(productName)
|
.getCableTagValueMap()
|
.put(productDto2.getCableTag(), productDto2.getLastValue());
|
map.get(productName)
|
.getCableTagResultMap()
|
.put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
// 添加标准要求来确定唯一性
|
map.get(productName).getTellSet().add(productDto2.getTell());
|
} else {
|
// 如果名称不存在，直接放入 map
|
productDto2.setLastValueList(new ArrayList<>()); // 检验内容
|
productDto2.getLastValueList().add(productDto2.getLastValue());
|
productDto2.setInsResultList(new ArrayList<>()); // 结果
|
productDto2.getInsResultList().add(productDto2.getInsResult());
|
productDto2.setTellSet(new LinkedHashSet<>());
|
productDto2.getTellSet().add(productDto2.getTell());// 标准要求
|
productDto2.setCableTagValueMap(new TreeMap<>());
|
// 判断是否有线芯颜色, 添加颜色对应的值和结果
|
productDto2.setCableTagValueMap(new TreeMap<>());
|
productDto2.setCableTagResultMap(new TreeMap<>());
|
if (StringUtils.isNotBlank(productDto2.getCableTag())) {
|
productDto2.getCableTagValueMap().put(productDto2.getCableTag(), productDto2.getLastValue());
|
productDto2.getCableTagResultMap().put(productDto2.getCableTag(), productDto2.getInsResult());
|
}
|
map.put(productName, productDto2);
|
}
|
}
|
List<SampleProductExportDto> result = new ArrayList<>(map.values());
|
|
//添加检验子项
|
for (SampleProductExportDto productDto2 : result) {
|
if (StringUtils.isNotBlank(productDto2.getInspectionItemSubclassEn())) {
|
productDto2.setInspectionName("--" + productDto2.getInspectionItemSubclass() + "@"
|
+ "--" + productDto2.getInspectionItemSubclassEn());
|
} else {
|
productDto2.setInspectionName("--" + productDto2.getInspectionItemSubclass());
|
}
|
sampleList.add(productDto2);
|
}
|
}
|
finalIndex.incrementAndGet();
|
});
|
productSize.set(finalIndex.get());
|
}
|
|
if (CollectionUtils.isEmpty(sampleList)) {
|
return productSize.get() - 1;
|
}
|
|
/* 检验项map, 如果不合格判断是否有大类和检验项, 有大类不需要重叠, 如(绝缘机械物理性能老化前断裂伸长率、绝缘机械物理性能老化前抗张强度)
|
* 需要修改成绝缘机械物理性能老化前断裂伸长率、抗张强度
|
* */
|
// 检验项分类 检验项 检验子项
|
Map<String, LinkedHashMap<String, List<String>>> errorClassItemMapCn = new LinkedHashMap<>();
|
Map<String, LinkedHashMap<String, List<String>>> errorClassItemMapEn = new LinkedHashMap<>();
|
// 中间检测值添加
|
for (int i = 0; i < sampleList.size(); i++) {
|
SampleProductExportDto sample = sampleList.get(i);
|
|
String fixedValue = "(100℃，168h)";
|
// 判断是否是 拉伸强度变化率(100℃，168h) 和 断裂拉伸应变变化率(100℃，168h) 需要去除条件
|
if (StrUtil.isNotBlank(sample.getInspectionName())
|
&& sample.getInspectionName().contains("断裂拉伸应变变化率(100℃，168h)")) {
|
sample.setInspectionName(sample.getInspectionName().replace(fixedValue, ""));
|
}
|
if (StrUtil.isNotBlank(sample.getInspectionName())
|
&& sample.getInspectionName().contains("拉伸强度变化率(100℃，168h)")) {
|
sample.setInspectionName(sample.getInspectionName().replace(fixedValue, ""));
|
}
|
if (StrUtil.isNotBlank(sample.getInspectionName())
|
&& sample.getInspectionName().contains("老化后机械性能(100℃，168h)")) {
|
sample.setInspectionName(sample.getInspectionName().replace(fixedValue, ""));
|
}
|
|
// 判断是否是 耐矿物油Ⅰ（150℃ 72h) 和 耐矿物油Ⅰ（150℃ 144h) 需要去除条件
|
if (StrUtil.isNotBlank(sample.getInspectionName())
|
&& sample.getInspectionName().contains("耐矿物油Ⅰ（150℃ 72h)")) {
|
sample.setInspectionName(sample.getInspectionName().replace("（150℃ 72h)", ""));
|
}
|
if (StrUtil.isNotBlank(sample.getInspectionName())
|
&& sample.getInspectionName().contains("耐矿物油Ⅰ（150℃ 144h)")) {
|
sample.setInspectionName(sample.getInspectionName().replace("（150℃ 144h)", ""));
|
}
|
|
// 序号
|
TextRenderData headRenderData1 = new TextRenderData();
|
headRenderData1.setText(sample.getIndex());
|
Style headStyle1 = new Style();
|
headStyle1.setFontFamily("宋体");
|
headStyle1.setColor("000000");
|
headRenderData1.setStyle(headStyle1);
|
text.add(headRenderData1);
|
|
// 检验项目
|
TextRenderData headRenderData2 = new TextRenderData();
|
headRenderData2.setText(sample.getInspectionName() + "∑" + (i + 999));
|
Style headStyle2 = new Style();
|
headStyle2.setFontFamily("宋体");
|
headStyle2.setColor("000000");
|
headRenderData2.setStyle(headStyle2);
|
text.add(headRenderData2);
|
|
// 检验项目
|
TextRenderData headRenderData3 = new TextRenderData();
|
headRenderData3.setText(sample.getInspectionName() + "∑" + (i + 999));
|
Style headStyle3 = new Style();
|
headStyle3.setFontFamily("宋体");
|
headStyle3.setColor("000000");
|
headRenderData3.setStyle(headStyle3);
|
text.add(headRenderData3);
|
|
// 单位
|
TextRenderData headRenderData4 = new TextRenderData();
|
headRenderData4.setText(sample.getUnit());
|
Style headStyle4 = new Style();
|
headStyle4.setFontFamily("宋体");
|
headStyle4.setColor("000000");
|
headRenderData4.setStyle(headStyle4);
|
text.add(headRenderData4);
|
|
//标准要求
|
String tell = sample.getTell();
|
if (CollectionUtils.isNotEmpty(sample.getTellSet())) {
|
tell = CollUtil.join(sample.getTellSet(), "/");
|
}
|
TextRenderData headRenderData5 = new TextRenderData();
|
headRenderData5.setText(tell);
|
Style headStyle5 = new Style();
|
headStyle5.setFontFamily("宋体");
|
headStyle5.setColor("000000");
|
headRenderData5.setStyle(headStyle5);
|
text.add(headRenderData5);
|
|
// 判断是否有电缆标识map
|
if (CollectionUtils.isNotEmpty(sample.getCableTagValueMap())) {
|
TreeMap<String, String> cableTagValues = new TreeMap<>(Comparator.comparingInt(cableTags::indexOf));
|
cableTagValues.putAll(sample.getCableTagValueMap());
|
sample.setLastValueList(new ArrayList<>(cableTagValues.values()));
|
}
|
if (CollectionUtils.isNotEmpty(sample.getCableTagResultMap())) {
|
sample.setInsResultList(new ArrayList<>(sample.getCableTagResultMap().values()));
|
}
|
|
// 检验结果
|
// 判断是否是多次检验
|
if (CollectionUtils.isNotEmpty(sample.getLastValueList())
|
&& sample.getLastValueList().size() == max) {
|
|
for (String s : sample.getLastValueList()) {
|
TextRenderData headRenderData6 = new TextRenderData();
|
headRenderData6.setText(s);
|
Style headStyle6 = new Style();
|
headStyle6.setFontFamily("宋体");
|
headStyle6.setColor("000000");
|
headRenderData6.setStyle(headStyle6);
|
text.add(headRenderData6);
|
}
|
} else {
|
for (int j = 0; j < max; j++) {
|
TextRenderData headRenderData6 = new TextRenderData();
|
headRenderData6.setText((StringUtils.isNotEmpty(sample.getLastValue()) ?
|
sample.getLastValue() : "")
|
+ "∑" + (7 + i));
|
Style headStyle6 = new Style();
|
headStyle6.setFontFamily("宋体");
|
headStyle6.setColor("000000");
|
headRenderData6.setStyle(headStyle6);
|
text.add(headRenderData6);
|
}
|
}
|
// 判定结果
|
if (showResult) {
|
String result = "";
|
if (sample.getInsResult() != null) {
|
switch (sample.getInsResult()) {
|
case 1:
|
result = "√";
|
break;
|
case 2:
|
result = "×";
|
break;
|
case 3:
|
result = "-";
|
break;
|
}
|
}
|
if (CollectionUtils.isNotEmpty(sample.getLastValueList())) {
|
// 判断是否有一个错误
|
if (sample.getInsResultList().stream().anyMatch(s -> Objects.equals(s, 3))) {
|
result = "-";
|
} else {
|
boolean error = sample.getInsResultList().stream().anyMatch(s -> Objects.equals(s, 0));
|
if (error) {
|
List<String> collect = new ArrayList<>();
|
int index = 0;
|
for (Integer count : sample.getInsResultList()) {
|
String type;
|
if (Objects.equals(count, 0)) {
|
String itemCh = "";
|
String itemEn = "";
|
// 添加不合格描述
|
// 判断长度是否为1
|
if (sample.getLastValueList().size() == 1) {
|
this.fillReportErrorResult(errorClassItemMapCn, errorClassItemMapEn, sample, itemCh, itemEn);
|
} else if (CollectionUtils.isNotEmpty(cableTags)) {
|
// 判断是否有电缆配置, 不是的话可能为原材料
|
// 添加不合格描述
|
itemCh = (max == 1 ? "" : cableTags.get(index));
|
itemEn = (max == 1 ? "" : "The " + Integer.toString(index + 1) + " time ");
|
this.fillReportErrorResult(errorClassItemMapCn, errorClassItemMapEn, sample, itemCh, itemEn);
|
} else {
|
// 添加不合格描述
|
itemCh = (max == 1 ? "" : "第" + Integer.toString(index + 1) + "次");
|
itemEn = (max == 1 ? "" : "The " + Integer.toString(index + 1) + " time ");
|
this.fillReportErrorResult(errorClassItemMapCn, errorClassItemMapEn, sample, itemCh, itemEn);
|
}
|
type = "×";
|
} else {
|
type = "√";
|
}
|
collect.add(type);
|
index++;
|
}
|
result = CollUtil.join(collect, " ");
|
;
|
} else {
|
result = "√";
|
}
|
}
|
}
|
|
if (showResult) {
|
TextRenderData headRenderData7 = new TextRenderData();
|
headRenderData7.setText(result);
|
Style headStyle7 = new Style();
|
headStyle7.setFontFamily("宋体");
|
headStyle7.setColor("000000");
|
headRenderData7.setStyle(headStyle7);
|
text.add(headRenderData7);
|
}
|
}
|
|
TextRenderData[] text2 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text2).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
text = new ArrayList<>();
|
|
}
|
if (CollectionUtils.isNotEmpty(errorClassItemMapCn)) {
|
// 循环检验项分类
|
errorClassItemMapCn.forEach((errorClass, errorItemMap) -> {
|
if (StringUtils.isNotBlank(resultCh.get())) {
|
resultCh.set(resultCh.get() + "，" + errorClass);
|
} else {
|
resultCh.set(errorClass);
|
}
|
// 循环检验项
|
AtomicBoolean flag = new AtomicBoolean(false);
|
errorItemMap.forEach((errorItem, errorSubClassList) -> {
|
if (flag.get()) {
|
resultCh.set(resultCh.get() + "，" + errorItem);
|
} else {
|
resultCh.set(resultCh.get() + errorItem);
|
}
|
flag.set(true);
|
// 循环检验项分类
|
if (CollectionUtils.isNotEmpty(errorSubClassList)) {
|
for (int i = 0; i < errorSubClassList.size(); i++) {
|
// 判断是否是第二个, 第二个添加顿号
|
if (i > 0) {
|
resultCh.set(resultCh.get() + "、" + errorSubClassList.get(i));
|
} else {
|
resultCh.set(resultCh.get() + errorSubClassList.get(i));
|
}
|
}
|
}
|
});
|
});
|
// 循环检验项分类
|
errorClassItemMapEn.forEach((errorClass, errorItemMap) -> {
|
if (StringUtils.isNotBlank(resultEn.get())) {
|
resultEn.set(resultEn.get() + "，" + errorClass);
|
} else {
|
resultEn.set(errorClass);
|
}
|
// 循环检验项
|
errorItemMap.forEach((errorItem, errorSubClassList) -> {
|
resultEn.set(resultEn.get() + errorItem);
|
// 循环检验项分类
|
if (CollectionUtils.isNotEmpty(errorSubClassList)) {
|
for (int i = 0; i < errorSubClassList.size(); i++) {
|
// 判断是否是第二个, 第二个添加顿号
|
if (i > 0) {
|
resultEn.set(resultEn.get() + "、" + errorSubClassList.get(i));
|
} else {
|
resultEn.set(resultEn.get() + errorSubClassList.get(i));
|
}
|
}
|
}
|
});
|
});
|
}
|
|
if (StringUtils.isNotBlank(resultCh.get())) {
|
String resultChString = resultCh.get();
|
String resultEnString = resultEn.get();
|
// 判断样品是否有多个, 有多个需要拼接样品编号
|
if (!isOneSample) {
|
resultChString = a.getSampleCode() + resultChString;
|
resultEnString = a.getSampleCode() + resultEnString;
|
}
|
resultChList.add(resultChString);
|
resultEhList.add(resultEnString);
|
}
|
|
|
return productSize.get() - 1;
|
}
|
|
/**
|
* NBSP（非间断空格） 转成 普通空格
|
* @param oldStr
|
* @return
|
*/
|
private String normalizedSpaces(String oldStr){
|
if(StringUtils.isBlank(oldStr)){
|
return oldStr;
|
}
|
return oldStr.replaceAll("\u00A0", " ").trim();
|
}
|
|
/**
|
* 添加报告结论中英文
|
* @param sample
|
* @param itemCh
|
* @param itemEn
|
*/
|
private void fillReportErrorResult(Map<String, LinkedHashMap<String, List<String>>> errorClassItemMapCn,
|
Map<String, LinkedHashMap<String, List<String>>> errorClassItemMapEn,
|
SampleProductExportDto sample,
|
String itemCh,
|
String itemEn) {
|
// 判断是否有检验项分类map
|
String classTiemName = itemCh + (StringUtils.isBlank(sample.getInspectionItemClass()) ? "" : normalizedSpaces(sample.getInspectionItemClass()));
|
String classTiemNameEn = itemEn + (StringUtils.isBlank(sample.getInspectionItemClassEN()) ? "" : normalizedSpaces(sample.getInspectionItemClassEN()));
|
String classTiemNameItemEN = StringUtils.isBlank(sample.getInspectionItemEn()) ? "" : normalizedSpaces(sample.getInspectionItemEn());
|
|
if (errorClassItemMapCn.containsKey(classTiemName)) {
|
// 判断是否有检验项map
|
if (errorClassItemMapCn.get(classTiemName).containsKey(sample.getInspectionItem())) {
|
// 添加检验项分类
|
if (StringUtils.isNotBlank(sample.getInspectionItemSubclass())) {
|
errorClassItemMapCn.get(classTiemName).get(sample.getInspectionItem()).add(sample.getInspectionItemSubclass());
|
}
|
if (StringUtils.isNotBlank(sample.getInspectionItemSubclassEn())) {
|
errorClassItemMapEn.get(classTiemNameEn).get(classTiemNameItemEN).add(sample.getInspectionItemSubclassEn());
|
}
|
} else {
|
// 添加检验项map
|
List<String> errorItemSubClassList = new ArrayList<>();
|
if (StringUtils.isNotBlank(sample.getInspectionItemSubclass())) {
|
errorItemSubClassList.add(sample.getInspectionItemSubclass());
|
}
|
List<String> errorItemSubClassListEn = new ArrayList<>();
|
if (StringUtils.isNotBlank(sample.getInspectionItemSubclassEn())) {
|
errorItemSubClassListEn.add(sample.getInspectionItemSubclassEn());
|
}
|
errorClassItemMapCn.get(classTiemName).put(sample.getInspectionItem(), errorItemSubClassList);
|
errorClassItemMapEn.get(classTiemNameEn).put(classTiemNameItemEN, errorItemSubClassListEn);
|
}
|
} else {
|
// map添加检验项分类
|
List<String> errorItemSubClassList = new ArrayList<>();
|
if (StringUtils.isNotBlank(sample.getInspectionItemSubclass())) {
|
errorItemSubClassList.add(sample.getInspectionItemSubclass());
|
}
|
List<String> errorItemSubClassListEn = new ArrayList<>();
|
if (StringUtils.isNotBlank(sample.getInspectionItemSubclassEn())) {
|
errorItemSubClassListEn.add(sample.getInspectionItemSubclassEn());
|
}
|
errorClassItemMapCn.put(classTiemName, new LinkedHashMap<String, List<String>>() {{
|
put(sample.getInspectionItem(), errorItemSubClassList);
|
}});
|
errorClassItemMapEn.put(classTiemNameEn, new LinkedHashMap<String, List<String>>() {{
|
put(classTiemNameItemEN, errorItemSubClassListEn);
|
}});
|
}
|
}
|
|
|
/**
|
* 格式化修改检验项
|
* @param sampleProductDto2s
|
*/
|
private void formatProducts(List<SampleProductExportDto> sampleProductDto2s) {
|
sampleProductDto2s.forEach(sampleProductDto2 -> {
|
// 清除全部结果的前后空格, 换行符
|
if (StrUtil.isNotBlank(sampleProductDto2.getLastValue())) {
|
sampleProductDto2.setLastValue(sampleProductDto2.getLastValue().trim());
|
}
|
|
if (Objects.equals(sampleProductDto2.getInsResult(), 0)) {
|
// 查询不合格复测
|
Long count = insUnqualifiedRetestProductMapper.selectCount(Wrappers.<InsUnqualifiedRetestProduct>lambdaQuery()
|
.eq(InsUnqualifiedRetestProduct::getInsProductId, sampleProductDto2.getInsProductId())
|
.ne(InsUnqualifiedRetestProduct::getInsResult, 0));
|
if (count == 2) {
|
// 复测内容都合格就取第一个结果
|
InsUnqualifiedRetestProduct retestProduct = insUnqualifiedRetestProductMapper.selectOne(Wrappers.<InsUnqualifiedRetestProduct>lambdaQuery()
|
.eq(InsUnqualifiedRetestProduct::getInsProductId, sampleProductDto2.getInsProductId())
|
.last("limit 1"));
|
sampleProductDto2.setLastValue(retestProduct.getLastValue());
|
sampleProductDto2.setInsResult(retestProduct.getInsResult());
|
}
|
}
|
// 判断是否是数字类型
|
if (sampleProductDto2.getInspectionValueType().equals("1")) {
|
// 把检验内容如果正硫化点和焦烧时间把 . 切割成 :
|
String lastValue = sampleProductDto2.getLastValue();
|
if (sampleProductDto2.getInspectionItem().contains("正硫化点") || sampleProductDto2.getInspectionItem().contains("焦烧时间")) {
|
sampleProductDto2.setLastValue(sampleProductDto2.getLastValue().replace('.', ':'));
|
} else {
|
// 判断当前结果是否是科学计数法
|
boolean scientificNotation = isScientificNotation(lastValue);
|
if (scientificNotation) {
|
// 修改要求描述
|
sampleProductDto2.setTell(convertToScientificNotation(sampleProductDto2.getTell()));
|
|
// 修改要求值
|
sampleProductDto2.setLastValue(toScientificNotationWithTimes(lastValue));
|
} else {
|
// 排除氧指数
|
if (sampleProductDto2.getInspectionItem().contains("氧指数")) {
|
|
// 特殊处理判断检验项是否等于外护套电导率, 是的话只需要保留一位小数
|
} else if (StringUtils.isNotBlank(sampleProductDto2.getInspectionItemSubclass())
|
&& sampleProductDto2.getInspectionItemSubclass().contains("外护套电导率")) {
|
BigDecimal bd = new BigDecimal(lastValue);
|
bd = bd.setScale(1, RoundingMode.HALF_UP);
|
sampleProductDto2.setLastValue(bd.stripTrailingZeros().toPlainString());
|
} else {
|
// 修改小数点位数根据要求值来
|
sampleProductDto2.setLastValue(modifyNumber(sampleProductDto2.getAsk(), lastValue));
|
}
|
}
|
}
|
}
|
// 判断是否是 拉伸强度变化率(100℃，168h) 和 断裂拉伸应变变化率(100℃，168h) 需要去除条件
|
if (StrUtil.isNotBlank(sampleProductDto2.getInspectionItemSubclass())
|
&& sampleProductDto2.getInspectionItemSubclass().equals("拉伸强度变化率(100℃，168h)")) {
|
sampleProductDto2.setInspectionItem("老化后机械性能(100℃，168h)");
|
}
|
if (StrUtil.isNotBlank(sampleProductDto2.getInspectionItemSubclass())
|
&& sampleProductDto2.getInspectionItemSubclass().equals("断裂拉伸应变变化率(100℃，168h)")) {
|
sampleProductDto2.setInspectionItem("老化后机械性能(100℃，168h)");
|
}
|
});
|
}
|
|
/**
|
* 添加结尾
|
* @param text
|
* @param rowRenderData
|
* @param rows
|
*/
|
private static void addEnding(List<TextRenderData> text, RowRenderData rowRenderData, List<RowRenderData> rows, int max, boolean showResult) {
|
for (int i = 0; i < 2; i++) {
|
TextRenderData endingRenderData = new TextRenderData();
|
endingRenderData.setText("备注∑1999");
|
Style endingStyle = new Style();
|
endingStyle.setFontFamily("宋体");
|
endingStyle.setColor("000000");
|
endingRenderData.setStyle(endingStyle);
|
text.add(endingRenderData);
|
}
|
|
for (int i = 0; i < (showResult ? 5 : 4) + max - 1; i++) {
|
TextRenderData endingRenderData = new TextRenderData();
|
endingRenderData.setText(showResult ? "“√”表示项目合格,“×”表示项目不合格,“-”表示不要判定，“/”表示没有标准要求。@“√” indicates test ltem is qualified,“×” indicates test ltem is unqualified,“-” indicates test ltem judgment is not required,“/” indicates test ltem is no test requirement.∑2000" : "");
|
Style endingStyle = new Style();
|
endingStyle.setFontFamily("宋体");
|
endingStyle.setColor("000000");
|
endingRenderData.setStyle(endingStyle);
|
text.add(endingRenderData);
|
}
|
TextRenderData[] text3 = text.toArray(new TextRenderData[0]);
|
rowRenderData = Rows.of(text3).center().rowAtleastHeight(1).create();
|
rows.add(rowRenderData);
|
}
|
|
/**
|
* 判断当前内容是否是科学计数法
|
* @param str
|
* @return
|
*/
|
public static boolean isScientificNotation(String str) {
|
if (StringUtils.isEmpty(str)) {
|
return false;
|
}
|
// 正则表达式匹配科学计数法，包括正数和负数
|
String regex = "^[+|-]?\\d*[.]?\\d*e[+|-]?\\d+$";
|
Pattern pattern = Pattern.compile(regex);
|
return pattern.matcher(str).matches();
|
}
|
|
|
/**
|
* 修改要求描述的科学计数法
|
* @param input
|
*/
|
public static String convertToScientificNotation(String input) {
|
// 保存原始输入
|
String originalInput = input;
|
|
// 去掉非科学计数法的字符
|
String cleanedInput = input.replaceAll("[^0-9eE+-.]", "");
|
|
// 判断要求描述是否是科学计数法
|
boolean scientificNotation = isScientificNotation(cleanedInput);
|
if (!scientificNotation) {
|
return input;
|
}
|
|
// 找出被去掉的字符
|
String removedChars = originalInput.replace(cleanedInput, "");
|
|
try {
|
String scientificNotationWithTimes = toScientificNotationWithTimes(cleanedInput);
|
return removedChars + scientificNotationWithTimes;
|
} catch (Exception e) {
|
return input;
|
}
|
|
}
|
|
/**
|
* 展示成科学计数法
|
* @param number
|
* @return
|
*/
|
public static String toScientificNotationWithTimes(String number) {
|
Double value = Double.valueOf(number);
|
|
// 提取小数部分和指数部分
|
String scientificFormat = String.format("%.1e", value);
|
String[] parts = scientificFormat.split("e");
|
|
// 处理数字部分和指数部分
|
String mantissa = parts[0]; // 小数部分
|
int exponent = Integer.parseInt(parts[1]); // 指数部分
|
|
String power = "";
|
switch (exponent) {
|
case 2:
|
power = "²";
|
break;
|
case 3:
|
power = "³";
|
break;
|
case 4:
|
power = "⁴";
|
break;
|
case 5:
|
power = "⁵";
|
break;
|
case 6:
|
power = "⁶";
|
break;
|
case 7:
|
power = "⁷";
|
break;
|
case 8:
|
power = "⁸";
|
break;
|
case 9:
|
power = "⁹";
|
break;
|
case 10:
|
power = "¹⁰";
|
break;
|
case 11:
|
power = "¹¹";
|
break;
|
case 12:
|
power = "¹²";
|
break;
|
case 13:
|
power = "¹³";
|
break;
|
case 14:
|
power = "¹⁴";
|
break;
|
case 15:
|
power = "¹⁵";
|
break;
|
case 16:
|
power = "¹⁶";
|
break;
|
case 17:
|
power = "¹⁷";
|
break;
|
case 18:
|
power = "¹⁸";
|
break;
|
case 19:
|
power = "¹⁹";
|
break;
|
case 20:
|
power = "²⁰";
|
break;
|
|
}
|
|
// 构建最终的科学计数法格式字符串
|
return String.format("%s×10%s", mantissa, power);
|
}
|
|
|
// 判断是否是数字
|
public static boolean isNumeric(String str) {
|
if (str == null || str.isEmpty()) {
|
return false;
|
}
|
try {
|
Double.parseDouble(str); // 尝试将字符串解析为双精度浮点数
|
return true;
|
} catch (NumberFormatException e) {
|
return false; // 解析失败则返回false
|
}
|
}
|
|
/**
|
* 根据要求描述保留结果小数点位数
|
* @param reference
|
* @param value
|
* @return
|
*/
|
public static String modifyNumber(String reference, String value) {
|
if (reference.equals("/") || reference.equals("-") || reference.equals("—")) {
|
// 不判定默认保留一位小数 > 默认小数位
|
// BigDecimal bd = new BigDecimal(value);
|
// bd = bd.setScale(1, RoundingMode.HALF_UP);
|
return value;
|
}
|
|
// 判断是否是数字
|
if (!isNumeric(value)) {
|
try {
|
// 可能是≤95.1A这样的, 需要截取保留位数
|
// 使用正则表达式提取数字部分
|
String numberPart = value.replaceAll("[^0-9.]", "");
|
// 将数字部分替换成占位符
|
String withPlaceholder = value.replaceAll(numberPart, "**");
|
// 提取小数点位数
|
int decimalPlaces = getDecimalPlaces(reference);
|
// 处理第二个字符串
|
BigDecimal number = new BigDecimal(numberPart);
|
number = number.setScale(decimalPlaces, RoundingMode.HALF_UP);
|
// 等于0需要进一步处理
|
if (number.compareTo(BigDecimal.ZERO) == 0) {
|
return formatNumber(value, decimalPlaces);
|
}
|
// 将占位符替换成指定数字
|
String finalResult = withPlaceholder.replace("**", number.toString());
|
return finalResult;
|
} catch (Exception e) {
|
return value;
|
}
|
}
|
|
// 提取小数点位数
|
int decimalPlaces = getDecimalPlaces(reference);
|
|
// 处理第二个字符串
|
BigDecimal number = new BigDecimal(value);
|
number = number.setScale(decimalPlaces, RoundingMode.HALF_UP);
|
|
// 等于0需要进一步处理
|
if (number.compareTo(BigDecimal.ZERO) == 0) {
|
return formatNumber(value, decimalPlaces);
|
}
|
|
return number.toString();
|
}
|
|
|
private static int getDecimalPlaces(String str) {
|
// 查找小数点位置
|
int decimalPointIndex = str.lastIndexOf('.');
|
|
if (decimalPointIndex == -1) {
|
// 如果没有小数点，返回0位小数
|
return 0;
|
}
|
|
// 计算小数点后的位数
|
return str.length() - decimalPointIndex - 1;
|
}
|
|
/**
|
* 保留位数, 如果等于0 返回找到的一个非0位数
|
* @param number 当前数字
|
* @param scale 原本保留的位数
|
* @return
|
*/
|
public static String formatNumber(String number, int scale) {
|
// 将输入的字符串转换为 BigDecimal
|
BigDecimal bd = new BigDecimal(number);
|
|
// 保留指定的小数位数，并使用四舍五入模式
|
bd = bd.setScale(scale, RoundingMode.HALF_UP);
|
|
// 检查保留的小数是否等于 0
|
if (bd.stripTrailingZeros().scale() <= 0) {
|
// 需要找到第一个不为 0 的小数位
|
String decimalPart = number.substring(number.indexOf('.') + 1);
|
int firstNonZeroIndex = findFirstNonZeroIndex(decimalPart);
|
|
if (firstNonZeroIndex != -1) {
|
// 计算需要保留的小数位数
|
int newScale = firstNonZeroIndex + 1;
|
bd = new BigDecimal(number).setScale(newScale, RoundingMode.HALF_UP);
|
}
|
}
|
|
return bd.toString();
|
}
|
|
private static int findFirstNonZeroIndex(String decimalPart) {
|
for (int i = 0; i < decimalPart.length(); i++) {
|
if (decimalPart.charAt(i) != '0') {
|
return i;
|
}
|
}
|
return -1; // 如果没有找到非零的数字
|
}
|
|
/**
|
* *****保存元此阿里进货验证原始记录*****
|
* @param insOrderId 订单Id
|
* @param examineUserId 复核人Id
|
* @param writeUserId 检验员Id
|
*/
|
private void reportFactoryVerify(Integer insOrderId, Integer examineUserId, Integer writeUserId) {
|
// 查询进货验证原始记录
|
InsOrderFactoryVerify factoryVerify = insOrderFactoryVerifyMapper.selectOne(Wrappers.<InsOrderFactoryVerify>lambdaQuery()
|
.eq(InsOrderFactoryVerify::getInsOrderId, insOrderId)
|
.last("limit 1"));
|
|
// 没有就结束
|
if (factoryVerify == null) {
|
return;
|
}
|
|
//1.材料名称
|
factoryVerify.setBasicName(this.formatBasic(factoryVerify.getBasicName()));
|
//2.规格型号
|
factoryVerify.setBasicModel(this.formatBasic(factoryVerify.getBasicModel()));
|
//3.材料批号
|
factoryVerify.setBasicBatchNo(this.formatBasic(factoryVerify.getBasicBatchNo()));
|
//4.执行标准
|
factoryVerify.setBasicStandard(this.formatBasic(factoryVerify.getBasicStandard()));
|
//5.生产日期
|
factoryVerify.setBasicDate(this.formatBasic(factoryVerify.getBasicDate()));
|
//6.供货数量
|
factoryVerify.setBasicNumber(this.formatBasic(factoryVerify.getBasicNumber()));
|
//7.材料名称
|
factoryVerify.setBasicColor(this.formatBasic(factoryVerify.getBasicColor()));
|
|
//8.其他
|
// 内容
|
if (factoryVerify.getBasicOtherValue() == null) {
|
factoryVerify.setBasicOtherValue("");
|
}
|
// 值
|
if (factoryVerify.getBasicOther() == null) {
|
factoryVerify.setBasicOther("");
|
}
|
switch (factoryVerify.getBasicOther()) {
|
case "1":
|
factoryVerify.setBasicOther("☑符合 □不符合");
|
break;
|
case "2":
|
factoryVerify.setBasicOther("□符合 ☑不符合");
|
break;
|
default:
|
factoryVerify.setBasicOther("□符合 □不符合");
|
}
|
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
String declareDate = factoryVerify.getDeclareDate().format(formatter);
|
|
// 修改验证项目
|
List<InsOrderFactoryVerifyItem> verifyItems = insOrderFactoryVerifyItemService.list(Wrappers.<InsOrderFactoryVerifyItem>lambdaQuery()
|
.eq(InsOrderFactoryVerifyItem::getFactoryVerifyId, factoryVerify.getFactoryVerifyId())
|
.orderByAsc(InsOrderFactoryVerifyItem::getSort));
|
|
for (InsOrderFactoryVerifyItem verifyItem : verifyItems) {
|
if (verifyItem.getResult() == null) {
|
verifyItem.setResult("");
|
}
|
switch (verifyItem.getResult()) {
|
case "1":
|
verifyItem.setResult("☑符合 □不符合 □不适用");
|
break;
|
case "2":
|
verifyItem.setResult("□符合 ☑不符合 □不适用");
|
break;
|
case "3":
|
verifyItem.setResult("□符合 □不符合 ☑不适用");
|
break;
|
default:
|
verifyItem.setResult("□符合 □不符合 □不适用");
|
}
|
}
|
|
//获取提交人的签名地址
|
String writeUrl;
|
try {
|
writeUrl = userMapper.selectById(writeUserId).getSignatureUrl();
|
} catch (Exception e) {
|
throw new ErrorException("找不到编制人的签名");
|
}
|
if (ObjectUtils.isEmpty(writeUrl) || writeUrl.equals("")) {
|
throw new ErrorException("找不到检验人的签名");
|
}
|
|
//获取复核人的签名地址
|
String examineUrl;
|
try {
|
examineUrl = userMapper.selectById(examineUserId).getSignatureUrl();
|
} catch (Exception e) {
|
throw new ErrorException("找不到复核人的签名");
|
}
|
if (ObjectUtils.isEmpty(examineUrl) || examineUrl.equals("")) {
|
throw new ErrorException("找不到复核人的签名");
|
}
|
|
|
InputStream inputStream = this.getClass().getResourceAsStream("/static/factory_verify.docx");
|
ConfigureBuilder builder = Configure.builder();
|
builder.useSpringEL(true);
|
|
XWPFTemplate template = XWPFTemplate.compile(inputStream, builder.build()).render(
|
new HashMap<String, Object>() {{
|
put("report", factoryVerify);
|
put("declareDate", declareDate);
|
put("factoryVerifyItemList", verifyItems);
|
put("writeUrl", Pictures.ofLocal(imgUrl + "/" + writeUrl).create());
|
put("examineUrl", Pictures.ofLocal(imgUrl + "/" + examineUrl).create());
|
put("writeDateUrl", Pictures.ofStream(DateImageUtil.createDateImage(null)).create());
|
put("examineDateUrl", Pictures.ofStream(DateImageUtil.createDateImage(null)).create());
|
}});
|
|
MultipartFile multipartFile = xwpfDocumentToMockMultipartFile(template.getXWPFDocument());
|
|
// 保存到附件里面
|
uploadFile(insOrderId, multipartFile);
|
try {
|
inputStream.close();
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
|
}
|
|
/**
|
* XWPFDocument 转 MultipartFile(MockMultipartFile)
|
*
|
* @param document 文档对象
|
* @return
|
*/
|
public static MultipartFile xwpfDocumentToMockMultipartFile(XWPFDocument document) {
|
String fileName = "原材料进货验证记录.docx";
|
try {
|
String contentType = "text/plain";
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
document.write(bos);
|
//XWPFDocument 转 byte[]
|
byte[] barray = bos.toByteArray();
|
//byte[] 转 InputStream
|
InputStream is = new ByteArrayInputStream(barray);
|
//InputStream 转 MultipartFile
|
MultipartFile multipartFile = new MockMultipartFile(fileName, fileName, contentType, is);
|
return multipartFile;
|
} catch (Exception e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
|
/**
|
* ***格式化进厂验证内容****
|
* @param basicType
|
* @return
|
*/
|
private String formatBasic(String basicType) {
|
if (basicType == null) {
|
basicType = "";
|
}
|
|
//格式化字段
|
String basic = "";
|
switch (basicType) {
|
case "1":
|
basic = "☑符合 □不符合 □不适用";
|
break;
|
case "2":
|
basic = "□符合 ☑不符合 □不适用";
|
break;
|
case "3":
|
basic = "□符合 □不符合 ☑不适用";
|
break;
|
default:
|
basic = "□符合 □不符合 □不适用";
|
}
|
|
return basic;
|
}
|
|
/**
|
* ***word转换pdf***
|
* @param path
|
* @return
|
*/
|
@Override
|
public String wordToPdfTemp(String path) {
|
try {
|
return wordToPdf(path, path.replace(".docx", "-临时.pdf"));
|
} catch (Exception e) {
|
throw new ErrorException("转换失败");
|
}
|
}
|
|
private String wordToPdf(String wordPath, String pdfPath) {
|
FileOutputStream os = null;
|
try {
|
//凭证 不然切换后有水印
|
InputStream is = new ClassPathResource("/lib/license.xml").getInputStream();
|
License license = new License();
|
license.setLicense(is);
|
if (!license.getIsLicensed()) {
|
return null;
|
}
|
//生成一个空的PDF文件
|
File file;
|
//判断是否是进厂报告
|
file = new File(pdfPath);
|
os = new FileOutputStream(file);
|
//要转换的word文件
|
com.aspose.words.Document doc = new com.aspose.words.Document(wordPath);
|
doc.save(os, SaveFormat.PDF);
|
String name = file.getName();
|
return file.getName();
|
} catch (Exception e) {
|
e.printStackTrace();
|
} finally {
|
if (os != null) {
|
try {
|
os.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
return null;
|
}
|
|
/**
|
* *****修改成品抽样状态******
|
* @param insSamples
|
* @param order
|
*/
|
private void addProductSpotCheck(List<InsSample> insSamples, InsOrder order) {
|
Long unqualifiedCount = 0L;
|
if (CollectionUtils.isNotEmpty(insSamples)) {
|
unqualifiedCount = insProductMapper.selectCount(Wrappers.<InsProduct>lambdaQuery()
|
.in(InsProduct::getInsSampleId, insSamples.stream().map(InsSample::getId).collect(Collectors.toList()))
|
.eq(InsProduct::getInsResult, 0));
|
|
// 判断如果有不合格的检验项, 判断有没有检验项复测, 复核合格也算合格通过
|
if (!unqualifiedCount.equals(0L)) {
|
List<InsProduct> productList = insProductMapper.selectList(Wrappers.<InsProduct>lambdaQuery()
|
.in(InsProduct::getInsSampleId, insSamples.stream().map(InsSample::getId).collect(Collectors.toList()))
|
.eq(InsProduct::getInsResult, 0));
|
|
boolean flag = true;
|
for (InsProduct insProduct : productList) {
|
Long unqualifiedProductCount = insUnqualifiedRetestProductMapper.selectCount(Wrappers.<InsUnqualifiedRetestProduct>lambdaQuery()
|
.eq(InsUnqualifiedRetestProduct::getInsProductId, insProduct.getId())
|
.ne(InsUnqualifiedRetestProduct::getInsResult, 0));
|
if (unqualifiedProductCount != 2) {
|
flag = false;
|
}
|
}
|
if (flag) {
|
unqualifiedCount = 0L;
|
}
|
}
|
}
|
spotCheckQuarterItemMapper.update(null, Wrappers.<SpotCheckQuarterItem>lambdaUpdate()
|
.eq(SpotCheckQuarterItem::getQuarterItemId, order.getQuarterItemId())
|
.set(SpotCheckQuarterItem::getResult, unqualifiedCount.equals(0L) ? "合格" : "不合格"));
|
}
|
|
/**
|
* 添加工时
|
* @param userId
|
* @param insProduct
|
* @param insOrder
|
*/
|
private synchronized void addAuxiliary(Integer userId, InsProduct insProduct, InsOrder insOrder) {
|
if (insProduct.getIsBinding().equals(1)) {
|
return;
|
}
|
|
//校验如果这个人这个检测项目已经添加过了
|
List<AuxiliaryOutputWorkingHours> count2s = auxiliaryOutputWorkingHoursMapper.selectList(Wrappers.<AuxiliaryOutputWorkingHours>lambdaQuery()
|
.eq(AuxiliaryOutputWorkingHours::getCheck, userId)
|
.eq(AuxiliaryOutputWorkingHours::getInsProductId, insProduct.getId()));
|
if (CollectionUtils.isNotEmpty(count2s)) {
|
for (AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHours : count2s) {
|
auxiliaryOutputWorkingHours.setCheck(userId);//检测人
|
}
|
auxiliaryOutputWorkingHoursService.updateBatchById(count2s);
|
} else {
|
if (ObjectUtils.isNotEmpty(insProduct.getManHour()) && StringUtils.isNotBlank(insProduct.getLastValue())) {
|
AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHours = new AuxiliaryOutputWorkingHours();
|
auxiliaryOutputWorkingHours.setInspectionItemClass(insProduct.getInspectionItemClass());//检测项分类
|
auxiliaryOutputWorkingHours.setInspectionItem(insProduct.getInspectionItem());//检测父项
|
auxiliaryOutputWorkingHours.setInspectionItemSubclass(insProduct.getInspectionItemSubclass());//检测子项
|
auxiliaryOutputWorkingHours.setSample(insSampleMapper.selectById(insProduct.getInsSampleId()).getSampleCode());//样品编号
|
auxiliaryOutputWorkingHours.setOrderId(insOrder.getId());//订单id
|
auxiliaryOutputWorkingHours.setOrderNo(insOrder.getEntrustCode());//非加班委托单号
|
auxiliaryOutputWorkingHours.setWorkTime(insProduct.getManHour());//非加班工时
|
auxiliaryOutputWorkingHours.setAmount(1);//非加班数量
|
auxiliaryOutputWorkingHours.setOutputWorkTime((ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHours.getOvertimeWorkTime()) ? auxiliaryOutputWorkingHours.getOvertimeWorkTime() : BigDecimal.ZERO).add(ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHours.getWorkTime()) ? auxiliaryOutputWorkingHours.getWorkTime() : BigDecimal.ZERO));//产量工时
|
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);//检测人
|
auxiliaryOutputWorkingHours.setPrice(insProduct.getPrice());//单价
|
auxiliaryOutputWorkingHours.setSampleId(insProduct.getInsSampleId());//样品id
|
auxiliaryOutputWorkingHours.setInsProductId(insProduct.getId());//检验项id
|
|
auxiliaryOutputWorkingHoursMapper.insert(auxiliaryOutputWorkingHours);
|
|
}
|
}
|
}
|
|
|
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 "未知";
|
}
|
}
|
}
|
