package com.qianwen.smartman.modules.system.service.impl;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
|
import org.apache.poi.ss.usermodel.Workbook;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.google.common.collect.Lists;
|
import com.jeecg.weibo.exception.BusinessException;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.oss.model.BladeFile;
|
import com.qianwen.core.secure.utils.AuthUtil;
|
import com.qianwen.core.tool.api.R;
|
import com.qianwen.core.tool.utils.FileUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.ExcelConstant;
|
import com.qianwen.smartman.common.utils.ExcelUtils;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.modules.coproduction.constant.PlanExcelConstant;
|
import com.qianwen.smartman.modules.coproduction.dto.CheckParamDTO;
|
import com.qianwen.smartman.modules.coproduction.dto.CheckResultDTO;
|
import com.qianwen.smartman.modules.coproduction.entity.Plan;
|
import com.qianwen.smartman.modules.coproduction.mapper.PlanMapper;
|
import com.qianwen.smartman.modules.cps.constant.ProductExcelConstant;
|
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
|
import com.qianwen.smartman.modules.resource.convert.AttachConvert;
|
import com.qianwen.smartman.modules.resource.entity.Attach;
|
import com.qianwen.smartman.modules.resource.service.IAttachService;
|
import com.qianwen.smartman.modules.system.convert.CustomTemplateConvert;
|
import com.qianwen.smartman.modules.system.dto.CustomTemplateFieldRelationDTO;
|
import com.qianwen.smartman.modules.system.entity.CustomTemplate;
|
import com.qianwen.smartman.modules.system.entity.CustomTemplateBusiness;
|
import com.qianwen.smartman.modules.system.entity.CustomTemplateField;
|
import com.qianwen.smartman.modules.system.entity.CustomTemplateFieldRelation;
|
import com.qianwen.smartman.modules.system.enums.BusinessTypeEnums;
|
import com.qianwen.smartman.modules.system.enums.ConfigTypeEnum;
|
import com.qianwen.smartman.modules.system.enums.ImportSpecialHandlingEnum;
|
import com.qianwen.smartman.modules.system.mapper.CustomTemplateMapper;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateBusinessService;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateFieldRelationService;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateFieldService;
|
import com.qianwen.smartman.modules.system.service.ICustomTemplateService;
|
import com.qianwen.smartman.modules.system.vo.CustomTemplateFieldRelationSubmitVO;
|
import com.qianwen.smartman.modules.system.vo.CustomTemplateSubmitVO;
|
import com.qianwen.smartman.modules.system.vo.CustomTemplateVO;
|
|
import cn.hutool.json.JSONObject;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/system/service/impl/CustomTemplateServiceImpl.class */
|
public class CustomTemplateServiceImpl extends BaseServiceImpl<CustomTemplateMapper, CustomTemplate> implements ICustomTemplateService {
|
@Autowired
|
@Lazy
|
private ICustomTemplateBusinessService customTemplateBusinessService;
|
@Autowired
|
@Lazy
|
private ICustomTemplateFieldService customTemplateFieldService;
|
@Autowired
|
@Lazy
|
private ICustomTemplateFieldRelationService customTemplateFieldRelationService;
|
@Autowired
|
private OssBuilder ossBuilder;
|
@Autowired
|
private IAttachService attachService;
|
@Autowired
|
private PlanMapper planMapper;
|
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public CustomTemplate savePlan(CustomTemplateSubmitVO customTemplateSubmitVO) {
|
if (checkNameIsExist(customTemplateSubmitVO.getId(), customTemplateSubmitVO.getTemplateName(), customTemplateSubmitVO.getBusinessType())) {
|
throw new ServiceException(MessageUtils.message("plan.name.already.exist", new Object[0]));
|
}
|
CustomTemplate customTemplate = CustomTemplateConvert.INSTANCE.convert(customTemplateSubmitVO);
|
this.customTemplateBusinessService.remove(Wrappers.<CustomTemplateBusiness>lambdaQuery().eq(CustomTemplateBusiness::getTemplateId, customTemplate.getId()));
|
/*
|
this.customTemplateBusinessService.remove((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getTemplateId();
|
}, customTemplate.getId()));*/
|
customTemplate.setDefaultTemplate(CommonConstant.DEACTIVATE);
|
save(customTemplate);
|
CustomTemplate customTemplate2 = handleBusinessRelation(customTemplateSubmitVO, customTemplate);
|
customTemplateSubmitVO.setId(customTemplate2.getId());
|
preSetData(customTemplateSubmitVO);
|
return customTemplate2;
|
}
|
|
private void preSetData(CustomTemplateSubmitVO customTemplateSubmitVO) {
|
Long id = customTemplateSubmitVO.getId();
|
Long copySourceId = customTemplateSubmitVO.getCopySourceId();
|
List<Integer> configTypes = customTemplateSubmitVO.getConfigTypes();
|
List<CustomTemplateFieldRelation> customTemplateFieldRelations = new ArrayList<>();
|
if (Func.isEmpty(copySourceId)) {
|
List<CustomTemplateField> list = this.customTemplateFieldService.list(Wrappers.<CustomTemplateField>lambdaQuery()
|
.eq(CustomTemplateField::getSystemField, CommonConstant.ENABLE));
|
/*
|
List<CustomTemplateField> list = this.customTemplateFieldService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getSystemField();
|
}, CommonConstant.ENABLE));*/
|
if (Func.isEmpty(configTypes)) {
|
return;
|
}
|
for (Integer configType : configTypes) {
|
CustomTemplateFieldRelationSubmitVO customTemplateFieldRelationSubmitVO = new CustomTemplateFieldRelationSubmitVO();
|
customTemplateFieldRelationSubmitVO.setTemplateId(id);
|
customTemplateFieldRelationSubmitVO.setFieldList(Lists.newArrayList());
|
customTemplateFieldRelationSubmitVO.setConfigType(configType);
|
if (Func.equals(configType, ConfigTypeEnum.VIEW_PAGE)) {
|
customTemplateFieldRelations.addAll(list.stream().filter(item -> {
|
return Func.equals(item.getViewShow(), CommonConstant.ENABLE);
|
}).map(item2 -> {
|
CustomTemplateFieldRelation field = new CustomTemplateFieldRelation();
|
field.setTemplateId(id);
|
field.setFieldId(item2.getId());
|
field.setSort(Integer.valueOf(list.indexOf(item2)));
|
field.setConfigType(configType);
|
field.setMustField(CommonConstant.DEACTIVATE);
|
return field;
|
}).collect(Collectors.toList()));
|
} else if (Func.equals(configType, ConfigTypeEnum.EDIT_PAGE)) {
|
customTemplateFieldRelations.addAll(list.stream().filter(item3 -> {
|
return Func.equals(item3.getUpdateShow(), CommonConstant.ENABLE);
|
}).map(item4 -> {
|
CustomTemplateFieldRelation field = new CustomTemplateFieldRelation();
|
field.setTemplateId(id);
|
field.setFieldId(item4.getId());
|
field.setSort(Integer.valueOf(list.indexOf(item4)));
|
field.setConfigType(configType);
|
field.setMustField(CommonConstant.DEACTIVATE);
|
return field;
|
}).collect(Collectors.toList()));
|
} else {
|
customTemplateFieldRelations.addAll(list.stream().map(item5 -> {
|
CustomTemplateFieldRelation field = new CustomTemplateFieldRelation();
|
field.setTemplateId(id);
|
field.setFieldId(item5.getId());
|
field.setSort(Integer.valueOf(list.indexOf(item5)));
|
field.setConfigType(configType);
|
field.setMustField(CommonConstant.DEACTIVATE);
|
return field;
|
}).collect(Collectors.toList()));
|
}
|
}
|
} else {
|
List<CustomTemplateFieldRelation> relations = this.customTemplateFieldRelationService.list(Wrappers.<CustomTemplateFieldRelation>lambdaQuery().eq(CustomTemplateFieldRelation::getTemplateId, copySourceId));
|
/*
|
List<CustomTemplateFieldRelation> relations = this.customTemplateFieldRelationService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getTemplateId();
|
}, copySourceId));*/
|
relations.forEach(item6 -> {
|
item6.setId(null);
|
item6.setTemplateId(id);
|
});
|
customTemplateFieldRelations.addAll(relations);
|
}
|
this.customTemplateFieldRelationService.saveBatch(customTemplateFieldRelations);
|
}
|
|
private CustomTemplate handleBusinessRelation(CustomTemplateSubmitVO customTemplateSubmitVO, CustomTemplate customTemplate) {
|
this.customTemplateBusinessService.remove(Wrappers.<CustomTemplateBusiness>lambdaQuery().eq(CustomTemplateBusiness::getTemplateId, customTemplate.getId()));
|
/*
|
this.customTemplateBusinessService.remove((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getTemplateId();
|
}, customTemplate.getId()));*/
|
if (Func.isNotEmpty(customTemplateSubmitVO.getRelationIds())) {
|
List<CustomTemplateBusiness> batchInsert = new ArrayList<>();
|
for (Long relationId : customTemplateSubmitVO.getRelationIds()) {
|
CustomTemplateBusiness customTemplateBusiness = new CustomTemplateBusiness();
|
customTemplateBusiness.setTemplateId(customTemplate.getId());
|
customTemplateBusiness.setRelationId(relationId);
|
customTemplateBusiness.setBusinessType(customTemplate.getBusinessType());
|
batchInsert.add(customTemplateBusiness);
|
}
|
this.customTemplateBusinessService.saveBatch(batchInsert);
|
}
|
return customTemplate;
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public CustomTemplate updatePlan(CustomTemplateSubmitVO customTemplateSubmitVO) {
|
if (checkNameIsExist(customTemplateSubmitVO.getId(), customTemplateSubmitVO.getTemplateName(), customTemplateSubmitVO.getBusinessType())) {
|
throw new ServiceException(MessageUtils.message("plan.name.already.exist", new Object[0]));
|
}
|
CustomTemplate customTemplate = CustomTemplateConvert.INSTANCE.convert(customTemplateSubmitVO);
|
updateById(customTemplate);
|
return handleBusinessRelation(customTemplateSubmitVO, customTemplate);
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
@Transactional(rollbackFor = {Exception.class})
|
public R removePlan(List<Long> ids) {
|
long count = this.planMapper.selectCount(Wrappers.<Plan>lambdaQuery().in(Plan::getTypeId, ids)).longValue();
|
/*
|
long count = this.planMapper.selectCount((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getTypeId();
|
}, ids)).longValue();*/
|
if (count > 0) {
|
throw new BusinessException(MessageUtils.message("plan.already.use", new Object[0]));
|
}
|
this.customTemplateBusinessService
|
.remove(Wrappers.<CustomTemplateBusiness>lambdaQuery().in(CustomTemplateBusiness::getTemplateId, ids));
|
/*
|
this.customTemplateBusinessService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getTemplateId();
|
}, ids));*/
|
this.customTemplateFieldRelationService.removeRelationByTemplateIds(ids);
|
return R.status(removeByIds(ids));
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public List<CustomTemplateVO> listCustomTemplate(Integer businessType) {
|
List<CustomTemplate> list = list(Wrappers.<CustomTemplate>lambdaQuery().eq(CustomTemplate::getBusinessType, businessType)
|
.orderByDesc(CustomTemplate::getId));
|
/*
|
List<CustomTemplate> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getBusinessType();
|
}, businessType)).orderByDesc((v0) -> {
|
return v0.getId();
|
}));*/
|
if (Func.isEmpty(list)) {
|
return new ArrayList<>();
|
}
|
List<Long> ids = list.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
|
List<CustomTemplateBusiness> data = this.customTemplateBusinessService.list(Wrappers.<CustomTemplateBusiness>lambdaQuery().in(CustomTemplateBusiness::getTemplateId, ids));
|
/*
|
List<CustomTemplateBusiness> data = this.customTemplateBusinessService.list(Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getTemplateId();
|
}, ids));*/
|
Map<Long, List<Long>> collect = data.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getTemplateId();
|
}, Collectors.mapping((v0) -> {
|
return v0.getRelationId();
|
}, Collectors.toList())));
|
List<CustomTemplateVO> convert = CustomTemplateConvert.INSTANCE.convert(list);
|
convert.forEach(item -> {
|
item.setRelationIds(collect.get(item.getId()));
|
});
|
return convert;
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public CustomTemplateVO detail(String id) {
|
List<CustomTemplateBusiness> list = this.customTemplateBusinessService.list(Wrappers.<CustomTemplateBusiness>lambdaQuery().eq(CustomTemplateBusiness::getTemplateId, id));
|
/*
|
List<CustomTemplateBusiness> list = this.customTemplateBusinessService.list((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getTemplateId();
|
}, id));*/
|
CustomTemplate customTemplate = (CustomTemplate) getById(id);
|
CustomTemplateVO convert = CustomTemplateConvert.INSTANCE.convert(customTemplate);
|
if (Func.isNotEmpty(list)) {
|
convert.setRelationIds( list.stream().map((v0) -> {
|
return v0.getRelationId();
|
}).collect(Collectors.toList()));
|
}
|
return convert;
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public BladeFile excelTemplate(Long templateId, String templateName, ExcelUtils.ExcelTemplateDTO excelTemplateDTO) {
|
List<CustomTemplateFieldRelation> relations = this.customTemplateFieldRelationService.list(
|
Wrappers.<CustomTemplateFieldRelation>lambdaQuery()
|
.eq(CustomTemplateFieldRelation::getConfigType, ConfigTypeEnum.NEW_PAGE.getCode())
|
.eq(CustomTemplateFieldRelation::getImportField, CommonConstant.ENABLE)
|
.eq(CustomTemplateFieldRelation::getTemplateId, templateId)
|
.orderByAsc(CustomTemplateFieldRelation::getImportSort));
|
/*
|
List<CustomTemplateFieldRelation> relations = this.customTemplateFieldRelationService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getConfigType();
|
}, ConfigTypeEnum.NEW_PAGE.getCode())).eq((v0) -> {
|
return v0.getImportField();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getTemplateId();
|
}, templateId)).orderByAsc((v0) -> {
|
return v0.getImportSort();
|
}));*/
|
List<Long> fieldIds = relations.stream().map((v0) -> {
|
return v0.getFieldId();
|
}).collect(Collectors.toList());
|
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list(Wrappers.<CustomTemplateField>lambdaQuery().in(CustomTemplateField::getId, fieldIds));
|
/*
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getId();
|
}, fieldIds));*/
|
Map<Long, CustomTemplateField> fieldMap = fields.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, item -> {
|
return item;
|
}));
|
for (CustomTemplateFieldRelation customTemplateFieldRelation : relations) {
|
Long fieldId = customTemplateFieldRelation.getFieldId();
|
CustomTemplateField customTemplateField = fieldMap.get(fieldId);
|
excelTemplateDTO.addTableHead(customTemplateField.getFieldName(), Func.equals(customTemplateFieldRelation.getMustField(), CommonConstant.ENABLE));
|
}
|
Workbook workbook = ExcelUtils.generateTemplate(excelTemplateDTO);
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
try {
|
workbook.write(bos);
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
InputStream is = new ByteArrayInputStream(bos.toByteArray());
|
return this.ossBuilder.systemTemplate().putFile(templateName + ExcelConstant.SUFFIX, is);
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public Boolean createTemplate(List<Long> ids, Integer businessType) {
|
buildTemplate(ids, businessType);
|
return true;
|
}
|
|
private Attach buildTemplate(List<Long> ids, Integer businessType) {
|
ExcelUtils.ExcelTemplateDTO excelTemplateDTO = getExcelTemplateDTO(businessType);
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list(Wrappers.<CustomTemplateField>lambdaQuery()
|
.in(CustomTemplateField::getId, ids)
|
.eq(CustomTemplateField::getAddShow, CommonConstant.ENABLE)
|
.eq(CustomTemplateField::getSupportImport, CommonConstant.ENABLE)
|
.eq(CustomTemplateField::getBusinessType, businessType));
|
/*
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getId();
|
}, ids)).eq((v0) -> {
|
return v0.getAddShow();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getSupportImport();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getBusinessType();
|
}, businessType));*/
|
fields.forEach(item -> {
|
item.setImportSort(Integer.valueOf(ids.indexOf(item.getId())));
|
});
|
fields.sort(Comparator.comparing((v0) -> {
|
return v0.getImportSort();
|
}));
|
for (CustomTemplateField customTemplateField : fields) {
|
String importName = ImportSpecialHandlingEnum.getImportName(customTemplateField.getFieldName(), businessType);
|
excelTemplateDTO.addTableHead(importName, Func.equals(customTemplateField.getMustImport(), CommonConstant.ENABLE));
|
}
|
Workbook workbook = ExcelUtils.generateTemplate(excelTemplateDTO);
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
try {
|
workbook.write(bos);
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
InputStream is = new ByteArrayInputStream(bos.toByteArray());
|
BusinessTypeEnums businessTypeEnums = BusinessTypeEnums.of(businessType);
|
if (Func.isEmpty(businessTypeEnums)) {
|
return null;
|
}
|
String fileName = businessTypeEnums.getTemplateEnum().getFileName() + ExcelConstant.SUFFIX;
|
BladeFile bladeFile = this.ossBuilder.systemTemplate().putFile(fileName, is);
|
Attach attach = (Attach)this.attachService.getOne(new QueryWrapper<Attach>().lambda().eq(Attach::getOriginalName, fileName));
|
/*
|
Attach attach = (Attach) this.attachService.getOne((Wrapper) new QueryWrapper().lambda().eq((v0) -> {
|
return v0.getOriginalName();
|
}, fileName));*/
|
String fileExtension = FileUtil.getFileExtension(fileName);
|
if (Func.isEmpty(attach)) {
|
attach = new Attach();
|
}
|
attach.setDomainName(bladeFile.getDomain());
|
attach.setLink(bladeFile.getLink());
|
attach.setName(bladeFile.getName());
|
attach.setOriginalName(bladeFile.getOriginalName());
|
attach.setAttachSize(Long.valueOf(bos.size()));
|
attach.setExtension(fileExtension);
|
this.attachService.saveOrUpdate(attach);
|
return attach;
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public BladeFile getTemplate(Integer businessType) {
|
BusinessTypeEnums businessTypeEnums = BusinessTypeEnums.of(businessType);
|
if (Func.isEmpty(businessTypeEnums)) {
|
return null;
|
}
|
String fileName = businessTypeEnums.getTemplateEnum().getFileName() + ExcelConstant.SUFFIX;
|
Attach target = this.attachService.getOne(new QueryWrapper<Attach>().lambda().eq(Attach::getOriginalName, fileName));
|
/*
|
Attach target = (Attach) this.attachService.getOne((Wrapper) new QueryWrapper().lambda().eq((v0) -> {
|
return v0.getOriginalName();
|
}, fileName));*/
|
if (!Func.isEmpty(target)) {
|
return AttachConvert.INSTANCE.convert(target);
|
}
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list(Wrappers.<CustomTemplateField>lambdaQuery()
|
.select(CustomTemplateField::getId, CustomTemplateField::getImportSort, CustomTemplateField::getFieldName )
|
.eq(CustomTemplateField::getAddShow, CommonConstant.ENABLE)
|
.eq(CustomTemplateField::getSupportImport, CommonConstant.ENABLE)
|
.eq(CustomTemplateField::getBusinessType, businessType)
|
.orderByAsc(CustomTemplateField::getImportSort));
|
|
/*
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().select(new SFunction[]{(v0) -> {
|
return v0.getId();
|
}, (v0) -> {
|
return v0.getImportSort();
|
}, (v0) -> {
|
return v0.getFieldName();
|
}}).eq((v0) -> {
|
return v0.getAddShow();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getSupportImport();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getBusinessType();
|
}, businessType)).orderByAsc((v0) -> {
|
return v0.getImportSort();
|
}));*/
|
fields.forEach(item -> {
|
if (Func.isEmpty(item.getImportSort())) {
|
Integer systemField = item.getSystemField();
|
if (systemField == null) {
|
systemField = 0;
|
}
|
item.setImportSort(Integer.valueOf(Integer.MAX_VALUE - systemField.intValue()));
|
}
|
});
|
fields.sort(Comparator.comparing((v0) -> {
|
return v0.getImportSort();
|
}));
|
List<Long> ids = (List) fields.stream().map((v0) -> {
|
return v0.getId();
|
}).collect(Collectors.toList());
|
Attach attach = buildTemplate(ids, businessType);
|
return AttachConvert.INSTANCE.convert(attach);
|
}
|
|
private ExcelUtils.ExcelTemplateDTO getExcelTemplateDTO(Integer businessType) {
|
ExcelUtils.ExcelTemplateDTO excelTemplateDTO = ExcelUtils.buildExcelTemplateDTO();
|
if (Func.equals(businessType, BusinessTypeEnums.PLAN_ORDER.getCode())) {
|
excelTemplateDTO.appendRemind("填写须知：", false, true);
|
excelTemplateDTO.appendRemind("一. 请勿修改表格结构；", true, false);
|
excelTemplateDTO.appendRemind("二. 标红字段为必填项，黑色字段为选填项；", true, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_4, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_5, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_6, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_7, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_8, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_9, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_10, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_11, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_12, false, false);
|
excelTemplateDTO.appendRemind(PlanExcelConstant.REMIND_13, false, false);
|
} else if (Func.equals(businessType, BusinessTypeEnums.PRODUCT.getCode())) {
|
excelTemplateDTO.appendRemind("填写须知：", false, true);
|
excelTemplateDTO.appendRemind("一. 请勿修改表格结构；", true, false);
|
excelTemplateDTO.appendRemind("二. 标红字段为必填项，黑色字段为选填项；", true, false);
|
excelTemplateDTO.appendRemind(ProductExcelConstant.REMIND_4, false, false);
|
excelTemplateDTO.appendRemind(ProductExcelConstant.REMIND_5, false, false);
|
excelTemplateDTO.appendRemind(ProductExcelConstant.REMIND_6, false, false);
|
excelTemplateDTO.appendRemind(ProductExcelConstant.REMIND_7, false, false);
|
}
|
return excelTemplateDTO;
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public List<CheckResultDTO> checkImport(Function<List<Map<String, String>>, List<CheckParamDTO>> function, Integer businessType, List<Map<String, String>> dataList) {
|
if (Func.isEmpty(dataList)) {
|
throw new ServiceException("无数据");
|
}
|
if (dataList.size() > 200) {
|
throw new ServiceException("最大支持导入200条数据");
|
}
|
Set<String> heads = dataList.get(0).keySet();
|
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list(Wrappers.<CustomTemplateField>lambdaQuery()
|
.eq(CustomTemplateField::getAddShow, CommonConstant.ENABLE)
|
.eq(CustomTemplateField::getSupportImport, CommonConstant.ENABLE)
|
.eq(CustomTemplateField::getBusinessType, businessType));
|
/*
|
List<CustomTemplateField> fields = this.customTemplateFieldService.list((Wrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getAddShow();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getSupportImport();
|
}, CommonConstant.ENABLE)).eq((v0) -> {
|
return v0.getBusinessType();
|
}, businessType));*/
|
fields.forEach(item -> {
|
if (Func.equals(item.getSystemField(), CommonConstant.ENABLE) && Func.equals(item.getMustImport(), CommonConstant.ENABLE) && !heads.contains(item.getFieldName())) {
|
throw new ServiceException("缺少" + item.getFieldName() + "列请重新下载模板录入");
|
}
|
});
|
Map<String, CustomTemplateField> fieldMap = fields.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getFieldName();
|
}, item2 -> {
|
return item2;
|
}));
|
heads.forEach(importName -> {
|
String fieldName = ImportSpecialHandlingEnum.getFieldName(importName, businessType);
|
if (!Func.equals(importName, ExcelConstant.FAIL_REASON) && !fieldMap.containsKey(fieldName)) {
|
throw new ServiceException(importName + "系统以及拓展字段中不存在");
|
}
|
});
|
List<Map<String, String>> list = reHandleData(businessType, dataList, fieldMap);
|
List<CheckParamDTO> paramDtos = function.apply(list);
|
List<CheckResultDTO> checkResultDTOS = new ArrayList<>();
|
for (int i = 0; i < list.size(); i++) {
|
Map<String, String> data = list.get(i);
|
CheckParamDTO checkParamDTO = paramDtos.get(i);
|
checkResultDTOS.add(checkAndHandleImportData(data, checkParamDTO));
|
}
|
return checkResultDTOS;
|
}
|
|
List<Map<String, String>> reHandleData(Integer businessType, List<Map<String, String>> dataList, Map<String, CustomTemplateField> fieldMap) {
|
List<Map<String, String>> data = new ArrayList<>();
|
dataList.forEach(item -> {
|
HashMap<String, String> hashMap = new HashMap<>();
|
data.add(hashMap);
|
item.forEach((importName, value) -> {
|
String fieldName = ImportSpecialHandlingEnum.getFieldName(importName, businessType);
|
if (fieldMap.containsKey(fieldName)) {
|
CustomTemplateField field = fieldMap.get(fieldName);
|
String fieldCode = field.getFieldCode();
|
hashMap.put(fieldCode, value);
|
}
|
});
|
});
|
return data;
|
}
|
|
private CheckResultDTO checkAndHandleImportData(Map<String, String> data, CheckParamDTO checkParamDTO) {
|
Map<String, CustomTemplateFieldRelationDTO> relationMap = checkParamDTO.getRelationMap();
|
JSONObject extendFieldJson = new JSONObject();
|
CheckResultDTO checkResultDTO = new CheckResultDTO();
|
checkResultDTO.setCode(CommonConstant.ENABLE);
|
CustomTemplate customTemplate = checkParamDTO.getCustomTemplate();
|
Map<String, String> specialData = checkParamDTO.getSpecialData();
|
if (Func.isEmpty(customTemplate)) {
|
checkResultDTO.error("拓展字段模板不存在");
|
}
|
data.forEach((k, v) -> {
|
if (Func.equals(ExcelConstant.FAIL_REASON, k) || !relationMap.containsKey(k)) {
|
return;
|
}
|
CustomTemplateFieldRelationDTO relation = (CustomTemplateFieldRelationDTO) relationMap.get(k);
|
Integer systemField = relation.getSystemField();
|
Integer mustField = relation.getMustField();
|
Integer mustImport = relation.getMustImport();
|
String fieldCode = relation.getFieldCode();
|
String fieldName = relation.getFieldName();
|
if (Func.isNotEmpty(specialData) && specialData.containsKey(k)) {
|
v = (String) specialData.get(k);
|
}
|
if (Func.equals(systemField, CommonConstant.ENABLE)) {
|
if (Func.equals(mustImport, CommonConstant.ENABLE) && Func.isEmpty(v)) {
|
checkResultDTO.setError(fieldName + ExcelConstant.REQUIRED_FAIL_TEMPLATE);
|
checkResultDTO.setCode(CommonConstant.DEACTIVATE);
|
return;
|
}
|
} else if (Func.equals(mustField, CommonConstant.ENABLE) && Func.isEmpty(v)) {
|
checkResultDTO.setError(fieldName + ExcelConstant.REQUIRED_FAIL_TEMPLATE);
|
checkResultDTO.setCode(CommonConstant.DEACTIVATE);
|
return;
|
}
|
if (!Func.equals(systemField, CommonConstant.ENABLE)) {
|
try {
|
Integer businessType = customTemplate.getBusinessType();
|
Object o = this.customTemplateFieldService.fieldCheck(businessType, fieldCode, v);
|
extendFieldJson.put(fieldCode, String.valueOf(o));
|
} catch (RuntimeException e) {
|
checkResultDTO.setError(e.getMessage());
|
checkResultDTO.setCode(CommonConstant.DEACTIVATE);
|
}
|
}
|
});
|
if (Func.equals(checkResultDTO.getCode(), CommonConstant.ENABLE)) {
|
checkResultDTO.setJson(extendFieldJson.toString());
|
}
|
return checkResultDTO;
|
}
|
|
@Override // org.springblade.modules.system.service.ICustomTemplateService
|
public BladeFile excelExport(List<Long> relationIds, String templateName, ExcelUtils.ExcelTemplateDTO excelTemplateDTO) {
|
return null;
|
}
|
|
private boolean checkNameIsExist(Long id, String name, Integer businessType) {
|
List<CustomTemplate> result = this.baseMapper.selectList(Wrappers.<CustomTemplate>query().lambda()
|
.eq(Func.isNotEmpty(AuthUtil.getTenantId()), CustomTemplate::getTenantId, AuthUtil.getTenantId())
|
.eq(Func.isNotBlank(name), CustomTemplate::getTemplateName, name)
|
.eq(Func.isNotEmpty(businessType), CustomTemplate::getBusinessType, businessType)
|
.notIn(Func.isNotEmpty(id), CustomTemplate::getId, new Object[] { id }));
|
/*
|
List<CustomTemplate> result = ((CustomTemplateMapper) this.baseMapper).selectList(Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
|
return v0.getTenantId();
|
}, AuthUtil.getTenantId()).eq(Func.isNotBlank(name), (v0) -> {
|
return v0.getTemplateName();
|
}, name).eq(Func.isNotEmpty(businessType), (v0) -> {
|
return v0.getBusinessType();
|
}, businessType).notIn(Func.isNotEmpty(id), (v0) -> {
|
return v0.getId();
|
}, new Object[]{id}));*/
|
return result != null && result.size() > 0;
|
}
|
}
|
