weiyunlong
/
dobe_comic8
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

采购订单引入引出

This commit is contained in:
李贵强 2025-04-25 15:44:28 +08:00
parent 4e78f4c85b
commit d4f382ab19
4 changed files with 723 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
main/java/shkd/repc/rebm/formplugin/PurchaseMaterialImportPlugin.java Normal file
View File

@ -0,0 +1,64 @@
package shkd.repc.rebm.formplugin;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.metadata.IDataEntityType;
import kd.bos.dataentity.utils.StringUtils;
import kd.bos.entity.datamodel.BasedataItem;
import kd.bos.entity.datamodel.events.QueryImportBasedataEventArgs;
import kd.bos.form.operate.webapi.RowMapper;
import kd.bos.form.plugin.AbstractFormPlugin;
import kd.sdk.plugin.Plugin;
import shkd.repc.recon.formplugin.dynamic.ImportMaterial;
import java.util.*;
/**
* 动态表单插件
* 采购需求物料导入插件
*/
public class PurchaseMaterialImportPlugin extends AbstractFormPlugin implements Plugin {
private static final String BOS_ORG = "bos_org";//组织实体
private static final String BD_MATERIAL = "bd_material";//物料实体
private static final Set<ImportMaterial> materialList=new HashSet<>();
@Override
public void queryImportBasedata(QueryImportBasedataEventArgs e) {
super.queryImportBasedata(e);
DynamicObject targetObj = ((RowMapper) e.getSource()).getTargetObj();
IDataEntityType dataEntityType = targetObj.getDataEntityType();
if (null!=dataEntityType){
String name = dataEntityType.getName();
if (StringUtils.equals("qeug_cgxqentry",name)){
Map<BasedataItem, List<Object>> searchResult = e.getSearchResult();
for (Map.Entry<BasedataItem, List<Object>> entry : searchResult.entrySet()) {
List<Object> basedata = entry.getValue();
// 查不到基础资料数据(导入基础资料类型会自动查找)
if (basedata.isEmpty()) {
String entityNumber = entry.getKey().getEntityNumber();
//只针对物料
if ("bd_material".equals(entityNumber)){
Long materialId = newMaterial(entry.getKey().getSearchValue(),materialList);
basedata.add(materialId);
}
} else {
// 查到多个基础资料数据
// 业务场景，应根据需求剔除不合法的基础资料数据（最终保留一个）
Iterator it = basedata.iterator();
it.next();
while (it.hasNext()) {
it.remove();
}
}
}
}
}
}
private Long newMaterial(String searchValue, Set<ImportMaterial> materialList) {
return null;
}
}

113
main/java/shkd/repc/recon/formplugin/MaterialSaveCarryNumberPlugin.java
View File

@ -1,10 +1,13 @@
package shkd.repc.recon.formplugin;
import kd.bos.bill.AbstractBillPlugIn;
import kd.bos.coderule.api.CodeRuleInfo;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.bos.dataentity.utils.StringUtils;
import kd.bos.entity.datamodel.IBillModel;
import kd.bos.entity.datamodel.IDataModel;
import kd.bos.form.control.events.BeforeItemClickEvent;
import kd.bos.form.plugin.AbstractFormPlugin;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.BusinessDataServiceHelper;
@ -12,7 +15,6 @@ import kd.bos.servicehelper.coderule.CodeRuleServiceHelper;
import kd.bos.servicehelper.operation.SaveServiceHelper;
import kd.bos.servicehelper.org.OrgUnitServiceHelper;
import kd.sdk.plugin.Plugin;
import shkd.repc.recon.formplugin.dynamic.ImportMaterial;
import java.util.EventObject;
@ -20,7 +22,7 @@ import java.util.EventObject;
* 动态表单插件
* 带出物料编码
*/
public class MaterialSaveCarryNumberPlugin extends AbstractFormPlugin implements Plugin {
public class MaterialSaveCarryNumberPlugin extends AbstractBillPlugIn implements Plugin {
private static final String BOS_ORG = "bos_org";//组织实体
@ -36,19 +38,32 @@ public class MaterialSaveCarryNumberPlugin extends AbstractFormPlugin implements
public void beforeItemClick(BeforeItemClickEvent evt) {
super.beforeItemClick(evt);
String key = evt.getItemKey().toLowerCase();
if ("bar_save".equals(key)) {
this.carryMaterialNumber();
String name = this.getModel().getDataEntityType().getName();
//合同非定额物料保存
if ("bar_save".equals(key)&&"recon_contractbill".equals(name)) {
this.carryMaterialNumber("qeug_orderformentry","qeug_material");
}
//采购订单保存
else if ("save".equals(key)&&"repe_orderform".equals(name)){
this.carryMaterialNumber("orderformentry","material");
}
//采购需求保存
else if ("qeug_baritemap".equals(key)&&"recon_settleplanbill".equals(name)){
this.carryMaterialNumber("qeug_cgxqentry","qeug_materialmasterid");
}
}
/**
* 携带物料编码
* @param entryLogotype 分录标识
* @param materialLogotype 物料字段标识
*/
private void carryMaterialNumber() {
DynamicObjectCollection entryEntity = this.getModel().getEntryEntity("qeug_orderformentry");
private void carryMaterialNumber(String entryLogotype,String materialLogotype) {
DynamicObjectCollection entryEntity = this.getModel().getEntryEntity(entryLogotype);
if (entryEntity != null && entryEntity.size() != 0) {
for (int i = 0; i < entryEntity.size(); i++) {
DynamicObject material = entryEntity.get(i).getDynamicObject("qeug_material");//物料-基础资料
DynamicObject material = entryEntity.get(i).getDynamicObject(materialLogotype);//物料-基础资料
String type = entryEntity.get(i).getString("qeug_importmaterialtype");//物料分类
String model = entryEntity.get(i).getString("qeug_importmodel");//规格型号
String unit = entryEntity.get(i).getString("qeug_importunit");//规格型号
@ -64,7 +79,7 @@ public class MaterialSaveCarryNumberPlugin extends AbstractFormPlugin implements
//新增物料
id=this.addNewMaterial(name,type,model,unit,brand,extModel);
}
this.getModel().setValue("qeug_material",id,i);
this.getModel().setValue(materialLogotype,id,i);
}
}
}
@ -171,4 +186,84 @@ public class MaterialSaveCarryNumberPlugin extends AbstractFormPlugin implements
materialType.set("material",materialId);
SaveServiceHelper.save(new DynamicObject[]{materialType});
}
/**
* 编码存在，但是二开属性为空的字段自动带出数据
* @param e
*/
@Override
public void afterLoadData(EventObject e) {
super.afterLoadData(e);
IBillModel model = (IBillModel) this.getModel();
Object pkValue = model.getPKValue();
String name = this.getModel().getDataEntityType().getName();
if ("recon_contractbill".equals(name)){
this.carryMaterialAttribute(pkValue,name,"qeug_orderformentry","qeug_material","qeug_materialnames");
}else if ("repe_orderform".equals(name)){
this.carryMaterialAttribute(pkValue,name,"orderformentry","material","qeug_materialnames");
}
}
private void carryMaterialAttribute(Object pkValue,String name,String entryLogotype,String materialLogotype,String materialNameLgt){
DynamicObject dynamicObject = BusinessDataServiceHelper.loadSingle(pkValue, name);
if (dynamicObject!=null){
DynamicObjectCollection collection = dynamicObject.getDynamicObjectCollection(entryLogotype);
if (collection!=null&&collection.size()!=0){
for (DynamicObject entry : collection) {
DynamicObject material = entry.getDynamicObject(materialLogotype);
if (material!=null){
DynamicObject queryMaterial = BusinessDataServiceHelper.loadSingle(material.getPkValue(), "bd_material");
if (queryMaterial!=null){
//物料名称
String materialName = entry.getString(materialNameLgt);
if (StringUtils.isEmpty(materialName)){
String queryName = queryMaterial.getString("name");
if (StringUtils.isNotEmpty(queryName)){
entry.set(materialNameLgt,queryName);
}
}
//物料分类
String materialType = entry.getString("qeug_importmaterialtype");
if (StringUtils.isEmpty(materialType)){
String queryType = queryMaterial.getString("group.name");
if (StringUtils.isNotEmpty(queryType)){
entry.set("qeug_importmaterialtype",queryType); }
}
//物料规格
String materialModel = entry.getString("qeug_importmodel");
if (StringUtils.isEmpty(materialModel)){
String queryModel = queryMaterial.getString("modelnum");
if (StringUtils.isNotEmpty(queryModel)){
entry.set("qeug_importmodel",queryModel); }
}
//物料单位
String materialUnit= entry.getString("qeug_importunit");
if (StringUtils.isEmpty(materialUnit)){
String queryUnit = queryMaterial.getString("baseunit.name");
if (StringUtils.isNotEmpty(queryUnit)){
entry.set("qeug_importunit",queryUnit); }
}
//物料品牌
String materialBrand= entry.getString("qeug_brand");
if (StringUtils.isEmpty(materialBrand)){
String queryBrand = queryMaterial.getString("qeug_brand");
if (StringUtils.isNotEmpty(queryBrand)){
entry.set("qeug_brand",queryBrand); }
}
//物料型号
String materialExtModel= entry.getString("qeug_model");
if (StringUtils.isEmpty(materialExtModel)){
String queryExtModel = queryMaterial.getString("qeug_model");
if (StringUtils.isNotEmpty(queryExtModel)){
entry.set("qeug_model",queryExtModel); }
}
}
}
}
}
}
SaveServiceHelper.update(dynamicObject);
}
}

254
main/java/shkd/repc/repe/formplugin/OrderFormMaterialExportPlugin.java Normal file
View File

@ -0,0 +1,254 @@
package shkd.repc.repe.formplugin;
import kd.bos.context.RequestContext;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.bos.dataentity.utils.StringUtils;
import kd.bos.fileservice.FileItem;
import kd.bos.fileservice.FileService;
import kd.bos.fileservice.FileServiceFactory;
import kd.bos.form.control.events.ItemClickEvent;
import kd.bos.form.plugin.AbstractFormPlugin;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.BusinessDataServiceHelper;
import kd.sdk.plugin.Plugin;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.xssf.usermodel.*;
import java.awt.*;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.EventObject;
import java.util.List;
/**
* 动态表单插件
*/
public class OrderFormMaterialExportPlugin extends AbstractFormPlugin implements Plugin {
@Override
public void registerListener(EventObject e) {
super.registerListener(e);
//工具栏控件
this.addItemClickListeners("advcontoolbarap2");
}
@Override
public void itemClick(ItemClickEvent evt) {
super.itemClick(evt);
//工具栏控件里的工具栏项-导出
if (StringUtils.equals("qeug_exportdata", evt.getItemKey())) {
Long value = (Long) this.getModel().getValue("id");
if (value.compareTo(0L)==0){
this.getView().showMessage("请先保存单据");
return;
}
DynamicObject contract = BusinessDataServiceHelper.loadSingle(value, "repe_orderform");
if (null!=contract){
DynamicObjectCollection orderFormEntry = contract.getDynamicObjectCollection("orderformentry");
if (orderFormEntry==null||orderFormEntry.size()==0){
this.getView().showMessage("请填入数据保存后导出！");
return;
}
//根据导入模板配置导出数据
QFilter number = new QFilter("number", QCP.equals, "repe_orderform_IMPT_ENTRY");
DynamicObject template = BusinessDataServiceHelper.loadSingle("bos_importentry_template", number.toArray());
if (null==template){
this.getView().showMessage("请先维护引入模板");
return;
}
//表头字段
List<DynamicObject> list =new ArrayList<>();
DynamicObjectCollection entry = template.getDynamicObjectCollection("treeentryentity");
if (null!=entry&&entry.size()!=0){
for (int i = 0; i < entry.size(); i++) {
DynamicObject dynamicObject = entry.get(i);
if (dynamicObject.getBoolean("isimport")){
list.add(dynamicObject);
}
}
}
if (list.size()==0) return;
//构建导出前四行数据
// 创建Excel工作簿
XSSFWorkbook workbook = new XSSFWorkbook();
XSSFSheet sheet = workbook.createSheet("明细 # orderformentry");
// 第一行：明细标题
XSSFRow row1 = sheet.createRow(0);
XSSFCell cell1 = row1.createCell(0);
cell1.setCellValue("明细 # orderformentry");
XSSFCellStyle style1 = workbook.createCellStyle();
XSSFFont font1 = workbook.createFont();
font1.setFontName("宋体");
font1.setFontHeightInPoints((short) 11);
style1.setFont(font1);
style1.setAlignment(HorizontalAlignment.CENTER);
style1.setVerticalAlignment(VerticalAlignment.CENTER);
sheet.setColumnWidth(0, 31 * 256); // 设置列宽
row1.setHeightInPoints(14.4f);
cell1.setCellStyle(style1);
// 第二行：说明文本
XSSFRow row2 = sheet.createRow(1);
XSSFCell cell2 = row2.createCell(0);
cell2.setCellValue("1、请将鼠标移到灰色标题行查看字段录入要求。2、红色带星号（*）的字段为必录字段。");
XSSFCellStyle style2 = workbook.createCellStyle();
XSSFFont font2 = workbook.createFont();
font2.setFontName("Calibri");
font2.setFontHeightInPoints((short) 11);
style2.setFont(font2);
style2.setAlignment(HorizontalAlignment.LEFT);
style2.setVerticalAlignment(VerticalAlignment.CENTER);
style2.setWrapText(true); // 自动换行
row2.setHeightInPoints(60);
sheet.setColumnWidth(0, 31 * 256); // 设置列宽
cell2.setCellStyle(style2);
// 第三行：list中的entitynumber
XSSFRow row3 = sheet.createRow(2);
for (int i = 0; i < list.size(); i++) {
DynamicObject dynamicObject = list.get(i);
String entityNumber=null;
String importProp = dynamicObject.getString("importprop");
if (!("").equals(importProp)){
entityNumber = dynamicObject.getString("entitynumber")+"."+dynamicObject.getString("importprop");
}else {
entityNumber = dynamicObject.getString("entitynumber");
}
XSSFCell cell = row3.createCell(i);
cell.setCellValue(entityNumber);
XSSFCellStyle style3 = workbook.createCellStyle();
XSSFFont font3 = workbook.createFont();
font3.setFontName("宋体");
font3.setFontHeightInPoints((short) 11);
style3.setFont(font3);
style3.setAlignment(HorizontalAlignment.CENTER);
style3.setVerticalAlignment(VerticalAlignment.CENTER);
sheet.setColumnWidth(i, 31 * 256); // 设置列宽
row3.setHeightInPoints(14.4f);
cell.setCellStyle(style3);
}
// 第四行：list中的entityname
XSSFRow row4 = sheet.createRow(3);
for (int i = 0; i < list.size(); i++) {
DynamicObject dynamicObject = list.get(i);
String entityName = dynamicObject.getString("entitydescription");
XSSFCell cell = row4.createCell(i);
cell.setCellValue(entityName);
XSSFCellStyle style4 = workbook.createCellStyle();
XSSFFont font4 = workbook.createFont();
font4.setFontName("Calibri");
font4.setFontHeightInPoints((short) 11);
font4.setColor(IndexedColors.RED.getIndex());
style4.setFont(font4);
style4.setAlignment(HorizontalAlignment.CENTER);
style4.setVerticalAlignment(VerticalAlignment.CENTER);
style4.setFillForegroundColor(new XSSFColor(new Color(192, 192, 192), new DefaultIndexedColorMap())); // 灰色背景
style4.setFillPattern(FillPatternType.SOLID_FOREGROUND);
sheet.setColumnWidth(i, 31 * 256); // 设置列宽
row4.setHeightInPoints(14.4f);
cell.setCellStyle(style4);
}
// 填充数据行（根据entitynumber匹配）
for (int i = 0; i < orderFormEntry.size(); i++) {
DynamicObject orderEntry = orderFormEntry.get(i);
// 创建数据行
XSSFRow dataRow = sheet.createRow(i + 4); // 从第5行开始填充数据
int colIndex = 0;
for (int j = 0; j < list.size(); j++) {
DynamicObject dynamicObject = list.get(j);
String entityNumber=null;
String importProp = dynamicObject.getString("importprop");
if (!("").equals(importProp)){
entityNumber = dynamicObject.getString("entitynumber")+"."+dynamicObject.getString("importprop");
}else {
entityNumber = dynamicObject.getString("entitynumber");
}
// 获取对应的数据
String data = orderEntry.getString(entityNumber);
if (data==null||"".equals(data)){
switch (entityNumber){
case "material.number":
continue;
case "qeug_importmaterialtype":
data=orderEntry.getString("material.group.name");
break;
case "qeug_importmodel":
data=orderEntry.getString("material.modelnum");
break;
case "qeug_importunit":
data=orderEntry.getString("material.baseunit.name");
break;
default:
break;
}
}
// 填充单元格
XSSFCell cell = dataRow.createCell(colIndex++);
cell.setCellValue(data != null ? data : "");
XSSFCellStyle dataStyle = workbook.createCellStyle();
XSSFFont dataFont = workbook.createFont();
dataFont.setFontName("宋体");
dataFont.setFontHeightInPoints((short) 11);
dataStyle.setFont(dataFont);
dataStyle.setAlignment(HorizontalAlignment.CENTER);
dataStyle.setVerticalAlignment(VerticalAlignment.CENTER);
dataRow.setHeightInPoints(14.4f);
cell.setCellStyle(dataStyle);
}
}
// 上传Excel文件并获取下载路径
String uploadedFilePath = uploadExcel(workbook);
String downloadUrl = RequestContext.get().getClientFullContextPath() + "/attachment/download.do?path=" + uploadedFilePath;
this.getView().openUrl(downloadUrl);
}
}
}
/**
* 上传Excel文件并返回路径
*/
private String uploadExcel(XSSFWorkbook workbook) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss");
String fileName = "导出数据_" + sdf.format(new Date()) + ".xlsx";
String pathName = "/offices/" + fileName;
try {
OutputStream outputStream = new ByteArrayOutputStream();
workbook.write(outputStream);
InputStream inputStream = parse(outputStream);
FileService fs = FileServiceFactory.getAttachmentFileService();
return fs.upload(new FileItem(fileName, pathName, inputStream));
} catch (Exception e) {
//logger.error("上传Excel失败", e);
throw new RuntimeException("上传Excel失败", e);
}
}
/**
* 解析输出流为输入流
*/
public ByteArrayInputStream parse(final OutputStream out) throws Exception {
ByteArrayOutputStream outputStream = (ByteArrayOutputStream) out;
return new ByteArrayInputStream(outputStream.toByteArray());
}
}

301
main/java/shkd/repc/repe/formplugin/OrderFormMaterialImportPlugin.java Normal file
View File

@ -0,0 +1,301 @@
package shkd.repc.repe.formplugin;
import com.alibaba.dubbo.common.utils.CollectionUtils;
import com.alibaba.fastjson.JSONObject;
import kd.bos.coderule.api.CodeRuleInfo;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.bos.dataentity.metadata.IDataEntityType;
import kd.bos.dataentity.utils.StringUtils;
import kd.bos.entity.datamodel.BasedataItem;
import kd.bos.entity.datamodel.events.BeforeImportEntryEventArgs;
import kd.bos.entity.datamodel.events.QueryImportBasedataEventArgs;
import kd.bos.entity.plugin.ImportLogger;
import kd.bos.form.operate.webapi.RowMapper;
import kd.bos.form.plugin.AbstractFormPlugin;
import kd.bos.form.plugin.importentry.resolving.ImportEntryData;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.BusinessDataServiceHelper;
import kd.bos.servicehelper.coderule.CodeRuleServiceHelper;
import kd.bos.servicehelper.operation.SaveServiceHelper;
import kd.bos.servicehelper.org.OrgUnitServiceHelper;
import kd.sdk.plugin.Plugin;
import shkd.repc.recon.formplugin.dynamic.ImportMaterial;
import java.util.*;
/**
* 动态表单插件
* 采购订单-订单明细导入插件
*/
public class OrderFormMaterialImportPlugin extends AbstractFormPlugin implements Plugin {
private static final String BOS_ORG = "bos_org";//组织实体
private static final String BD_MATERIAL = "bd_material";//物料实体
private static final Set<ImportMaterial> materialList=new HashSet<>();
//TODO: 生成物料逻辑迁移到导入过程中,获取excel行
@Override
public void queryImportBasedata(QueryImportBasedataEventArgs e) {
super.queryImportBasedata(e);
DynamicObject targetObj = ((RowMapper) e.getSource()).getTargetObj();
IDataEntityType dataEntityType = targetObj.getDataEntityType();
if (null!=dataEntityType){
String name = dataEntityType.getName();
if (StringUtils.equals("orderformentry",name)){
Map<BasedataItem, List<Object>> searchResult = e.getSearchResult();
for (Map.Entry<BasedataItem, List<Object>> entry : searchResult.entrySet()) {
List<Object> basedata = entry.getValue();
// 查不到基础资料数据(导入基础资料类型会自动查找)
if (basedata.isEmpty()) {
String entityNumber = entry.getKey().getEntityNumber();
//只针对物料
if ("bd_material".equals(entityNumber)){
Long materialId = newMaterial(entry.getKey().getSearchValue(),materialList);
basedata.add(materialId);
}
} else {
// 查到多个基础资料数据
// 业务场景，应根据需求剔除不合法的基础资料数据（最终保留一个）
Iterator it = basedata.iterator();
it.next();
while (it.hasNext()) {
it.remove();
}
}
}
}
}
}
private Long newMaterial(String number,Set<ImportMaterial> set){
DynamicObject bd_material;
Long id = null;
try {
ImportMaterial materialByNumber = getMaterialByNumber(number, set);
bd_material = BusinessDataServiceHelper.newDynamicObject(BD_MATERIAL);
//物料编码
bd_material.set("number", number);
//物料名称
bd_material.set("name", materialByNumber.getMaterialName());
//所属组织
long rootOrgId = OrgUnitServiceHelper.getRootOrgId();
DynamicObject org = BusinessDataServiceHelper.loadSingle(rootOrgId, BOS_ORG);
if (null != org) {
bd_material.set("createorg", org);
}
//物料单位
QFilter unit = new QFilter("name", QCP.equals, materialByNumber.getMaterialUnit());
DynamicObject measureUnits = BusinessDataServiceHelper.loadSingle("bd_measureunits", unit.toArray());
if (null != measureUnits) {
bd_material.set("baseunit", measureUnits);
}
bd_material.set("modelnum", materialByNumber.getMaterialModel());//规格
bd_material.set("materialtype", "1");//物料类型:物资
//业务属性
DynamicObjectCollection collection = bd_material.getDynamicObjectCollection("serviceattribute");
DynamicObject serviceAttribute = BusinessDataServiceHelper.loadSingle("bd_serviceattribute", (new QFilter("number", QCP.equals, "1001")).toArray());
if (serviceAttribute!=null){
DynamicObject dynamicObject = new DynamicObject(collection.getDynamicObjectType());
dynamicObject.set("fbasedataId",serviceAttribute);
collection.add(dynamicObject);
}
bd_material.set("qeug_brand",materialByNumber.getMaterialBrand());//品牌
bd_material.set("qeug_model",materialByNumber.getMaterialExtModel());//型号
bd_material.set("enable", "1");//使用状态:可用
bd_material.set("status", "C");//数据状态:审核
bd_material.set("ctrlstrategy", "5");//控制策略:全局共享
bd_material.set("enablepur",true);//可采购
bd_material.set("enablesale",true);//可销售
bd_material.set("enableinv",true);//可库存
SaveServiceHelper.save(new DynamicObject[]{bd_material});
//物料分类映射
DynamicObject group = BusinessDataServiceHelper.loadSingle("bd_materialgroup", (new QFilter("name", QCP.equals, materialByNumber.getMaterialType())).toArray());
if (group==null) {
//待分类
group = BusinessDataServiceHelper.loadSingle("bd_materialgroup", (new QFilter("number", QCP.equals, "waitgroup")).toArray());
}
id = bd_material.getLong("id");
this.newMaterialType(id,group);
} catch (Exception e) {
this.getView().showMessage(e.getMessage());
}
return id;
}
private String checkMaterial(String materialName, String materialModel) {
QFilter qFilter = new QFilter("name", QCP.equals, materialName);
qFilter.and("modelnum",QCP.equals,materialModel);
DynamicObject dynamicObject = BusinessDataServiceHelper.loadSingle("bd_material", qFilter.toArray());
if (dynamicObject!=null){
return dynamicObject.getString("number");
}
return null;
}
private void newMaterialType(Long materialId,DynamicObject group){
DynamicObject materialType = BusinessDataServiceHelper.newDynamicObject("bd_materialgroupdetail");
//分类标准
DynamicObject standard = BusinessDataServiceHelper.loadSingle("bd_materialgroupstandard", (new QFilter("number", QCP.equals, "JBFLBZ")).toArray());
materialType.set("standard",standard);
materialType.set("group",group);
//物料
materialType.set("material",materialId);
SaveServiceHelper.save(new DynamicObject[]{materialType});
}
@Override
public void beforeImportEntry(BeforeImportEntryEventArgs e) {
super.beforeImportEntry(e);
try {
// 提前加载所有物料类型
Set<String> validMaterialTypes = new HashSet<>();
DynamicObject[] typeList = BusinessDataServiceHelper.load("bd_materialgroup", "id,name", null);
for (DynamicObject obj : typeList) {
validMaterialTypes.add(obj.getString("name"));
}
materialList.clear();
Set<String> existCodes = new HashSet<>();
// 获取已存在的物料编码
DynamicObjectCollection orderFormEntry = (DynamicObjectCollection) this.getModel().getValue("orderformentry");
if (orderFormEntry != null && !orderFormEntry.isEmpty()) {
for (DynamicObject dynamicObject : orderFormEntry) {
String number = dynamicObject.getString("material.number");
existCodes.add(number);
}
}
// 处理导入数据
HashMap itemEntry = (HashMap) e.getSource();
ArrayList list = (ArrayList) itemEntry.get("orderformentry");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
ImportEntryData importData = (ImportEntryData) iterator.next();
JSONObject data = importData.getData();
Map<String, Object> map = data.toJavaObject(Map.class);
JSONObject material = (JSONObject) map.get("material");//物料编码
String number=null;
ImportMaterial importMaterial = new ImportMaterial();
// 如果 material 为空
if (material == null) {
//TODO:判断物料是否已在系统
number= this.checkMaterial((String) map.get("qeug_materialnames"),(String) map.get("qeug_importmodel"));
if (number==null){
DynamicObject dynamicObject = BusinessDataServiceHelper.newDynamicObject("bd_material");
CodeRuleInfo codeRule = CodeRuleServiceHelper.getCodeRule(dynamicObject.getDataEntityType().getName(),
dynamicObject, null);
number = CodeRuleServiceHelper.getNumber(codeRule, dynamicObject);
}
// 构造一个新的 JSONObject 来保存生成的物料编码
JSONObject materialJson = new JSONObject();
materialJson.put("importprop","number");
materialJson.put("number", number);
map.put("material", materialJson); // 注意这里要传递完整对象
importMaterial.setMaterialNumber(number);
}else {
importMaterial.setMaterialNumber(material.getString("number"));
}
//物料类型校验
String impMaterialType = (String) map.get("qeug_importmaterialtype");
if (!validMaterialTypes.contains(impMaterialType)) {
map.replace("qeug_importmaterialtype", "待分类");
}
importMaterial.setMaterialName((String) map.get("qeug_materialnames"));
importMaterial.setMaterialType((String) map.get("qeug_importmaterialtype"));
importMaterial.setMaterialModel((String) map.get("qeug_importmodel"));
importMaterial.setMaterialUnit((String) map.get("qeug_importunit"));
importMaterial.setMaterialBrand((String) map.get("qeug_brand"));
importMaterial.setMaterialExtModel((String) map.get("qeug_model"));
materialList.add(importMaterial);
}
// 校验数据
Set<Map.Entry<String, List<ImportEntryData>>> entries = itemEntry.entrySet();
for (Map.Entry<String, List<ImportEntryData>> entry : entries) {
String entryName = entry.getKey();
List<ImportEntryData> entryEntityImportDataList = entry.getValue();
if (CollectionUtils.isEmpty(entryEntityImportDataList)) {
return;
}
// 进行校验
Map<Integer, String> indexVsMsgMap = validateEntry(entryEntityImportDataList, existCodes);
Set<Integer> indexSet = indexVsMsgMap.keySet();
Map<String, List<Object>> logMap = e.getEntryDataMap();
ImportLogger importLogger = (ImportLogger) logMap.get(entryName).get(0);
// 记录错误日志
for (Map.Entry<Integer, String> indexVsMsgEntry : indexVsMsgMap.entrySet()) {
Integer index = indexVsMsgEntry.getKey();
importLogger.log(index, indexVsMsgEntry.getValue());
importLogger.fail();
importLogger.setTotal(importLogger.getTotal() + 1);
}
// 移除校验失败的数据
Iterator<ImportEntryData> iterator2 = entryEntityImportDataList.iterator();
while (iterator2.hasNext()) {
ImportEntryData entryData = iterator2.next();
Integer rowNum = (Integer) entryData.getData().get("rowNum");
if (indexSet.contains(rowNum)) {
iterator2.remove();
}
}
}
} catch (Exception ex) {
this.getView().showMessage(ex.getMessage());
}
}
/**
* 校验物料名称、物料单位
* @param entryDataList
* @param existingMaterialCodes
* @return
*/
private Map<Integer, String> validateEntry(List<ImportEntryData> entryDataList,Set<String> existingMaterialCodes) {
Map<Integer, String> indexVsMsgMap = new HashMap<>();
for (int i = 0; i < entryDataList.size(); i++) {
ImportEntryData entryData = entryDataList.get(i);
// 获取当前行的 JSONObject 数据
JSONObject data = entryData.getData();
Map<String, Object> map = data.toJavaObject(Map.class);
String materialUnit = (String) map.get("qeug_importunit"); // 物料单位
// 获取当前行号
Integer rowNum = (Integer) entryData.getData().get("rowNum");
if (materialUnit == null || materialUnit.trim().isEmpty()) {
indexVsMsgMap.put(rowNum, "第" + (i + 1) + "行：物料单位不能为空或空字符串");
}
}
return indexVsMsgMap;
}
public ImportMaterial getMaterialByNumber(String number, Set<ImportMaterial> set) {
ImportMaterial result = null;
if (set != null && !set.isEmpty()) {
// 使用for-each循环遍历set
for (ImportMaterial importMaterial : set) {
String materialNumber = importMaterial.getMaterialNumber();
if (number.equals(materialNumber)) {
result = importMaterial;
break; // 找到后立刻跳出循环
}
}
}
return result;
}
}