package com.chinaztt.mes.production.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.alibaba.csp.sentinel.util.StringUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
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.chinaztt.ifs.api.feign.IfsFeignClient;
|
import com.chinaztt.mes.basic.entity.Location;
|
import com.chinaztt.mes.basic.entity.Part;
|
import com.chinaztt.mes.basic.entity.PartFamily;
|
import com.chinaztt.mes.basic.mapper.LocationMapper;
|
import com.chinaztt.mes.basic.mapper.PartFamilyMapper;
|
import com.chinaztt.mes.basic.mapper.PartMapper;
|
import com.chinaztt.mes.production.dto.ExaminerDTO;
|
import com.chinaztt.mes.production.dto.FeederCertificateSelectDTO;
|
import com.chinaztt.mes.production.dto.IfsFeederCertificateDTO;
|
import com.chinaztt.mes.production.entity.Examiner;
|
import com.chinaztt.mes.production.entity.FeederCertificate;
|
import com.chinaztt.mes.production.entity.ProductOutput;
|
import com.chinaztt.mes.production.mapper.ExaminerMapper;
|
import com.chinaztt.mes.production.mapper.FeederCertificateMapper;
|
import com.chinaztt.mes.production.mapper.ProductOutputMapper;
|
import com.chinaztt.mes.production.service.FeederCertificateService;
|
import com.chinaztt.mes.quality.entity.BasicCustomerPartRelationMap;
|
import com.chinaztt.mes.quality.mapper.BasicCustomerPartRelationMapMapper;
|
import com.chinaztt.mes.warehouse.dto.*;
|
import com.chinaztt.mes.warehouse.entity.Stock;
|
import com.chinaztt.mes.warehouse.mapper.StockMapper;
|
import com.chinaztt.mes.warehouse.service.StockService;
|
import com.chinaztt.ztt.admin.api.feign.RemoteParamService;
|
import com.chinaztt.ztt.common.core.constant.SecurityConstants;
|
import com.chinaztt.ztt.common.core.util.R;
|
import com.google.gson.Gson;
|
import lombok.AllArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
|
/**
|
* 馈线合格证
|
*
|
* @author yy
|
* @date 2022-11-17 09:11:25
|
*/
|
@Service
|
@AllArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class FeederCertificateServiceImpl extends ServiceImpl<FeederCertificateMapper, FeederCertificate> implements FeederCertificateService {
|
|
|
private StockService stockService;
|
private StockMapper stockMapper;
|
private PartMapper partMapper;
|
private IfsFeignClient ifsFeignClient;
|
private LocationMapper locationMapper;
|
private ExaminerMapper examinerMapper;
|
private ProductOutputMapper productOutputMapper;
|
private BasicCustomerPartRelationMapMapper basicCustomerPartRelationMapMapper;
|
private RemoteParamService remoteParamService;
|
private PartFamilyMapper partFamilyMapper;
|
|
|
@Override
|
public FeederCertificateDTO getFeederCertificateBySn(String sn,String commonSn) {
|
FeederCertificate feederCertificate = baseMapper.selectOne(Wrappers.<FeederCertificate>lambdaQuery()
|
.eq(FeederCertificate::getSn, sn));
|
if(feederCertificate!=null){
|
throw new RuntimeException("已有该sn号，不能重复提交");
|
}
|
//实时库存中的库存数量大于零且在合格库位
|
List<Location> locationList = locationMapper.selectList(Wrappers.<Location>lambdaQuery().eq(Location::getLocType, "2"));
|
List<Long> locationIdList = locationList.stream().map(Location::getId).collect(Collectors.toList());
|
FeederCertificateDTO feederCertificateBySn = stockMapper.getFeederCertificate(sn,locationIdList);
|
if(feederCertificateBySn==null){
|
throw new RuntimeException("该sn号在实时库存没有合格库记录");
|
}
|
Part origPart = null;
|
Part partAfter = null;
|
List<ProductOutput> productOutputList = productOutputMapper.selectList(Wrappers.<ProductOutput>lambdaQuery()
|
.eq(ProductOutput::getOutBatchNo, feederCertificateBySn.getSn()));
|
if(CollectionUtil.isNotEmpty(productOutputList) && productOutputList.get(0).getOrigPartId()!=null){
|
origPart = partMapper.selectById(productOutputList.get(0).getOrigPartId());
|
partAfter = partMapper.selectById(productOutputList.get(0).getPartId());
|
}else {
|
origPart = partMapper.selectList(Wrappers.<Part>lambdaQuery().eq(Part::getPartNo, feederCertificateBySn.getPartNo())).get(0);
|
partAfter = origPart;
|
}
|
|
//同类SN校验
|
if(StringUtils.isNotBlank(commonSn)){
|
FeederCertificate commonFeederCertificate = baseMapper.selectOne(Wrappers.<FeederCertificate>lambdaQuery()
|
.eq(FeederCertificate::getSn, commonSn));
|
if(commonFeederCertificate!=null){
|
throw new RuntimeException("已有该同类sn号，不能重复提交");
|
}
|
FeederCertificateDTO commonFeederCertificateBySn = stockMapper.getFeederCertificate(commonSn,locationIdList);
|
if(commonFeederCertificateBySn==null){
|
throw new RuntimeException("该同类sn号在实时库存没有合格库记录");
|
}
|
if(feederCertificateBySn.getStockQuantity().compareTo(commonFeederCertificateBySn.getStockQuantity())!=0){
|
throw new RuntimeException("同类sn号和初始sn号生产长度不同");
|
}
|
if(!feederCertificateBySn.getLocationId().equals(commonFeederCertificateBySn.getLocationId())){
|
throw new RuntimeException("同类sn号和初始sn号所在库位不一样");
|
}
|
List<ProductOutput> commonProductOutputList = productOutputMapper.selectList(Wrappers.<ProductOutput>lambdaQuery()
|
.eq(ProductOutput::getOutBatchNo, commonFeederCertificateBySn.getSn()));
|
Long commonOrigPartId = null;
|
if(CollectionUtil.isNotEmpty(commonProductOutputList) && commonProductOutputList.get(0).getOrigPartId()!=null){
|
commonOrigPartId = partMapper.selectById(commonProductOutputList.get(0).getOrigPartId()).getId();
|
}else{
|
commonOrigPartId = partMapper.selectList(Wrappers.<Part>lambdaQuery().eq(Part::getPartNo,commonFeederCertificateBySn.getPartNo())).get(0).getId();
|
}
|
if(!origPart.getId().equals(commonOrigPartId)){
|
throw new RuntimeException("同类sn号和初始sn号生产零件号不同");
|
}
|
return commonFeederCertificateBySn;
|
}
|
|
//根据入库零件号找零件族编号
|
if(partAfter.getPartFamilyId()!=null){
|
PartFamily partFamily = partFamilyMapper.selectById(partAfter.getPartFamilyId());
|
if(partFamily!=null){
|
feederCertificateBySn.setPartFamilyNo(partFamily.getPartFamilyNo());
|
}
|
}
|
feederCertificateBySn.setPartNo(origPart.getPartNo());
|
feederCertificateBySn.setPartNoAfter(partAfter.getPartNo());
|
feederCertificateBySn.setExaminer(origPart.getExaminer());
|
feederCertificateBySn.setSpecs(partAfter.getSpecs());
|
feederCertificateBySn.setPartModel(partAfter.getPartModel());
|
feederCertificateBySn.setProdName(partAfter.getProdName());
|
|
BasicCustomerPartRelationMap basicCustomerPartRelationMap = basicCustomerPartRelationMapMapper.selectOne(Wrappers.<BasicCustomerPartRelationMap>lambdaQuery()
|
.eq(BasicCustomerPartRelationMap::getPartNo, feederCertificateBySn.getPartNo()));
|
if(basicCustomerPartRelationMap!=null) {
|
feederCertificateBySn.setCusMaterialCode(basicCustomerPartRelationMap.getCusMaterialCode());
|
}
|
Calendar calendar = Calendar.getInstance();
|
String year = calendar.get(Calendar.YEAR) + "";
|
String month = (calendar.get(Calendar.MONTH) + 1) + "";
|
String date = year + "." + month;
|
feederCertificateBySn.setDate(date);
|
return feederCertificateBySn;
|
}
|
|
@Override
|
public List<String> changeExaminer(String partNo) {
|
List<Examiner> examinerList = examinerMapper.selectList(Wrappers.<Examiner>lambdaQuery()
|
.eq(Examiner::getPartNo, partNo));
|
/* if(CollectionUtil.isEmpty(examinerList)){
|
throw new RuntimeException("零件降级配置尚未配置");
|
}*/
|
List<String> examinerAfterList = examinerList.stream().map(Examiner::getExaminerAfter).collect(Collectors.toList());
|
return examinerAfterList;
|
}
|
|
|
@Override
|
public List<Long> saveSnBatch(List<FeederCertificate> feederCertificateList) {
|
List<String> snList = feederCertificateList.stream().map(FeederCertificate::getSn).collect(Collectors.toList());
|
List<FeederCertificate> feederCertificateListBySnList = baseMapper.selectList(Wrappers.<FeederCertificate>lambdaQuery()
|
.in(FeederCertificate::getSn, snList));
|
if(CollectionUtil.isNotEmpty(feederCertificateListBySnList)){
|
throw new RuntimeException("已有该sn号，不能重复提交");
|
}
|
//实时库存中的库存数量大于零且在合格库位
|
List<Location> locationList = locationMapper.selectList(Wrappers.<Location>lambdaQuery().eq(Location::getLocType, "2"));
|
List<Long> locationIdList = locationList.stream().map(Location::getId).collect(Collectors.toList());
|
List<Stock> stockList = stockMapper.selectList(Wrappers.<Stock>lambdaQuery()
|
.in(Stock::getPartBatchNo,snList)
|
.in(Stock::getLocationId,locationIdList)
|
.gt(Stock::getAvailableStockQuantity,BigDecimal.ZERO));
|
if(CollectionUtil.isEmpty(stockList)){
|
throw new RuntimeException("库存表合格库位没有该sn号");
|
}
|
|
saveBatch(feederCertificateList);
|
Part partAfter = partMapper.selectOne(Wrappers.<Part>lambdaQuery()
|
.eq(Part::getPartNo, feederCertificateList.get(0).getPartNoAfter()));
|
stockList.stream().forEach(
|
a-> a.setPartId(partAfter.getId())
|
);
|
stockService.updateBatchById(stockList);
|
|
|
//库存发放
|
List<FeederCertificate> provideFeederCertificateList = new ArrayList<>();
|
for (FeederCertificate feederCertificate:feederCertificateList) {
|
if(feederCertificate.getStockQuantity().subtract(feederCertificate.getStockQuantityAfter()).compareTo(BigDecimal.ZERO)>0){
|
provideFeederCertificateList.add(feederCertificate);
|
}
|
}
|
if(CollectionUtil.isNotEmpty(provideFeederCertificateList)){
|
List<String> provideSnList = provideFeederCertificateList.stream().map(FeederCertificate::getSn).collect(Collectors.toList());
|
List<StockDTO> provideStockBySnList = stockMapper.getStockBySnList(provideSnList);
|
for (StockDTO stockDTO:provideStockBySnList) {
|
for (FeederCertificate provideFeederCertificate:provideFeederCertificateList) {
|
if(stockDTO.getPartBatchNo().equals(provideFeederCertificate.getSn())){
|
stockDTO.setAvailableStockQuantityMove(provideFeederCertificate.getStockQuantity()
|
.subtract(provideFeederCertificate.getStockQuantityAfter()));
|
stockDTO.setSynIfs(true);
|
}
|
}
|
}
|
stockService.deleteStock(provideStockBySnList);
|
}
|
|
//ifs更新wdr接口
|
List<IfsFeederCertificateDTO> ifsFeederCertificateList = baseMapper.getIfsFeederCertificateList(snList);
|
IfsImportChangeWdrStdDTO ifsImportChangeWdrStdDTO = new IfsImportChangeWdrStdDTO();
|
ifsImportChangeWdrStdDTO.setRECORD_ID(UUID.randomUUID().toString().replace("-", ""));
|
List<IfsImportChangeWdrStdDTO.DataBean> dataBeanList = new ArrayList<>();//批量标识
|
for(IfsFeederCertificateDTO ifsFeederCertificate:ifsFeederCertificateList){
|
FeederCertificate feederCertificate = baseMapper.selectOne(Wrappers.<FeederCertificate>lambdaQuery()
|
.eq(FeederCertificate::getSn, ifsFeederCertificate.getPartBatchNo()));
|
String wdr = null;
|
if(feederCertificate.getExaminerAfter()==null){
|
wdr = feederCertificate.getExaminer();
|
}else{
|
wdr = feederCertificate.getExaminerAfter();
|
}
|
IfsImportChangeWdrStdDTO.DataBean batchInfo = new IfsImportChangeWdrStdDTO.DataBean();
|
batchInfo.setPART_NO(ifsFeederCertificate.getPartNo());//零件号
|
batchInfo.setLOT_BATCH_NO(ifsFeederCertificate.getIfsBatchNo());//ifs批次号
|
batchInfo.setMOVE_QTY(ifsFeederCertificate.getStockQuantity());//移库数量
|
//判断是否启用批次管理
|
//WDR号
|
if(ifsFeederCertificate.getLotTrackingIfs() != null && ifsFeederCertificate.getLotTrackingIfs()){
|
batchInfo.setWAIV_DEV_REJ_NO(feederCertificate.getSn());
|
}else{
|
batchInfo.setWAIV_DEV_REJ_NO("*");
|
}
|
//版本号
|
batchInfo.setENG_CHG_LEVEL(ifsFeederCertificate.getEngChgLevel());
|
//库位号
|
batchInfo.setLOCATION_NO(ifsFeederCertificate.getLocationNo());
|
//至WDR号
|
batchInfo.setTO_WAIV_DEV_REJ_NO(wdr);
|
dataBeanList.add(batchInfo);
|
}
|
ifsImportChangeWdrStdDTO.setBATCH_INFO(dataBeanList);
|
Gson gson = new Gson();
|
String jsonstr = gson.toJson(ifsImportChangeWdrStdDTO);
|
JSONObject jsonObject = JSONObject.parseObject(jsonstr);
|
R res = ifsFeignClient.importChangeWdrStd(jsonObject, true);
|
if(res.getCode() != 0){
|
throw new RuntimeException("ifs更新wdr接口失败;erromsg:" + res.getMsg());
|
}
|
|
List<Long> idList = feederCertificateList.stream().map(FeederCertificate::getId).collect(Collectors.toList());
|
return idList;
|
}
|
|
|
@Override
|
public List<String> getExaminer(String partNo) {
|
List<Examiner> examinerList = examinerMapper.selectList(Wrappers.<Examiner>lambdaQuery()
|
.eq(Examiner::getPartNo, partNo));
|
if(CollectionUtil.isNotEmpty(examinerList)){
|
List<String> examinerAfterList = examinerList.stream().map(Examiner::getExaminerAfter).collect(Collectors.toList());
|
return examinerAfterList;
|
}else{
|
return null;
|
}
|
}
|
@Override
|
public IPage<List<FeederCertificateSelectDTO>> getPage(Page page, QueryWrapper<FeederCertificateSelectDTO> gen) {
|
return baseMapper.getPage(page, gen);
|
}
|
|
|
/**
|
* 更新打印次数
|
*
|
* @param ids
|
* @param copies
|
* @return
|
*/
|
@Override
|
public Boolean updatePrintNum(List<Long> ids, Long copies) {
|
List<FeederCertificate> feederCertificateList = baseMapper.selectBatchIds(ids);
|
for (FeederCertificate feederCertificate:feederCertificateList) {
|
if(feederCertificate.getPrintNum()==null){
|
feederCertificate.setPrintNum(copies);
|
}else{
|
feederCertificate.setPrintNum(feederCertificate.getPrintNum()+copies);
|
}
|
}
|
updateBatchById(feederCertificateList);
|
return true;
|
}
|
|
|
|
@Override
|
public Boolean checkPrintNumPassword(String password) {
|
String res = remoteParamService.getByKey("WORKBENCH_LABEL_REPRINT", SecurityConstants.FROM_IN).getData();
|
if (null != res) {
|
return res.equals(password);
|
}else{
|
return false;
|
}
|
}
|
}
|
