package com.qianwen.smartman.modules.cps.service.impl;
|
|
import com.alibaba.excel.write.merge.AbstractMergeStrategy;
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import java.lang.invoke.SerializedLambda;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
import javax.servlet.http.HttpServletResponse;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import com.qianwen.smartman.common.cache.DictCache;
|
import com.qianwen.smartman.common.cache.RegionCache;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.enums.DictEnum;
|
import com.qianwen.smartman.common.enums.StatusType;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.common.utils.ValidatorUtils;
|
import com.qianwen.core.excel.util.ExcelUtil;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.mp.support.Condition;
|
import com.qianwen.core.mp.support.Query;
|
import com.qianwen.core.oss.model.BladeFile;
|
import com.qianwen.core.secure.utils.AuthUtil;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.modules.cps.convert.MaterialConvert;
|
import com.qianwen.smartman.modules.cps.entity.Material;
|
import com.qianwen.smartman.modules.cps.entity.MaterialType;
|
import com.qianwen.smartman.modules.cps.enums.MaterialPropertyEnum;
|
import com.qianwen.smartman.modules.cps.excel.MaterialExcel;
|
import com.qianwen.smartman.modules.cps.excel.MaterialImport;
|
import com.qianwen.smartman.modules.cps.mapper.MaterialMapper;
|
import com.qianwen.smartman.modules.cps.service.IMaterialService;
|
import com.qianwen.smartman.modules.cps.service.IMaterialTypeService;
|
import com.qianwen.smartman.modules.cps.vo.MaterialAddVO;
|
import com.qianwen.smartman.modules.cps.vo.MaterialIdListVO;
|
import com.qianwen.smartman.modules.cps.vo.MaterialQueryVO;
|
import com.qianwen.smartman.modules.cps.vo.MaterialUpdateVO;
|
import com.qianwen.smartman.modules.cps.vo.MaterialVO;
|
import com.qianwen.smartman.modules.cps.vo.ProductVO;
|
import com.qianwen.smartman.modules.cps.vo.SynchronizedProductMaterialVO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
|
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/MaterialServiceImpl.class */
|
public class MaterialServiceImpl extends BaseServiceImpl<MaterialMapper, Material> implements IMaterialService {
|
private static final Logger log = LoggerFactory.getLogger(MaterialServiceImpl.class);
|
private final IMaterialTypeService materialTypeService;
|
private final OssBuilder ossBuilder;
|
private final ICodeGeneratorService codeGeneratorService;
|
|
|
public MaterialServiceImpl(final IMaterialTypeService materialTypeService, final OssBuilder ossBuilder, final ICodeGeneratorService codeGeneratorService) {
|
this.materialTypeService = materialTypeService;
|
this.ossBuilder = ossBuilder;
|
this.codeGeneratorService = codeGeneratorService;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public List<MaterialVO> listByProperty(Integer property) {
|
List<MaterialType> materialTypeList = this.materialTypeService.list();
|
Map<Long, MaterialType> typeIdToValue = materialTypeList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, v -> {
|
return v;
|
}));
|
List<Material> materialList = list(Wrappers.<Material>lambdaQuery()
|
.eq(Material::getProperty, property)
|
.eq(Material::getStatus, CommonConstant.ENABLE));
|
/*
|
List<Material> materialList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getProperty();
|
}, property)).eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE));*/
|
List<MaterialVO> materialVoList = MaterialConvert.INSTANCE.convertList(materialList);
|
materialVoList.forEach(materialVo -> {
|
MaterialType materialType = (MaterialType) typeIdToValue.get(materialVo.getTypeId());
|
if (Func.isNotEmpty(materialType)) {
|
materialVo.setTypeName(materialType.getName());
|
materialVo.setTypeCode(materialType.getCode());
|
}
|
});
|
return materialVoList;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public IPage<MaterialVO> getPageMaterial(MaterialQueryVO vo, Query query) {
|
Integer status = Func.isNull(vo.getStatus()) ? CommonConstant.ENABLE : vo.getStatus();
|
|
QueryWrapper<MaterialQueryVO> wrapper = Wrappers.<MaterialQueryVO>query().eq("bm.status", status)
|
.eq(!Func.isNull(vo.getProperty()), "property", vo.getProperty())
|
.eq(!Func.isNull(vo.getTypeId()), "bm.type_id", vo.getTypeId())
|
.and(Func.isNotBlank(vo.getKeyWord()), i -> i.likeRight("bm.name", vo.getKeyWord()).or().likeRight("bm.code", vo.getKeyWord()))
|
.orderByDesc("bm.create_time", new String[] { "bm.id" });
|
|
/*
|
Wrapper<MaterialQueryVO> wrapper = (QueryWrapper) ((QueryWrapper) Wrappers.query().eq("bm.status", status)).eq(!Func.isNull(vo.getProperty()), "property", vo.getProperty()).eq(!Func.isNull(vo.getTypeId()), "bm.type_id", vo.getTypeId()).and(Func.isNotBlank(vo.getKeyWord()), i -> {
|
QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) i.likeRight("bm.name", vo.getKeyWord())).or()).likeRight("bm.code", vo.getKeyWord());
|
}).orderByDesc("bm.create_time", new String[]{"bm.id"});
|
*/
|
return this.baseMapper.getPageMaterial(Condition.getPage(query), Func.isNotBlank(wrapper.getSqlSegment()) ? wrapper : null);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public boolean checkMaterialIsExist(List<Long> idList) {
|
List<Material> materialList = list(Wrappers.<Material>query().lambda()
|
.eq(Func.isNotEmpty(AuthUtil.getTenantId()), Material::getTenantId, AuthUtil.getTenantId())
|
.in(Material::getTypeId, idList)
|
.eq(Material::getIsDeleted, 0));
|
/*
|
List<Material> materialList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
|
return v0.getTenantId();
|
}, AuthUtil.getTenantId()).in((v0) -> {
|
return v0.getTypeId();
|
}, idList)).eq((v0) -> {
|
return v0.getIsDeleted();
|
}, 0));*/
|
return Func.isNotEmpty(materialList);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public MaterialVO createMaterial(MaterialAddVO materialAddVO) {
|
MaterialType materialType = (MaterialType) this.materialTypeService.getById(materialAddVO.getTypeId());
|
if (Func.isEmpty(materialType)) {
|
throw new ServiceException(MessageUtils.message("cps.material.type.is.incorrect", new Object[0]) + materialAddVO.getTypeId());
|
}
|
materialAddVO.setTypeName(materialType.getName());
|
if (Func.isBlank(materialAddVO.getCode())) {
|
String code = this.codeGeneratorService.getGeneratorCode(materialAddVO, MetaTypeEnum.MATERIAL.getCode());
|
log.info("物料编码规则生成的code:{}", code + " ," + code.length());
|
materialAddVO.setCode(code);
|
}
|
checkCodeIsExist(materialAddVO.getCode());
|
Material material = MaterialConvert.INSTANCE.convert(materialAddVO);
|
save(material);
|
return MaterialConvert.INSTANCE.convert(material);
|
}
|
|
private void checkCodeIsExist(String code) {
|
Material material = getOne(Wrappers.<Material>query().lambda()
|
.eq(Material::getStatus, CommonConstant.ENABLE)
|
.eq(Func.isNotEmpty(AuthUtil.getTenantId()), Material::getTenantId, AuthUtil.getTenantId())
|
.eq(Material::getCode, code));
|
/*
|
Material material = (Material) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
|
return v0.getStatus();
|
}, CommonConstant.ENABLE)).eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
|
return v0.getTenantId();
|
}, AuthUtil.getTenantId()).eq((v0) -> {
|
return v0.getCode();
|
}, code));*/
|
if (!Func.isNull(material)) {
|
throw new ServiceException(MessageUtils.message("cps.material.code.already.exists", new Object[0]));
|
}
|
Material material2 = getOne(Wrappers.<Material>query().lambda()
|
.eq(Material::getStatus, CommonConstant.DEACTIVATE)
|
.eq(Func.isNotEmpty(AuthUtil.getTenantId()), Material::getTenantId, AuthUtil.getTenantId())
|
.eq(Material::getCode, code));
|
|
if (!Func.isNull(material2)) {
|
throw new ServiceException(MessageUtils.message("cps.material.code.unable.already.exists", new Object[0]));
|
}
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public MaterialVO updateMaterial(MaterialUpdateVO materialUpdateVO) {
|
MaterialType materialType = (MaterialType) this.materialTypeService.getById(materialUpdateVO.getTypeId());
|
if (Func.isEmpty(materialType)) {
|
throw new ServiceException(MessageUtils.message("cps.material.type.is.incorrect", new Object[0]) + materialUpdateVO.getTypeId());
|
}
|
materialUpdateVO.setTypeName(materialType.getName());
|
Material material = MaterialConvert.INSTANCE.convert(materialUpdateVO);
|
updateById(material);
|
return MaterialConvert.INSTANCE.convert(material);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean deleteMaterial(List<String> ids, Integer type) {
|
List<Long> idList = ids.stream().map(Long::valueOf).collect(Collectors.toList());
|
if (StatusType.REMOVE.getType().equals(type)) {
|
return removeByIds(idList);
|
}
|
return changeStatus(idList, CommonConstant.DEACTIVATE);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public BladeFile importMaterial(List<MaterialImport> data) {
|
if (Func.isEmpty(data)) {
|
throw new ServiceException(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
|
}
|
Map<String, MaterialType> materialTypeCodeEnable = this.materialTypeService.list().stream().filter(c -> {
|
return CommonConstant.ENABLE.equals(c.getStatus());
|
}).collect(Collectors.toMap((v0) -> {
|
return v0.getCode();
|
}, v -> {
|
return v;
|
}));
|
Map<String, MaterialType> materialTypeCodeDisable = this.materialTypeService.list().stream().filter(c2 -> {
|
return CommonConstant.DEACTIVATE.equals(c2.getStatus());
|
}).collect(Collectors.toMap((v0) -> {
|
return v0.getCode();
|
}, v2 -> {
|
return v2;
|
}));
|
List<Material> materialList = list();
|
Map<String, String> dictValueToKey = DictCache.getList(DictEnum.MATERIAL_PROPERTY.getName()).stream().collect(Collectors.toMap((v0) -> {
|
return v0.getDictValue();
|
}, (v0) -> {
|
return v0.getDictKey();
|
}));
|
boolean flag = Boolean.TRUE.booleanValue();
|
for (MaterialImport materialImport : data) {
|
checkMaterialImport(materialImport, materialTypeCodeEnable, materialTypeCodeDisable, materialList, dictValueToKey);
|
if (Func.isNotEmpty(materialImport.getFailReason())) {
|
flag = Boolean.FALSE.booleanValue();
|
}
|
if (!flag) {
|
MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "materialFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "物料信息表", data.stream().filter(x -> {
|
return Func.isNotEmpty(x.getFailReason());
|
}).collect(Collectors.toList()), (Object) null, (AbstractMergeStrategy) null);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
}
|
data.forEach(materialImport2 -> {
|
MaterialAddVO convert = MaterialConvert.INSTANCE.convert(materialImport2);
|
createMaterial(convert);
|
});
|
return null;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public BladeFile exportMaterial(MaterialQueryVO materialQueryVO, HttpServletResponse response) {
|
Integer status = materialQueryVO.getStatus();
|
if (Func.isNull(status)) {
|
materialQueryVO.setStatus(CommonConstant.ENABLE);
|
}
|
List<MaterialVO> materialList = getPageMaterial(materialQueryVO, new Query().setSize(-1)).getRecords();
|
List<MaterialExcel> materialExcelList = MaterialConvert.INSTANCE.convertExcel(materialList);
|
materialExcelList.forEach(materialExcel -> {
|
materialExcel.setIsMustCheckName(1 == materialExcel.getIsMustCheck().intValue() ? "是" : "否");
|
materialExcel.setPropertyName(DictCache.getValue(DictEnum.MATERIAL_PROPERTY, materialExcel.getProperty()));
|
});
|
String fileName = String.format("%s-%s.xlsx", "物料信息", DateUtil.time());
|
MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "物料信息表", materialExcelList, MaterialExcel.class);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
public List<MaterialVO> getMaterialListByIds(MaterialIdListVO materialIdListVO) {
|
List<Material> materialList = listByIds(materialIdListVO.getIds());
|
List<Long> typeIdList = materialList.stream().map((v0) -> {
|
return v0.getTypeId();
|
}).distinct().collect(Collectors.toList());
|
LinkedHashMap<Long, MaterialType> typeMap = new LinkedHashMap<>();
|
if (typeIdList.size() > 0) {
|
List<MaterialType> typeList = this.materialTypeService.listByIds(typeIdList);
|
for (MaterialType bean : typeList) {
|
typeMap.put(bean.getId(), bean);
|
}
|
}
|
List<MaterialVO> result = (List) MaterialConvert.INSTANCE.convertList(materialList).stream().map(i -> {
|
if (!Func.isNull(typeMap.get(i.getTypeId()))) {
|
i.setTypeName(((MaterialType) typeMap.get(i.getTypeId())).getName());
|
}
|
return i;
|
}).collect(Collectors.toList());
|
return result;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialService
|
@Transactional(rollbackFor = {Exception.class})
|
public Boolean synchronizedMaterial(SynchronizedProductMaterialVO synchronizedProductMaterialVO) {
|
List<String> nameList = synchronizedProductMaterialVO.getProductList().stream().map(i -> {
|
return i.getName();
|
}).collect(Collectors.toList());
|
List<String> codeList = synchronizedProductMaterialVO.getProductList().stream().map(i2 -> {
|
return i2.getCode();
|
}).collect(Collectors.toList());
|
|
List<Material> list = list(Wrappers.<Material>query().lambda()
|
.and(i -> i.in(Material::getName, nameList))
|
.or(i -> i.in(Material::getCode, codeList)));
|
/*
|
List<Material> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().and(i3 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i3.in((v0) -> {
|
return v0.getName();
|
}, nameList);
|
})).or(i4 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i4.in((v0) -> {
|
return v0.getCode();
|
}, codeList);
|
}));*/
|
List<ProductVO> needAddList = new ArrayList<>();
|
List<Long> deleteIdList = new ArrayList<>();
|
list.forEach(m -> {
|
for (ProductVO p : synchronizedProductMaterialVO.getProductList()) {
|
if (m.getCode().equals(p.getCode()) || m.getName().equals(p.getName())) {
|
deleteIdList.add(m.getId());
|
} else {
|
needAddList.add(p);
|
}
|
}
|
});
|
if (Func.isEmpty(deleteIdList)) {
|
return insertProductMaterial(synchronizedProductMaterialVO);
|
}
|
if (synchronizedProductMaterialVO.getIsDeleted().intValue() == 1) {
|
removeByIds(deleteIdList);
|
return insertProductMaterial(synchronizedProductMaterialVO);
|
}
|
return Boolean.FALSE;
|
}
|
|
private Boolean insertProductMaterial(SynchronizedProductMaterialVO synchronizedProductMaterialVO) {
|
List<Material> insertList = synchronizedProductMaterialVO.getProductList().stream().map(i -> {
|
Material bean = new Material();
|
bean.setName(i.getName());
|
bean.setCode(i.getCode());
|
bean.setTypeId(synchronizedProductMaterialVO.getMaterialTypeId());
|
bean.setProperty(Integer.valueOf(MaterialPropertyEnum.T3.getType()));
|
bean.setIsMustCheck(Integer.valueOf("0"));
|
return bean;
|
}).collect(Collectors.toList());
|
saveBatch(insertList);
|
return Boolean.TRUE;
|
}
|
|
private void checkMaterialImport(MaterialImport materialImport, Map<String, MaterialType> materialTypeCodeToValue, Map<String, MaterialType> materialTypeCodeDisable, List<Material> materialList, Map<String, String> dictValueToKey) {
|
if (Func.isEmpty(materialImport.getCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.code.can.not.be.null", new Object[0]));
|
} else if (Func.isEmpty(materialImport.getName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.name.can.not.be.null", new Object[0]));
|
} else if (Func.isEmpty(materialImport.getTypeCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.type.code.can.not.be.null", new Object[0]));
|
} else if (Func.isEmpty(materialImport.getTypeName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.type.name.can.not.be.null", new Object[0]));
|
} else if (Func.isEmpty(materialImport.getPropertyName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.property.can.not.be.null", new Object[0]));
|
} else if (ValidatorUtils.stringFilter(materialImport.getCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.code.exist.special.symbols.error", new Object[0]));
|
} else if (ValidatorUtils.stringFilter(materialImport.getName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.name.exist.special.symbols.error", new Object[0]));
|
} else if (Func.isNotEmpty(materialImport.getUnit()) && ValidatorUtils.stringFilter(materialImport.getUnit())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.unit.exist.special.symbols.error", new Object[0]));
|
} else if (Func.isNotEmpty(materialImport.getStuff()) && ValidatorUtils.stringFilter(materialImport.getStuff())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.stuff.exist.special.symbols.error", new Object[0]));
|
} else if (Func.isNotEmpty(materialImport.getIsMustCheckName()) && !"是".equals(materialImport.getIsMustCheckName()) && !"否".equals(materialImport.getIsMustCheckName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.must.check.name.can.only.be.yes.or.no", new Object[0]));
|
} else {
|
if ("是".equals(materialImport.getIsMustCheckName())) {
|
materialImport.setIsMustCheck(1);
|
} else {
|
materialImport.setIsMustCheck(0);
|
}
|
if (materialTypeCodeDisable.containsKey(materialImport.getTypeCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.type.disable.not.exists", new Object[0]));
|
} else if (!materialTypeCodeToValue.containsKey(materialImport.getTypeCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.type.not.exists", new Object[0]));
|
} else if (!materialImport.getTypeName().equals(materialTypeCodeToValue.get(materialImport.getTypeCode()).getName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.type.code.not.match.name", new Object[0]));
|
} else {
|
materialImport.setTypeId(materialTypeCodeToValue.get(materialImport.getTypeCode()).getId());
|
List<String> materialCodeEnableList = (List) materialList.stream().filter(c -> {
|
return CommonConstant.ENABLE.equals(c.getStatus());
|
}).map((v0) -> {
|
return v0.getCode();
|
}).collect(Collectors.toList());
|
List<String> materialCodeDisableList = (List) materialList.stream().filter(c2 -> {
|
return CommonConstant.DEACTIVATE.equals(c2.getStatus());
|
}).map((v0) -> {
|
return v0.getCode();
|
}).collect(Collectors.toList());
|
if (materialCodeEnableList.contains(materialImport.getCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.code.already.exists", new Object[0]));
|
} else if (materialCodeDisableList.contains(materialImport.getCode())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.code.unable.already.exists", new Object[0]));
|
} else if (!dictValueToKey.containsKey(materialImport.getPropertyName())) {
|
materialImport.setFailReason(MessageUtils.message("cps.material.property.not.exists", new Object[0]));
|
} else {
|
materialImport.setProperty(Integer.valueOf(dictValueToKey.get(materialImport.getPropertyName())));
|
}
|
}
|
}
|
}
|
}
|
