package cn.iocoder.yudao.module.mes.service.pd.ctc;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
|
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pd.ctc.vo.*;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.ctc.ProductCtcDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pd.ctc.ProductCtcMapper;
|
import cn.iocoder.yudao.module.mes.service.pd.reel.ProductCtcReelService;
|
import jakarta.annotation.Resource;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.PD_CTC_CALC_PARAM_INVALID;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.PD_CTC_IMPORT_LIST_IS_EMPTY;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.PD_CTC_ITEM_DUPLICATE;
|
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.PD_CTC_NOT_EXISTS;
|
|
/**
|
* MES 换位导线产品技术参数 Service 实现类
|
*
|
* @author 超级管理员
|
*/
|
@Service
|
@Validated
|
public class ProductCtcServiceImpl implements ProductCtcService {
|
|
@Resource
|
private ProductCtcMapper ctcMapper;
|
|
@Resource
|
private MdmItemApi mdmItemApi;
|
@Resource
|
private ProductCtcReelService reelService;
|
|
@Override
|
public Long createCtc(ProductCtcSaveReqVO createReqVO) {
|
// 校验物料存在
|
mdmItemApi.validateItemExists(createReqVO.getItemId());
|
// 校验物料唯一
|
validateItemUnique(createReqVO.getItemId(), null);
|
// 插入
|
ProductCtcDO ctc = BeanUtils.toBean(createReqVO, ProductCtcDO.class);
|
ctcMapper.insert(ctc);
|
return ctc.getId();
|
}
|
|
@Override
|
public void updateCtc(ProductCtcSaveReqVO updateReqVO) {
|
// 校验存在
|
ProductCtcDO ctc = validateCtcExists(updateReqVO.getId());
|
// 校验物料存在
|
mdmItemApi.validateItemExists(updateReqVO.getItemId());
|
// 校验物料唯一（排除自身）
|
validateItemUnique(updateReqVO.getItemId(), updateReqVO.getId());
|
// 更新
|
ProductCtcDO updateObj = BeanUtils.toBean(updateReqVO, ProductCtcDO.class);
|
ctcMapper.updateById(updateObj);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteCtc(Long id) {
|
// 校验存在
|
validateCtcExists(id);
|
// 删除关联盘具
|
reelService.deleteByCtcId(id);
|
// 删除
|
ctcMapper.deleteById(id);
|
}
|
|
@Override
|
public ProductCtcDO getCtc(Long id) {
|
return ctcMapper.selectById(id);
|
}
|
|
@Override
|
public ProductCtcDO getCtcByOrderSpec(String orderSpec) {
|
return ctcMapper.selectByOrderSpec(orderSpec);
|
}
|
|
@Override
|
public PageResult<ProductCtcDO> getCtcPage(ProductCtcPageReqVO pageReqVO) {
|
return ctcMapper.selectPage(pageReqVO);
|
}
|
|
@Override
|
public ProductCtcAngleCalcRespVO calcAngle(ProductCtcAngleCalcReqVO reqVO) {
|
double a = reqVO.getConductorThickness().doubleValue();
|
double b = reqVO.getConductorWidth().doubleValue();
|
double r = reqVO.getCornerRadius().doubleValue();
|
double t = reqVO.getInsulationThickness().doubleValue();
|
double w = reqVO.getTapeWidth().doubleValue();
|
double overlap = reqVO.getOverlapWidth().doubleValue();
|
// 导线周长：圆角矩形，厚度方向含绝缘，宽度方向不含
|
double circumference = 2 * (a + b + 2 * t) - (8 - 2 * Math.PI) * r;
|
// 有效纸带宽度 = 纸带宽度 - 重叠宽度
|
double effectiveWidth = w - overlap;
|
if (circumference <= 0 || effectiveWidth <= 0 || effectiveWidth > circumference) {
|
throw exception(PD_CTC_CALC_PARAM_INVALID);
|
}
|
double angle = Math.asin(effectiveWidth / circumference);
|
double angleDeg = Math.toDegrees(angle);
|
double pitch = effectiveWidth / Math.cos(angle);
|
ProductCtcAngleCalcRespVO respVO = new ProductCtcAngleCalcRespVO();
|
respVO.setCircumference(BigDecimal.valueOf(circumference).setScale(6, RoundingMode.HALF_UP));
|
respVO.setWrappingAngle(BigDecimal.valueOf(angleDeg).setScale(6, RoundingMode.HALF_UP));
|
respVO.setWrappingPitch(BigDecimal.valueOf(pitch).setScale(6, RoundingMode.HALF_UP));
|
return respVO;
|
}
|
|
@Override
|
public ProductCtcResistanceCalcRespVO calcResistance(ProductCtcResistanceCalcReqVO reqVO) {
|
double thickness = reqVO.getConductorThickness().doubleValue();
|
double width = reqVO.getConductorWidth().doubleValue();
|
double temp = reqVO.getTemperature().doubleValue();
|
// 材质参数：铜/铝（ρ20 单位 Ω·mm²/m，α 单位 1/℃）
|
double rho20;
|
double alpha;
|
if ("aluminum".equalsIgnoreCase(reqVO.getMaterial())) {
|
rho20 = 0.0283;
|
alpha = 0.00403;
|
} else {
|
rho20 = 0.0175;
|
alpha = 0.00393;
|
}
|
double area = thickness * width;
|
if (area <= 0) {
|
throw exception(PD_CTC_CALC_PARAM_INVALID);
|
}
|
// R20 = ρ20 / A（Ω/m）
|
double r20 = rho20 / area;
|
// Rt = R20 × (1 + α × (t - 20))
|
double rt = r20 * (1 + alpha * (temp - 20));
|
ProductCtcResistanceCalcRespVO respVO = new ProductCtcResistanceCalcRespVO();
|
respVO.setCrossSection(BigDecimal.valueOf(area).setScale(6, RoundingMode.HALF_UP));
|
respVO.setResistance20cKm(BigDecimal.valueOf(r20 * 1000).setScale(6, RoundingMode.HALF_UP));
|
respVO.setResistanceAtTemp(BigDecimal.valueOf(rt).setScale(6, RoundingMode.HALF_UP));
|
respVO.setResistanceAtTempKm(BigDecimal.valueOf(rt * 1000).setScale(6, RoundingMode.HALF_UP));
|
return respVO;
|
}
|
|
@Override
|
public ProductCtcReelCalcRespVO calcReelCapacity(ProductCtcReelCalcReqVO reqVO) {
|
double d1 = reqVO.getReelOuterDiameter().doubleValue();
|
double d2 = reqVO.getReelInnerDiameter().doubleValue();
|
double l2 = reqVO.getReelWidth().doubleValue();
|
double ct = reqVO.getCtcThickness().doubleValue();
|
double cw = reqVO.getCtcWidth().doubleValue();
|
if (d1 - 70 <= d2 || l2 <= 0 || ct <= 0 || cw <= 0) {
|
throw exception(PD_CTC_CALC_PARAM_INVALID);
|
}
|
// 盘具容量公式（参照需求文档盘具计算 sheet）：
|
// ((d1-60)+(d2+10)) × INT(l2/(CTC宽+1)) × (d1-d2-70) / (CTC高+0.2) / 1274
|
double capacityM = ((d1 - 60) + (d2 + 10)) * Math.floor(l2 / (cw + 1))
|
* (d1 - d2 - 70) / (ct + 0.2) / 1274;
|
ProductCtcReelCalcRespVO respVO = new ProductCtcReelCalcRespVO();
|
respVO.setCapacityMeter(BigDecimal.valueOf(capacityM).setScale(2, RoundingMode.HALF_UP));
|
respVO.setCapacityKm(BigDecimal.valueOf(capacityM / 1000).setScale(4, RoundingMode.HALF_UP));
|
return respVO;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public ProductCtcImportRespVO importCtcList(List<ProductCtcImportExcelVO> importList, boolean updateSupport) {
|
if (CollUtil.isEmpty(importList)) {
|
throw exception(PD_CTC_IMPORT_LIST_IS_EMPTY);
|
}
|
ProductCtcImportRespVO respVO = ProductCtcImportRespVO.builder()
|
.createCodes(new ArrayList<>()).updateCodes(new ArrayList<>())
|
.failureCodes(new LinkedHashMap<>()).build();
|
AtomicInteger index = new AtomicInteger(1);
|
importList.forEach(importItem -> {
|
int currentIndex = index.getAndIncrement();
|
String key = StrUtil.blankToDefault(importItem.getItemCode(), "第 " + currentIndex + " 行");
|
if (StrUtil.isBlank(importItem.getItemCode())) {
|
respVO.getFailureCodes().put(key, "物料编码不能为空");
|
return;
|
}
|
// 1. 解析物料（关联 mdm_item）
|
MdmItemRespDTO mdmItem = mdmItemApi.getItemByCode(importItem.getItemCode().trim()).getCheckedData();
|
if (mdmItem == null) {
|
respVO.getFailureCodes().put(key, "物料编码[" + importItem.getItemCode() + "]不存在");
|
return;
|
}
|
// 2. 构建请求并创建/更新（复用现有 create/update 服务）
|
ProductCtcSaveReqVO reqVO = BeanUtils.toBean(importItem, ProductCtcSaveReqVO.class);
|
reqVO.setItemId(mdmItem.getId());
|
ProductCtcDO existCtc = ctcMapper.selectByItemId(mdmItem.getId());
|
try {
|
if (existCtc == null) {
|
reqVO.setId(null);
|
createCtc(reqVO);
|
respVO.getCreateCodes().add(importItem.getItemCode());
|
} else if (updateSupport) {
|
reqVO.setId(existCtc.getId());
|
updateCtc(reqVO);
|
respVO.getUpdateCodes().add(importItem.getItemCode());
|
} else {
|
respVO.getFailureCodes().put(key, "物料编码已存在技术参数");
|
}
|
} catch (ServiceException e) {
|
respVO.getFailureCodes().put(key, e.getMessage());
|
}
|
});
|
return respVO;
|
}
|
|
private void validateItemUnique(Long itemId, Long excludeId) {
|
ProductCtcDO ctc = ctcMapper.selectByItemId(itemId);
|
if (ctc != null && !ctc.getId().equals(excludeId)) {
|
throw exception(PD_CTC_ITEM_DUPLICATE);
|
}
|
}
|
|
private ProductCtcDO validateCtcExists(Long id) {
|
ProductCtcDO ctc = ctcMapper.selectById(id);
|
if (ctc == null) {
|
throw exception(PD_CTC_NOT_EXISTS);
|
}
|
return ctc;
|
}
|
|
}
|
