package com.chinaztt.mes.quality.service.impl;
|
|
import cn.hutool.core.date.DateUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
|
import com.chinaztt.ifs.api.feign.IfsFeignClient;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.quality.dto.ApplyPartDTO;
|
import com.chinaztt.mes.quality.dto.IfsShopOrderDTO;
|
import com.chinaztt.mes.quality.dto.ReportMDTO;
|
import com.chinaztt.mes.quality.dto.SubmitReportDTO;
|
import com.chinaztt.mes.quality.entity.*;
|
import com.chinaztt.mes.quality.mapper.*;
|
|
import com.chinaztt.mes.quality.service.ApplyPartService;
|
import com.chinaztt.mes.quality.service.ReportSampleService;
|
import com.chinaztt.mes.quality.service.ReportSamplingRecordService;
|
import com.chinaztt.mes.quality.service.ReportService;
|
import com.chinaztt.mes.quality.state.result.constant.ResultStateStringValues;
|
import com.chinaztt.mes.quality.utils.QualityModuleDockIfsUtils;
|
import com.chinaztt.mes.quality.utils.ReportUtils;
|
import com.chinaztt.mes.warehouse.dto.StockDTO;
|
import com.chinaztt.mes.warehouse.mapper.StockMapper;
|
import com.chinaztt.ztt.common.core.util.R;
|
import com.chinaztt.ztt.common.security.util.SecurityUtils;
|
import com.google.gson.Gson;
|
|
import com.google.gson.internal.LinkedTreeMap;
|
import lombok.AllArgsConstructor;
|
import org.apache.http.HttpEntity;
|
import org.apache.http.client.methods.CloseableHttpResponse;
|
import org.apache.http.client.methods.HttpPost;
|
import org.apache.http.entity.ContentType;
|
import org.apache.http.entity.StringEntity;
|
import org.apache.http.impl.client.CloseableHttpClient;
|
import org.apache.http.impl.client.HttpClientBuilder;
|
import org.apache.http.util.EntityUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.core.env.Environment;
|
import org.springframework.stereotype.Component;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 检测汇报表
|
*
|
* @author cxf
|
* @date 2021-04-06 14:29:39
|
*/
|
@Service
|
@AllArgsConstructor
|
@Component
|
@Transactional(rollbackFor = Exception.class)
|
public class ReportServiceImpl extends ServiceImpl<ReportMapper, Report> implements ReportService {
|
private static final Long LOCATION_TYPE_QUALIFIED = 4L;//mes产出合格库位码
|
private ReportUtils reportUtils;
|
private ResultMapper resultMapper;
|
private IfsFeignClient ifsFeignClient;
|
private PartMapper partMapper;
|
private ApplyPartService applyPartService;
|
private ApplyPartMapper applyPartMapper;
|
private QualityModuleDockIfsUtils qualityModuleDockIfsUtils;
|
private ApplyPartFileMapper applyPartFileMapper;
|
private ReportSampleMapper reportSampleMapper;
|
private ReportSampleService reportSampleService;
|
private StockMapper stockMapper;
|
private ReportSamplingRecordService reportSamplingRecordService;
|
private ReportSamplingRecordMapper reportSamplingRecordMapper;
|
private ReportSampleItemMapper reportSampleItemMapper;
|
private Environment environment;
|
|
// @Autowired
|
// public ReportServiceImpl(@Lazy ApplyPartService applyPartService) {
|
// this.applyPartService = applyPartService;
|
// }
|
|
|
@Override
|
public boolean save(Report report) {
|
reportUtils.checkReportNo(report);//自动生成或校验检测汇报编号（支持手动定义编号）
|
return SqlHelper.retBool(baseMapper.insert(report));
|
}
|
|
@Override
|
public boolean updateById(Report report) {
|
reportUtils.checkReportNo(report);
|
return SqlHelper.retBool(baseMapper.updateById(report));
|
}
|
|
|
@Override
|
public boolean removeById(Long id) {
|
Report report = this.baseMapper.selectById(id);
|
List<ApplyPart> applyParts = applyPartMapper.selectListByReportId(id);
|
if (!applyParts.isEmpty()) {
|
// 清空检测结果状态
|
List<String> systemNos = applyParts.stream().map(ApplyPart::getSystemNo).collect(Collectors.toList());
|
resultMapper.clearCheckStatusBySystemNosAndType(report.getReportType(), systemNos);
|
}
|
|
// 清空检测申请材料表的汇报id
|
applyPartMapper.clearReportId(id);
|
|
// 清除抽检记录
|
if (report.getSamplingRecordId() != null) {
|
reportSamplingRecordService.reduceSamplingRecordNum(report.getSamplingRecordId(), id);
|
}
|
|
|
// 删除检测汇报
|
return SqlHelper.retBool(this.baseMapper.deleteById(id));
|
}
|
|
@Override
|
public R saveFamily(ReportMDTO reportMDTO){
|
//校验SN、光标位置码
|
if(reportMDTO.getSn() == null || reportMDTO.getSn().length() == 0){
|
return R.failed("SN号为空！");
|
}else if(!(reportMDTO.getSweepCodeGunCursorLocation().equals("M") || reportMDTO.getSweepCodeGunCursorLocation().equals("D"))){
|
return R.failed("扫码枪光标位置码异常！");
|
}else{
|
switch(reportMDTO.getSweepCodeGunCursorLocation()){
|
case "M"://光标在主表表头
|
break;
|
case "D"://光标在明细表表头
|
break;
|
default:
|
break;
|
}
|
|
return R.ok("该需求取消，有射频老MES调接口推送");
|
}
|
}
|
|
/**
|
* 扫码枪扫码——新增检测汇报
|
* @param sn
|
* @return 检测汇报记录行id
|
*/
|
private long addReportM(String sn) {
|
//根据sn号获取检测汇报类型
|
//该SN号有且仅有一条检测申请记录，则支持自动创建检测汇报
|
List<String> applyTypeList = baseMapper.getApplyTypeBySN(sn);
|
if(applyTypeList == null || applyTypeList.size() == 0){
|
throw new RuntimeException("该对象查无检测申请，无法自动创建检测汇报！");
|
}else if(applyTypeList.size() > 1){
|
throw new RuntimeException("该对象存在多条检测申请，无法自动创建检测汇报！");
|
}else{
|
//创建检测汇报主表
|
Report report = new Report();
|
report.setCheckState(Report.CHECK_STATE_UNCHECK);//初始化状态：未检测
|
report.setReportType(applyTypeList.get(0));//初始化汇报类型
|
reportUtils.checkReportNo(report);//自动生成检测汇报编号
|
baseMapper.insert(report);
|
return report.getId();//返回自增id
|
}
|
}
|
|
/**
|
* 扫码枪扫码——新增检测汇报零件
|
* @param reportId 检测汇报主表id
|
* @param sn
|
* @param reportType 检测汇报类型
|
* @return 检测汇报零件记录行id
|
*/
|
private long addReportPart(Long reportId,String sn,String reportType) {
|
//根据sn、检测汇报类型获取其对应的检测申请明细（此时sn号对应的检测申请明细只存在唯一一条记录）
|
List<ApplyPart> applyPartList = applyPartMapper.selectApplyApertByInspState(sn,reportType);
|
if(applyPartList == null || applyPartList.size() != 1){
|
throw new RuntimeException("通过SN号及检测汇报类型查无检测申请或检测申请记录数>1");
|
}else{
|
//将检测汇报id根据sn号更新至检测申请明细中
|
baseMapper.updateApplyPartReportId(sn,reportId);
|
return applyPartList.get(0).getId();//返回记录行id
|
}
|
}
|
|
@Override
|
public R submit(Long id){
|
//校验检测汇报是否已提交
|
Report report = baseMapper.selectById(id);
|
|
if(report.getIsSubmit() != null && report.getIsSubmit()){
|
if(report.getIsSubmit()){
|
throw new RuntimeException("请勿重复提交检测汇报！");
|
}
|
}
|
|
List<ApplyPart> applyPartList = applyPartMapper.selectListByReportId(id);
|
//判断检测汇报中的明细全部已检测是否成立，不成立则拒绝提交报告
|
if(CollectionUtils.isNotEmpty(applyPartList)){
|
reportUtils.checkOperationNoIsSame(id);//检验汇报零件工序是否一致
|
for(int i = 0;i < applyPartList.size();i++){
|
if(applyPartList.get(i).getIsQualified() == null){
|
throw new RuntimeException("该检测汇报存在汇报明细未检测，无法提交！");
|
}
|
}
|
}else{
|
throw new RuntimeException("检测汇报明细为空！无法提交检测汇报！");
|
}
|
|
//更新检测汇报主表状态为：已提交
|
baseMapper.updateQualityReportSubmitState(id,true);
|
|
// ERP 不需要移库
|
//对接库存件移库
|
// if(report.getReportType().equals(Apply.PRODUCT_APPLY)){
|
// //此处的移库是处理成品检中的移库
|
// qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.MOVE_PART, true);
|
// }
|
|
// 是否需要成品检处理
|
boolean isNeedFinishApply = false;
|
|
//首检及批次首检只做检测，不做其他关联业务
|
if(!report.getReportType().equals(Apply.FIRST_APPLY)&&!report.getReportType().equals(Apply.BATCHFIRST_APPLY)){
|
//ERP 不需要移库
|
//移库
|
// isNeedFinishApply = applyPartService.moveLibrary(id,ApplyPartServiceImpl.MOVELIBRARY);
|
|
if(false){//直接屏蔽，放弃整改
|
//ifs移库成功，车间订单接收失败怎么处理？理论上不存在，这两种汇报类型不应该同时存在
|
List<ApplyPart> applyPartListFilter_last = filterSynIfsApplyParts(id);
|
for(int i = 0;i < applyPartListFilter_last.size();i++){
|
//更新产出明细是否提交ifs为：已提交（根据system_no）
|
if(applyPartMapper.isLastOperationBySystemNo(applyPartListFilter_last.get(i).getSystemNo()) && !report.getReportType().equals(Apply.PRODUCT_APPLY)){
|
continue;//是最后一道工序，且不是成品检，则跳过
|
}
|
baseMapper.updateProductOutIsSynIfs(applyPartListFilter_last.get(i).getSystemNo(),true);
|
}
|
shopOrderReceive(applyPartListFilter_last,report,"re");//车间订单接收
|
}
|
}
|
|
// 对接ERP产品入口
|
List<String> partNos = applyPartList.stream().map(ApplyPart::getPartNo).collect(Collectors.toList());
|
List<Part> parts = partMapper.selectList(new LambdaQueryWrapper<Part>().in(Part::getPartNo, partNos));
|
Map<String,Object> _Map = new HashMap<>();
|
_Map.put("title","成品入库");
|
_Map.put("sort",1);// 规定1 成品入库 等ERP确认
|
// _Map.put("sort",1);// 规定1 成品入库 等ERP确认
|
// SecurityUtils.getUser().getId()
|
_Map.put("date3", DateUtil.format(new Date(),"YYYY-MM-dd"));
|
List<Map<String,Object>> details = new ArrayList<>();
|
_Map.put("details",details);
|
for (ApplyPart applyPart:applyPartList) {
|
Map<String,Object> pMap = new HashMap<>();
|
Part part = parts.stream().filter(e->e.getPartNo().equals(applyPart.getPartNo())).findFirst().get();
|
pMap.put("ord",part.getPartFamilyId());
|
details.add(pMap);
|
}
|
_Map.put("details",details);
|
inWareHoiuse(_Map);
|
// //对接工序报废
|
// if(false){
|
// //取消对接ifs工序报工，是否自动报工设置为：是
|
// qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SCRAP_OPERATION, isNeedFinishApply);
|
// }
|
//
|
// //对接工序报工
|
// if(false){
|
// //取消对接ifs工序报废
|
// qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.REPORT_OPERATION, isNeedFinishApply);
|
// }
|
//
|
// //对接车间订单接收
|
// qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SHOP_ORDER_REC, isNeedFinishApply);
|
|
return R.ok("检测汇报单提交成功！");
|
}
|
|
private void inWareHoiuse(Map<String,Object> map) {
|
CloseableHttpClient httpClient = HttpClientBuilder.create().build();
|
String inWareHouse = environment.getProperty("inWareHouse");
|
HttpPost httpPost = new HttpPost(inWareHouse);
|
|
String jsonParams = new Gson().toJson(map);
|
// 设置请求体为JSON格式
|
StringEntity requestEntity = new StringEntity(jsonParams, ContentType.APPLICATION_JSON);
|
httpPost.setEntity(requestEntity);
|
String responseString = null;
|
|
try {
|
CloseableHttpResponse response = httpClient.execute(httpPost);
|
HttpEntity entity = response.getEntity();
|
responseString = EntityUtils.toString(entity, "UTF-8");
|
R r = new Gson().fromJson(responseString, R.class);
|
if (r.getCode()!=0){
|
throw new RuntimeException(r.getMsg());
|
}
|
|
response.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
throw new RuntimeException(e.getMessage());
|
} finally {
|
try {
|
httpClient.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
@Override
|
public R submitV2(Long id) {
|
synchronized (id.toString().intern()) {
|
|
//校验检测汇报是否已提交
|
Report report = baseMapper.selectById(id);
|
|
if(report.getIsSubmit() != null && report.getIsSubmit()){
|
if(report.getIsSubmit()){
|
throw new RuntimeException("请勿重复提交检测汇报！");
|
}
|
}
|
|
List<ApplyPart> applyPartList = applyPartMapper.selectListByReportId(id);
|
ApplyPart applyPart = null;
|
//判断检测汇报中的明细全部已检测是否成立，不成立则拒绝提交报告
|
if(CollectionUtils.isNotEmpty(applyPartList)){
|
reportUtils.checkOperationNoIsSame(id);//检验汇报零件工序是否一致
|
if (applyPartList.size() > 1) {
|
throw new RuntimeException("检测汇报中仅支持一条待检零件！");
|
}
|
applyPart = applyPartList.get(0);
|
if (applyPart.getIsQualified() == null) {
|
throw new RuntimeException("该检测汇报存在汇报明细未检测，无法提交！");
|
}
|
}else{
|
throw new RuntimeException("检测汇报明细为空！无法提交检测汇报！");
|
}
|
|
if (report.getSamplingRecordId() == null) {
|
reportSamplingRecordService.submitSamplingRecord(applyPart.getSystemNo(), id, report.getReportType());
|
}
|
// Long samplingReportId = reportSamplingRecordService.addSamplingRecordNum(applyPart.getSystemNo(), id, report.getReportType());
|
// if (samplingReportId != null) {
|
// List<ReportSample> reportSamples = reportSampleMapper.selectList(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId, id));
|
// for (ReportSample reportSample : reportSamples) {
|
// // 删除旧检测样品记录
|
// reportSampleService.deleteById(reportSample.getId());
|
// }
|
//
|
// // 生成新的检测样品记录
|
// // 如果存在抽检规则记录，则将抽检规则记录样品记录复制为当前样品记录
|
// List<ReportSample> reportSampleList = this.reportSampleMapper.selectList(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId, samplingReportId));
|
// if (CollectionUtils.isEmpty(reportSampleList)) {
|
// Report samplingReport = this.getById(samplingReportId);
|
// throw new RuntimeException("抽检检测汇报->" + samplingReport.getReportNo() + "，检测汇报不存在样品记录");
|
// }
|
// ReportSample reportSample = new ReportSample();
|
// reportSample.setReportId(applyPart.getReportId());
|
// reportSample.setSystemNo(applyPart.getSystemNo());
|
// reportSample.setTestStandardNo(reportSampleList.get(0).getTestStandardNo());
|
// reportSample.setTestStandardId(reportSampleList.get(0).getTestStandardId());
|
// reportSample.setIsMoTestStandard(reportSampleList.get(0).getIsMoTestStandard());
|
// reportSampleService.insert(reportSample);
|
//
|
// // 抽检规则记录样品记录复制为当前样品记录
|
// reportSampleItemMapper.copyReportSampleItem(reportSampleList.get(0).getId(), reportSample.getId());
|
// }
|
|
//更新检测汇报主表状态为：已提交
|
baseMapper.updateQualityReportSubmitState(id,true);
|
|
//对接库存件移库
|
if(report.getReportType().equals(Apply.PRODUCT_APPLY)){
|
// 存在替代零件号，走单独逻辑
|
if (applyPart.getReplacePartId() == null) {
|
//此处的移库是处理成品检中的移库
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.MOVE_PART_V2, true);
|
}
|
}
|
|
// 是否需要成品检处理
|
boolean isNeedFinishApply = false;
|
|
//首检及批次首检只做检测，不做其他关联业务
|
if(!report.getReportType().equals(Apply.FIRST_APPLY)&&!report.getReportType().equals(Apply.BATCHFIRST_APPLY)){
|
//移库
|
isNeedFinishApply = applyPartService.moveLibraryV2(id,ApplyPartServiceImpl.MOVELIBRARY);
|
|
//对接车间订单接收
|
if (applyPart.getSourceLocationId() != null) {
|
// 存在源库位，走单独逻辑
|
if (applyPart.getReplacePartId() != null) {
|
// 存在替代零件号，走单独逻辑
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.MOVE_PART_REPLACE_NO_OUTPUT, isNeedFinishApply);
|
} else {
|
if (applyPart.getScrapArrived() != null && applyPart.getScrapArrived().compareTo(BigDecimal.ZERO) > 0) {
|
// 如果存在报废数量，发放报废数量
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SCRAP_ISSUANCE, isNeedFinishApply);
|
}
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.MOVE_PART_NO_OUTPUT, isNeedFinishApply);
|
}
|
} else if (applyPart.getReplacePartId() != null) {
|
// 存在替代零件号，走单独逻辑
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.MOVE_PART_REPLACE, isNeedFinishApply);
|
} else {
|
if (applyPart.getScrapArrived() != null && applyPart.getScrapArrived().compareTo(BigDecimal.ZERO) > 0) {
|
// 如果存在报废数量，发放报废数量
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SCRAP_ISSUANCE, isNeedFinishApply);
|
}
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SHOP_ORDER_REC_V2, isNeedFinishApply);
|
}
|
}
|
|
return R.ok("检测汇报单提交成功！");
|
}
|
}
|
|
|
@Override
|
public R cancelSubmit(Long id){
|
//校验检测汇报是否未提交
|
Report report = baseMapper.selectById(id);
|
|
if(report.getIsSubmit() == null || !report.getIsSubmit()){
|
throw new RuntimeException("检测汇报未提交，无需取消提交！");
|
}
|
|
|
//更新检测汇报主表状态为：未提交
|
baseMapper.updateQualityReportSubmitState(id,false);
|
|
//对接库存件移库
|
if(report.getReportType().equals(Apply.PRODUCT_APPLY)){
|
//此处的移库是处理成品检中的移库
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_MOVE_PART, true);
|
}
|
|
// 是否需要成品检处理
|
boolean isNeedFinishApply = false;
|
|
//首检及批次首检只做检测，不做其他关联业务
|
if(!report.getReportType().equals(Apply.FIRST_APPLY)&&!report.getReportType().equals(Apply.BATCHFIRST_APPLY)){
|
List<ApplyPart> applyPartListFilter_last = filterSynIfsApplyParts(id);
|
isNeedFinishApply = applyPartService.moveLibrary(id,ApplyPartServiceImpl.UNMOVELIBRARY);//取消移库
|
|
if(false){//直接屏蔽，放弃整改
|
for(int i = 0;i < applyPartListFilter_last.size();i++){
|
//更新产出明细是否提交ifs为：未提交（根据system_no）
|
baseMapper.updateProductOutIsSynIfs(applyPartListFilter_last.get(i).getSystemNo(),false);
|
}
|
|
shopOrderReceive(applyPartListFilter_last,report,"unre");//车间订单取消接收
|
}
|
|
//对接取消工序报工
|
if(false){
|
//取消对接ifs工序报工，是否自动报工设置为：是
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_REPORT_OPERATION, isNeedFinishApply);
|
}
|
|
//对接取消工序报废
|
if(false){
|
//取消对接ifs工序报废
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_SCRAP_OPERATION, isNeedFinishApply);
|
}
|
|
//对接取消车间订单接收
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SHOP_ORDER_CANCEL_REC, isNeedFinishApply);
|
|
}
|
|
return R.ok("检测汇报单取消提交成功！");
|
}
|
|
@Override
|
public R cancelSubmitV2(Long id) {
|
synchronized (id.toString().intern()) {
|
//校验检测汇报是否未提交
|
Report report = baseMapper.selectById(id);
|
|
if(report.getIsSubmit() == null || !report.getIsSubmit()){
|
throw new RuntimeException("检测汇报未提交，无需取消提交！");
|
}
|
|
List<ApplyPart> applyPartList = applyPartMapper.selectListByReportId(id);
|
ApplyPart applyPart = null;
|
if (CollectionUtils.isEmpty(applyPartList) || applyPartList.size() > 1) {
|
throw new RuntimeException("不存在检测汇报零件或者检测汇报零件存在多个！");
|
} else {
|
applyPart = applyPartList.get(0);
|
}
|
|
//更新检测汇报主表状态为：未提交
|
baseMapper.updateQualityReportSubmitState(id,false);
|
|
//对接库存件移库
|
if(report.getReportType().equals(Apply.PRODUCT_APPLY)){
|
// 存在替代零件号，走单独逻辑
|
if (applyPart.getReplacePartId() == null) {
|
//此处的移库是处理成品检中的移库
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_MOVE_PART_V2, true);
|
}
|
}
|
|
// 是否需要成品检处理
|
boolean isNeedFinishApply = false;
|
|
//首检及批次首检只做检测，不做其他关联业务
|
if(!report.getReportType().equals(Apply.FIRST_APPLY)&&!report.getReportType().equals(Apply.BATCHFIRST_APPLY)){
|
// List<ApplyPart> applyPartListFilter_last = filterSynIfsApplyParts(id);
|
isNeedFinishApply = applyPartService.moveLibraryV2(id,ApplyPartServiceImpl.UNMOVELIBRARY);//取消移库
|
|
//对接取消车间订单接收
|
if (applyPart.getSourceLocationId() != null) {
|
// 存在源库位，走单独逻辑
|
if (applyPart.getReplacePartId() != null) {
|
// 存在替代零件号，走单独逻辑
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_MOVE_PART_REPLACE_NO_OUTPUT, isNeedFinishApply);
|
} else {
|
if (applyPart.getScrapArrived() != null) {
|
// 如果存在报废数量，发放报废数量
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_SCRAP_ISSUANCE, isNeedFinishApply);
|
}
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_MOVE_PART_NO_OUTPUT, isNeedFinishApply);
|
}
|
} else if (applyPart.getReplacePartId() != null) {
|
// 存在替代零件号，走单独逻辑
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_MOVE_PART_REPLACE, isNeedFinishApply);
|
} else {
|
// 不存在替代零件号，走正常逻辑
|
if (applyPart.getScrapArrived() != null) {
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.CANCEL_SCRAP_ISSUANCE, isNeedFinishApply);
|
}
|
qualityModuleDockIfsUtils.dockIfsByReportId(id,QualityModuleDockIfsUtils.SHOP_ORDER_CANCEL_REC_V2, isNeedFinishApply);
|
}
|
|
}
|
|
return R.ok("检测汇报单取消提交成功！");
|
}
|
}
|
|
/**
|
* 筛选需要对接ifs的检测汇报明细数据
|
* @param reportId
|
* @return
|
*/
|
public List<ApplyPart> filterSynIfsApplyParts(Long reportId){
|
List<ApplyPart> applyPartList = applyPartMapper.selectListByReportId(reportId);
|
List<ApplyPart> applyPartListFilter_last = new ArrayList<>();
|
//过滤掉非产出报检的
|
List<ApplyPart> applyPartListFilter = applyPartList.stream().filter(l -> !l.getIsErp()).collect(Collectors.toList());
|
if(CollectionUtils.isNotEmpty(applyPartListFilter)){
|
List<Long> applyPartIds = new ArrayList<>();
|
for(int i = 0;i < applyPartListFilter.size();i++){
|
if(applyPartListFilter.get(i).getIsQualified()){
|
//合格成立
|
Part part = partMapper.selectById(applyPartListFilter.get(i).getPartId());
|
if(part.getPlanningMethod().equals("A") || part.getPlanningMethod().equals("P")){
|
//根据零件id获取零件计划方法=A||P成立
|
//增加一个过滤条件：是否是最后一道工序，若是则对接ifs车间订单接收
|
if(reportUtils.isProdOutLastOperationBySystemNo(applyPartListFilter.get(i).getSystemNo())){
|
applyPartIds.add(applyPartListFilter.get(i).getId());//如果零件计划方法是A或是P，则记录其id
|
}
|
}
|
}
|
}
|
|
//筛选出在id列表中的检测申请(1.过滤掉了非产出报检;2.过滤掉了不合格;3.过滤掉了虚拟件)
|
//applyPartListFilter_last = applyPartMapper.selectList(Wrappers.<ApplyPart>lambdaQuery().in(ApplyPart::getId,applyPartIds));//用不到先注释
|
}
|
return applyPartListFilter_last;
|
}
|
|
/**
|
* 车间订单接收、取消接收
|
* @param applyPartListSynIfs
|
* @param report
|
* @param dir "re"：接收；"unre"：取消接收
|
*/
|
public void shopOrderReceive(List<ApplyPart> applyPartListSynIfs,Report report,String dir){
|
//拼接inAttr
|
//对接车间订单接收
|
IfsShopOrderDTO ifsShopOrderDTO = new IfsShopOrderDTO();
|
ifsShopOrderDTO.setRECORD_ID(report.getReportNo());
|
List<IfsShopOrderDTO.DataBean> dataBeanList = new ArrayList<>();//批量标识
|
|
|
for(int i = 0;i < applyPartListSynIfs.size();i++){
|
if(applyPartMapper.isLastOperationBySystemNo(applyPartListSynIfs.get(i).getSystemNo()) && !report.getReportType().equals(Apply.PRODUCT_APPLY)){
|
continue;//是最后一道工序，且不是成品检，则跳过
|
}
|
SubmitReportDTO submitReportDTO = baseMapper.getManufacturingOrderInfo(applyPartListSynIfs.get(i).getId());
|
IfsShopOrderDTO.DataBean batchInfo = new IfsShopOrderDTO.DataBean();
|
batchInfo.setORDER_NO(submitReportDTO.getIfsOrderNo());//车间订单号
|
batchInfo.setRELEASE_NO(submitReportDTO.getIfsReleaseNo());//下达号
|
batchInfo.setSEQUENCE_NO(submitReportDTO.getIfsSequenceNo());//序列号
|
batchInfo.setPART_NO(submitReportDTO.getPartNo());//零件号
|
batchInfo.setLOT_BATCH_NO(submitReportDTO.getIfsBatchNo());//ifs批次号
|
batchInfo.setQUANTITY(submitReportDTO.getQtyArrived());//接收数量
|
batchInfo.setSHIFT_DATE(submitReportDTO.getNowDutyDate());//班次日期
|
if("早".equals(submitReportDTO.getShiftName().substring(0,1))){
|
batchInfo.setSHIFT_TYPE("白");
|
}else if("夜".equals(submitReportDTO.getShiftName().substring(0,1))) {
|
batchInfo.setSHIFT_TYPE("夜");
|
}
|
batchInfo.setOUT_SYS_LOT_BAT_NO(submitReportDTO.getOutBatchNo());//SN号
|
//batchInfo.setLOCATION_NO(getIfsLocationArrivedByWorkstationId(submitReportDTO.getWorkstationId()));
|
batchInfo.setLOCATION_NO(reportUtils.getIfsLocationArrivedBySystemNo(applyPartListSynIfs.get(i).getSystemNo()));
|
dataBeanList.add(batchInfo);
|
}
|
ifsShopOrderDTO.setBATCH_INFO(dataBeanList);
|
Gson gson = new Gson();
|
String jsonstr = gson.toJson(ifsShopOrderDTO);
|
JSONObject jsonObject = JSONObject.parseObject(jsonstr);//解决序列化时自动将大写转小写问题
|
|
//JSONObject jsonObject = (JSONObject) JSONObject.toJSON(ifsShopOrderDTO);
|
|
R res;
|
if(dir.equals("re")){
|
|
res = ifsFeignClient.importSoReceiveStd(jsonObject,true);
|
}else if(dir.equals("unre")){
|
res = ifsFeignClient.importSoUnReceiveStd(jsonObject,true);
|
}else{
|
throw new RuntimeException("车间订单接收/取消接收方向码错误！");
|
}
|
|
if(res.getCode() != 0){
|
if(dir.equals("re")){
|
throw new RuntimeException("ifs车间订单接收失败;erromsg:" + res.getMsg());
|
}else{
|
throw new RuntimeException("ifs车间订单取消接收失败;erromsg:" + res.getMsg());
|
}
|
}
|
}
|
|
/**
|
* 根据工作站id获取ifs接收库位
|
* @param workstationId
|
* @return
|
*/
|
public String getIfsLocationArrivedByWorkstationId(Long workstationId){
|
String ifsLocation = baseMapper.getIfsLocationArrivedByWorkstationId(workstationId,LOCATION_TYPE_QUALIFIED);//只有合格的才对接ifs车间订单接收，不合格的ifs无需接收
|
if(StringUtils.isBlank(ifsLocation)){
|
throw new RuntimeException("通过工作站id：" + workstationId + "无法获取ifs接收库位！");
|
}else{
|
return ifsLocation;
|
}
|
}
|
|
@Override
|
public boolean isApplyReportIsSubmitByReportId(Long id){
|
Report report = baseMapper.selectById(id);
|
if(report == null){
|
throw new RuntimeException("检测汇报状态获取失败！");
|
}else{
|
if(report.getIsSubmit() == null || !report.getIsSubmit()){
|
return false;//检测汇报未提交
|
}else{
|
return true;//检测汇报已提交
|
}
|
}
|
}
|
|
@Override
|
public ApplyPartDTO createReport(Long applyPartId, String applyType, String reportPerson) {
|
synchronized (applyPartId.toString().intern()) {
|
// 校验检测零件是否已绑定检测汇报
|
ApplyPart applyPart = this.applyPartMapper.selectById(applyPartId);
|
if (applyPart.getReportId() != null && this.getById(applyPart.getReportId()) != null) {
|
throw new RuntimeException("检测零件已绑定检测汇报");
|
}
|
|
Report report = new Report();
|
report.setReportType(applyType);
|
report.setReportPerson(reportPerson);
|
// 创建检测汇报
|
this.save(report);
|
|
// 生成抽检记录
|
Long samplingReportId = this.reportSamplingRecordService.generateSamplingRecord(applyPart.getSystemNo(), report.getId(), applyType);
|
|
// 更新检测零件的检测汇报id
|
Part part = this.partMapper.selectById(applyPart.getPartId());
|
applyPart.setExaminer(part.getExaminer());
|
applyPart.setReportId(report.getId());
|
this.applyPartMapper.updateById(applyPart);
|
|
//2.如果是绑定汇报，把检测结果状态打成检测中
|
this.applyPartService.changeStatus(applyPart.getSystemNo(), ResultStateStringValues.TESTING, null, applyType);
|
//新增报检后，需要将检测汇报状态改为未检测
|
this.applyPartService.changeCheckState(applyPart);
|
//如果不存在汇报样品则自动创建一条汇报样品
|
if (samplingReportId == null) {
|
List<ReportSample> reportSampleList = this.reportSampleMapper.selectList(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId,applyPart.getReportId()));
|
if(CollectionUtils.isEmpty(reportSampleList)){
|
ReportSample reportSample = new ReportSample();
|
reportSample.setReportId(applyPart.getReportId());
|
reportSample.setSystemNo(applyPart.getSystemNo());
|
reportSample.setTestStandardNo(applyPart.getTestStandardNo());
|
reportSample.setTestStandardId(applyPart.getMoTestStandardId());
|
reportSample.setIsMoTestStandard(true);
|
reportSampleList.add(reportSample);
|
this.reportSampleService.saveBatchList(reportSampleList);
|
}
|
} else {
|
// 生成新的检测样品记录
|
// 如果存在抽检规则记录，则将抽检规则记录样品记录复制为当前样品记录
|
List<ReportSample> reportSampleList = this.reportSampleMapper.selectList(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId, samplingReportId));
|
if (CollectionUtils.isEmpty(reportSampleList)) {
|
Report samplingReport = this.getById(samplingReportId);
|
throw new RuntimeException("抽检检测汇报->" + samplingReport.getReportNo() + "，检测汇报不存在样品记录");
|
}
|
ReportSample reportSample = new ReportSample();
|
reportSample.setReportId(applyPart.getReportId());
|
reportSample.setSystemNo(applyPart.getSystemNo());
|
reportSample.setTestStandardNo(reportSampleList.get(0).getTestStandardNo());
|
reportSample.setTestStandardId(reportSampleList.get(0).getTestStandardId());
|
reportSample.setIsMoTestStandard(reportSampleList.get(0).getIsMoTestStandard());
|
reportSampleService.insert(reportSample);
|
|
// 抽检规则记录样品记录复制为当前样品记录
|
reportSampleItemMapper.copyReportSampleItem(reportSampleList.get(0).getId(), reportSample.getId());
|
}
|
|
|
ApplyPartDTO result = this.applyPartMapper.getApplyPartDtoById(applyPartId);
|
List<ApplyPartFile> applyPartFiles = this.applyPartFileMapper.selectList(Wrappers.<ApplyPartFile>lambdaQuery().eq(ApplyPartFile::getApplyPartId, applyPartId));
|
result.setApplyPartFileList(applyPartFiles);
|
List<ReportSample> reportSamples = reportSampleMapper.selectList(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getReportId, applyPart.getReportId()));
|
result.setReportSampleList(reportSamples);
|
// 如果不存在产出时间，标记为非库存报检
|
if (result.getProduceTime() == null) {
|
result.setIsNotOutCheck(true);
|
}
|
return result;
|
}
|
}
|
}
|
