package com.ruoyi.process.service.impl;
|
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
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.ruoyi.common.numgen.NumberGenerator;
|
import com.ruoyi.common.core.domain.entity.Custom;
|
import com.ruoyi.common.core.domain.entity.User;
|
import com.ruoyi.common.utils.QueryWrappers;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.framework.exception.ErrorException;
|
import com.ruoyi.inspect.dto.InsPlaceOrderDto;
|
import com.ruoyi.inspect.pojo.InsOrder;
|
import com.ruoyi.inspect.pojo.InsReport;
|
import com.ruoyi.inspect.service.InsOrderService;
|
import com.ruoyi.inspect.service.InsReportService;
|
import com.ruoyi.inspect.util.HackLoopTableRenderPolicy;
|
import com.ruoyi.process.dto.InspectionOrderDto;
|
import com.ruoyi.process.dto.InspectionOrderBindingDto;
|
import com.ruoyi.process.dto.InspectionOrderExportDto;
|
import com.ruoyi.process.mapper.InspectionOrderBindLogMapper;
|
import com.ruoyi.process.mapper.InspectionOrderMapper;
|
import com.ruoyi.process.mapper.InspectionOrderAttachmentMapper;
|
import com.ruoyi.process.mapper.InspectionOrderBindingMapper;
|
import com.ruoyi.process.pojo.InspectionOrder;
|
import com.ruoyi.process.pojo.InspectionOrderAttachment;
|
import com.ruoyi.process.pojo.InspectionOrderBinding;
|
import com.ruoyi.process.pojo.InspectionOrderBindLog;
|
import com.ruoyi.process.pojo.InspectionOrderDetail;
|
import com.ruoyi.process.service.*;
|
import com.ruoyi.system.mapper.UserMapper;
|
import com.ruoyi.system.mapper.CustomMapper;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.File;
|
import java.io.InputStream;
|
import java.io.OutputStream;
|
import java.net.URLEncoder;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.nio.file.StandardCopyOption;
|
import java.nio.charset.StandardCharsets;
|
import java.security.MessageDigest;
|
import java.time.LocalDateTime;
|
import java.time.LocalDate;
|
import java.time.format.DateTimeFormatter;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.LinkedHashMap;
|
import java.util.Objects;
|
import java.util.UUID;
|
|
/**
|
* <p>
|
* 检验委托单 服务实现类
|
* </p>
|
*
|
* @author 江苏鵷雏网络科技有限公司
|
* @since 2024-12-09
|
*/
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
public class InspectionOrderServiceImpl extends ServiceImpl<InspectionOrderMapper, InspectionOrder> implements InspectionOrderService {
|
@Resource
|
private InspectionOrderBindLogMapper inspectionOrderBindLogMapper;
|
@Resource
|
private InspectionOrderBindingMapper inspectionOrderBindingMapper;
|
@Resource
|
private InspectionOrderAttachmentMapper inspectionOrderAttachmentMapper;
|
@Resource
|
private InspectionOrderDetailService inspectionOrderDetailService;
|
@Resource
|
private InsOrderService insOrderService;
|
@Resource
|
private InsReportService insReportService;
|
@Value("${wordUrl}")
|
private String wordUrl;
|
@Resource
|
private UserMapper userMapper;
|
@Resource
|
private CustomMapper customMapper;
|
@Resource
|
private NumberGenerator<InspectionOrder> numberGenerator;
|
|
|
/**
|
* 检验委托单分页查询
|
*
|
* @param page
|
* @param InspectionOrder
|
* @return
|
*/
|
@Override
|
public IPage<InspectionOrderDto> pageInspectionOrder(Page page, InspectionOrder InspectionOrder) {
|
return baseMapper.pageInspectionOrder(page, QueryWrappers.queryWrappers(InspectionOrder));
|
}
|
|
/**
|
* 检验委托单新增
|
*
|
* @param inspectionOrder
|
* @return
|
*/
|
@Override
|
public InspectionOrderDto addInspectionOrder(InspectionOrderDto inspectionOrder) {
|
if (inspectionOrder.getInsOrderId() != null) {
|
throw new ErrorException("新增检验委托单不允许直接绑定成品下单，请在成品下单页面选择委托单");
|
}
|
normalizeCommissionParty(inspectionOrder);
|
|
inspectionOrder.setInspectionOrderCode(numberGenerator.generateNumberWithPrefix(4,
|
"WTD" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")),
|
InspectionOrder::getInspectionOrderCode));
|
// 委托编号由成品下单流程生成，委托单新增阶段不得手工填写。
|
inspectionOrder.setEntrustCode(null);
|
inspectionOrder.setFileUrl(null);
|
baseMapper.insert(inspectionOrder);
|
// 新增详情
|
if (CollectionUtils.isNotEmpty(inspectionOrder.getOrderDetailList())) {
|
for (InspectionOrderDetail InspectionOrderDetail : inspectionOrder.getOrderDetailList()) {
|
InspectionOrderDetail.setInspectionOrderId(inspectionOrder.getInspectionOrderId());
|
}
|
inspectionOrderDetailService.saveBatch(inspectionOrder.getOrderDetailList());
|
}
|
return inspectionOrder;
|
}
|
|
/**
|
* 检验委托单修改
|
*
|
* @param InspectionOrder
|
* @return
|
*/
|
@Override
|
public boolean updateInspectionOrder(InspectionOrderDto InspectionOrder) {
|
InspectionOrder oldInspectionOrder = baseMapper.selectByIdForUpdate(InspectionOrder.getInspectionOrderId());
|
if (oldInspectionOrder == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
Long bindingHistoryCount = inspectionOrderBindingMapper.selectCount(Wrappers.<InspectionOrderBinding>lambdaQuery()
|
.eq(InspectionOrderBinding::getInspectionOrderId, InspectionOrder.getInspectionOrderId()));
|
if (bindingHistoryCount > 0 && !Objects.equals(oldInspectionOrder.getCommissionUnitId(), InspectionOrder.getCommissionUnitId())) {
|
throw new ErrorException("已有下单记录，不允许修改委托单位");
|
}
|
normalizeCommissionParty(InspectionOrder);
|
// 编号、关联关系、正式委托编号和报告地址只能由专用流程维护。
|
InspectionOrder.setInspectionOrderCode(null);
|
InspectionOrder.setInsOrderId(null);
|
InspectionOrder.setEntrustCode(null);
|
InspectionOrder.setFileUrl(null);
|
InspectionOrder.setSampleTakerUserId(null);
|
InspectionOrder.setSampleTakerUser(null);
|
baseMapper.updateById(InspectionOrder);
|
|
// 删除之前的详情
|
inspectionOrderDetailService.remove(Wrappers.<InspectionOrderDetail>lambdaQuery()
|
.eq(InspectionOrderDetail::getInspectionOrderId, InspectionOrder.getInspectionOrderId()));
|
|
// 新增详情
|
if (CollectionUtils.isNotEmpty(InspectionOrder.getOrderDetailList())) {
|
for (InspectionOrderDetail InspectionOrderDetail : InspectionOrder.getOrderDetailList()) {
|
InspectionOrderDetail.setInspectionOrderId(InspectionOrder.getInspectionOrderId());
|
}
|
inspectionOrderDetailService.saveBatch(InspectionOrder.getOrderDetailList());
|
}
|
|
return true;
|
}
|
|
/**
|
* 检验委托单删除
|
*
|
* @param inspectionOrderId
|
* @return
|
*/
|
@Override
|
public boolean delInspectionOrder(Integer inspectionOrderId) {
|
InspectionOrder inspectionOrder = baseMapper.selectByIdForUpdate(inspectionOrderId);
|
if (inspectionOrder == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
Long bindingHistoryCount = inspectionOrderBindingMapper.selectCount(Wrappers.<InspectionOrderBinding>lambdaQuery()
|
.eq(InspectionOrderBinding::getInspectionOrderId, inspectionOrderId));
|
Long bindLogCount = inspectionOrderBindLogMapper.selectCount(Wrappers.<InspectionOrderBindLog>lambdaQuery()
|
.and(wrapper -> wrapper.eq(InspectionOrderBindLog::getOldInspectionOrderId, inspectionOrderId)
|
.or().eq(InspectionOrderBindLog::getNewInspectionOrderId, inspectionOrderId)));
|
Long attachmentCount = inspectionOrderAttachmentMapper.selectCount(Wrappers.<InspectionOrderAttachment>lambdaQuery()
|
.eq(InspectionOrderAttachment::getInspectionOrderId, inspectionOrderId));
|
if (bindingHistoryCount > 0 || bindLogCount > 0 || attachmentCount > 0) {
|
throw new ErrorException("该检验委托单已有下单或附件历史，不允许删除");
|
}
|
|
inspectionOrderDetailService.remove(Wrappers.<InspectionOrderDetail>lambdaQuery()
|
.eq(InspectionOrderDetail::getInspectionOrderId, inspectionOrderId));
|
baseMapper.deleteById(inspectionOrderId);
|
return true;
|
}
|
|
/**
|
* 检验委托单查看详情
|
*
|
* @param inspectionOrderId
|
* @return
|
*/
|
@Override
|
public InspectionOrderDto getInspectionOrderOne(Integer inspectionOrderId) {
|
InspectionOrder inspectionOrder = baseMapper.selectById(inspectionOrderId);
|
if (inspectionOrder == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
InspectionOrderDto inspectionOrderDto = new InspectionOrderDto();
|
BeanUtils.copyProperties(inspectionOrder, inspectionOrderDto);
|
|
// 查询详细信息
|
inspectionOrderDto.setOrderDetailList(inspectionOrderDetailService.list(Wrappers.<InspectionOrderDetail>lambdaQuery()
|
.eq(InspectionOrderDetail::getInspectionOrderId, inspectionOrderId)));
|
return inspectionOrderDto;
|
}
|
|
@Override
|
public IPage<InspectionOrder> pageUnboundInspectionOrder(Page page, InspectionOrder inspectionOrder) {
|
return baseMapper.pageUnboundInspectionOrder(page, QueryWrappers.queryWrappers(inspectionOrder));
|
}
|
|
@Override
|
public IPage<InspectionOrderBindingDto> pageInspectionOrderBindings(Page page, Integer inspectionOrderId,
|
Boolean includeDeleted) {
|
if (inspectionOrderId == null || baseMapper.selectById(inspectionOrderId) == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
return inspectionOrderBindingMapper.pageBindings(page, inspectionOrderId, includeDeleted);
|
}
|
|
@Override
|
public List<InspectionOrderAttachment> listInspectionOrderAttachments(Integer inspectionOrderId, Long bindingId) {
|
if (inspectionOrderId == null || baseMapper.selectById(inspectionOrderId) == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
if (bindingId != null) {
|
InspectionOrderBinding binding = inspectionOrderBindingMapper.selectById(bindingId);
|
if (binding == null || !Objects.equals(binding.getInspectionOrderId(), inspectionOrderId)) {
|
throw new ErrorException("下单记录不属于该检验委托单");
|
}
|
}
|
return inspectionOrderAttachmentMapper.selectVisibleAttachments(inspectionOrderId, bindingId);
|
}
|
|
@Override
|
public InspectionOrderDto getInspectionOrderForPlaceOrder(Integer inspectionOrderId) {
|
InspectionOrder inspectionOrder = baseMapper.selectById(inspectionOrderId);
|
if (inspectionOrder == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
return getInspectionOrderOne(inspectionOrderId);
|
}
|
|
@Override
|
public Integer addInsOrderWithInspectionOrder(InsPlaceOrderDto insPlaceOrderDto) {
|
if (insPlaceOrderDto == null || insPlaceOrderDto.getInspectionOrderId() == null) {
|
throw new ErrorException("请选择检验委托单");
|
}
|
if (insPlaceOrderDto.getInsOrder() == null) {
|
throw new ErrorException("缺少成品下单信息");
|
}
|
if (CollectionUtils.isEmpty(insPlaceOrderDto.getSampleList())) {
|
throw new ErrorException("请填写本次样品");
|
}
|
String requestId = normalizeRequestId(insPlaceOrderDto.getRequestId());
|
Integer requestUserId = SecurityUtils.getUserId().intValue();
|
String requestHash = calculateRequestHash(insPlaceOrderDto);
|
if (inspectionOrderBindingMapper.lockRequestUser(requestUserId) == null) {
|
throw new ErrorException("当前操作人不存在");
|
}
|
InspectionOrderBinding existing = inspectionOrderBindingMapper.selectByRequest(requestUserId, requestId);
|
if (existing != null) {
|
return resolveIdempotentRequest(existing, requestHash);
|
}
|
InspectionOrder inspectionOrder = baseMapper.selectByIdForUpdate(insPlaceOrderDto.getInspectionOrderId());
|
if (inspectionOrder == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
existing = inspectionOrderBindingMapper.selectByRequest(requestUserId, requestId);
|
if (existing != null) {
|
return resolveIdempotentRequest(existing, requestHash);
|
}
|
if (inspectionOrder.getCommissionUnitId() == null) {
|
throw new ErrorException("请先完善委托单位");
|
}
|
if (inspectionOrder.getCommissionUserId() == null) {
|
throw new ErrorException("请先完善委托人");
|
}
|
|
fillInsOrderFromInspectionOrder(inspectionOrder, insPlaceOrderDto.getInsOrder());
|
Integer insOrderId = insOrderService.addInsOrder(insPlaceOrderDto.getSampleList(), insPlaceOrderDto.getInsOrder());
|
Long sampleTakerUserId = SecurityUtils.getUserId();
|
User sampleTaker = sampleTakerUserId == null ? null : userMapper.selectById(sampleTakerUserId);
|
InspectionOrderBinding binding = new InspectionOrderBinding();
|
binding.setInspectionOrderId(inspectionOrder.getInspectionOrderId());
|
binding.setInsOrderId(insOrderId);
|
binding.setSourceType("NEW");
|
binding.setRequestId(requestId);
|
binding.setRequestHash(requestHash);
|
binding.setRequestUserId(requestUserId);
|
binding.setSampleTakerUserId(sampleTakerUserId == null ? null : sampleTakerUserId.intValue());
|
binding.setSampleTakerUser(sampleTaker == null ? null : sampleTaker.getName());
|
binding.setSampleData(LocalDate.now());
|
binding.setOrderDeleted(0);
|
binding.setCreateUser(requestUserId);
|
binding.setCreateTime(LocalDateTime.now());
|
inspectionOrderBindingMapper.insert(binding);
|
return insOrderId;
|
}
|
|
private String normalizeRequestId(String requestId) {
|
if (StrUtil.isBlank(requestId)) {
|
throw new ErrorException("缺少下单请求号，请刷新页面后重试");
|
}
|
try {
|
return UUID.fromString(requestId.trim()).toString();
|
} catch (IllegalArgumentException e) {
|
throw new ErrorException("下单请求号格式错误，请刷新页面后重试");
|
}
|
}
|
|
private Integer resolveIdempotentRequest(InspectionOrderBinding existing, String requestHash) {
|
if (!Objects.equals(existing.getRequestHash(), requestHash)) {
|
throw new ErrorException("请求号已被其他下单内容使用，请重新发起下单");
|
}
|
if (Integer.valueOf(1).equals(existing.getOrderDeleted())) {
|
throw new ErrorException("原订单已删除，请重新发起下单");
|
}
|
return existing.getInsOrderId();
|
}
|
|
private String calculateRequestHash(InsPlaceOrderDto dto) {
|
LinkedHashMap<String, Object> content = new LinkedHashMap<>();
|
content.put("inspectionOrderId", dto.getInspectionOrderId());
|
content.put("insOrder", dto.getInsOrder());
|
content.put("sampleList", dto.getSampleList());
|
try {
|
byte[] digest = MessageDigest.getInstance("SHA-256")
|
.digest(JSON.toJSONString(content).getBytes(StandardCharsets.UTF_8));
|
StringBuilder result = new StringBuilder(64);
|
for (byte value : digest) {
|
result.append(String.format("%02x", value & 0xff));
|
}
|
return result.toString();
|
} catch (Exception e) {
|
throw new ErrorException("下单请求校验失败");
|
}
|
}
|
|
private void fillInsOrderFromInspectionOrder(InspectionOrder inspectionOrder, InsOrder insOrder) {
|
insOrder.setEntrustCode(null);
|
insOrder.setSample(inspectionOrder.getSampleName());
|
insOrder.setCompany(inspectionOrder.getCommissionUnit());
|
insOrder.setCompanyId(inspectionOrder.getCommissionUnitId());
|
insOrder.setProduction(inspectionOrder.getProduction());
|
insOrder.setPrepareUser(inspectionOrder.getCommissionUser());
|
insOrder.setPhone(inspectionOrder.getCommissionPhone());
|
insOrder.setSampleStatus(inspectionOrder.getSampleStatus());
|
insOrder.setIsLeave(inspectionOrder.getIsLeave());
|
insOrder.setProcessing(inspectionOrder.getProcessing());
|
insOrder.setAppointed(inspectionOrder.getAppointed());
|
insOrder.setSend(inspectionOrder.getSend());
|
}
|
|
/** 仅信任客户和人员主数据，名称与电话均以主数据快照为准。 */
|
private void normalizeCommissionParty(InspectionOrder inspectionOrder) {
|
if (inspectionOrder.getCommissionUnitId() == null) {
|
throw new ErrorException("请选择委托单位");
|
}
|
Custom custom = customMapper.selectById(inspectionOrder.getCommissionUnitId());
|
if (custom == null) {
|
throw new ErrorException("委托单位不存在或已停用");
|
}
|
inspectionOrder.setCommissionUnit(custom.getCompany());
|
|
if (inspectionOrder.getCommissionUserId() == null) {
|
throw new ErrorException("请选择委托人");
|
}
|
User commissionUser = userMapper.selectById(inspectionOrder.getCommissionUserId());
|
if (commissionUser == null) {
|
throw new ErrorException("委托人不存在或已停用");
|
}
|
inspectionOrder.setCommissionUser(commissionUser.getName());
|
inspectionOrder.setCommissionPhone(commissionUser.getPhone());
|
}
|
|
@Override
|
public void syncEntrustCode(Integer insOrderId) {
|
// 委托编号属于具体成品订单，页面通过绑定关系实时读取，不再回写委托单主表。
|
}
|
|
@Override
|
public void syncReportFile(Integer insReportId) {
|
if (insReportId == null) {
|
return;
|
}
|
InsReport insReport = insReportService.getById(insReportId);
|
if (insReport == null || !Integer.valueOf(1).equals(insReport.getIsRatify())) {
|
return;
|
}
|
InspectionOrderBinding binding = inspectionOrderBindingMapper.selectOne(Wrappers.<InspectionOrderBinding>lambdaQuery()
|
.eq(InspectionOrderBinding::getInsOrderId, insReport.getInsOrderId())
|
.eq(InspectionOrderBinding::getOrderDeleted, 0)
|
.last("limit 1"));
|
if (binding == null) {
|
return;
|
}
|
InspectionOrder inspectionOrder = baseMapper.selectById(binding.getInspectionOrderId());
|
if (inspectionOrder == null) return;
|
|
String sourceUrl = StrUtil.isBlank(insReport.getUrlS()) ? insReport.getUrl() : insReport.getUrlS();
|
if (StrUtil.isBlank(sourceUrl)) {
|
throw new ErrorException("正式报告文件不存在，无法同步到检验委托单");
|
}
|
String sourceFileName = sourceUrl.substring(sourceUrl.lastIndexOf('/') + 1);
|
String extension = sourceFileName.lastIndexOf('.') >= 0
|
? sourceFileName.substring(sourceFileName.lastIndexOf('.')) : ".docx";
|
String fileName = inspectionOrder.getInspectionOrderCode() + "_order_" + insReport.getInsOrderId()
|
+ "_report_" + insReportId + "_" + UUID.randomUUID() + extension;
|
Path sourcePath = Paths.get(wordUrl + sourceUrl.replaceFirst("/word", ""));
|
Path targetPath = Paths.get(wordUrl, fileName);
|
try {
|
if (!Files.exists(sourcePath)) {
|
throw new ErrorException("正式报告文件不存在，无法同步到检验委托单");
|
}
|
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
|
InspectionOrderAttachment attachment = inspectionOrderAttachmentMapper.selectOne(
|
Wrappers.<InspectionOrderAttachment>lambdaQuery()
|
.eq(InspectionOrderAttachment::getInsReportId, insReportId).last("limit 1"));
|
if (attachment == null) {
|
attachment = new InspectionOrderAttachment();
|
attachment.setInsReportId(insReportId);
|
attachment.setSourceType("REPORT");
|
attachment.setCreateUser(SecurityUtils.getUserId().intValue());
|
attachment.setCreateTime(LocalDateTime.now());
|
}
|
attachment.setInspectionOrderId(binding.getInspectionOrderId());
|
attachment.setBindingId(binding.getId());
|
attachment.setFileName(fileName);
|
attachment.setFileUrl("/word/" + fileName);
|
attachment.setUpdateTime(LocalDateTime.now());
|
if (attachment.getId() == null) {
|
inspectionOrderAttachmentMapper.insert(attachment);
|
} else {
|
inspectionOrderAttachmentMapper.updateById(attachment);
|
}
|
} catch (ErrorException e) {
|
throw e;
|
} catch (Exception e) {
|
throw new ErrorException("报告同步失败");
|
}
|
}
|
|
@Override
|
public boolean changeBinding(Integer insOrderId, Integer inspectionOrderId, String reason) {
|
if (insOrderId == null || inspectionOrderId == null || StrUtil.isBlank(reason)) {
|
throw new ErrorException("缺少变更关联所需参数");
|
}
|
InsOrder insOrder = insOrderService.getById(insOrderId);
|
if (insOrder == null) {
|
throw new ErrorException("成品下单不存在");
|
}
|
if (!(Integer.valueOf(0).equals(insOrder.getState()) || Integer.valueOf(2).equals(insOrder.getState()))
|
|| StrUtil.isNotBlank(insOrder.getEntrustCode())) {
|
throw new ErrorException("当前下单已进入检验流程或已生成委托编号，不允许变更关联");
|
}
|
InspectionOrderBinding binding = inspectionOrderBindingMapper.selectByOrderIdForUpdate(insOrderId);
|
if (binding == null || Integer.valueOf(1).equals(binding.getOrderDeleted())) {
|
throw new ErrorException("成品下单未绑定有效检验委托单");
|
}
|
InspectionOrder target = baseMapper.selectByIdForUpdate(inspectionOrderId);
|
if (target == null) {
|
throw new ErrorException("目标检验委托单不存在");
|
}
|
if (Objects.equals(binding.getInspectionOrderId(), inspectionOrderId)) {
|
throw new ErrorException("目标检验委托单与当前委托单相同");
|
}
|
if (!Objects.equals(target.getCommissionUnitId(), insOrder.getCompanyId())) {
|
throw new ErrorException("目标检验委托单与成品订单的委托单位不一致");
|
}
|
Integer oldInspectionOrderId = binding.getInspectionOrderId();
|
binding.setInspectionOrderId(inspectionOrderId);
|
binding.setUpdateUser(SecurityUtils.getUserId().intValue());
|
binding.setUpdateTime(LocalDateTime.now());
|
inspectionOrderBindingMapper.updateById(binding);
|
inspectionOrderAttachmentMapper.update(null, Wrappers.<InspectionOrderAttachment>lambdaUpdate()
|
.eq(InspectionOrderAttachment::getBindingId, binding.getId())
|
.set(InspectionOrderAttachment::getInspectionOrderId, inspectionOrderId)
|
.set(InspectionOrderAttachment::getUpdateTime, LocalDateTime.now()));
|
InspectionOrderBindLog bindLog = new InspectionOrderBindLog();
|
bindLog.setInsOrderId(insOrderId);
|
bindLog.setOldInspectionOrderId(oldInspectionOrderId);
|
bindLog.setNewInspectionOrderId(inspectionOrderId);
|
bindLog.setChangeReason(reason.trim());
|
bindLog.setCreateUser(SecurityUtils.getUserId().intValue());
|
bindLog.setCreateTime(LocalDateTime.now());
|
inspectionOrderBindLogMapper.insert(bindLog);
|
return true;
|
}
|
|
/**
|
* 委托单成品报告上传
|
*
|
* @param file
|
* @param inspectionOrderId
|
* @return
|
*/
|
@Override
|
public boolean uploadInspectionOrderFile(MultipartFile file, Integer inspectionOrderId) {
|
throw new ErrorException("请在下单记录中选择具体订单后上传附件");
|
}
|
|
@Override
|
public boolean uploadInspectionOrderBindingFile(MultipartFile file, Long bindingId) {
|
if (file == null || file.isEmpty() || bindingId == null) {
|
throw new ErrorException("请选择下单记录和上传文件");
|
}
|
InspectionOrderBinding binding = inspectionOrderBindingMapper.selectById(bindingId);
|
if (binding == null || Integer.valueOf(1).equals(binding.getOrderDeleted())) {
|
throw new ErrorException("下单记录不存在或订单已删除");
|
}
|
try {
|
File realpath = new File(wordUrl);
|
if (!realpath.exists() && !realpath.mkdirs()) {
|
throw new ErrorException("文件目录创建失败");
|
}
|
String originalName = new File(file.getOriginalFilename() == null ? "attachment" : file.getOriginalFilename()).getName();
|
String pathName = "binding_" + bindingId + "_" + UUID.randomUUID() + "_" + originalName;
|
file.transferTo(new File(realpath, pathName));
|
InspectionOrderAttachment attachment = new InspectionOrderAttachment();
|
attachment.setInspectionOrderId(binding.getInspectionOrderId());
|
attachment.setBindingId(bindingId);
|
attachment.setSourceType("MANUAL");
|
attachment.setFileName(originalName);
|
attachment.setFileUrl("/word/" + pathName);
|
attachment.setCreateUser(SecurityUtils.getUserId().intValue());
|
attachment.setCreateTime(LocalDateTime.now());
|
inspectionOrderAttachmentMapper.insert(attachment);
|
return true;
|
} catch (ErrorException e) {
|
throw e;
|
} catch (Exception e) {
|
throw new ErrorException("文件上传失败");
|
}
|
}
|
|
@Override
|
public void exportInspectionOrder(Integer inspectionOrderId, Long bindingId, HttpServletResponse response) {
|
InspectionOrder inspectionOrder = baseMapper.selectById(inspectionOrderId);
|
if (inspectionOrder == null) {
|
throw new ErrorException("检验委托单不存在");
|
}
|
InspectionOrderExportDto inspectionOrderExportDto = extracted(inspectionOrder);
|
if (bindingId == null) {
|
inspectionOrderExportDto.setEntrustCode(null);
|
inspectionOrderExportDto.setSampleTakerUser(null);
|
inspectionOrderExportDto.setSampleTakerUserId(null);
|
inspectionOrderExportDto.setSampleData(null);
|
inspectionOrderExportDto.setSampleDataString(null);
|
} else {
|
InspectionOrderBinding binding = inspectionOrderBindingMapper.selectById(bindingId);
|
if (binding == null || !Objects.equals(binding.getInspectionOrderId(), inspectionOrderId)) {
|
throw new ErrorException("下单记录不属于该检验委托单");
|
}
|
InsOrder insOrder = insOrderService.getById(binding.getInsOrderId());
|
inspectionOrderExportDto.setEntrustCode(insOrder == null ? null : insOrder.getEntrustCode());
|
inspectionOrderExportDto.setSampleTakerUser(binding.getSampleTakerUser());
|
inspectionOrderExportDto.setSampleTakerUserId(binding.getSampleTakerUserId());
|
inspectionOrderExportDto.setSampleData(binding.getSampleData());
|
if (binding.getSampleData() != null) {
|
inspectionOrderExportDto.setSampleDataString(binding.getSampleData()
|
.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")));
|
}
|
}
|
List<InspectionOrderDetail> list = inspectionOrderDetailService.list(Wrappers.<InspectionOrderDetail>lambdaQuery()
|
.eq(InspectionOrderDetail::getInspectionOrderId, inspectionOrderId));
|
int index = 1;
|
for (InspectionOrderDetail inspectionOrderDetail : list) {
|
inspectionOrderDetail.setIndex(index);
|
index++;
|
}
|
|
// 获取路径
|
InputStream inputStream = this.getClass().getResourceAsStream("/static/inspection-order.docx");
|
Configure configure = Configure.builder()
|
.bind("inspectionOrderDetailList", new HackLoopTableRenderPolicy())
|
.build();
|
XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
|
new HashMap<String, Object>() {{
|
put("inspectionOrder", inspectionOrderExportDto);
|
put("inspectionOrderDetailList", list);
|
}});
|
|
try {
|
response.setContentType("application/msword");
|
String fileName = URLEncoder.encode(
|
inspectionOrderExportDto.getSampleName(), "UTF-8");
|
response.setHeader("Content-disposition",
|
"attachment;filename=" + fileName + ".docx");
|
OutputStream os = response.getOutputStream();
|
template.write(os);
|
os.flush();
|
os.close();
|
inputStream.close();
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RuntimeException("导出失败");
|
}
|
}
|
|
private InspectionOrderExportDto extracted(InspectionOrder inspectionOrder) {
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
|
InspectionOrderExportDto inspectionOrderExportDto = new InspectionOrderExportDto();
|
BeanUtils.copyProperties(inspectionOrder, inspectionOrderExportDto);
|
|
if (inspectionOrder.getCommissionDate() != null) {
|
inspectionOrderExportDto.setCommissionDateString(inspectionOrder.getCommissionDate().format(formatter));
|
}
|
if (inspectionOrder.getReceiptData() != null) {
|
inspectionOrderExportDto.setReceiptDataString(inspectionOrder.getReceiptData().format(formatter));
|
}
|
if (inspectionOrder.getSampleData() != null) {
|
inspectionOrderExportDto.setSampleDataString(inspectionOrder.getSampleData().format(formatter));
|
}
|
if (inspectionOrder.getAppointed() != null) {
|
inspectionOrderExportDto.setAppointedString(inspectionOrder.getAppointed().format(formatter));
|
}
|
|
inspectionOrderExportDto.setIsLeave1(inspectionOrder.getIsLeave() != null && inspectionOrder.getIsLeave() == 1 ? "☑" : "□");
|
inspectionOrderExportDto.setIsLeave2(inspectionOrder.getIsLeave() != null && inspectionOrder.getIsLeave() == 0 ? "☑" : "□");
|
inspectionOrderExportDto.setSend0(inspectionOrder.getSend() != null && inspectionOrder.getSend() == 1 ? "☑" : "□");
|
inspectionOrderExportDto.setSend1(inspectionOrder.getSend() != null && inspectionOrder.getSend() == 0 ? "☑" : "□");
|
inspectionOrderExportDto.setProcessing0(inspectionOrder.getProcessing() != null && inspectionOrder.getProcessing() == 0 ? "☑" : "□");
|
inspectionOrderExportDto.setProcessing1(inspectionOrder.getProcessing() != null && inspectionOrder.getProcessing() == 1 ? "☑" : "□");
|
inspectionOrderExportDto.setCriterionRule0(inspectionOrder.getCriterionRule() != null && inspectionOrder.getCriterionRule() == 0 ? "☑" : "□");
|
inspectionOrderExportDto.setCriterionRule1(inspectionOrder.getCriterionRule() != null && inspectionOrder.getCriterionRule() == 1 ? "☑" : "□");
|
return inspectionOrderExportDto;
|
}
|
}
|
