Merge remote-tracking branch 'origin/dev' into dev

modules/i3plus-ext-mes-api/src/main/java/cn/estsh/i3plus/ext/mes/api/base/IMesPartService.java

@@ -1,6 +1,5 @@
 package cn.estsh.i3plus.ext.mes.api.base;
 
-import cn.estsh.i3plus.pojo.mes.bean.MesBom;
 import cn.estsh.i3plus.pojo.mes.bean.MesPart;
 
 /**
@@ -10,5 +9,7 @@ import cn.estsh.i3plus.pojo.mes.bean.MesPart;
  */
 public interface IMesPartService extends IBaseMesService<MesPart> {
 
+    MesPart getPartByPartNo(String partNo, String organizeCode);
+
 
 }

modules/i3plus-ext-mes-api/src/main/java/cn/estsh/i3plus/ext/mes/api/base/IMesProductOffLineService.java

@@ -0,0 +1,15 @@
+package cn.estsh.i3plus.ext.mes.api.base;
+
+import cn.estsh.i3plus.pojo.mes.bean.MesProductOffLine;
+
+/**
+ * @Description : 生产汇报
+ * @Reference :
+ * @Author : junsheng.li
+ * @CreateDate 2024/5/10 14:37
+ * @Modify:
+ **/
+public interface IMesProductOffLineService extends IBaseMesService<MesProductOffLine>{
+
+
+}

modules/i3plus-ext-mes-api/src/main/java/cn/estsh/i3plus/ext/mes/api/base/IMesWorkOrderService.java

@@ -1,7 +1,6 @@
 package cn.estsh.i3plus.ext.mes.api.base;
 
 import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
-import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderLog;
 
 /**
  * @Description:
@@ -10,5 +9,5 @@ import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderLog;
  */
 public interface IMesWorkOrderService extends IBaseMesService<MesWorkOrder> {
 
-
+    void doProductReport(MesWorkOrder mesWorkOrder);
 }

modules/i3plus-ext-mes-api/src/main/java/cn/estsh/i3plus/ext/mes/api/base/IMesWorkOrderToSapService.java

@@ -0,0 +1,15 @@
+package cn.estsh.i3plus.ext.mes.api.base;
+
+import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
+import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderToSap;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author : junsheng.li
+ * @CreateDate 2024/5/8 16:48
+ * @Modify:
+ **/
+public interface IMesWorkOrderToSapService extends IBaseMesService<MesWorkOrderToSap> {
+    MesWorkOrderToSap insert(MesWorkOrder mesWorkOrder);
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/controller/base/MesProductOffLineController.java

@@ -0,0 +1,19 @@
+package cn.estsh.i3plus.ext.mes.apiservice.controller.base;
+
+import cn.estsh.i3plus.ext.mes.pojo.constant.MesCommonConstant;
+import cn.estsh.i3plus.pojo.mes.bean.MesProductOffLine;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * @Description : 生产汇报
+ * @Reference :
+ * @Author : junsheng.li
+ * @CreateDate 2024/5/10 14:36
+ * @Modify:
+ **/
+@RestController
+@RequestMapping(MesCommonConstant.MES_YANFEN + "/mesProductOffLine")
+public class MesProductOffLineController extends BaseMesController<MesProductOffLine> {
+
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/controller/base/MesWorkOrderController.java

@@ -1,17 +1,77 @@
 package cn.estsh.i3plus.ext.mes.apiservice.controller.base;
 
+import cn.estsh.i3plus.ext.mes.api.base.IMesWorkOrderService;
+import cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.excel.MesExcelTool;
 import cn.estsh.i3plus.ext.mes.pojo.constant.MesCommonConstant;
-import cn.estsh.i3plus.pojo.mes.bean.MesLoadingVehiclesOrderDetail;
+import cn.estsh.i3plus.platform.common.convert.ConvertBean;
+import cn.estsh.i3plus.pojo.base.enumutil.ResourceEnumUtil;
 import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
+import cn.estsh.impp.framework.boot.auth.AuthUtil;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+import cn.estsh.impp.framework.boot.util.RedisCacheTool;
+import cn.estsh.impp.framework.boot.util.ResultBean;
 import io.swagger.annotations.Api;
-import org.springframework.web.bind.annotation.RequestMapping;
+import io.swagger.annotations.ApiOperation;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.List;
 
 @Api(description = "工单主页面")
 @RestController
 @RequestMapping(MesCommonConstant.MES_YANFEN + "/mesWorkOrder")
-
 public class MesWorkOrderController extends BaseMesController<MesWorkOrder> {
 
+    @Autowired
+    private IMesWorkOrderService mesWorkOrderService;
+
+    @PostMapping(value = "/import-mes-work-order")
+    @ApiOperation(value = "导入数据")
+    public ResultBean importMesWorkOrderExcel(@RequestParam("file") MultipartFile file, Integer type) {
+        try {
+            MesExcelTool excelTool = new MesExcelTool(entityManager, RedisCacheTool.getImppRedis());
+            List<MesWorkOrder> beanList = excelTool.importData(file.getOriginalFilename(), file.getInputStream(), MesWorkOrder.class);
+
+            // 校验导入数据
+            validateImport(beanList);
+            String userName = AuthUtil.getSessionUser().getUserName();
+            String organizeCode = AuthUtil.getOrganize().getOrganizeCode();
+            // 导入数据初始化
+            for (MesWorkOrder bean : beanList) {
+                bean.setWorkOrderType(type);
+                ConvertBean.serviceModelInitialize(bean, userName);
+                bean.setOrganizeCode(organizeCode);
+            }
+            baseService.insertBatch(beanList);
+
+            // 导入后
+            afterImport(beanList);
+            return ResultBean.success("导入成功").setCode(ResourceEnumUtil.MESSAGE.SUCCESS.getCode());
+        } catch (ImppBusiException e) {
+            return ResultBean.fail(e);
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e);
+        }
+    }
+
+    @PostMapping(value = "/doProductReport")
+    @ApiOperation(value = "生产报工")
+    public ResultBean doProductReport(@RequestBody MesWorkOrder mesWorkOrder) {
+        try {
+            //新增初始化
+            mesWorkOrder.setOrganizeCode(AuthUtil.getOrganizeCode());
+            ConvertBean.serviceModelInitialize(mesWorkOrder, AuthUtil.getSessionUser().getUserName());
+            mesWorkOrderService.doProductReport(mesWorkOrder);
+            return ResultBean.success("操作成功")
+                    .setCode(ResourceEnumUtil.MESSAGE.SUCCESS.getCode());
+        } catch (ImppBusiException e) {
+            return ResultBean.fail(e).build();
+        } catch (Exception e) {
+            return ResultBean.fail(e);
+        }
+    }
+
 
 }

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/controller/dbinterface/WmsSAPDbInterfaceController.java

@@ -0,0 +1,91 @@
+package cn.estsh.i3plus.ext.mes.apiservice.controller.dbinterface;
+
+import cn.estsh.i3plus.ext.mes.apiservice.dbinterface.MesSAPDbAdapter;
+import cn.estsh.i3plus.icloud.softswitch.sdk.IBsSuitServiceCloud;
+import cn.estsh.i3plus.mes.apiservice.serviceimpl.engine.script.EngineScriptManager;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceEnumUtil;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+import cn.estsh.impp.framework.boot.util.ResultBean;
+import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+
+/**
+ * @Description : SAP接口同步控制器
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 12:08
+ * @Modify:
+ **/
+@RestController
+@RequestMapping("/impp/white/mes-sap-if/")
+@Api(description = "SAP接口同步控制器")
+public class WmsSAPDbInterfaceController {
+    private static final Logger LOGGER = LoggerFactory.getLogger(WmsSAPDbInterfaceController.class);
+
+    @Autowired
+    IBsSuitServiceCloud bsSuitServiceCloud;
+
+    // 注入脚本引擎对象
+    @Autowired
+    private EngineScriptManager scriptManager;
+
+    @GetMapping(value = "sync-data/do")
+    @ApiOperation(value = "执行接口数据同步，支持的参数：SAP2MES, MES2SAP ")
+    public ResultBean doSyncSAPData(String syncParam) {
+        try {
+            // 判断作业参数是否支持
+            if (MesInterfaceEnumUtil.DIRECTION_TYPE.nameOf(syncParam) == -1) {
+                throw new IllegalArgumentException("不支持的同步参数：" + syncParam);
+            }
+            LOGGER.info("WmsSAPDbInterfaceController.doSyncSAPData start.....");
+            MesSAPDbAdapter wmsSAPDbAdapter = new MesSAPDbAdapter();
+            // new 的对象需要手工注入 bean
+            if (SpringContextsUtil.getApplicationContext() != null) {
+                SpringContextsUtil.getApplicationContext().
+                        getAutowireCapableBeanFactory().autowireBean(wmsSAPDbAdapter);
+            }
+            wmsSAPDbAdapter.syncData(syncParam,null);
+            LOGGER.info("WmsSAPDbInterfaceController.doSyncSAPData end.....");
+
+            return new ResultBean(true).setMsg("SAP-->WMS接口数据同步执行成功");
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e).setResultObject(e);
+        }
+    }
+
+    @GetMapping(value = "sync-data-id/do")
+    @ApiOperation(value = "按ID单个执行接口数据同步，支持的参数：SAP2MES, MES2SAP ")
+    public ResultBean doSyncSAPData(String syncParam,String o, String id) {
+        try {
+            // 判断作业参数是否支持
+            if (MesInterfaceEnumUtil.DIRECTION_TYPE.nameOf(syncParam) == -1) {
+                throw new IllegalArgumentException("不支持的同步参数：" + syncParam);
+            }
+            LOGGER.info("WmsSAPDbInterfaceController.doSyncSAPData start.....");
+            // 开始同步数据
+            // 一定要 new 对象，不然会有并发问题
+            MesSAPDbAdapter wmsSAPDbAdapter = new MesSAPDbAdapter();
+            // new 的对象需要手工注入 bean
+            if (SpringContextsUtil.getApplicationContext() != null) {
+                SpringContextsUtil.getApplicationContext().
+                        getAutowireCapableBeanFactory().autowireBean(wmsSAPDbAdapter);
+            }
+            wmsSAPDbAdapter.syncData(syncParam, id);
+            LOGGER.info("WmsSAPDbInterfaceController.doSyncSAPData end.....");
+
+            return new ResultBean(true).setMsg("SAP-->WMS接口数据同步执行成功");
+        } catch (Exception e) {
+            return ImppExceptionBuilder.newInstance().buildExceptionResult(e).setResultObject(e);
+        }
+    }
+
+
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/daoimpl/SapProductPlanDaoImpl.java

@@ -39,7 +39,7 @@ public class SapProductPlanDaoImpl implements ISapProductPlanDao {
         StringBuilder hql = new StringBuilder();
         hql.append(" from sap_product_plan sap left join mes_work_order mes on sap.plnum = mes.plan_order_no and sap.plmat = mes.part_no " +
                 "where sap.is_deleted=:isDeleted and sap.is_valid=:isValid and sap.organize_code=:organizeCode " +
-                " and mes.is_deleted=:isDeleted and mes.is_valid=:isValid and mes.organize_code=:organizeCode");
+                " and ((mes.is_deleted=:isDeleted and mes.is_valid=:isValid and mes.organize_code=:organizeCode) or mes.id is null)");
         //拼接查询条件
         packWhere(sapProductPlan, hql);
         StringBuffer unionDataHql = new StringBuffer("select sap.plnum,mes.part_no,mes.qty," +

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/MesSAPDbAdapter.java

@@ -0,0 +1,479 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataSet;
+import cn.estsh.i3plus.platform.common.tool.TimeTool;
+import cn.estsh.i3plus.platform.common.util.MesConstWords;
+import cn.estsh.i3plus.platform.plugin.datasource.DynamicDataSourceProxy;
+import cn.estsh.i3plus.pojo.base.codemaker.SnowflakeIdMaker;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceDataMapper;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceEnumUtil;
+import cn.estsh.impp.framework.boot.util.ImppRedis;
+import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
+import com.alibaba.fastjson.JSON;
+import lombok.NoArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.sql.Connection;
+import java.text.SimpleDateFormat;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description : 接口数据适配器
+ * 从接口规则表中读取所有需要转换的接口表信息并调用读取类进行数据获取，再调用转换类进行转换，最后调用写入类把数据保存到业务表
+ * @Reference :
+ * @Author : rock.yu
+ * @CreateDate : 2019-06-11 19:34
+ * @Modify: 1.
+ **/
+@Component
+@NoArgsConstructor
+public class MesSAPDbAdapter {
+
+    public static final Logger LOGGER = LoggerFactory.getLogger(WmsSAPDbWriter.class);
+
+    @Resource(name = "yfasDataSource")
+    private DynamicDataSourceProxy sapDataSourceProxy;
+ 
+    @Resource(name = "mesDataSource")
+    private DynamicDataSourceProxy mesDataSourceProxy;
+
+    @Value("${sync.redis.time:1800}")
+    private Integer redisTime;
+
+    private WmsSAPDbExpression wmsSAPDbExpression;
+
+    private WmsSAPDbWriter writer;
+
+    private WmsSAPDbReader reader;
+
+    private WmsSAPDbTranslator translator;
+
+    private MesSAPDbDataMapper dbDataMapper;
+
+    private Connection srcConn;
+    private Connection destConn;
+    private Connection mesConn;
+
+    @Resource(name = "redisMes")
+    private ImppRedis redisMes;
+
+    // 获取 IMPP ID
+    @Autowired
+    private SnowflakeIdMaker snowflakeIdMaker;
+
+    private WmsSAPDbWriter buildWriter(String groupName,
+                                       DynamicDataSourceProxy sapDataSourceProxy, 
+                                       DynamicDataSourceProxy mesDataSourceProxy) throws Exception {
+
+        WmsSAPDbWriter wmsSAPDbWriter = null;
+
+        if (groupName.equals(MesInterfaceEnumUtil.DIRECTION_TYPE.SAP2MES.getName())) {
+            wmsSAPDbWriter = new WmsSAPDbWriter(sapDataSourceProxy, mesDataSourceProxy);
+        }
+
+        if (groupName.equals(MesInterfaceEnumUtil.DIRECTION_TYPE.MES2SAP.getName())) {
+            wmsSAPDbWriter = new WmsSAPDbWriter(mesDataSourceProxy, sapDataSourceProxy);
+        }
+
+      
+
+
+        // new 的对象需要手工注入 bean
+        if (SpringContextsUtil.getApplicationContext() != null) {
+            SpringContextsUtil.getApplicationContext().
+                    getAutowireCapableBeanFactory().autowireBean(wmsSAPDbWriter);
+        }
+
+        this.srcConn = wmsSAPDbWriter.getSrcDataSourceProxy().getWriteConnectionWithoutPool();
+        this.destConn = wmsSAPDbWriter.getDestDataSourceProxy().getWriteConnectionWithoutPool();
+        this.mesConn = mesDataSourceProxy.getWriteConnectionWithoutPool();
+
+        if (wmsSAPDbWriter != null) {
+            wmsSAPDbExpression = new WmsSAPDbExpression();
+            wmsSAPDbExpression.setSrcConn(mesConn);
+            // new 的对象需要手工注入 bean
+            if (SpringContextsUtil.getApplicationContext() != null) {
+                SpringContextsUtil.getApplicationContext().
+                        getAutowireCapableBeanFactory().autowireBean(wmsSAPDbExpression);
+            }
+            wmsSAPDbWriter.setWmsSAPDbExpression(wmsSAPDbExpression);
+        }
+
+
+        return wmsSAPDbWriter;
+    }
+
+    private WmsSAPDbReader buildReader(String groupName,
+                                       DynamicDataSourceProxy sapDataSourceProxy,
+                                       DynamicDataSourceProxy mesDataSourceProxy) {
+
+        WmsSAPDbReader wmsSAPDbReader = null;
+
+        if (groupName.equals(MesInterfaceEnumUtil.DIRECTION_TYPE.SAP2MES.getName())) {
+            wmsSAPDbReader = new WmsSAPDbReader(sapDataSourceProxy);
+        }
+
+        if (groupName.equals(MesInterfaceEnumUtil.DIRECTION_TYPE.MES2SAP.getName())) {
+            wmsSAPDbReader = new WmsSAPDbReader(mesDataSourceProxy);
+        }
+
+//        if (groupName.equals(MesInterfaceEnumUtil.DIRECTION_TYPE.WMS2MES.getName())) {
+//            wmsSAPDbReader = new WmsSAPDbReader(mesDataSourceProxy);
+//        }
+//
+//        if (groupName.equals(MesInterfaceEnumUtil.DIRECTION_TYPE.MES2WMS.getName())) {
+//            wmsSAPDbReader = new WmsSAPDbReader(mesDataSourceProxy);
+//        }
+
+
+        if (wmsSAPDbReader != null && SpringContextsUtil.getApplicationContext() != null) {
+            SpringContextsUtil.getApplicationContext().
+                    getAutowireCapableBeanFactory().autowireBean(wmsSAPDbReader);
+        }
+
+        return wmsSAPDbReader;
+    }
+
+    private String getTime() {
+        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
+        return df.format(new Date());// new Date()为获取当前系统时间
+    }
+
+    /**
+     * 按照配置表同步所有的数据
+     * 单一数据源，要防止并发
+     */
+    public void syncData(String groupName, String id) throws Exception {
+        String redisKey = MesConstWords.SAP_TRANS_JOB_LOCK_TAG + ":" + groupName;
+
+        // 按ID单个调试时 key 要带上 id，防止跟正常 job 冲突
+        if (id != null && !id.isEmpty()) {
+            redisKey = redisKey + ":" + id;
+        }
+
+        //添加redis锁（半小时失效）
+        if (redisMes.getObject(redisKey) != null) {
+            LOGGER.error("数据正在处理中！不能并发处理！RedisKey: {}", redisKey);
+            // 直接返回
+            return;
+        }
+
+        LOGGER.info("WmsSAPDbAdapter.syncData start...");
+
+        //  存放错误信息
+        StringBuilder errorMessage = new StringBuilder();
+        try {
+            redisMes.putObject(redisKey, "starting...", redisTime);
+
+            // 一次性拿到数据源连接，处理完成后再统一关闭
+            // 不需要在这里处理
+            //initConnection();
+
+            writer = buildWriter(groupName, sapDataSourceProxy,  mesDataSourceProxy);
+            writer.setSrcConn(this.srcConn);
+            writer.setDestConn(this.destConn);
+
+            reader = buildReader(groupName, sapDataSourceProxy, mesDataSourceProxy);
+            reader.setSrcConn(this.srcConn);
+
+
+            // 映射关系始终从 WMS 表获取
+            dbDataMapper = new MesSAPDbDataMapper(mesDataSourceProxy);
+            dbDataMapper.setSrcConn(mesConn);
+
+            translator = new WmsSAPDbTranslator(wmsSAPDbExpression);
+
+            List<MesInterfaceDataMapper> dataMappers = dbDataMapper.readDataMappersBySQL(groupName, id, null, null, null);
+
+            LOGGER.info("WmsSAPDbAdapter.foreach dataMapper ...");
+
+            // 遍历所有已配置的接口表
+            for (MesInterfaceDataMapper dataMapper : dataMappers) {
+                try {
+                    // 检查同步周期是否达到预设值
+                    if (!checkSyncTime(dataMapper)) {
+                        // 未到达同步时间，继续判断下一个接口
+                        continue;
+                    }
+                } catch (Exception e) {
+                    LOGGER.error("同步数据发生异常", e);
+                }
+
+                try {
+                    // 设置本此发送的 SID
+                    dataMapper.setSid(snowflakeIdMaker.nextId());
+                    // 用当前配置信息初始化对象
+                    reader.setDataMapper(dataMapper);
+                    writer.setDataMapper(dataMapper);
+                    translator.setDataMapper(dataMapper);
+
+                    // 从来源表读取数据
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{} read data", dataMapper.getSoftAdaptorCode());
+
+                    List<Map<String, Object>> srcData = reader.readData();
+                    // 来源表中没有数据，跳过当前循环，处理下一个表
+                    if (srcData == null || srcData.size() == 0) {
+                        continue;
+                    }
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{},size:{}", dataMapper.getSoftAdaptorCode(), srcData.size());
+                    // 把来源表转换成目标表
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{} start translateData", dataMapper.getSoftAdaptorCode());
+
+                    DataSet dataSet = translator.translateData(srcData);
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{} end translateData", dataMapper.getSoftAdaptorCode());
+
+                    // 没有获取到转换后的数据，不执行写入操作，处理下一个表
+                    if (dataSet == null || dataSet.size() == 0) {
+                        continue;
+                    }
+                    LOGGER.info("WmsSAPDbAdapter.syncData.saveData softAdapter:{} start", dataMapper.getSoftAdaptorCode());
+
+                    // 写入目标表信息并更新来源表标志字段
+                    writer.saveData(srcData, dataSet, reader.getOriginReadData());
+                    LOGGER.info("WmsSAPDbAdapter.syncData.saveData softAdapter:{} end", dataMapper.getSoftAdaptorCode());
+                    String updateSql = String.format("update mes_interface_data_mapper set" +
+                            " last_sync_time ='%s' where id =%s", TimeTool.getNowTime(true), dataMapper.getId());
+                    mesDataSourceProxy.execute(mesConn, updateSql);
+                    mesConn.setAutoCommit(false);
+                    // 把当前时间写入 redis，便于跟踪
+                    redisMes.putObject(redisKey, getTime(), 1800);
+
+                    dbDataMapper.updateWmsInterfaceDataMapperLastSyncTimeById(dataMapper.getId());
+                    // 更新下次执行时间
+                    dbDataMapper.updateNextSyncTime(dataMapper);
+
+                } catch (Exception e) {
+                    LOGGER.error("接口同步错误！ 接口对象：" + JSON.toJSONString(dataMapper) + "\n" + e.getMessage());
+
+                    errorMessage.append("接口同步错误！ 接口对象：" + JSON.toJSONString(dataMapper) + "\n");
+                    errorMessage.append(e.getMessage() + ", " + e.getCause());
+                    errorMessage.append("\n\n");
+                }
+            }
+
+
+        } catch (Exception e) {
+            LOGGER.error("WmsSAPDbAdapter: " + e.getStackTrace().toString());
+            throw e;
+        } finally {
+            // 解除REDIS执行锁，这个要放到第一行，否则执行有异常时可能导致 KEY 删不掉
+            redisMes.deleteKey(redisKey);
+            // 手工关闭连接
+            //closeConnection();
+            mesDataSourceProxy.closeConnectionWithoutPoll(this.srcConn);
+            mesDataSourceProxy.closeConnectionWithoutPoll(this.destConn);
+            mesDataSourceProxy.closeConnectionWithoutPoll(this.mesConn);
+        }
+        LOGGER.info("WmsSAPDbAdapter.syncData stop...");
+
+        // 执行过程中出现了异常，抛出异常
+        if (errorMessage.length() > 0) {
+            throw new RuntimeException(errorMessage.toString());
+        }
+    }
+
+    /**
+     * 检查距离上次同步的间隔时间是否满足预设的同步间隔时间
+     *
+     * @param dataMapper 接口实体
+     * @return 是否满足同步条件
+     */
+    private boolean checkSyncTime(MesInterfaceDataMapper dataMapper) {
+        try {
+            DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+            int syncFrequency = dataMapper.getSyncFrequency();//间隔分钟数
+            String lastSyncTimes = dataMapper.getLastSyncTime();//时分秒的三种数据
+            LocalDateTime localDateTimeSatrt = LocalDateTime.parse(lastSyncTimes, df);
+            LocalDateTime localDateTimeEnd = LocalDateTime.now();
+            Duration duration = Duration.between(localDateTimeSatrt, localDateTimeEnd);
+            long minutes = duration.toMinutes();
+            // 间隔时间未到达预设的同步周期
+            if (minutes < syncFrequency) {
+                String msg = String.format("上次同步频率时间相差太短!syncFrequency=%s " +
+                                "--- localDateTimeSatrt=%s " +
+                                "--- localDateTimeEnd=%s",
+                        syncFrequency, localDateTimeSatrt, localDateTimeEnd);
+                LOGGER.info(msg);
+                return false;
+            }
+        } catch (Exception e) {
+
+        }
+
+        return true;
+    }
+
+    /**
+     * 按照配置表+工厂同步所有的数据
+     * 单一数据源，要防止并发
+     */
+    public void syncDataByOrganizeCode(String groupName, String organizeCode, List<String> destBeanNameList, List<String> destBeanNameNotList) throws Exception {
+
+        //分组代码+工厂代码作业KEY值
+        String redisKey = MesConstWords.SAP_TRANS_JOB_LOCK_TAG + ":" + groupName + ":" + organizeCode + destBeanNameList + destBeanNameNotList;
+
+        //添加redis锁（半小时失效）
+        if (redisMes.getObject(redisKey) != null) {
+            LOGGER.error("数据正在处理中！不能并发处理！RedisKey: {}", redisKey);
+            // 直接返回
+            return;
+        }
+
+        LOGGER.info("WmsSAPDbAdapter.syncData organizeCode:{},start...", organizeCode);
+
+        //  存放错误信息
+        StringBuilder errorMessage = new StringBuilder();
+        try {
+            redisMes.putObject(redisKey, "starting...", redisTime);
+
+            // 一次性拿到数据源连接，处理完成后再统一关闭
+            // 不需要在这里处理
+            //initConnection();
+
+            writer = buildWriter(groupName, sapDataSourceProxy, mesDataSourceProxy);
+            writer.setSrcConn(this.srcConn);
+            writer.setDestConn(this.destConn);
+
+            reader = buildReader(groupName, sapDataSourceProxy, mesDataSourceProxy);
+            reader.setSrcConn(this.srcConn);
+
+
+            // 映射关系始终从 WMS 表获取
+            dbDataMapper = new MesSAPDbDataMapper(mesDataSourceProxy);
+            dbDataMapper.setSrcConn(mesConn);
+
+            translator = new WmsSAPDbTranslator(wmsSAPDbExpression);
+
+            List<MesInterfaceDataMapper> dataMappers = dbDataMapper.readDataMappersBySQL(groupName, null, organizeCode, destBeanNameList, destBeanNameNotList);
+
+            LOGGER.info("WmsSAPDbAdapter.foreach dataMapper ...");
+
+            // 遍历所有已配置的接口表
+            for (MesInterfaceDataMapper dataMapper : dataMappers) {
+                try {
+                    // 检查同步周期是否达到预设值
+                    if (!checkSyncTime(dataMapper)) {
+                        // 未到达同步时间，继续判断下一个接口
+                        continue;
+                    }
+                } catch (Exception e) {
+                    LOGGER.error("同步数据发生异常", e);
+                }
+
+                try {
+                    // 设置本此发送的 SID
+                    dataMapper.setSid(snowflakeIdMaker.nextId());
+                    // 用当前配置信息初始化对象
+                    reader.setDataMapper(dataMapper);
+                    writer.setDataMapper(dataMapper);
+                    translator.setDataMapper(dataMapper);
+
+                    // 从来源表读取数据
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{} read data", dataMapper.getSoftAdaptorCode());
+
+                    List<Map<String, Object>> srcData = reader.readData();
+                    // 来源表中没有数据，跳过当前循环，处理下一个表
+                    if (srcData == null || srcData.size() == 0) {
+                        continue;
+                    }
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{},size:{}", dataMapper.getSoftAdaptorCode(), srcData.size());
+                    // 把来源表转换成目标表
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{} start translateData", dataMapper.getSoftAdaptorCode());
+
+                    DataSet dataSet = translator.translateData(srcData);
+                    LOGGER.info("WmsSAPDbAdapter.syncData softAdapter:{} end translateData", dataMapper.getSoftAdaptorCode());
+
+                    // 没有获取到转换后的数据，不执行写入操作，处理下一个表
+                    if (dataSet == null || dataSet.size() == 0) {
+                        continue;
+                    }
+                    LOGGER.info("WmsSAPDbAdapter.syncData.saveData softAdapter:{} start", dataMapper.getSoftAdaptorCode());
+
+                    // 写入目标表信息并更新来源表标志字段
+                    writer.saveData(srcData, dataSet, reader.getOriginReadData());
+                    LOGGER.info("WmsSAPDbAdapter.syncData.saveData softAdapter:{} end", dataMapper.getSoftAdaptorCode());
+                    String updateSql = String.format("update mes_interface_data_mapper set" +
+                            " last_sync_time ='%s' where id =%s", TimeTool.getNowTime(true), dataMapper.getId());
+                    mesDataSourceProxy.execute(mesConn, updateSql);
+                    mesConn.setAutoCommit(false);
+                    // 把当前时间写入 redis，便于跟踪
+                    redisMes.putObject(redisKey, getTime(), 1800);
+
+                    dbDataMapper.updateWmsInterfaceDataMapperLastSyncTimeById(dataMapper.getId());
+                    // 更新下次执行时间
+                    dbDataMapper.updateNextSyncTime(dataMapper);
+
+                } catch (Exception e) {
+                    LOGGER.error("接口同步错误！ 接口对象：" + JSON.toJSONString(dataMapper) + "\n" + e.getMessage());
+
+                    errorMessage.append("接口同步错误！ 接口对象：" + JSON.toJSONString(dataMapper) + "\n");
+                    errorMessage.append(e.getMessage() + ", " + e.getCause());
+                    errorMessage.append("\n\n");
+                }
+            }
+
+
+        } catch (Exception e) {
+            LOGGER.error("WmsSAPDbAdapter: " + e.getStackTrace().toString());
+            throw e;
+        } finally {
+            // 解除REDIS执行锁，这个要放到第一行，否则执行有异常时可能导致 KEY 删不掉
+            redisMes.deleteKey(redisKey);
+            // 手工关闭连接
+            //closeConnection();
+            mesDataSourceProxy.closeConnectionWithoutPoll(this.srcConn);
+            mesDataSourceProxy.closeConnectionWithoutPoll(this.destConn);
+            mesDataSourceProxy.closeConnectionWithoutPoll(this.mesConn);
+        }
+        LOGGER.info("WmsSAPDbAdapter.syncData organizeCode:{} stop...", organizeCode);
+
+        // 执行过程中出现了异常，抛出异常
+        if (errorMessage.length() > 0) {
+            throw new RuntimeException(errorMessage.toString());
+        }
+    }
+
+    /**
+     * Rock.Yu 2019-07-26
+     * 读写用2个数据源有问题，写进去的数据从读数据源查不到（可能是事务问题，没有深入分析）
+     * 实际上配置文件中的读写连接串都是相同的，没必要用2个连接（做读写分离可以用 MyCAT）
+     * 此处读写都是用的同一个连接（写连接），可以解决上述问题
+     *
+     * @throws Exception
+     */
+//    private void initConnection() throws Exception {
+//        sapDataSourceProxy.setReadConnHold(sapDataSourceProxy.getWriteConnectionWithoutPool());
+//        sapDataSourceProxy.setWriteConnHold(sapDataSourceProxy.getWriteConnectionWithoutPool());
+//        mesDataSourceProxy.setReadConnHold(mesDataSourceProxy.getWriteConnectionWithoutPool());
+//        mesDataSourceProxy.setWriteConnHold(mesDataSourceProxy.getWriteConnectionWithoutPool());
+//        mesDataSourceProxy.setReadConnHold(mesDataSourceProxy.getWriteConnectionWithoutPool());
+//        mesDataSourceProxy.setWriteConnHold(mesDataSourceProxy.getWriteConnectionWithoutPool());
+//        swebDataSourceProxy.setReadConnHold(swebDataSourceProxy.getWriteConnectionWithoutPool());
+//        swebDataSourceProxy.setWriteConnHold(swebDataSourceProxy.getWriteConnectionWithoutPool());
+//    }
+//
+//    private void closeConnection() throws Exception {
+//        try {
+//            sapDataSourceProxy.closeConnectionWithoutPoll(sapDataSourceProxy.getReadConnHold());
+//            sapDataSourceProxy.closeConnectionWithoutPoll(sapDataSourceProxy.getWriteConnHold());
+//            mesDataSourceProxy.closeConnectionWithoutPoll(mesDataSourceProxy.getReadConnHold());
+//            mesDataSourceProxy.closeConnectionWithoutPoll(mesDataSourceProxy.getWriteConnHold());
+//            mesDataSourceProxy.closeConnectionWithoutPoll(mesDataSourceProxy.getReadConnHold());
+//            mesDataSourceProxy.closeConnectionWithoutPoll(mesDataSourceProxy.getWriteConnHold());
+//            swebDataSourceProxy.closeConnectionWithoutPoll(swebDataSourceProxy.getReadConnHold());
+//            swebDataSourceProxy.closeConnectionWithoutPoll(swebDataSourceProxy.getWriteConnHold());
+//        } catch (Exception e) {
+//            LOGGER.error(e.getStackTrace().toString());
+//        }
+//    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/MesSAPDbDataMapper.java

@@ -0,0 +1,171 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.ext.mes.pojo.util.CronUtil;
+import cn.estsh.i3plus.ext.mes.pojo.util.OverwriteStringJoin;
+import cn.estsh.i3plus.platform.common.tool.TimeTool;
+import cn.estsh.i3plus.platform.plugin.datasource.DynamicDataSourceProxy;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceDataMapper;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.util.CollectionUtils;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+/**
+ * @Description :
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 16:08
+ * @Modify:
+ **/
+public class MesSAPDbDataMapper extends WmsSAPDbSyncBase {
+
+    public static final Logger LOGGER = LoggerFactory.getLogger(MesSAPDbDataMapper.class);
+
+    private DynamicDataSourceProxy mesDataSourceProxy;
+
+    @Getter
+    @Setter
+    private Connection srcConn;
+ 
+    public MesSAPDbDataMapper(DynamicDataSourceProxy mesDataSourceProxy) {
+        this.mesDataSourceProxy = mesDataSourceProxy;
+    }
+
+    /**
+     * 查询 SQL 返回数据转换配置对象的列表
+     * @return
+     * @throws Exception
+     */
+    public List<MesInterfaceDataMapper> readDataMappersBySQL(String groupName, String id,String organizeCode,List<String> destBeanNameList,List<String> destBeanNameNotList) throws Exception {
+        String sqlString = "select * from mes_interface_data_mapper " +
+                "where is_deleted=2 and is_valid=1 and group_name='"
+                + groupName + "' ";
+
+        // 如果 id 不为空，则按照单个 id 查询
+        if (id != null && !id.isEmpty()) {
+            // 带 id 调试时不考虑删除和有效2个字段
+            sqlString = sqlString.replace("is_deleted=2 and is_valid=1 and", " ");
+            sqlString = sqlString + " and id=" + id;
+        }
+
+        // 如果 organizeCode 不为空，则按照 organizeCode 查询
+        if (organizeCode != null && !organizeCode.isEmpty()) {
+            // 带 id 调试时不考虑删除和有效2个字段
+            sqlString = sqlString + " and organize_code= '" + organizeCode +"'";
+        }
+        // 按照目标表进行拆分，参数不为空则in
+        if (!CollectionUtils.isEmpty(destBeanNameList)) {
+            sqlString = sqlString + " and dest_bean_name in ("+ OverwriteStringJoin.join(",",destBeanNameList)+")";
+            LOGGER.info("接口映射添加目标表参数，sql为:{}",sqlString);
+        }
+        // 按照目标表进行拆分，参数不为空则 not in
+        if (!CollectionUtils.isEmpty(destBeanNameNotList)) {
+            sqlString = sqlString + " and dest_bean_name not in ("+ OverwriteStringJoin.join(",",destBeanNameNotList)+")";
+            LOGGER.info("接口映射不添加目标表参数，sql为:{}",sqlString);
+        }
+
+        sqlString = sqlString + " order by seq";
+
+        List<Map<String, Object>> rows = mesDataSourceProxy.queryMapList(sqlString, srcConn);
+
+        if (rows == null || rows.size() == 0) {
+            LOGGER.error("not set data in talbe: mes_interface_data_mapper !");
+            throw new IllegalArgumentException("not set data in talbe: mes_interface_data_mapper !");
+        }
+
+        List<MesInterfaceDataMapper> dataMappers = new ArrayList<>();
+
+        for(Map<String, Object> row : rows) {
+            MesInterfaceDataMapper mapper = new MesInterfaceDataMapper();
+
+            mapper.setSeq(this.getSafetyInteger(row.get("seq")));
+            mapper.setOrganizeCode(this.getSafetyString(row.get("organize_code")));
+            mapper.setSrcGetLimit(this.getSafetyInteger(row.get("src_get_limit")));
+            mapper.setDataSource(this.getSafetyString(row.get("src_data_source")));
+            mapper.setSrcTableName(this.getSafetyString(row.get("src_table_name")));
+            mapper.setSrcOrderBy(this.getSafetyString(row.get("src_order_by")));
+            mapper.setSrcWhere(this.getSafetyString(row.get("src_where")));
+            mapper.setSrcGroupColumns(this.getSafetyString(row.get("src_group_columns")));
+            mapper.setSrcUpdateSync(this.getSafetyString(row.get("src_update_sync")));
+            mapper.setSrcPkColumns(this.getSafetyString(row.get("src_pk_columns")));
+            mapper.setCopyByOrgs(this.getSafetyString(row.get("copy_py_orgs")));
+            mapper.setDestBeanName(this.getSafetyString(row.get("dest_bean_name")));
+            mapper.setDestPkProperties(this.getSafetyString(row.get("dest_pk_properties")));
+            mapper.setDestColumnMapping(this.getSafetyString(row.get("dest_column_mapping")));
+            mapper.setBusiRoute(this.getSafetyString(row.get("busi_route")));
+            mapper.setId(this.getSafetyLong(row.get("id")));
+            mapper.setCopyByOrgs(this.getSafetyString(row.get("copy_by_orgs")));
+            mapper.setSyncCron(this.getSafetyString(row.get("sync_cron")));
+            mapper.setNextSyncTime(this.getSafetyString(row.get("next_sync_time")));
+
+            mapper.setSyncFrequency(this.getSafetyInteger(row.get("sync_frequency")));
+            mapper.setLastSyncTime(this.getSafetyString(row.get("last_sync_time")));
+            mapper.setSoftDataType(this.getSafetyInteger(row.get("soft_data_type")));
+
+            // 与软适配和脚本对接相关的属性
+            mapper.softAdaptorCode = this.getSafetyString(row.get("soft_adapator_code"));
+            mapper.scriptNo = this.getSafetyString(row.get("script_no"));
+            mapper.useScriptPull = this.getSafetyInteger(row.get("use_script_pull"));
+            mapper.useScriptPush = this.getSafetyInteger(row.get("use_script_push"));
+            mapper.useScriptMark = this.getSafetyInteger(row.get("use_script_mark"));
+            mapper.useScriptFilter = this.getSafetyInteger(row.get("use_script_filter"));
+
+            // 备份表名
+            mapper.setCutToTableName(this.getSafetyString(row.get("cut_to_table_name")));
+
+            dataMappers.add(mapper);
+        }
+
+        return dataMappers;
+    }
+
+    public void updateWmsInterfaceDataMapperLastSyncTimeById(Long id) throws SQLException {
+        StringBuffer sql = new StringBuffer("update mes_interface_data_mapper");
+        sql.append(" set last_sync_time='" + TimeTool.getNowTime(true) + "'");
+        sql.append(" where id=" + id);
+        mesDataSourceProxy.execute(sql.toString());
+    }
+
+    /**
+     * 更新接口的下次执行时间
+     * @param mapper
+     * @throws SQLException
+     */
+    public void updateNextSyncTime(MesInterfaceDataMapper mapper) throws SQLException {
+        if (mapper != null && StringUtils.isNotEmpty(mapper.getSyncCron())
+                && StringUtils.isNotEmpty(mapper.getNextSyncTime())) {
+            // 计算下次执行时间
+            String nextSyncTime = CronUtil.getRecentTriggerTime(mapper.getSyncCron());
+            String sqlString = String.format("update mes_interface_data_mapper set next_sync_time='%s' where id=%s",
+                    nextSyncTime, mapper.getId());
+            mesDataSourceProxy.execute(sqlString);
+            LOGGER.debug("接口ID {} 名称 {} 下次执行时间更新为 {}", mapper.getId(), mapper.getInterfaceName(), nextSyncTime);
+        }
+    }
+
+    /**
+     * 重写判断对象相等的方法
+     * @param obj
+     * @return
+     */
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    /**
+     * 重写 hashCode 方法
+     * @return
+     */
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbConstWords.java

@@ -0,0 +1,21 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+/**
+ * @Description : 脚本引擎中可以实现的方法
+ * @Reference :
+ * @Author : rock.yu
+ * @CreateDate : 2019-10-14 19:14
+ * @Modify:
+ * 1.
+ **/
+public class WmsSAPDbConstWords {
+
+    // 脚本读取数据的方法名，入参：WmsInterfaceDataMapper 返回值： List<Map<String, Object>>
+    public static final String SCRIPT_PULL_FUN_NAME = "readData";
+    // 脚本写入目标数据的方法名，入参：WmsInterfaceDataMapper，List<Map<String, Object>> 返回值：void
+    public static final String SCRIPT_PUSH_FUN_NAME = "saveDestData";
+    // 脚本更新来源数据标志的方法名，入参：WmsInterfaceDataMapper，List<Map<String, Object>> 返回值：void
+    public static final String SCRIPT_MARK_FUN_NAME = "saveSrcData";
+    // 脚本过滤来源数据的方法名，入参： List<Map<String, Object>> 返回值：List<Map<String, Object>>
+    public static final String SCRIPT_FILTER_FUN_NAME = "filterData";
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbExpression.java

@@ -0,0 +1,121 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.mes.apiservice.serviceimpl.engine.script.EngineScriptManager;
+import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.expression.ExpressionParser;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
+import org.springframework.expression.spel.support.StandardEvaluationContext;
+import org.springframework.stereotype.Component;
+
+import java.sql.Connection;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 16:08
+ * @Modify:
+ **/
+@Component
+public class WmsSAPDbExpression {
+    /**
+     * 获取系统相关的 ID
+     */
+    @Autowired
+    private WmsSAPDbID wmsSAPDbID;
+
+    /**
+     * 脚本引擎
+     */
+    @Autowired
+    private EngineScriptManager engineScriptManager;
+
+    @Getter
+    @Setter
+    private Connection srcConn;
+
+    WmsSAPDbQuery wmsSAPDbQuery = null;
+
+    // 更新时不处理的特殊标志
+    public static final String NOT_TRANS = "NotTrans";
+
+    /**
+     * 执行表达式计算
+     * @param expString 表达式
+     * @param varMap 临时变量
+     * @throws Exception
+     */
+    public Object parse(String expString, Map<String, Object> varMap) {
+        ExpressionParser parser = new SpelExpressionParser();
+
+        StandardEvaluationContext ctx = new StandardEvaluationContext();
+
+        // 先设置基础变量
+        ctx.setVariables(getConstVarMap());
+
+        // 再设置临时变量
+        if (varMap != null) {
+            ctx.setVariables(varMap);
+        }
+
+        return parser.parseExpression(expString).getValue(ctx);
+    }
+
+    /**
+     * 执行表达式计算，不带变量
+     * @param expString
+     * @return
+     * @throws Exception
+     */
+    public Object parse(String expString) {
+        return parse(expString, null);
+    }
+
+    /**
+     * 初始化基础变量
+     */
+    public Map<String, Object> getConstVarMap() {
+        if (wmsSAPDbQuery == null) {
+            wmsSAPDbQuery = new WmsSAPDbQuery();
+            // 初始化查询对象
+            wmsSAPDbQuery.setSrcConn(srcConn);
+            // new 的对象需要手工注入 bean
+            if (SpringContextsUtil.getApplicationContext() != null) {
+                SpringContextsUtil.getApplicationContext().
+                        getAutowireCapableBeanFactory().autowireBean(wmsSAPDbQuery);
+            }
+        }
+
+        Map<String, Object> constVarMap = new HashMap<>();
+
+        constVarMap.put("date", getFormatDate("yyyy-MM-dd"));
+        constVarMap.put("time", getFormatDate("HH:mm:ss"));
+        constVarMap.put("sap_date", getFormatDate("yyyyMMdd"));
+        constVarMap.put("sap_time", getFormatDate("HHmmss"));
+        constVarMap.put("now", getFormatDate("yyyy-MM-dd HH:mm:ss"));
+        constVarMap.put("Q", wmsSAPDbQuery);
+        constVarMap.put("ID", wmsSAPDbID);
+        constVarMap.put("I", wmsSAPDbID);
+        constVarMap.put("S", engineScriptManager);
+
+        return constVarMap;
+    }
+
+    /**
+     * 获取格式化后的日期字符串
+     * @param format
+     * @return
+     */
+    public static String getFormatDate(String format) {
+        DateFormat df = new SimpleDateFormat(format);
+        return df.format(new Date());
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbID.java

@@ -0,0 +1,39 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.pojo.base.codemaker.SnowflakeIdMaker;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.UUID;
+
+/**
+ * @Description :用于生成系统 ID、GUID
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 16:08
+ * @Modify:
+ **/
+@Component
+public class WmsSAPDbID {
+
+    // 获取 IMPP ID
+    @Autowired
+    private SnowflakeIdMaker snowflakeIdMaker;
+
+
+    /**
+     * 获取系统 ID，线程安全
+     * @return
+     */
+    public synchronized long nextId() {
+        return snowflakeIdMaker.nextId();
+    }
+
+    /**
+     * 获取 GUID（Globals Unique Identifiers）
+     * @return
+     */
+    public synchronized String guid() {
+        return UUID.randomUUID().toString();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbQuery.java

@@ -0,0 +1,105 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.platform.common.tool.TimeTool;
+import cn.estsh.i3plus.platform.plugin.datasource.DynamicDataSourceProxy;
+import cn.estsh.i3plus.pojo.base.codemaker.SnowflakeIdMaker;
+import cn.estsh.impp.framework.boot.util.LocaleUtils;
+import lombok.Getter;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.sql.Connection;
+
+/**
+ * @Description :
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 16:08
+ * @Modify:
+ **/
+@Component
+public class WmsSAPDbQuery {
+    public static final Logger LOGGER = LoggerFactory.getLogger(WmsSAPDbQuery.class);
+    public static boolean needI18N = true;
+//    @Resource(name = "wmsDataSource")
+//    private DynamicDataSourceProxy wmsDataSourceProxy;
+
+    @Resource(name = "mesDataSource")
+    private DynamicDataSourceProxy mesDataSourceProxy;
+
+    @Autowired
+    private SnowflakeIdMaker snowflakeIdMaker;
+
+
+    @Getter
+    @Setter
+    private  MesSAPDbDataMapper mesSAPDbDataMapper;
+
+    @Getter
+    @Setter
+    private Connection srcConn;
+
+    /**
+     * 根据单据类型获取单据存放的表名
+     *
+     * @param orderType 单据类型
+     * @return 单据的表名
+     */
+    private String getOrderTypeTable(String orderType,String organizeCode) {
+        String sqlTableName = "";
+
+        switch (orderType.trim().toUpperCase()) {
+            case "ASN":
+                sqlTableName = "wms_doc_asn_details_"+organizeCode;
+                break;
+            case "PO":
+                sqlTableName = "wms_doc_po_details";
+                break;
+            case "MOVE":
+                sqlTableName = "wms_doc_movement_details_"+organizeCode;
+                break;
+            case "CS":
+                sqlTableName = "wms_doc_cs_details_"+organizeCode;
+                break;
+            default:
+                break;
+        }
+
+        if (StringUtils.isEmpty(sqlTableName)) {
+            throw new RuntimeException("单据类型必须是 ASN/PO/MOVE/CS 中的一种！");
+        }
+
+        return sqlTableName;
+    }
+
+    /**
+     * 将字符串转换成指定的格式（需要指定源字符串的格式）
+     *
+     * @param value      要转换的字符串
+     * @param srcFormat  原始格式
+     * @param destFormat 目标格式
+     * @return
+     * @throws Exception
+     */
+    public String strFormat(String value, String srcFormat, String destFormat) throws Exception {
+        return TimeTool.parseStringFormat(value, srcFormat, destFormat);
+    }
+   /**
+     * 翻译带参数的字符串
+     *
+     * @param msg  字符串
+     * @param args String.format 参数
+     * @return 翻译后的字符串
+     */
+    public static String lz(String msg, Object... args) {
+        if (!needI18N) {
+            return String.format(msg, args);
+        }
+        return String.format(LocaleUtils.getLocaleRes(msg), args);
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbReader.java

@@ -0,0 +1,256 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.mes.apiservice.serviceimpl.engine.script.EngineScriptManager;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataTable;
+import cn.estsh.i3plus.platform.plugin.datasource.DynamicDataSourceProxy;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceDataMapper;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.sql.Connection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description : 接口数据读取
+ * 按照配置规则调用 DAO 层读取数据
+ * @Reference :
+ * @Author : rock.yu
+ * @CreateDate : 2019-06-11 19:34
+ * @Modify: 1. 2019-10-14 19:13 增加了调用脚本引擎处理数据的逻辑
+ * 1.
+ **/
+@Component
+@NoArgsConstructor
+public class WmsSAPDbReader extends WmsSAPDbSyncBase {
+    public static final Logger LOGGER = LoggerFactory.getLogger(WmsSAPDbReader.class);
+
+    // 动态数据源，靠外部调用类传入此对象
+    private DynamicDataSourceProxy dataSourceProxy;
+
+    // 数据库读写用的数据源
+    @Getter
+    @Setter
+    private Connection srcConn;
+
+    /**
+     * 使用脚本过滤之前的原始数据集要保留下来，有肯能用这个数据集回写同步标识
+     */
+    @Getter
+    private List<Map<String, Object>> originReadData = null;
+
+    // 脚本引擎
+    @Autowired
+    private EngineScriptManager engineScriptManager;
+
+    public WmsSAPDbReader(DynamicDataSourceProxy dataSourceProxy) {
+        this.dataSourceProxy = dataSourceProxy;
+    }
+
+    public WmsSAPDbReader(MesInterfaceDataMapper dataMapper) {
+        super(dataMapper);
+    }
+
+    /**
+     * 读取数据
+     * @return 读取到的接口表数据
+     * @throws Exception 接口映射关系不存在时抛出异常
+     */
+    public List<Map<String, Object>> readData() throws Exception {
+        List<Map<String, Object>> resultList;
+
+        this.originReadData = null;
+        if (this.dataMapper == null) {
+            throw new IllegalArgumentException("not set data mapper!");
+        }
+
+        // 配置了使用脚本引擎获取数据
+        if (this.dataMapper.getUseScriptPull() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+            resultList = getDataByScript();
+        } else {
+            resultList = getDataBySQL();
+        }
+
+        // 配置了使用脚本引擎过滤来源数据
+        if (this.dataMapper.getUseScriptFilter() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+            // 保留原始数据集
+            this.originReadData = resultList;
+            resultList = getDataByFilter(resultList);
+        }
+
+        return resultList;
+    }
+
+    /**
+     * 执行 SQL 语句获取原始数据
+     * @return 原始数据
+     * @throws Exception 数据库异常
+     */
+    private List<Map<String, Object>> getDataBySQL() throws Exception {
+        // 构建查询语句
+        String sqlString = buildQuerySQL(isMSSQL());
+        LOGGER.info("WmsSAPDbReader.getDataBySQL:{}", sqlString);
+        return dataSourceProxy.queryMapList(sqlString, srcConn);
+    }
+
+    /**
+     * 根据映射表的配置参数构建查询数据的 SQL 语句
+     * @param isMSSql 是否 MSSQL 数据库，目前只支持了 MSSQL 和 MYSQL 的判断
+     * @return 查询 SQL
+     */
+    public String buildQuerySQL(boolean isMSSql) {
+        String sqlString;
+
+        if (isMSSql) {
+            if (StringUtils.isEmpty(this.dataMapper.getSrcGroupColumns())) {
+                sqlString = "select top " + this.dataMapper.getSrcGetLimit()
+                        + " * from " + this.dataMapper.getSrcTableName() + " model "
+                        + " where " + this.dataMapper.getSrcWhere()
+                        + " order by " + this.dataMapper.getSrcOrderBy();
+            } else {
+                sqlString = "select * from " + this.dataMapper.getSrcTableName() + " model "
+                        + " where " + this.dataMapper.getSrcWhere()
+                        + " and " + this.dataMapper.getSrcGroupColumns() + " in ( "
+                        + " select top " + this.dataMapper.getSrcGetLimit() + " "
+                        + this.dataMapper.getSrcGroupColumns()
+                        + " from " + this.dataMapper.getSrcTableName()
+                        + " where " + this.dataMapper.getSrcWhere()
+                        + " group by " + this.dataMapper.getSrcGroupColumns()
+                        + " )" + " order by " + this.dataMapper.getSrcOrderBy();
+            }
+        } else {
+            if (StringUtils.isEmpty(this.dataMapper.getSrcGroupColumns())) {
+                sqlString = "select * from " + this.dataMapper.getSrcTableName() + " model "
+                        + " where " + this.dataMapper.getSrcWhere()
+                        + " order by " + this.dataMapper.getSrcOrderBy()
+                        + " limit " + this.dataMapper.getSrcGetLimit();
+            } else {
+                sqlString = "select * from " + this.dataMapper.getSrcTableName()
+                        + " where " + this.dataMapper.getSrcWhere()
+                        + " and " + this.dataMapper.getSrcGroupColumns() + " in ( "
+                        + " select * from ( "
+                        + " select " + this.dataMapper.getSrcGroupColumns()
+                        + " from " + this.dataMapper.getSrcTableName() + " model "
+                        + " where " + this.dataMapper.getSrcWhere()
+                        + " group by " + this.dataMapper.getSrcGroupColumns()
+                        + " order by " + this.dataMapper.getSrcOrderBy() + " limit "
+                        + this.dataMapper.getSrcGetLimit() + " ) as ds ) order by "+ this.dataMapper.getSrcOrderBy();
+            }
+        }
+
+        return sqlString;
+    }
+
+    /**
+     * 执行脚本获取原始数据
+     * @return 原始数据
+     * @throws Exception 脚本异常
+     */
+    private List<Map<String, Object>> getDataByScript() throws Exception {
+        String scriptNo = this.dataMapper.getScriptNo();
+        Object returnObj;
+
+        // 如果脚本编号配置的是 groovy 文件，就直接调用文件，便于运行中打断点调试
+        if (scriptNo.indexOf(".groovy") > 0) {
+            returnObj = engineScriptManager.invokeGroovyScript(
+                    scriptNo,
+                    WmsSAPDbConstWords.SCRIPT_PULL_FUN_NAME,
+                    this.dataMapper);
+        } else {
+            returnObj = engineScriptManager.invokeFuncation(
+                    this.dataMapper.getOrganizeCode(),
+                    scriptNo,
+                    WmsSAPDbConstWords.SCRIPT_PULL_FUN_NAME,
+                    this.dataMapper);
+        }
+
+        if (!(returnObj instanceof List)) {
+            throw new RuntimeException("Script pull data result object type error !");
+        }
+
+        return (List<Map<String, Object>>)returnObj;
+    }
+
+    /**
+     * 执行脚本过滤原始数据
+     * @param srcData 原始数据
+     * @return 过滤后的原始数据
+     * @throws Exception 脚本异常
+     */
+    private List<Map<String, Object>> getDataByFilter(List<Map<String, Object>> srcData) throws Exception {
+        String scriptNo = this.dataMapper.getScriptNo();
+        Object returnObj;
+
+        // 如果脚本编号配置的是 groovy 文件，就直接调用文件，便于运行中打断点调试
+        if (scriptNo.indexOf(".groovy") > 0) {
+            returnObj = engineScriptManager.invokeGroovyScript(
+                    scriptNo,
+                    WmsSAPDbConstWords.SCRIPT_FILTER_FUN_NAME,
+                    this.dataMapper, srcData);
+        } else {
+            returnObj = engineScriptManager.invokeFuncation(
+                    this.dataMapper.getOrganizeCode(),
+                    this.dataMapper.getScriptNo(),
+                    WmsSAPDbConstWords.SCRIPT_FILTER_FUN_NAME,
+                    this.dataMapper, srcData);
+        }
+
+        if (!(returnObj instanceof List)) {
+            throw new RuntimeException("Script filter data result object type error !");
+        }
+
+        return (List<Map<String, Object>>)returnObj;
+    }
+
+    /**
+     * 判断数据库是不是 MSSQL
+     * @return
+     * @throws Exception
+     */
+    private boolean isMSSQL() throws Exception {
+        return srcConn
+                .getMetaData().getURL().contains("sqlserver");
+    }
+
+    /**
+     * 读取数据（DataTable 格式）
+     * @return
+     */
+    public DataTable readDataTable() {
+        DataTable dataTable = null;
+
+        try {
+            dataTable = new DataTable(this.dataMapper.getSrcTableName(), this.readData());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return dataTable;
+    }
+
+    /**
+     * 重写判断对象相等的方法
+     * @param obj
+     * @return
+     */
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    /**
+     * 重写 hashCode 方法
+     * @return
+     */
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbSyncBase.java

@@ -0,0 +1,246 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceDataMapper;
+import cn.estsh.i3plus.pojo.wms.dbinterface.MappingItem;
+import cn.estsh.i3plus.pojo.wms.dbinterface.UpdateSyncItem;
+import com.alibaba.fastjson.JSONObject;
+import lombok.Data;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+
+/**
+ * @Description : 接口数据同步基类
+ * @Reference :
+ * @Author : rock.yu
+ * @CreateDate : 2019-06-11 19:34
+ * @Modify:
+ * 1.
+ **/
+@Data
+@Component
+public class WmsSAPDbSyncBase {
+
+    /**
+     * 数据映射对象，对应接口库的一张表
+     */
+    protected MesInterfaceDataMapper dataMapper;
+    /**
+     * 源表的排序字段
+     */
+    protected List<String> scrOrderBy;
+    /**
+     * 源表的查询条件
+     */
+    protected List<String> srcWhere;
+    /**
+     * 源表同步成功后需要更新的字段以及值（用表达式替换变量值）
+     */
+    protected List<UpdateSyncItem> srcUpdateSync;
+    /**
+     * 源表的主键
+     */
+    protected List<String> srcPkColumn;
+    /**
+     * 如果此属性不为空，则把源记录复制多份到每个组织下面
+     */
+    protected List<String> copyByOrg;
+    /**
+     * 目标对象的名称（或者表名）
+     */
+    protected List<String> destBeanName;
+    /**
+     * 目标表的业务主键，用于判断记录是否存在
+     */
+    protected List<String> destPkProperty;
+    /**
+     * 源表与目标表的字段映射关系，当源表中不存在此字段时用配置的默认值写入到目标表
+     */
+    protected List<MappingItem> mappingItem;
+
+    public WmsSAPDbSyncBase() { }
+
+    public WmsSAPDbSyncBase(MesInterfaceDataMapper dataMapper) {
+        setDataMapper(dataMapper);
+    }
+
+    public void setDataMapper(MesInterfaceDataMapper dataMapper) {
+        this.dataMapper = dataMapper;
+
+        this.setScrOrderBy(getSplitArray(dataMapper.srcOrderBy));
+        this.setSrcWhere(getSplitArray(dataMapper.srcWhere));
+        this.setSrcUpdateSync(getJSONItems(dataMapper.srcUpdateSync, UpdateSyncItem.class));
+        this.setSrcPkColumn(getSplitArray(dataMapper.srcPkColumns));
+        this.setCopyByOrg(getSplitArray(dataMapper.copyByOrgs));
+        this.setDestPkProperty(getSplitArray(dataMapper.destPkProperties));
+        this.setMappingItem(sortedMappingItem(getJSONItems(dataMapper.destColumnMapping, MappingItem.class)));
+        if (this.getMappingItem() == null) {
+            this.setMappingItem(new ArrayList<>());
+        }
+        // 依赖于 this.mappingItem 的值，赋值顺序不能变
+        this.setDestBeanName(this.getDistinctDestBeanName());
+    }
+
+
+    /**
+     * 根据目标表的名称获取主键列表
+     * @param beanName 目标表的名称
+     * @return 主键列表
+     */
+    public List<String> getDestPkByBeanName(String beanName) {
+        List<String> pkList = new ArrayList<>();
+
+        for (MappingItem item : this.getMappingItem()) {
+            if (item.getDestBeanName().equals(beanName) && isPk(item)) {
+                pkList.add(item.getDestName());
+            }
+        }
+
+        return pkList;
+    }
+
+    /**
+     * 判断该字段是不是主键
+     * @param item 自对对照关系
+     * @return 是否主键
+     */
+    private Boolean isPk(MappingItem item) {
+        return item.getDestPk() != null && item.getDestPk() == 1;
+    }
+
+    /**
+     * 从字段映射关系中获取所有的目标表名
+     * @return
+     */
+    private List<String> getDistinctDestBeanName() {
+        Map<String, String> beanNamesMap = new HashMap<>();
+
+        for (MappingItem item : this.getMappingItem()) {
+            if (!beanNamesMap.containsKey(item.getDestBeanName())) {
+                beanNamesMap.put(item.getDestBeanName(), null);
+            }
+        }
+
+        return new ArrayList<String>(beanNamesMap.keySet());
+    }
+
+    /**
+     * 把半角逗号分隔的字符串转换成字符串列表
+     * @param text 半角逗号分隔的字符串
+     * @return 分割后的字符串数组
+     */
+    private List<String> getSplitArray(String text) {
+        if (text == null || text.isEmpty()) {
+            return null;
+        }
+
+        String[] items = text.split(",");
+
+        return Arrays.asList(items);
+    }
+
+    /**
+     * 获取字段映射列表
+     * @param jsonString JSON 字符串
+     * @return 字段映射列表
+     */
+    public <T> List<T> getJSONItems(String jsonString, Class<T> objClass) {
+        if (jsonString == null || jsonString.isEmpty()) {
+            return null;
+        }
+
+        return JSONObject.parseArray(jsonString, objClass);
+    }
+
+    /**
+     * 根据 seq 对 MappingItem 列表进行排序
+     * @param mappingItems 字段映射关系集合
+     * @return 排序后的字段映射关系集合
+     */
+    public List<MappingItem> sortedMappingItem(List<MappingItem> mappingItems) {
+        if (mappingItems == null) {
+            return null;
+        }
+
+        if (mappingItems.size() <= 1) {
+            return mappingItems;
+        }
+
+        Collections.sort(mappingItems);
+
+        return mappingItems;
+    }
+
+    /**
+     * 安全获取整数值
+     * @param obj
+     * @return
+     */
+    public Integer getSafetyInteger(Object obj) {
+        if (obj == null) {
+            return 0;
+        }
+
+        return Integer.valueOf(String.valueOf(obj));
+    }
+
+    /**
+     * 安全获取整数值
+     *
+     * @param obj
+     * @return
+     */
+    public Long getSafetyLong(Object obj) {
+        if (obj == null) {
+            return 0L;
+        }
+
+        return Long.valueOf(String.valueOf(obj));
+    }
+    /**
+     * 安全获取字符串值
+     * @param obj
+     * @return
+     */
+    public String getSafetyString(Object obj) {
+        if (obj == null) {
+            return "";
+        }
+
+        return String.valueOf(obj);
+    }
+
+    /**
+     * 重写判断对象相等的方法
+     * 用 JSON 字符串比较可能会性能比较低，逐个字段判断又太繁琐
+     * @param obj
+     * @return
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+
+        if (obj instanceof WmsSAPDbSyncBase) {
+            WmsSAPDbSyncBase newObj = (WmsSAPDbSyncBase)obj;
+
+            if (JSONObject.toJSONString(this).
+                    equals(JSONObject.toJSONString(newObj))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * 重写 hashCode 方法，实际上这个对象不会作为 key 放到 Hash 中
+     * 用 JSON 字符串比较可能会性能比较低，逐个字段判断又太繁琐
+     * @return
+     */
+    @Override
+    public int hashCode() {
+        return JSONObject.toJSONString(this).hashCode();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbTranslator.java

@@ -0,0 +1,246 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataRow;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataSet;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataTable;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataTypes;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceDataMapper;
+import cn.estsh.i3plus.pojo.wms.dbinterface.MappingItem;
+import com.alibaba.fastjson.JSONObject;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description : 接口数据转换
+ * 按照配置规则把读取的接口数据转换成业务数据
+ * @Reference :
+ * @Author : rock.yu
+ * @CreateDate : 2019-06-11 19:34
+ * @Modify:
+ * 1.
+ **/
+@Component
+public class WmsSAPDbTranslator extends WmsSAPDbSyncBase {
+
+
+    @Getter
+    @Setter
+    private WmsSAPDbExpression wmsSAPDbExpression;
+
+    public WmsSAPDbTranslator() { }
+
+    public WmsSAPDbTranslator(WmsSAPDbExpression wmsSAPDbExpression) {
+        this.wmsSAPDbExpression = wmsSAPDbExpression;
+    }
+
+    public WmsSAPDbTranslator(MesInterfaceDataMapper dataMapper) {
+        super(dataMapper);
+    }
+
+    /**
+     * 把原始数据表按照字段对应关系转换成目标数据集（存在一对多的关系）
+     * @param originData
+     * @return
+     * @throws Exception
+     */
+    public DataSet translateData(List<Map<String, Object>> originData) throws Exception {
+        if (this.dataMapper == null) {
+            throw new IllegalArgumentException("not set data mapper!");
+        }
+
+        // 原始数据表
+        DataTable originTable = new DataTable(this.dataMapper.srcTableName, originData);
+
+        // 构建目标数据集
+        DataSet destDataSet = buildDestDataSet(this.getDestBeanName(), this.getMappingItem());
+
+        for(DataRow row : originTable.getRows()) {
+            // 拆分数据行
+            Map<String, DataRow> destRowsMap = splitDataRow(destDataSet, row);
+
+            // 把拆分好的数据行放到目标数据表中
+            for(DataTable table : destDataSet.getDataTables()) {
+                if (destRowsMap.containsKey(table.getTableName())) {
+                    table.addRow(destRowsMap.get(table.getTableName()));
+                }
+            }
+        }
+
+        return destDataSet;
+    }
+
+    /**
+     * 把原始数据行拆分成目标数据行，存在一对多的情况
+     * @param dataSet
+     * @param originRow
+     * @return
+     * @throws Exception
+     */
+    private Map<String, DataRow> splitDataRow(DataSet dataSet, DataRow originRow) throws Exception {
+        // 最终返回的 Map
+        Map<String, DataRow> rowsMap = new HashMap<>();
+
+        // 构建临时数据行对象
+        for (DataTable table : dataSet.getDataTables()) {
+            rowsMap.put(table.getTableName(), table.newRow());
+        }
+
+        // 遍历字段映射列表
+        for (MappingItem item : this.getMappingItem()) {
+            // 原始表中有这个字段
+            if (originRow.getColumns().contains(item.getSrcName())) {
+                // 把来源数据行的值放到对应的目标数据行中
+                rowsMap.get(item.getDestBeanName()).
+                        setValue(item.getDestName(), originRow.getValue(item.getSrcName()));
+            } else {
+                // 原始表中没有这个字段，用预设的默认值填充此字段
+                rowsMap.get(item.getDestBeanName()).
+                        setValue(item.getDestName(), item.getDefaultValue());
+            }
+        }
+
+        // 遍历第二遍，进行默认值的表达式计算，此时所有属性都已赋值，在配置字段映射关系就可以不用管属性的配置顺序
+        // 如果强制要求配置字段映射关系时把有表达式的属性放在后面，也可以不用再循环一遍，直接在上面的循环解析即可
+        for (MappingItem item : this.getMappingItem()) {
+            if (item.getDefaultValue() != null // 不是空对象
+                    && (item.getDefaultValue() instanceof String) // 字符串类型
+                    && !item.getDefaultValue().toString().isEmpty() // 字符串不为空
+                    && item.getDefaultValue().toString().indexOf("#") > -1) { // 包含表达式
+
+
+                // 取出当前字段的值
+                //Object valueObj = rowsMap.get(item.getDestBeanName()).getValue(item.getDestName());
+                // 把当前行的数据（原始数据行和目标数据行都参与计算）和表达式进行计算
+                Object valueObj = parseDefaultValue(
+                        combineRowMap(originRow.getItemMap(), rowsMap.get(item.getDestBeanName()).getItemMap()),
+                        item.getDefaultValue());
+                // 把计算后的值设置回数据行中
+                rowsMap.get(item.getDestBeanName()).setValue(item.getDestName(), valueObj);
+            }
+        }
+
+        return rowsMap;
+    }
+
+    /**
+     * 合并来源表的所有字段和目标表的所有字段
+     * 为了防止字段重复，来源表的字段名统一加上 _o 后缀(暂时不加后缀，因为两套系统的字段编码格式很少相同)
+     * @param originMap 来源表的字段
+     * @param destMap 目标表的字段
+     * @return 合并后的 Map
+     */
+    private Map<String, Object> combineRowMap(Map<String, Object> originMap, Map<String, Object> destMap) {
+        Map<String, Object> combineMap = new HashMap<>();
+
+//        if (originMap != null && originMap.size() > 0) {
+//            for(Map.Entry<String, Object> entry : originMap.entrySet()) {
+//                // 来源表的字段名加上 _o 后缀，防止跟目标表的字段重名
+//                combineMap.put(entry.getKey() + "_o", entry.getValue());
+//            }
+//        }
+
+        if (originMap != null && originMap.size() > 0) {
+            combineMap.putAll(originMap);
+        }
+
+        if (destMap != null && destMap.size() > 0) {
+            combineMap.putAll(destMap);
+        }
+
+        return combineMap;
+    }
+
+    /**
+     * 构建目标数据集（可能存在一张原始表对应多张目标表）
+     * @param destBeanNames
+     * @param mappingItems
+     * @return
+     * @throws Exception
+     */
+    private DataSet buildDestDataSet(List<String> destBeanNames, List<MappingItem> mappingItems) throws Exception {
+        // 目标数据集
+        DataSet destDataSet = new DataSet();
+
+        // 构建目标表
+        for(String tableName : destBeanNames) {
+            DataTable table = new DataTable(tableName);
+
+            // 构建目标表的结构
+            for(MappingItem item : mappingItems) {
+                // 当前字段属于这张表，并且目标字段不为空
+                if (item.getDestBeanName().equals(tableName) && item.destName != null && !item.destName.isEmpty()) {
+                    // 加入字段
+                    // 此处暂不进行表达式计算
+                    table.addColumn(item.getDestName(), DataTypes.getDataType(item.getDefaultValue()));
+                }
+            }
+
+            // 把数据表加入数据集
+            destDataSet.add(table);
+        }
+
+        return destDataSet;
+    }
+
+    /**
+     * 根据表达式计算默认值
+     * @param rowMap 当前行的数据 Map
+     * @param defaultValue 原始默认值（可能包含表达式）
+     * @return 计算后的默认值
+     */
+    private Object parseDefaultValue(Map<String, Object> rowMap, Object defaultValue) throws Exception {
+        if (defaultValue == null) {
+            return null;
+        }
+
+        // 不是字符串类型，直接返回
+        if (!(defaultValue instanceof String)) {
+            return defaultValue;
+        }
+
+        // 没有包含表达式，直接返回
+        if (defaultValue.toString().indexOf("#") == -1) {
+            return defaultValue;
+        }
+
+        Object objResult;
+
+        try {
+            objResult = wmsSAPDbExpression.parse(defaultValue.toString(), rowMap);
+        } catch (Exception e) {
+            e.printStackTrace();
+
+            throw new IllegalArgumentException("表达式计算异常，请检查表达式语法是否正确！ exp: "
+                    + defaultValue.toString() + " Exception: "
+                    + e.getMessage() + " rowMap:"
+                    + JSONObject.toJSONString(rowMap));
+        }
+
+        // 计算后返回
+        return objResult;
+    }
+
+    /**
+     * 重写判断对象相等的方法
+     * @param obj
+     * @return
+     */
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    /**
+     * 重写 hashCode 方法
+     * @return
+     */
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbUtil.java

@@ -0,0 +1,313 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.icloud.softswitch.sdk.IBsSuitServiceCloud;
+import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum;
+import cn.estsh.i3plus.pojo.base.bean.BaseResultBean;
+import cn.estsh.i3plus.pojo.base.enumutil.BlockSoftSwitchEnumUtil;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.i3plus.pojo.softswitch.bean.BsSuitCase;
+import cn.estsh.i3plus.pojo.softswitch.bean.BsSuitCaseParam;
+import cn.estsh.i3plus.pojo.softswitch.bean.BsSuitDataDetail;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+import cn.estsh.impp.framework.boot.util.ResultBean;
+import lombok.NoArgsConstructor;
+import org.dom4j.Document;
+import org.dom4j.DocumentHelper;
+import org.dom4j.Element;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+
+@Component
+@NoArgsConstructor
+public class WmsSAPDbUtil {
+    private static final Logger LOGGER = LoggerFactory.getLogger(WmsSAPDbUtil.class);
+
+    // 软适配微服调用代理对象
+    @Autowired
+    IBsSuitServiceCloud bsSuitServiceCloud;
+
+
+    /**
+     * 从 XML 格式的报文中抽取数据
+     * @param xmlString XML 报文
+     * @param tableList XML 报文中的数据对象结构，要按从大到小排序
+     * @return 抽取到的数据，扁平化的 List<Map<String, Object>> 格式
+     * @throws Exception XML 解析异常
+     */
+    public List<Map<String, Object>> convertXmlToList(String xmlString, List<String> tableList)
+            throws Exception {
+        Document document = DocumentHelper.parseText(xmlString);
+        Element rootElement = document.getRootElement();
+        List<Element> elements = rootElement.selectNodes("//*");
+
+        List<Map<String, Object>> rows = new ArrayList<>();
+
+        for (Element element : elements) {
+            if (tableList.get(0).equals(element.getName())) {
+                Map<String, Object> row = new HashMap<>();
+                parseElement(element, row, rows, tableList);
+            }
+        }
+
+        return rows;
+    }
+
+    /**
+     * 从 XML 格式的报文中抽取数据
+     * @param xmlString XML 报文
+     * @param tables 数据结构的层级，用半角逗号分隔
+     * @return 抽取到的数据，扁平化的 List<Map<String, Object>> 格式
+     * @throws Exception XML 解析异常
+     */
+    public List<Map<String, Object>> convertXmlToList(String xmlString, String tables)
+            throws Exception {
+        List<String> tableList = this.getListByString(tables);
+
+        if (tableList == null || tableList.size() == 0) {
+            return null;
+        }
+
+        return convertXmlToList(xmlString, tableList);
+    }
+
+    /**
+     * 把 List<Map<String, Object> 格式的数据转换成 XML 字符串
+     * @param listData 原始数据
+     * @param rootNodeName 根节点名称
+     * @param nodeName 叶子节点名称
+     * @param rootClassName 根节点的类名
+     * @param nodeClassName 叶子节点的类名
+     * @return XML 字符串
+     */
+    public String convertListToXml(List<Map<String, Object>> listData, String rootNodeName, String nodeName,
+                                   String rootClassName, String nodeClassName) {
+        if (listData == null || listData.size() == 0) {
+            throw new RuntimeException("listData is null ! ");
+        }
+
+        StringBuilder sb = new StringBuilder();
+
+        if (rootNodeName != null && !rootNodeName.isEmpty()) {
+            sb.append(String.format("<%s class=\"%s\">\n", rootNodeName, rootClassName));
+        }
+
+        for(Map<String, Object> row : listData) {
+            sb.append(String.format("<%s class=\"%s\">\n", nodeName, nodeClassName));
+
+            for (Map.Entry<String, Object> entry : row.entrySet()) {
+                sb.append(String.format("<%s>%s</%s>\n", entry.getKey(), entry.getValue(), entry.getKey()));
+            }
+
+            sb.append(String.format("</%s>\n", nodeName));
+        }
+
+        if (rootNodeName != null && !rootNodeName.isEmpty()) {
+            sb.append(String.format("</%s>\n", rootNodeName));
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * 把报文的 ID 加入到数据集中（增加一列 SID）
+     * @param listData 原始数据集
+     * @param sid 报文 ID
+     */
+    public void packSID(List<Map<String, Object>> listData, Long sid) {
+        if (listData == null || listData.size() == 0) {
+            return;
+        }
+
+        for (Map<String, Object> row : listData) {
+            row.put("SID", sid);
+        }
+    }
+
+    /**
+     * 把半角逗号分隔的字符串转成 List<String> 格式
+     * @param strList 半角逗号分隔的字符串
+     * @return List<String>
+     */
+    public List<String> getListByString(String strList) {
+        if (strList == null || strList.isEmpty()) {
+            return null;
+        }
+
+        String[] arrList = strList.split(",");
+
+        return Arrays.asList(arrList);
+    }
+
+    /**
+     * 递归函数，用户解析 XML 报文并抽取数据
+     * @param element XML 元素
+     * @param row 当前数据行
+     * @param rows 数据行列表
+     * @param tableList 数据对象的结构
+     */
+    private void parseElement(Element element, Map<String, Object> row,
+                              List<Map<String, Object>> rows, List<String> tableList) {
+
+        List<Element> childElements = element.elements();
+
+        if (childElements != null) {
+            // 先遍历没有子节点的属性，因为有属性值在子节点之后，所以必须先遍历一遍
+            for (Element eleData : childElements) {
+                if (eleData.elements() == null || eleData.elements().size() == 0) {
+                    row.put(element.getName() + "_" + eleData.getName(), eleData.getStringValue().trim());
+                }
+            }
+
+            // 再遍历包含子节点的属性
+            for (Element ele : childElements) {
+                if (tableList.contains(ele.getName()) || ele.getName().startsWith("List")) {
+                    parseElement(ele, row, rows, tableList);
+                }
+            }
+
+            // 末尾元素，开始新增行
+            if (element.getName().equals(tableList.get(tableList.size() - 1))) {
+                HashMap<String, Object> newRow = new HashMap<>();
+                newRow.putAll(row);
+                rows.add(newRow);
+            }
+        }
+    }
+
+    /**
+     * 从软适配中按照适配编号获取报文（微服务调用）
+     * @param suitCaseCode 适配编号
+     * @param packageCount 获取报文的数量
+     * @return 报文对象
+     */
+    public ResultBean readSoftSwitchPackage(String suitCaseCode, Integer packageCount) {
+        BaseResultBean<BsSuitDataDetail> resultBean =
+                bsSuitServiceCloud.findLastUnProcessBsSuitDataDetailBySuitCaseCode(suitCaseCode, packageCount);
+
+        if (resultBean.isSuccess()) {
+            List<BsSuitDataDetail> bsSuitDataDetailList = resultBean.getResultList();
+
+            return new ResultBean(true).setResultObject(bsSuitDataDetailList);
+        } else {
+            throw ImppExceptionBuilder.newInstance()
+                    .setSystemID(CommonEnumUtil.SOFT_TYPE.WMS.getCode())
+                    .setErrorCode(ImppExceptionEnum.CLOUD_CALL_EXCEPTION.getCode())
+                    .setErrorDetail("微服调用失败: " + resultBean.getErrorMsg())
+                    .build();
+        }
+    }
+
+    /**
+     * 按照报文编号调用软适配，把报文标记为已处理
+     * @param packageIds 报文编号
+     * @return 标记结果
+     */
+    public boolean ackSoftSwitchPackage(Long[] packageIds) {
+        BaseResultBean<BsSuitDataDetail> resultBean =
+                bsSuitServiceCloud.updateBsSuitDataDetailProcessStateByIds(
+                        packageIds, BlockSoftSwitchEnumUtil.SUIT_PROCESS_STATUS.PROCESS.getValue());
+
+        if (resultBean.isSuccess()) {
+            return true;
+        } else {
+            throw ImppExceptionBuilder.newInstance()
+                    .setSystemID(CommonEnumUtil.SOFT_TYPE.WMS.getCode())
+                    .setErrorCode(ImppExceptionEnum.CLOUD_CALL_EXCEPTION.getCode())
+                    .setErrorDetail("微服调用失败: " + resultBean.getErrorMsg())
+                    .build();
+        }
+    }
+
+    /**
+     * 调用微服务接口发送报文
+     * @param suitCaseCode 适配编号
+     * @param xmlString XML 报文
+     */
+    public void sendSoftSwitchPackage(String suitCaseCode, String xmlString) {
+        LOGGER.info("WmsSAPDbUtil.sendSoftSwitchPackage input:suitCaseCode：{} ;xmlString:{}",suitCaseCode,xmlString);
+        BsSuitCase bsSuitCase = new BsSuitCase();
+        // 设置适配器代码
+        bsSuitCase.setSuitCaseCode(suitCaseCode);
+        bsSuitCase.setBsSuitCaseParamList(new ArrayList<>());
+        bsSuitCase.setParamXml(xmlString);
+
+        BaseResultBean<BsSuitDataDetail> resultBean =
+                bsSuitServiceCloud.executeBsSuitCase(bsSuitCase);
+        LOGGER.info("bsSuitServiceCloud.executeBsSuitCase result:{}", resultBean);
+        if (!resultBean.isSuccess()) {
+            throw ImppExceptionBuilder.newInstance()
+                    .setSystemID(CommonEnumUtil.SOFT_TYPE.WMS.getCode())
+                    .setErrorCode(ImppExceptionEnum.CLOUD_CALL_EXCEPTION.getCode())
+                    .setErrorDetail("bsSuitServiceCloud.executeBsSuitCase failed: %s; suitCaseCode:%s; xmlString:%s", resultBean.getErrorMsg(), suitCaseCode, xmlString)
+                    .build();
+        }
+    }
+
+    /**
+     * 以带参数名的方式调用微服务接口发送报文
+     *
+     * @param suitCaseCode 适配编号
+     * @param xmlString    XML 报文
+     */
+    public void sendSoftSwitchPackageWithParams(String suitCaseCode, String xmlString) {
+        BsSuitCase bsSuitCase = new BsSuitCase();
+        // 设置适配器代码
+        bsSuitCase.setSuitCaseCode(suitCaseCode);
+
+        List<BsSuitCaseParam> bsSuitCaseParamList = new ArrayList<>();
+        BsSuitCaseParam bsSuitCaseParam = new BsSuitCaseParam();
+        bsSuitCaseParam.setParamName("params");
+        bsSuitCaseParam.setParamValue(xmlString);
+        bsSuitCaseParamList.add(bsSuitCaseParam);
+        bsSuitCase.setBsSuitCaseParamList(bsSuitCaseParamList); // 多个数据
+
+        BaseResultBean<BsSuitDataDetail> resultBean =
+                bsSuitServiceCloud.executeBsSuitCase(bsSuitCase);
+        LOGGER.info("bsSuitServiceCloud.executeBsSuitCase result:{}",resultBean);
+        if (!resultBean.isSuccess()) {
+            throw ImppExceptionBuilder.newInstance()
+                    .setSystemID(CommonEnumUtil.SOFT_TYPE.WMS.getCode())
+                    .setErrorCode(ImppExceptionEnum.CLOUD_CALL_EXCEPTION.getCode())
+                    .setErrorDetail("bsSuitServiceCloud.executeBsSuitCase failed: %s; suitCaseCode:%s; xmlString:%s",resultBean.getErrorMsg(), suitCaseCode, xmlString)
+                    .build();
+        }
+    }
+
+    /**
+     * 以带参数名的方式调用微服务接口发送报文
+     *
+     * @param suitCaseCode 适配编号
+     * @param resultMap     发送的数据
+     */
+    public void sendSoftSwitchPackageWithMap(String suitCaseCode, Map<String, Object> resultMap) {
+        BsSuitCase bsSuitCase = new BsSuitCase();
+        // 设置适配器代码
+        bsSuitCase.setSuitCaseCode(suitCaseCode);
+
+        List<BsSuitCaseParam> bsSuitCaseParamList = new ArrayList<>();
+        Iterator<String> iterator = resultMap.keySet().iterator();
+        while(iterator.hasNext()) {
+            String key = iterator.next();
+            BsSuitCaseParam bsSuitCaseParam = new BsSuitCaseParam();
+            bsSuitCaseParam.setParamName(key);
+            bsSuitCaseParam.setParamValue(resultMap.get(key));
+            bsSuitCaseParamList.add(bsSuitCaseParam);
+        }
+        bsSuitCase.setBsSuitCaseParamList(bsSuitCaseParamList); // 多个数据
+        BaseResultBean<BsSuitDataDetail> resultBean =
+                bsSuitServiceCloud.executeBsSuitCase(bsSuitCase);
+        LOGGER.info("bsSuitServiceCloud.executeBsSuitCase result:{}",resultBean);
+        if (!resultBean.isSuccess()) {
+            throw ImppExceptionBuilder.newInstance()
+                    .setSystemID(CommonEnumUtil.SOFT_TYPE.WMS.getCode())
+                    .setErrorCode(ImppExceptionEnum.CLOUD_CALL_EXCEPTION.getCode())
+                    .setErrorDetail("bsSuitServiceCloud.executeBsSuitCase failed: %s; suitCaseCode:%s, data:%s", resultBean.getErrorMsg(), suitCaseCode, resultMap.toString())
+                    .build();
+        }
+    }
+
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/dbinterface/WmsSAPDbWriter.java

@@ -0,0 +1,533 @@
+package cn.estsh.i3plus.ext.mes.apiservice.dbinterface;
+
+import cn.estsh.i3plus.mes.apiservice.serviceimpl.engine.script.EngineScriptManager;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataRow;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataSet;
+import cn.estsh.i3plus.mes.apiservice.util.datatable.DataTable;
+import cn.estsh.i3plus.platform.plugin.datasource.DynamicDataSourceProxy;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.i3plus.pojo.base.util.StringUtil;
+import cn.estsh.i3plus.pojo.wms.dbinterface.UpdateSyncItem;
+import cn.estsh.i3plus.pojo.wms.dbinterface.WmsInterfaceEnumUtil;
+import cn.estsh.impp.framework.boot.util.ImppRedis;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import javax.annotation.Resource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @Description : 业务数据写入
+ * 按照配置的规则把业务数据写入业务库
+ * @Reference :
+ * @Author : rock.yu
+ * @CreateDate : 2019-06-11 19:34
+ * @Modify: 1. 2019-10-14 19:13 增加了调用脚本引擎处理数据的逻辑
+ **/
+@Component
+@NoArgsConstructor
+public class WmsSAPDbWriter extends WmsSAPDbSyncBase {
+
+    public static final Logger LOGGER = LoggerFactory.getLogger(WmsSAPDbWriter.class);
+
+    public static final int REQ_COUNT = 20;
+
+    @Getter
+    private DynamicDataSourceProxy srcDataSourceProxy;
+    @Getter
+    private DynamicDataSourceProxy destDataSourceProxy;
+
+    // 脚本引擎
+    @Autowired
+    private EngineScriptManager engineScriptManager;
+
+    @Resource(name = "redisMes")
+    private ImppRedis redisMes;
+
+    @Getter
+    @Setter
+    private WmsSAPDbExpression wmsSAPDbExpression;
+
+    // 数据库读写用的数据源
+    @Getter
+    @Setter
+    private Connection srcConn;
+    @Getter
+    @Setter
+    private Connection destConn;
+
+    public WmsSAPDbWriter(DynamicDataSourceProxy srcDataSourceProxy, DynamicDataSourceProxy destDataSourceProxy) {
+        this.srcDataSourceProxy = srcDataSourceProxy;
+        this.destDataSourceProxy = destDataSourceProxy;
+    }
+
+    /**
+     * 保存来源和目标数据
+     * 如果 originDataList 不为空，则表示来源数据集被脚本过滤过，需要使用原始查询到的数据集回写来源表的更新标识
+     */
+    public void saveData(List<Map<String, Object>> srcDataList, DataSet destDataSet, List<Map<String, Object>> originDataList) throws Exception {
+        // 先保存目标数据
+        // 配置了使用脚本引擎保存数据
+        try {
+            if (this.dataMapper.getUseScriptPush() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+                callScript(destDataSet, WmsSAPDbConstWords.SCRIPT_PUSH_FUN_NAME);
+            } else {
+                saveDestData(destDataSet);
+            }
+        } catch (Exception e) {
+            //记录sap过来的数据 超过一定的请求次数放弃数据
+            if (WmsInterfaceEnumUtil.DIRECTION_TYPE.SAP2WMS.getName().equals(this.dataMapper.getGroupName())) {
+                if (!CollectionUtils.isEmpty(srcDataList)) {
+                    String key = this.dataMapper.getSoftAdaptorCode() + ":" + srcDataList.get(0).get("SID");
+                    if (redisMes.hasKey(key)) {
+                        int reqCount = Integer.parseInt(String.valueOf(redisMes.getObject(key)));
+                        if (reqCount + 1 > REQ_COUNT) {
+                            if (this.dataMapper.getUseScriptMark() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+                                callScriptMark(srcDataList, originDataList);
+                            } else {
+                                callSqlMark(srcDataList, originDataList);
+                            }
+                            LOGGER.error("超过请求次数放弃数据 WmsSAPDbWriter.saveData SoftAdaptorCode:{}, SID:{}", this.dataMapper.getSoftAdaptorCode(), srcDataList.get(0).get("SID"));
+                            return;
+                        } else {
+                            redisMes.incr(key, 1);
+                        }
+                    } else {
+                        redisMes.incr(key, 1);
+                    }
+                }
+            }
+            throw e;
+        }
+
+        // 再更新来源数据的同步标志
+        // 配置了使用脚本引擎标记来源数据
+        if (this.dataMapper.getUseScriptMark() == CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()) {
+            callScriptMark(srcDataList, originDataList);
+        } else {
+            callSqlMark(srcDataList, originDataList);
+        }
+    }
+
+    /**
+     * 执行SQL回写来源表的更新标记
+     * @param srcDataList 来源数据集
+     * @param originDataList 原始查询到的数据集
+     * @throws Exception
+     */
+    private void callSqlMark(List<Map<String, Object>> srcDataList, List<Map<String, Object>> originDataList)
+            throws Exception {
+        if (originDataList != null) {
+            saveSrcData(originDataList);
+        } else {
+            saveSrcData(srcDataList);
+        }
+    }
+
+    /**
+     * 执行脚本回写来源表的更新标记
+     * @param srcDataList 来源数据集
+     * @param originDataList 原始查询到的数据集
+     * @throws Exception
+     */
+    private void callScriptMark(List<Map<String, Object>> srcDataList, List<Map<String, Object>> originDataList)
+            throws Exception {
+        if (originDataList != null) {
+            callScript(originDataList, WmsSAPDbConstWords.SCRIPT_MARK_FUN_NAME);
+        } else {
+            callScript(srcDataList, WmsSAPDbConstWords.SCRIPT_MARK_FUN_NAME);
+        }
+    }
+
+    /**
+     * 调用脚本引擎处理数据
+     * @param data 数据集
+     * @param funName 调用脚本中的方法名称
+     * @throws Exception 脚本执行异常
+     */
+    private void callScript(Object data, String funName) throws Exception {
+        // 调用脚本引擎写入目标数据
+        String scriptNo = this.dataMapper.getScriptNo();
+
+        // 如果脚本编号配置的是 groovy 文件，就直接调用文件，便于运行中打断点调试
+        if (scriptNo.indexOf(".groovy") > 0) {
+            engineScriptManager.invokeGroovyScript(
+                    scriptNo,
+                    funName,
+                    this.dataMapper,
+                    data);
+        } else {
+            engineScriptManager.invokeFuncation(
+                    this.dataMapper.getOrganizeCode(),
+                    scriptNo,
+                    funName,
+                    this.dataMapper,
+                    data);
+        }
+    }
+
+    /**
+     * 保存目标数据
+     *
+     * @param destDataSet
+     * @throws Exception
+     */
+    public void saveDestData(DataSet destDataSet) throws Exception {
+        if (destDataSet == null || destDataSet.getDataTables().size() == 0) {
+            LOGGER.error("no data in  dest dataset!");
+            throw new IllegalArgumentException("no data in  dest dataset!");
+        }
+
+        List<String> sqlStringList = new ArrayList<>();
+        // 保存主键查询的 SQL 语句，用于判断表内数据行是否重复
+        Map<String, Integer> sqlCacheMap = new HashMap<>();
+
+        // 循环处理每一行目标表数据
+        for (DataTable table : destDataSet.getDataTables()) {
+            for (DataRow destRow : table.getRows()) {
+                // 生成 SQL 语句
+                sqlStringList.add(packRowSQL(destRow, sqlCacheMap));
+            }
+        }
+
+        try {
+            // 作为一个事务批量执行
+            destDataSourceProxy.executeAsBatch(sqlStringList, destConn);
+            for(String sql : sqlStringList) {
+                LOGGER.info(sql);
+            }
+//            LOGGER.info(sqlStringList.toString());
+        } catch (Exception e) {
+            // 包装异常信息，把 SQL 加进去，便于调试
+            throw new SQLException("执行SQL异常" + e.getMessage() + " "
+                    + getSqlStrings(sqlStringList));
+        }
+    }
+
+    /**
+     * 包装 SQL 语句，供测试参考
+     *
+     * @param sqlStringList
+     * @return
+     */
+    private String getSqlStrings(List<String> sqlStringList) {
+        if (sqlStringList == null) {
+            return null;
+        }
+
+        StringBuffer sb = new StringBuffer();
+        int index = 0;
+
+        for (String sql : sqlStringList) {
+            sb.append(String.valueOf(index) + " < ");
+            sb.append(sql);
+            sb.append(">  ");
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * 更新来源数据
+     *
+     * @param srcDataList
+     * @throws Exception
+     */
+    private void saveSrcData(List<Map<String, Object>> srcDataList) throws Exception {
+        if (srcDataList == null || srcDataList.size() == 0) {
+            LOGGER.error("no data in src datalist!");
+            throw new IllegalArgumentException("no data in src datalist!");
+        }
+
+        List<String> sqlStringList = new ArrayList<>();
+        // 存放插入备份表的SQL语句列表
+        List<String> insertSqlStringList = new ArrayList<>();
+        // 存放删除来源表的SQL语句列表
+        List<String> deleteSqlStringList = new ArrayList<>();
+
+        List<String> saveAndRemoveList = new ArrayList<>();
+
+        String sqlString;
+
+        HashMap<String, Object> srcPkMap = new HashMap<>();
+
+        // 循环处理每一行数据
+        for (Map<String, Object> srcRow : srcDataList) {
+            // 先清空主键 Map
+            srcPkMap.clear();
+            if (StringUtil.isEmpty(this.getSrcPkColumn())) {
+                LOGGER.error("WmsSAPDbWriter.saveSrcData params srcPkColumn is null!");
+                throw new Exception("WmsSAPDbWriter.saveSrcData params srcPkColumn is null");
+            }
+            // 构建主键 Map
+            for (String column : this.getSrcPkColumn()) {
+                srcPkMap.put(column, srcRow.get(column));
+            }
+
+            // 把来源表的数据行放到表达式中，确保表达式可以引用
+            HashMap<String, Object> updateValueMap = getUpdateSyncMap(srcRow);
+            // 存在来源表不需要更新同步标志的情况
+            if (updateValueMap.size() > 0) {
+                // 拼接更新来源表同步标志的 SQL LIST
+                sqlString = srcDataSourceProxy.packUpdateSQL(this.dataMapper.getSrcTableName(), srcPkMap,
+                        updateValueMap);
+                // 如果设置了分组处理，在回写来源表时就要加上原始的 Where 条件，以防止多更新数据
+                if (StringUtils.isNotBlank(this.dataMapper.getSrcGroupColumns())) {
+                    // 先去掉原来拼接的分号
+                    sqlString = sqlString.replace(";"," ") + " and (" + this.dataMapper.getSrcWhere() + "); ";
+                }
+
+                sqlStringList.add(sqlString);
+            }
+
+            // 添加处理完成的数据及时剪切到备份表的逻辑
+            if (!StringUtils.isBlank(this.dataMapper.getCutToTableName())) {
+                // 插入历史表的语句
+                sqlString = srcDataSourceProxy.packInsertSQL(this.dataMapper.getCutToTableName(), (HashMap<String, Object>)srcRow);
+                insertSqlStringList.add(sqlString);
+
+                // 删除来源表的语句
+                sqlString = srcDataSourceProxy.packDeleteSQL(this.dataMapper.getSrcTableName(), srcPkMap);
+//                // 如果设置了分组处理，在回写来源表时就要加上原始的 Where 条件，以防止多更新数据
+//                if (StringUtils.isNotBlank(this.dataMapper.getSrcGroupColumns())) {
+//                    // 先去掉原来拼接的分号
+//                    sqlString = sqlString.replace(";"," ") + " and (" + this.dataMapper.getSrcWhere() + "); ";
+//                }
+                deleteSqlStringList.add(sqlString);
+            }
+        }
+
+        try {
+            if (sqlStringList.size() > 0) {
+                // 去掉重复的 SQL
+                List<String> uniqeSqlList = sqlStringList.stream().distinct().collect(Collectors.toList());
+                // 批量更新来源表的同步标志
+                srcDataSourceProxy.executeAsBatch(uniqeSqlList, srcConn);
+            }
+        } catch (Exception e) {
+            // 包装异常信息，把 SQL 加进去，便于调试
+            throw new SQLException("执行SQL异常" + e.getMessage() + " "
+                    + getSqlStrings(sqlStringList));
+        }
+        try {
+            if (insertSqlStringList.size() > 0) {
+                saveAndRemoveList.addAll(insertSqlStringList);
+            }
+            if (deleteSqlStringList.size() > 0) {
+                saveAndRemoveList.addAll(deleteSqlStringList);
+            }
+            if (saveAndRemoveList.size() > 0) {
+                // 去掉重复的 SQL
+                LOGGER.info("执行迁移的sql脚本为:sqlString:"+getSqlStrings(saveAndRemoveList));
+                List<String> uniqeSqlList = saveAndRemoveList.stream().distinct().collect(Collectors.toList());
+                //插入备份表 & 删除来源表数据
+                srcDataSourceProxy.executeAsBatch(uniqeSqlList, srcConn);
+            }
+        } catch (Exception e) {
+            // 包装异常信息，把 SQL 加进去，便于调试
+            throw new SQLException("执行SQL异常" + e.getMessage() + " "
+                    + getSqlStrings(saveAndRemoveList));
+        }
+    }
+
+    /**
+     * 根据表达式获来源表取待更新的值Map
+     *
+     * @return
+     */
+    private HashMap<String, Object> getUpdateSyncMap(Map<String, Object> srcRow) throws Exception {
+        HashMap<String, Object> updateSyncMap = new HashMap<>();
+
+        if (this.getSrcUpdateSync() == null) {
+            return updateSyncMap;
+        }
+
+        for (UpdateSyncItem item : this.getSrcUpdateSync()) {
+            Object updateValue = item.getUpdateValue();
+
+            // 如果包含表达式，则计算后赋值
+            if (item.getUpdateValue().indexOf("#") != -1) {
+                updateValue = wmsSAPDbExpression.parse(item.getUpdateValue(), srcRow);
+            }
+
+            updateSyncMap.put(item.getColumnName(), updateValue);
+        }
+
+        return updateSyncMap;
+    }
+
+
+    /**
+     * 生成保存一行数据到目标表的SQL
+     *
+     * @param row
+     * @throws Exception
+     */
+    private String packRowSQL(DataRow row, Map<String, Integer> sqlCacheMap) throws Exception {
+        if (row == null || row.getColumns().size() == 0) {
+            LOGGER.error("no column in row!");
+            throw new IllegalArgumentException("no column in row!");
+        }
+
+        // 获取主键列表
+        List<String> destPks = getPkList(row);
+
+        // 获取主键查询 SQL & KeyMap
+        SqlAndKeyMap sqlAndKeyMap = new SqlAndKeyMap(row, destPks).invoke();
+        String sqlString = sqlAndKeyMap.getSqlString();
+        Map<String, Object> pkMap = sqlAndKeyMap.getPkMap();
+
+        // 按照主键从业务表查询数据
+        List<Map<String, Object>> resutlMap = destDataSourceProxy.queryMapList(sqlString, destConn);
+
+        // 判断按主键查询的 SQL 有没有出现过
+        Boolean dataDupInBatch = sqlCacheMap.containsKey(sqlString);
+
+        // 没出现过，加入缓存中
+        if (!dataDupInBatch) {
+            sqlCacheMap.put(sqlString, 1);
+        }
+
+        // 最终要生成的插入或更新SQL
+        String sqlResult;
+
+        // 目标数据存在或者在本次处理的数据中重复则更新，不存在则新增
+        if ((resutlMap != null && resutlMap.size() > 0) || dataDupInBatch) {
+            HashMap<String, Object> rowMap = (HashMap<String, Object>) row.getItemMap();
+
+            // id 不用更新
+            if (rowMap.containsKey("id")) {
+                rowMap.remove("id");
+            }
+
+            // 过滤标记为 NotTrans 数据项，这些数据不更新到数据库
+            Iterator<Map.Entry<String, Object>> iterator = rowMap.entrySet().iterator();
+            Object value;
+            while (iterator.hasNext()) {
+                value = iterator.next().getValue();
+                if (value != null && value.toString().endsWith(WmsSAPDbExpression.NOT_TRANS)) {
+                    iterator.remove();
+                }
+            }
+
+            sqlResult = destDataSourceProxy.packUpdateSQL(row.getTable().getTableName(), (HashMap<String, Object>) pkMap,rowMap);
+        } else {
+            HashMap<String, Object> rowMap = (HashMap<String, Object>) row.getItemMap();
+            // 带 NotTrans 的数据先把 :NotTrans 或者 NotTrans 标记去掉
+            for (Map.Entry<String, Object> entry : rowMap.entrySet()) {
+                if (entry.getValue() != null && entry.getValue().toString().endsWith(WmsSAPDbExpression.NOT_TRANS)) {
+                    String transValue = entry.getValue().toString();
+                    transValue = transValue.replace(":" + WmsSAPDbExpression.NOT_TRANS, "");
+                    transValue = transValue.replace(WmsSAPDbExpression.NOT_TRANS, "");
+                    LOGGER.debug("NotTrans Item: {} Insert before: {} after: {}", entry.getKey(), entry.getValue(), transValue);
+                    rowMap.put(entry.getKey(), transValue);
+                }
+            }
+
+            sqlResult = destDataSourceProxy.packInsertSQL(row.getTable().getTableName(),
+                    (HashMap<String, Object>) row.getItemMap());
+        }
+
+        return sqlResult;
+    }
+
+    /**
+     * 获取主键列表
+     *
+     * @param row
+     * @return
+     */
+    private List<String> getPkList(DataRow row) {
+        // 先查找外面配置的主键
+        List<String> destPks = this.getDestPkProperty();
+
+        // 一表对多表，主键设置在字段对照表里
+        if (destPks == null || destPks.isEmpty()) {
+            destPks = this.getDestPkByBeanName(row.getTable().getTableName());
+        }
+
+        // 没有找到主键时抛出异常
+        if (destPks == null || destPks.isEmpty()) {
+            LOGGER.error("no pk in table: " + row.getTable().getTableName());
+            throw new IllegalArgumentException("no pk in table: " + row.getTable().getTableName());
+        }
+
+        return destPks;
+    }
+
+
+    /**
+     * 内部类，用于拼接主键查询 SQL & KeyMap
+     */
+    private class SqlAndKeyMap {
+        private DataRow row;
+        private List<String> destPks;
+        private String sqlString;
+        private Map<String, Object> pkMap;
+
+        public SqlAndKeyMap(DataRow row, List<String> destPks) {
+            this.row = row;
+            this.destPks = destPks;
+        }
+
+        public String getSqlString() {
+            return sqlString;
+        }
+
+        public Map<String, Object> getPkMap() {
+            return pkMap;
+        }
+
+        public SqlAndKeyMap invoke() {
+            sqlString = "select 1 from " + row.getTable().getTableName()
+                    + " where 1=1 ";
+
+            // 目标表的主键列表
+            pkMap = new HashMap<>();
+
+            for (String column : destPks) {
+                String value = WmsSAPDbWriter.this.getSafetyString(row.getValue(column));
+                // 处理掉 NotTrans 字段
+                if (value != null && value.contains(WmsSAPDbExpression.NOT_TRANS)) {
+                    value = value.replace(":" + WmsSAPDbExpression.NOT_TRANS, "");
+                    value = value.replace(WmsSAPDbExpression.NOT_TRANS, "");
+                }
+                sqlString += "and " + column + "='" + value + "' ";
+                pkMap.put(column, row.getValue(column));
+            }
+
+            return this;
+        }
+    }
+
+    /**
+     * 重写判断对象相等的方法
+     *
+     * @param obj
+     * @return
+     */
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj);
+    }
+
+    /**
+     * 重写 hashCode 方法
+     *
+     * @return
+     */
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/schedulejob/MesSAPDbTransByWorksJob.java

@@ -0,0 +1,103 @@
+package cn.estsh.i3plus.ext.mes.apiservice.schedulejob;
+
+import cn.estsh.i3plus.ext.mes.apiservice.dbinterface.MesSAPDbAdapter;
+import cn.estsh.i3plus.mes.apiservice.schedulejob.BaseMesScheduleJob;
+import cn.estsh.i3plus.platform.common.tool.JsonUtilTool;
+import cn.estsh.i3plus.pojo.mes.dbinterface.MesInterfaceEnumUtil;
+import cn.estsh.i3plus.pojo.model.wms.WmsJobParamModel;
+import cn.estsh.impp.framework.boot.init.ApplicationProperties;
+import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
+import io.swagger.annotations.ApiOperation;
+import org.apache.commons.lang3.StringUtils;
+import org.quartz.DisallowConcurrentExecution;
+import org.quartz.JobExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.util.CollectionUtils;
+
+import java.util.List;
+
+/**
+ * @Description : 按工厂划分：把 SAP 接口表的数据同步到 MES 业务表中（单据+基础数据）
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 11:03
+ * @Modify:
+ **/
+// 禁止 JOB 并发执行
+@DisallowConcurrentExecution
+@ApiOperation("SAP接口表数据同步作业按工厂划分")
+public class MesSAPDbTransByWorksJob extends BaseMesScheduleJob {
+
+    public static final Logger LOGGER = LoggerFactory.getLogger(MesSAPDbTransByWorksJob.class);
+
+    private static final long serialVersionUID = 9072058154235836696L;
+
+    @Value("${server.port}")
+    private String serverPort;
+    @Value("${impp.server.ip}")
+    private String ip;
+
+    public MesSAPDbTransByWorksJob() {
+        super(MesSAPDbTransByWorksJob.class, "SAP接口表数据同步作业按工厂划分");
+        this.setMultiInstance(true);
+    }
+
+    @Override
+    public void executeMesJob(JobExecutionContext context, ApplicationProperties applicationProperties) {
+        try {
+            String jobParam = this.getJobParam();
+
+            if (StringUtils.isBlank(jobParam)) {
+                throw new IllegalArgumentException("jobc参数为空，请检查参数");
+            }
+
+            //参数： [{ "organizeCodeList" : [ "3610",2752","2751"],"groupName" : "SAP2MES"}]
+            //参数： [{ "organizeCodeList" : [ "3610",2752","2751"],"groupName" : "WMS2SAP"}]
+            List<WmsJobParamModel> wmsJobParamModelList = JsonUtilTool.toList(jobParam, WmsJobParamModel.class);
+
+            if (!CollectionUtils.isEmpty(wmsJobParamModelList)) {
+
+                //正常应该一个工厂一个分组JOB。所以一个【jobParam】就有一个解析对象。
+                WmsJobParamModel wmsJobParamModel = wmsJobParamModelList.get(0);
+
+                //解析job参数
+                List<String> organizeCodeList = wmsJobParamModel.getOrganizeCodeList();
+                List<String> destBeanNameList = wmsJobParamModel.getDestBeanNameList();
+                List<String> destBeanNameNotList = wmsJobParamModel.getDestBeanNameNotList();
+                String groupName = wmsJobParamModel.getGroupName();
+
+                // 判断作业参数是否支持
+                if (MesInterfaceEnumUtil.DIRECTION_TYPE.nameOf(groupName) == -1) {
+                    throw new IllegalArgumentException("不支持的作业参数：" + groupName);
+                }
+
+                LOGGER.info("SAP接口表数据同步作业按工厂划分开始 -----start");
+
+                // 开始同步数据
+                // 一定要 new 对象，不然会有并发问题
+                MesSAPDbAdapter mesSAPDbAdapter;
+                for (String organizeCode : organizeCodeList) {
+
+                    mesSAPDbAdapter = new MesSAPDbAdapter();
+                    // new 的对象需要手工注入 bean
+                    if (SpringContextsUtil.getApplicationContext() != null) {
+                        SpringContextsUtil.getApplicationContext().
+                                getAutowireCapableBeanFactory().autowireBean(mesSAPDbAdapter);
+                    }
+                    mesSAPDbAdapter.syncDataByOrganizeCode(groupName, organizeCode,destBeanNameList,destBeanNameNotList);
+                }
+
+//                LOGGER.info("SAP接口表数据同步作业按工厂划分开始结束 -----  projectName：{}, port:{}",
+//                        applicationProperties.getApplicationName(), applicationProperties.getServerPort());
+                LOGGER.info("SAP接口表数据同步作业按工厂划分开始结束 ----- end");
+            }
+
+        } catch (Exception e) {
+            LOGGER.error("SAP接口表数据同步作业任务结束e:{}",e.toString());
+            //sendErrorMessage(e.toString());
+        }
+    }
+
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesPartService.java

@@ -1,10 +1,10 @@
 package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base;
 
 import cn.estsh.i3plus.ext.mes.api.base.IMesPartService;
+import cn.estsh.i3plus.ext.mes.apiservice.unit.exception.MesException;
 import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
 import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
 import cn.estsh.i3plus.pojo.mes.bean.MesPart;
-import cn.estsh.i3plus.pojo.mes.bean.MesPartPtr;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
@@ -17,4 +17,15 @@ public class MesPartService extends BaseMesService<MesPart> implements IMesPartS
         DdlPreparedPack.getStringLikeEqualPack(bean.getPartName(), "partName", packBean);
 
     }
+
+    @Override
+    public MesPart getPartByPartNo(String partNo, String organizeCode) {
+        DdlPackBean ddlPackBean = DdlPackBean.getDdlPackBean(organizeCode);
+        DdlPreparedPack.getStringEqualPack(partNo, "partNo", ddlPackBean);
+        MesPart mesPart = baseRDao.getByProperty(ddlPackBean);
+        if (null == mesPart) {
+            MesException.throwMesBusiException("物料【%s】信息不存在", partNo);
+        }
+        return mesPart;
+    }
 }

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesProductOffLineImpl.java

@@ -0,0 +1,17 @@
+package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base;
+
+import cn.estsh.i3plus.ext.mes.api.base.IMesProductOffLineService;
+import cn.estsh.i3plus.pojo.mes.bean.MesProductOffLine;
+import org.springframework.stereotype.Service;
+
+/**
+ * @Description : 生产汇报
+ * @Reference :
+ * @Author : junsheng.li
+ * @CreateDate 2024/5/10 14:40
+ * @Modify:
+ **/
+@Service
+public class MesProductOffLineImpl extends BaseMesService<MesProductOffLine> implements IMesProductOffLineService {
+
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesWorkOrderService.java

@@ -1,26 +1,35 @@
 package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base;
 
+import cn.estsh.i3plus.ext.mes.api.base.IMesPartService;
+import cn.estsh.i3plus.ext.mes.api.base.IMesProductOffLineService;
 import cn.estsh.i3plus.ext.mes.api.base.IMesWorkOrderService;
+import cn.estsh.i3plus.ext.mes.api.base.IMesWorkOrderToSapService;
+import cn.estsh.i3plus.ext.mes.apiservice.unit.exception.MesException;
 import cn.estsh.i3plus.ext.mes.pojo.util.MesExtEnumUtil;
 import cn.estsh.i3plus.mes.api.iservice.busi.ISyncFuncService;
 import cn.estsh.i3plus.platform.common.convert.ConvertBean;
 import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum;
+import cn.estsh.i3plus.platform.common.tool.MathOperation;
 import cn.estsh.i3plus.pojo.base.bean.DdlPackBean;
 import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
 import cn.estsh.i3plus.pojo.base.tool.DdlPreparedPack;
-import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
+import cn.estsh.i3plus.pojo.base.util.StringUtil;
-import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderLog;
+import cn.estsh.i3plus.pojo.mes.bean.*;
 import cn.estsh.i3plus.pojo.mes.model.GenSerialNoModel;
+import cn.estsh.i3plus.pojo.mes.repository.MesBomRepository;
+import cn.estsh.i3plus.pojo.mes.repository.MesProductVersionRepository;
 import cn.estsh.impp.framework.boot.auth.AuthUtil;
 import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
 import cn.estsh.impp.framework.boot.util.ValidatorBean;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 @Service
 @Slf4j
@@ -29,6 +38,16 @@ public class MesWorkOrderService extends BaseMesService<MesWorkOrder> implements
     private MesWorkOrderLogService workOrderLogService;
     @Autowired
     private ISyncFuncService syncFuncService;
+    @Autowired
+    private IMesWorkOrderToSapService iMesWorkOrderToSapService;
+    @Autowired
+    private IMesPartService iMesPartService;
+    @Autowired
+    private MesProductVersionRepository mesProductVersionRDao;
+    @Autowired
+    private MesBomRepository mesBomRDao;
+    @Autowired
+    private IMesProductOffLineService mesProductOffLineService;
 
     @Override
     public MesWorkOrder insert(MesWorkOrder bean) {
@@ -46,35 +65,32 @@ public class MesWorkOrderService extends BaseMesService<MesWorkOrder> implements
         GenSerialNoModel genSerialNoModel = new GenSerialNoModel();
         //若工单类型为排序 则根据排序插入工单数量插入多行 工单数量为1
         if (bean.getWorkOrderType() == MesExtEnumUtil.ORDER_TYPE.SORT.getValue()) {
-
-
             Integer produceSeq = 0;
-            if (result.getProduceSeq() != null) {
+            if (null != result && result.getProduceSeq() != null) {
                 produceSeq = result.getProduceSeq();
             }
-            List<MesWorkOrder> sortWorkOrderList = new ArrayList<>();
+
             List<MesWorkOrderLog> orderLogList = new ArrayList<>();
-            for (int i = 0; i < bean.getSortInsertOrderQty(); i++) {
             //生成工单号
             genSerialNoModel = new GenSerialNoModel("ORDER_NO_JIS_SORT");
             genSerialNoModel.setPartNo(bean.getPartNo());
-                List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel, AuthUtil.getSessionUser().getUserName(), bean.getOrganizeCode(), 1).getResultList();
+            List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel, bean.getCreateUser(), bean.getOrganizeCode(), 1).getResultList();
 
             MesWorkOrder copyMesWorkOrder = new MesWorkOrder();
             BeanUtils.copyProperties(bean, copyMesWorkOrder);
-                copyMesWorkOrder.setProduceSeq(produceSeq + i + 1);
+            copyMesWorkOrder.setProduceSeq(produceSeq + 1);
             copyMesWorkOrder.setQty(1D);
             copyMesWorkOrder.setOrderNo(resultList.get(0));
-                ConvertBean.serviceModelInitialize(copyMesWorkOrder, AuthUtil.getSessionUser().getUserName());
+            ConvertBean.serviceModelInitialize(copyMesWorkOrder, bean.getCreateUser());
-                sortWorkOrderList.add(copyMesWorkOrder);
 
             MesWorkOrderLog workOrderLog = new MesWorkOrderLog();
             BeanUtils.copyProperties(copyMesWorkOrder, workOrderLog, "id");
             orderLogList.add(workOrderLog);
 
-            }
+            baseRDao.insert(copyMesWorkOrder);
-            insertBatch(sortWorkOrderList);
             workOrderLogService.insertBatch(orderLogList);
+            //写入接口表
+            iMesWorkOrderToSapService.insert(bean);
             return bean;
         } else if (bean.getWorkOrderType() == MesExtEnumUtil.ORDER_TYPE.UN_SORT.getValue()) {
             //生成工单号
@@ -83,50 +99,82 @@ public class MesWorkOrderService extends BaseMesService<MesWorkOrder> implements
             //生成工单号
             genSerialNoModel = new GenSerialNoModel("ORDER_NO_BTO");
             Integer produceSeq = 0;
-            if (result.getProduceSeq() != null) {
+            if (null != result && result.getProduceSeq() != null) {
                 produceSeq = result.getProduceSeq();
             }
             bean.setProduceSeq(produceSeq + 1);
             GenSerialNoModel orderSeqSerialNoModel = new GenSerialNoModel("ORDER_NO_BTO_SEQ");
             orderSeqSerialNoModel.setPartNo(bean.getPartNo());
-            List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel, AuthUtil.getSessionUser().getUserName(), bean.getOrganizeCode(), 1).getResultList();
+            List<String> resultList = syncFuncService.syncSerialNo(orderSeqSerialNoModel, bean.getCreateUser(), bean.getOrganizeCode(), 1).getResultList();
             bean.setOrderSeq(Integer.parseInt(resultList.get(0)));
         }
         genSerialNoModel.setPartNo(bean.getPartNo());
-        List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel, AuthUtil.getSessionUser().getUserName(), bean.getOrganizeCode(), 1).getResultList();
+        List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel, bean.getCreateUser(), bean.getOrganizeCode(), 1).getResultList();
         bean.setOrderNo(resultList.get(0));
-        bean.setQty(bean.getSortInsertOrderQty().doubleValue());
+        bean.setQty(bean.getQty());
 
-        ConvertBean.serviceModelInitialize(bean, AuthUtil.getSessionUser().getUserName());
+        ConvertBean.serviceModelInitialize(bean, bean.getCreateUser());
 
         MesWorkOrderLog workOrderLog = new MesWorkOrderLog();
         BeanUtils.copyProperties(bean, workOrderLog, "id");
         workOrderLogService.insert(workOrderLog);
         bean = baseRDao.insert(bean);
+        //写入接口表
+        iMesWorkOrderToSapService.insert(bean);
         return bean;
     }
 
     @Override
     public MesWorkOrder update(MesWorkOrder bean) {
-        //插入前构造数据
+        //回传sap
-        onInsertBean(bean);
+        boolean sendToSap = false;
 
         MesWorkOrder result = baseRDao.getById(bean.getId());
         //若工单类型为排序 则根据排序插入工单数量插入多行 工单数量为1
         if (result.getWorkOrderType() == MesExtEnumUtil.ORDER_TYPE.SORT.getValue()) {
-            throw ImppExceptionBuilder.newInstance()
+            if (!Objects.equals(bean.getQty(), result.getQty())) {
-                    .setErrorCode(ImppExceptionEnum.BUSINESS_EXCEPTION_DATA_ERROR.getCode())
+                MesException.throwMesBusiException(String.format("工单类型为【%s】 不需要修改数量",
-                    .setErrorDetail(String.format("工单类型为【%s】 不需要修改数量", MesExtEnumUtil.ORDER_TYPE.SORT.getValue()))
+                        MesExtEnumUtil.ORDER_TYPE.SORT.getDescription()));
-                    .setSystemID(CommonEnumUtil.SOFT_TYPE.MES.getCode())
+            }
-                    .build();
+        } else {
+            //工单数量只能比原来的大
+            if (bean.getQty() < result.getQty()) {
+                MesException.throwMesBusiException(String.format("工单数量不能小于工单源数量【%s】",
+                        result.getQty()));
+            }
+            //修改状态或者指令下发需要传给SAP
+            if (!Objects.equals(bean.getQty(), result.getQty())) {
+                sendToSap = true;
+            }
+        }
+        if (MesExtEnumUtil.ORDER_STATUS.RELEASE.getValue() == bean.getWorkOrderStatus() ||
+                MesExtEnumUtil.ORDER_STATUS.COMPLETE.getValue() == bean.getWorkOrderStatus()) {
+            sendToSap = true;
+        }
+        //在加工的工单不能修改物料信息
+        if (result.getWorkOrderStatus() >= MesExtEnumUtil.ORDER_STATUS.process.getValue()) {
+            if (!Objects.equals(bean.getPartNo(), result.getPartNo())) {
+                MesException.throwMesBusiException(String.format("工单状态为【%s】不允许修改物料",
+                        MesExtEnumUtil.ORDER_TYPE.valueOfDescription(result.getWorkOrderStatus())));
+            }
         }
 
-        result.setQty(bean.getSortInsertOrderQty().doubleValue());
+        result.setQty(bean.getQty());
+        result.setWorkOrderStatus(bean.getWorkOrderStatus());
         ConvertBean.serviceModelInitialize(bean, AuthUtil.getSessionUser().getUserName());
 
         MesWorkOrderLog workOrderLog = new MesWorkOrderLog();
         BeanUtils.copyProperties(result, workOrderLog, "id");
         workOrderLogService.insert(workOrderLog);
+        //关闭工单
+        if (MesExtEnumUtil.ORDER_STATUS.CLOSE.getValue() == bean.getWorkOrderStatus()) {
+            bean.setQty(0d);
+            sendToSap = true;
+        }
+        //发送给SAP
+        if (sendToSap) {
+            iMesWorkOrderToSapService.insert(bean);
+        }
 
         baseRDao.update(result);
         return bean;
@@ -134,6 +182,19 @@ public class MesWorkOrderService extends BaseMesService<MesWorkOrder> implements
 
 
     protected void setPackQueryBean(MesWorkOrder bean, DdlPackBean packBean) {
+        DdlPreparedPack.getStringLikerPack(bean.getOrderNo(), "orderNo", packBean);
+        DdlPreparedPack.getStringLikerPack(bean.getPartNameRdd(), "partNameRdd", packBean);
+        DdlPreparedPack.getStringEqualPack(bean.getPartNo(), "partNo", packBean);
+        DdlPreparedPack.getStringEqualPack(bean.getCustPartNo(), "custPartNo", packBean);
+        DdlPreparedPack.getStringEqualPack(bean.getWorkCenterCode(), "workCenterCode", packBean);
+        DdlPreparedPack.getNumEqualPack(bean.getWorkOrderStatus(), "workOrderStatus", packBean);
+        DdlPreparedPack.getNumEqualPack(bean.getWorkOrderType(), "workOrderType", packBean);
+        DdlPreparedPack.getStringBiggerPack(bean.getCreateDateTimeStart(), "createDatetime", packBean);
+        DdlPreparedPack.getStringSmallerPack(bean.getCreateDateTimeEnd(), "createDatetime", packBean);
+        DdlPreparedPack.getStringBiggerPack(bean.getStartTimeStart(), "planStartTime", packBean);
+        DdlPreparedPack.getStringSmallerPack(bean.getStartTimeEnd(), "planStartTime", packBean);
+        DdlPreparedPack.getStringBiggerPack(bean.getEndTimeStart(), "planEndTime", packBean);
+        DdlPreparedPack.getStringSmallerPack(bean.getEndTimeEnd(), "planEndTime", packBean);
     }
 
     protected void onInsertBean(MesWorkOrder item) {
@@ -142,7 +203,7 @@ public class MesWorkOrderService extends BaseMesService<MesWorkOrder> implements
         ValidatorBean.checkNotNull(item.getWorkOrderType(), "工单类型不能为空");
         ValidatorBean.checkNotNull(item.getWorkCenterCode(), "产线不能为空");
 
-        ValidatorBean.checkNotNull(item.getShiftCode(), "班次不能为空");
+        //ValidatorBean.checkNotNull(item.getShiftCode(), "班次不能为空");
 
         //校验标识
         //若工单类型为排序
@@ -177,10 +238,76 @@ public class MesWorkOrderService extends BaseMesService<MesWorkOrder> implements
                         .build();
             }
         }
+        //物料名称不存在，从物料信息中获取
+        if (StringUtil.isEmpty(item.getPartNameRdd())) {
+            MesPart mesPart = iMesPartService.getPartByPartNo(item.getPartNo(), item.getOrganizeCode());
+            item.setPartNameRdd(mesPart.getPartName());
+        }
+        item.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.CREATE.getValue());
     }
 
     protected void onUpdateBean(MesWorkOrder item) {
 
     }
 
+    @Override
+    public void doProductReport(MesWorkOrder mesWorkOrder) {
+        //查询物料信息
+        MesPart mesPart = iMesPartService.getPartByPartNo(mesWorkOrder.getPartNo(), mesWorkOrder.getOrganizeCode());
+        //获取生产版本
+        DdlPackBean ddlPackBean = DdlPackBean.getDdlPackBean(mesWorkOrder.getOrganizeCode());
+        DdlPreparedPack.getStringEqualPack(mesPart.getPartNo(), "partNo", ddlPackBean);
+        MesProductVersion mesProductVersion = mesProductVersionRDao.getByProperty(ddlPackBean);
+        if (null == mesProductVersion) {
+            MesException.throwMesBusiException("物料【%s】生产版本信息不存在", mesWorkOrder.getPartNo());
+        }
+        //物料+生产版本获取bom信息
+        ddlPackBean = DdlPackBean.getDdlPackBean(mesWorkOrder.getOrganizeCode());
+        DdlPreparedPack.getStringEqualPack(mesPart.getPartNo(), "partNo", ddlPackBean);
+        DdlPreparedPack.getStringEqualPack(mesProductVersion.getProductVersion(), "bomVersion", ddlPackBean);
+        List<MesBom> mesBoms = mesBomRDao.findByHqlWhere(ddlPackBean);
+        if (CollectionUtils.isEmpty(mesBoms)) {
+            MesException.throwMesBusiException("物料【%s】生产版本【%s】对应bom信息不存在",
+                            mesWorkOrder.getPartNo(), mesProductVersion.getProductVersion());
+        }
+        //更新工单状态
+        mesWorkOrder.setCompleteQty(MathOperation.add(mesWorkOrder.getNum(), mesWorkOrder.getCompleteQty()));
+        if (mesWorkOrder.getCompleteQty() >= mesWorkOrder.getQty()) {
+            mesWorkOrder.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.COMPLETE.getValue());
+        } else {
+            mesWorkOrder.setWorkOrderStatus(MesExtEnumUtil.ORDER_STATUS.process.getValue());
+        }
+        update(mesWorkOrder);
+
+        //生成条码
+        GenSerialNoModel genSerialNoModel = new GenSerialNoModel("REPORT_SN");
+        genSerialNoModel.setPartNo(mesWorkOrder.getPartNo());
+        List<String> resultList = syncFuncService.syncSerialNo(genSerialNoModel, mesWorkOrder.getCreateUser(), mesWorkOrder.getOrganizeCode(), mesWorkOrder.getNum()).getResultList();
+        //保存数据
+        List<MesProductOffLine> mesProductOffLineList = new ArrayList<>();
+        MesProductOffLine newMesProductOffLine;
+        for (String sn : resultList) {
+            for (MesBom mesBom : mesBoms) {
+                newMesProductOffLine = new MesProductOffLine();
+                newMesProductOffLine.setReportPartNo(mesWorkOrder.getPartNo());
+                newMesProductOffLine.setReportPartNameRdd(mesWorkOrder.getPartNameRdd());
+                newMesProductOffLine.setItemPartNo(mesBom.getItemPartNo());
+                newMesProductOffLine.setItemPartNameRdd(mesBom.getItemPartName());
+                newMesProductOffLine.setItemQty(mesBom.getItemQty());
+                newMesProductOffLine.setQty(1d);
+                newMesProductOffLine.setReportSn(sn);
+                newMesProductOffLine.setBomVersion(mesBom.getBomVersion());
+                newMesProductOffLine.setSerialNumber(sn);
+                newMesProductOffLine.setUnit(mesBom.getUnit());
+                newMesProductOffLine.setItemUnit(mesBom.getItemUnit());
+                newMesProductOffLine.setWorkOrderNo(mesWorkOrder.getOrderNo());
+                newMesProductOffLine.setWorkCenterCode(mesWorkOrder.getWorkCenterCode());
+                newMesProductOffLine.setWorkCellCode(mesWorkOrder.getWorkCellCode());
+
+                ConvertBean.serviceModelInitialize(newMesProductOffLine, mesWorkOrder.getCreateUser());
+                mesProductOffLineList.add(newMesProductOffLine);
+            }
+        }
+        mesProductOffLineService.insertBatch(mesProductOffLineList);
+    }
 }

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/serviceimpl/base/MesWorkOrderToSapServiceImpl.java

@@ -0,0 +1,21 @@
+package cn.estsh.i3plus.ext.mes.apiservice.serviceimpl.base;
+
+import cn.estsh.i3plus.ext.mes.api.base.IMesWorkOrderToSapService;
+import cn.estsh.i3plus.platform.common.convert.ConvertBean;
+import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrder;
+import cn.estsh.i3plus.pojo.mes.bean.MesWorkOrderToSap;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+@Service
+@Slf4j
+public class MesWorkOrderToSapServiceImpl extends BaseMesService<MesWorkOrderToSap> implements IMesWorkOrderToSapService {
+
+    @Override
+    public MesWorkOrderToSap insert(MesWorkOrder mesWorkOrder) {
+        MesWorkOrderToSap mesWorkOrderToSap = new MesWorkOrderToSap(mesWorkOrder.getOrganizeCode(),
+                mesWorkOrder.getOrganizeCode(), mesWorkOrder.getPartNo(), mesWorkOrder.getProductVersion(), mesWorkOrder.getQty(), mesWorkOrder.getPlanEndTime());
+        ConvertBean.serviceModelUpdate(mesWorkOrderToSap,mesWorkOrder.getModifyUser());
+        return baseRDao.insert(mesWorkOrderToSap);
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/java/cn/estsh/i3plus/ext/mes/apiservice/unit/exception/MesException.java

@@ -0,0 +1,71 @@
+package cn.estsh.i3plus.ext.mes.apiservice.unit.exception;
+
+import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum;
+import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
+import cn.estsh.impp.framework.boot.exception.ImppBusiException;
+import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
+
+/**
+ * @Description : 抛出异常的工具类，用于简化抛出异常的代码
+ * @Reference :
+ * @Author : junsheng.li
+ * @CreateDate 2024/5/8 17:16
+ * @Modify:
+ **/
+public class MesException {
+
+    /**
+     * 抛出业务系统异常
+     * @param errorDetail 异常信息
+     * @param errorSolution 异常的解决方案
+     * @throws ImppBusiException
+     */
+    public static void throwFlowException(String errorDetail, String errorSolution)
+            throws ImppBusiException {
+
+        throw ImppExceptionBuilder.newInstance()
+                .setSystemID(CommonEnumUtil.SOFT_TYPE.MES.getCode())
+                .setErrorCode(ImppExceptionEnum.BUSINESS_EXCEPTION_DATA_ERROR.getCode())
+                .setErrorDetail(errorDetail)
+                .setErrorSolution(errorSolution)
+                .build();
+    }
+
+    /**
+     * 抛出业务系统异常
+     * @param errorDetail 异常信息
+     * @throws ImppBusiException
+     */
+    public static void throwFlowException(String errorDetail)
+            throws ImppBusiException {
+
+        throwFlowException(errorDetail, "");
+    }
+
+    /**
+     * WMS 抛出业务异常
+     * @param errorCode 错误代码
+     * @param errorDetail 错误详情
+     * @param errorSoluction 解决办法
+     */
+    public static void throwBusiException(String errorCode,String errorDetail,String errorSoluction,Object...args){
+        throw ImppExceptionBuilder.newInstance()
+                .setSystemID(CommonEnumUtil.SOFT_TYPE.MES.getCode())
+                .setErrorCode(errorCode)
+                .setErrorDetail(errorDetail,args)
+                .setErrorSolution(errorSoluction)
+                .build();
+    }
+    /**
+     * 抛异常
+     *
+     * @param
+     */
+    public static void throwMesBusiException(String errorDetailString, Object... args) {
+        throw ImppExceptionBuilder.newInstance()
+                .setSystemID(CommonEnumUtil.SOFT_TYPE.MES.getCode())
+                .setErrorCode(ImppExceptionEnum.BUSINESS_EXCEPTION_DATA_ERROR.getCode())
+                .setErrorDetail(errorDetailString,args)
+                .build();
+    }
+}

modules/i3plus-ext-mes-apiservice/src/main/resources/application-cus-71.properties

@@ -16,7 +16,23 @@ impp.mes.datasource.password=estsh123
 #\u6570\u636E\u6E90\u7684\u522B\u540D
 impp.yfas.datasource.alias=yfasDataSource
 impp.yfas.datasource.driver-class-name=com.mysql.jdbc.Driver
-impp.yfas.datasource.jdbc-url=jdbc:mysql://10.195.88.71:3306/impp_i3_mes?autoReconnect=true&useSSL=false&characterEncoding=utf-8&allowPublicKeyRetrieval=true
+impp.yfas.datasource.jdbc-url=jdbc:mysql://10.195.88.71:3306/impp_i3_wms_sap_if?autoReconnect=true&useSSL=false&characterEncoding=utf-8&allowPublicKeyRetrieval=true
 #impp.yfas.datasource.jdbc-url=jdbc:sqlserver://139.224.200.147:20037;DatabaseName=impp_i3_mes;
 impp.yfas.datasource.username=root
 impp.yfas.datasource.password=estsh123
+
+#\u6570\u636E\u6E90\u7684\u522B\u540D
+#impp.wms.datasource.isopen=true
+#impp.wms.datasource.alias=wmsDataSource
+#impp.wms.datasource.driver-class-name=com.mysql.jdbc.Driver
+#impp.wms.datasource.jdbc-url=jdbc:mysql://dbmaster:3306/impp_i3_wms?autoReconnect=true&useSSL=false&characterEncoding=utf-8
+#impp.wms.datasource.username=root
+#impp.wms.datasource.password=estsh123
+#
+##SWEB??????????
+#impp.sweb.datasource.isopen=true
+#impp.sweb.datasource.alias=swebDataSource
+#impp.sweb.datasource.driver-class-name=com.mysql.jdbc.Driver
+#impp.sweb.datasource.jdbc-url=jdbc:mysql://dbmaster:3306/impp_i3_wms?autoReconnect=true&useSSL=false&characterEncoding=utf-8
+#impp.sweb.datasource.username=root
+#impp.sweb.datasource.password=estsh123

modules/i3plus-ext-mes-apiservice/src/main/resources/application.properties

@@ -1,5 +1,5 @@
 #\u9879\u76EE\u540D\u79F0
-spring.application.name=mes-zxw
+spring.application.name=mes
 #\u4F7F\u7528\u914D\u7F6E
 spring.profiles.active=71,cus-71
 ######### \u81EA\u5B9A\u4E49\u53C2\u6570 #########

modules/i3plus-ext-mes-pojo/pom.xml

@@ -19,7 +19,10 @@
             <version>1.0.0-yfai</version>
 
         </dependency>
-
+        <dependency>
+            <groupId>org.quartz-scheduler</groupId>
+            <artifactId>quartz</artifactId>
+        </dependency>
 
 
     </dependencies>

modules/i3plus-ext-mes-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pojo/util/CronUtil.java

@@ -0,0 +1,42 @@
+package cn.estsh.i3plus.ext.mes.pojo.util;
+
+
+import org.quartz.TriggerUtils;
+import org.quartz.impl.triggers.CronTriggerImpl;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+/**
+ * @Description :CronUtil
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 16:08
+ * @Modify:
+ **/
+public class CronUtil {
+
+
+
+    public static String getRecentTriggerTime(String cron) {
+        String newTime = "";
+        try {
+            CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
+            cronTriggerImpl.setCronExpression(cron);
+            //下次执行时间 增加一秒
+            Date cronTime = new Date();
+            cronTime.setTime(new Date().getTime()+1000);
+            cronTriggerImpl.setStartTime(cronTime);
+            // 这个是重点，一行代码搞定
+            List<Date> dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null,5 );
+            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            newTime = dateFormat.format(dates.get(0));
+
+        } catch (ParseException e) {
+            e.printStackTrace();
+        }
+        return newTime;
+    }
+
+}

modules/i3plus-ext-mes-pojo/src/main/java/cn/estsh/i3plus/ext/mes/pojo/util/OverwriteStringJoin.java

@@ -0,0 +1,35 @@
+package cn.estsh.i3plus.ext.mes.pojo.util;
+
+
+import java.util.List;
+import java.util.Objects;
+import java.util.StringJoiner;
+/**
+ * @Description :OverwriteStringJoin
+ * @Reference :
+ * @Author : gsz
+ * @CreateDate : 2024-05-10 16:08
+ * @Modify:
+ **/
+public class OverwriteStringJoin {
+
+    public static String join(CharSequence delimiter, CharSequence... elements) {
+        Objects.requireNonNull(delimiter);
+        Objects.requireNonNull(elements);
+        StringJoiner joiner = new StringJoiner(delimiter);
+        for (CharSequence cs: elements) {
+            joiner.add("'" + cs + "'");
+        }
+        return joiner.toString();
+    }
+    public static String join(CharSequence delimiter, List<String> elements) {
+        Objects.requireNonNull(delimiter);
+        Objects.requireNonNull(elements);
+        StringJoiner joiner = new StringJoiner(delimiter);
+        for (String cs: elements) {
+            joiner.add("'" + cs + "'");
+        }
+        return joiner.toString();
+    }
+
+}