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.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.google.common.collect.Lists;
|
import java.lang.invoke.SerializedLambda;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.core.excel.util.ExcelUtil;
|
import com.qianwen.core.mp.service.impl.BladeServiceImpl;
|
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.tool.utils.Func;
|
import com.qianwen.smartman.modules.cps.convert.MaterialStorageConvert;
|
import com.qianwen.smartman.modules.cps.entity.Material;
|
import com.qianwen.smartman.modules.cps.entity.MaterialStorage;
|
import com.qianwen.smartman.modules.cps.entity.WarehouseStation;
|
import com.qianwen.smartman.modules.cps.excel.MaterialStorageImport;
|
import com.qianwen.smartman.modules.cps.mapper.MaterialStorageMapper;
|
import com.qianwen.smartman.modules.cps.service.IMaterialService;
|
import com.qianwen.smartman.modules.cps.service.IMaterialStorageService;
|
import com.qianwen.smartman.modules.cps.service.IWarehouseStationService;
|
import com.qianwen.smartman.modules.cps.utils.StringUtils;
|
import com.qianwen.smartman.modules.cps.utils.ThrowFun;
|
import com.qianwen.smartman.modules.cps.vo.MaterialStorageAddVO;
|
import com.qianwen.smartman.modules.cps.vo.MaterialStorageVO;
|
import com.qianwen.smartman.modules.cps.vo.MaterialVO;
|
import com.qianwen.smartman.modules.cps.vo.WareMaterialStorageVO;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import org.springframework.stereotype.Service;
|
import org.springframework.web.multipart.MultipartFile;
|
|
@Service
|
public class MaterialStorageServiceImpl extends BladeServiceImpl<MaterialStorageMapper, MaterialStorage> implements IMaterialStorageService {
|
private final IWarehouseStationService warehouseStationService;
|
private final IMaterialService materialService;
|
private final OssBuilder ossBuilder;
|
|
|
public MaterialStorageServiceImpl(final IWarehouseStationService warehouseStationService, final IMaterialService materialService, final OssBuilder ossBuilder) {
|
this.warehouseStationService = warehouseStationService;
|
this.materialService = materialService;
|
this.ossBuilder = ossBuilder;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialStorageService
|
public List<WareMaterialStorageVO> listMaterial(Long wareId, String keyword) {
|
return this.baseMapper.listMaterial(wareId, keyword);
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialStorageService
|
public List<MaterialStorageVO> addMaterialStorage(MaterialStorageAddVO vo) {
|
List<Long> materialIds = vo.getMaterialIds();
|
Long warehouseStationId = vo.getWarehouseStationId();
|
if (Func.isNotEmpty(materialIds)) {
|
List<MaterialStorage> storages = materialIds.stream().map(c -> {
|
return convert(c, warehouseStationId);
|
}).collect(Collectors.toList());
|
saveBatch(storages);
|
return MaterialStorageConvert.INSTANCE.convert(storages);
|
}
|
return Lists.newArrayList();
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialStorageService
|
public List<MaterialVO> materialNotBind() {
|
return this.baseMapper.materialNotBind();
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialStorageService
|
public BladeFile importMaterialStorage(MultipartFile file) {
|
List<MaterialStorageImport> rawData = ExcelUtil.read(file, 0, 2, MaterialStorageImport.class);
|
ThrowFun.isTrue(Func.isEmpty(rawData)).throwMessage(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
|
ThrowFun.isTrue(rawData.size() > 200).throwMessage(MessageUtils.message("excel.import.size.failed", new Object[0]));
|
Map<String, WarehouseStation> warehouseStationMap = new HashMap<>(rawData.size());
|
Map<String, Material> materialMap = new HashMap<>(rawData.size());
|
getMaterialStorage(rawData, warehouseStationMap, materialMap);
|
List<MaterialStorage> materialStorageList = list();
|
Set<Long> materialIds = materialStorageList.stream().map((v0) -> {
|
return v0.getMaterialId();
|
}).collect(Collectors.toSet());
|
List<MaterialStorageImport> failExcel = Lists.newArrayList();
|
for (MaterialStorageImport data : rawData) {
|
boolean validImport = validImport(data, warehouseStationMap, materialMap, materialIds, failExcel);
|
if (validImport) {
|
break;
|
}
|
}
|
if (Func.isNotEmpty(failExcel)) {
|
return exportFailFile(failExcel);
|
}
|
saveMaterialStorage(rawData, warehouseStationMap, materialMap, materialStorageList);
|
return null;
|
}
|
|
@Override // org.springblade.modules.cps.service.IMaterialStorageService
|
public IPage<WareMaterialStorageVO> pageMaterial(Query query, Long wareId, String keyword) {
|
return this.baseMapper.pageMaterial(Condition.getPage(query), wareId, keyword);
|
}
|
|
private void saveMaterialStorage(List<MaterialStorageImport> rawData, Map<String, WarehouseStation> warehouseStationMap, Map<String, Material> materialMap, List<MaterialStorage> materialStorageList) {
|
List<MaterialStorage> materialStorages = Lists.newArrayList();
|
rawData.forEach(data -> {
|
WarehouseStation warehouseStation = (WarehouseStation) warehouseStationMap.get(data.getLocationCode());
|
Material material = (Material) materialMap.get(data.getMaterialCode());
|
MaterialStorage materialStorage = buildMaterialStorage(warehouseStation, material);
|
materialStorages.add(materialStorage);
|
});
|
Map<String, MaterialStorage> storageMap = (Map) materialStorageList.stream().collect(Collectors.toMap(k -> {
|
return StringUtils.getKey(k.getMaterialId(), k.getWarehouseStationId());
|
}, v -> {
|
return v;
|
}));
|
List<MaterialStorage> collect = (List) materialStorages.stream().filter(k2 -> {
|
return !storageMap.containsKey(StringUtils.getKey(k2.getMaterialId(), k2.getWarehouseStationId()));
|
}).distinct().collect(Collectors.toList());
|
if (Func.isNotEmpty(collect)) {
|
saveBatch(collect);
|
}
|
}
|
|
private MaterialStorage buildMaterialStorage(WarehouseStation warehouseStation, Material material) {
|
return new MaterialStorage().setMaterialId(material.getId()).setWarehouseStationId(warehouseStation.getId());
|
}
|
|
private BladeFile exportFailFile(List<MaterialStorageImport> failExcel) {
|
MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "materialStorageFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, ExcelConstant.SHEET, failExcel, (Object) null, (AbstractMergeStrategy) null);
|
return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
|
}
|
|
private boolean validImport(MaterialStorageImport data, Map<String, WarehouseStation> warehouseStationMap, Map<String, Material> materialMap, Set<Long> materialIds, List<MaterialStorageImport> failExcel) {
|
boolean validLocation = validLocation(data, warehouseStationMap, failExcel);
|
if (validLocation) {
|
return true;
|
}
|
return validMaterial(data, materialMap, materialIds, failExcel);
|
}
|
|
private boolean validMaterial(MaterialStorageImport data, Map<String, Material> materialMap, Set<Long> materialIds, List<MaterialStorageImport> failExcel) {
|
String materialCode = data.getMaterialCode();
|
if (Func.isBlank(materialCode)) {
|
data.setFailReason(MessageUtils.message("excel.export.material.code.not.be.null", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
Material material = materialMap.get(materialCode);
|
if (Func.isEmpty(material)) {
|
data.setFailReason(MessageUtils.message("excel.export.material.code.system.not.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (CommonConstant.DEACTIVATE.equals(material.getStatus())) {
|
data.setFailReason(MessageUtils.message("excel.export.material.code.system.not.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (materialIds.contains(material.getId())) {
|
data.setFailReason(MessageUtils.message("excel.export.material.code.bind", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
private boolean validLocation(MaterialStorageImport data, Map<String, WarehouseStation> warehouseStationMap, List<MaterialStorageImport> failExcel) {
|
String locationCode = data.getLocationCode();
|
if (Func.isBlank(locationCode)) {
|
data.setFailReason(MessageUtils.message("excel.export.station.code.not.be.null", new Object[0]));
|
failExcel.add(data);
|
return true;
|
}
|
WarehouseStation warehouseStation = warehouseStationMap.get(locationCode);
|
if (Func.isEmpty(warehouseStation)) {
|
data.setFailReason(MessageUtils.message("excel.export.station.code.system.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else if (CommonConstant.DEACTIVATE.equals(warehouseStation.getStatus())) {
|
data.setFailReason(MessageUtils.message("excel.export.material.code.disable.system.not.exists", new Object[0]));
|
failExcel.add(data);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
private void getMaterialStorage(List<MaterialStorageImport> rawData, Map<String, WarehouseStation> warehouseStationMap, Map<String, Material> materialMap) {
|
//Wrapper lambdaQuery = Wrappers.lambdaQuery();
|
LambdaQueryWrapper<WarehouseStation> warehouseQuery = Wrappers.lambdaQuery();
|
|
boolean flag1 = false;
|
boolean flag2 = false;
|
// MaterialStorage t;
|
//t.getWarehouseStationId()
|
//Wrapper lambdaQuery2 = Wrappers.lambdaQuery();
|
LambdaQueryWrapper<Material> materialQuery = Wrappers.lambdaQuery();
|
for (MaterialStorageImport data : rawData) {
|
if (requiredLocation(data)) {
|
if (flag1) {
|
warehouseQuery.or();
|
}
|
flag1 = true;
|
warehouseQuery.nested(i -> i.eq(WarehouseStation::getWarehouseCode, data.getLocationCode()));
|
/*
|
warehouseQuery.nested(i -> {
|
LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
|
return v0.getWarehouseCode();
|
}, data.getLocationCode());
|
});*/
|
}
|
if (requiredMaterial(data)) {
|
if (flag2) {
|
materialQuery.or();
|
}
|
flag2 = true;
|
materialQuery.nested(i -> i.eq(Material::getCode, data.getMaterialCode()));
|
/*
|
materialQuery.nested(i2 -> {
|
LambdaQueryWrapper lambdaQueryWrapper = i2.eq((v0) -> {
|
return v0.getCode();
|
}, data.getMaterialCode());
|
});*/
|
}
|
}
|
String sqlSegment1 = warehouseQuery.getSqlSegment();
|
if (Func.isNotBlank(sqlSegment1)) {
|
List<WarehouseStation> warehouseStations = this.warehouseStationService.list(warehouseQuery);
|
if (Func.isNotEmpty(warehouseStations)) {
|
Map<String, WarehouseStation> map1 = (Map) warehouseStations.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getWarehouseCode();
|
}, v -> {
|
return v;
|
}));
|
warehouseStationMap.putAll(map1);
|
}
|
}
|
String sqlSegment2 = materialQuery.getSqlSegment();
|
if (Func.isNotBlank(sqlSegment2)) {
|
List<Material> materials = this.materialService.list(materialQuery);
|
if (Func.isNotEmpty(materials)) {
|
Map<String, Material> map2 = materials.stream().collect(Collectors.toMap(Material::getCode, v -> v));
|
materialMap.putAll(map2);
|
}
|
}
|
}
|
|
private boolean requiredLocation(MaterialStorageImport data) {
|
return Func.isNotBlank(data.getLocationCode());
|
}
|
|
private boolean requiredMaterial(MaterialStorageImport data) {
|
return Func.isNotBlank(data.getMaterialCode());
|
}
|
|
private MaterialStorage convert(Long material, Long warehouseStationId) {
|
return new MaterialStorage().setMaterialId(material).setWarehouseStationId(warehouseStationId);
|
}
|
}
|
