merage

kimi

2020-05-27 c007f0ca1785db093d48f4846cda82fe8e955765

merage

 .gitignore

@@ -33,3 +33,4 @@
mvnw.cmd
.mvn/
*.gz
mdm.log

 mdm.log

File was deleted

 src/main/java/com/highdatas/mdm/controller/MasterAuthorController.java

@@ -567,9 +567,7 @@
                        String maintainFieldId = masterAuthor.getMaintainFieldId();
                        String tableName = masterAuthor.getTableName();
                        List<Maintain> maintainByMaintainField = maintainFieldService.getMaintainByMaintainField(maintainFieldId, tableName);
                        if (maintainByMaintainField != null && !maintainByMaintainField.isEmpty()) {
                            maintainSet.addAll(maintainByMaintainField);
                        }
                        maintainSet.addAll(maintainByMaintainField);
                    }
                    int unActiveCnt = masterAuthorUnactiveService.selectCount(new EntityWrapper<MasterAuthorUnactive>().in("maintain_id", maintainSet).eq("user_id", user.getUserId()));
                    if (maintainSet.size() != unActiveCnt) {

 src/main/java/com/highdatas/mdm/controller/MasterDataController.java

@@ -6,7 +6,10 @@
import com.highdatas.mdm.entity.Character;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.*;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Operate;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.pojo.SysAssembleUpdateType;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
@@ -232,11 +235,9 @@
                jsonObject.remove(Constant.ID);
                datas = jsonObject.toJSONString();
                String updateSegment = masterDataService.getUpdateSegment(maintain.getTableName(), maintain.getTableName() + Constant.RECORD, datas);
                String tempTable = maintain.getTableName() + Constant.RECORD;
                Segment segment = new Segment(MessageFormat.format(Constant.Alias, tempTable, Constant.STD_ID), id);

                tableInfoMapper.update(tempTable, updateSegment, segment.toString());
                result = Result.success(null);
                Integer updateCount = tableInfoMapper.updateRecordByMaintainId(maintain.getTableName() + Constant.RECORD, updateSegment, DbUtils.quotedStr(maintainId));
                result = Result.success(updateCount);
                break;
            case create:
                JSONObject createObject = JSONObject.parseObject(datas);

 src/main/java/com/highdatas/mdm/controller/MenuMappingController.java

@@ -91,14 +91,17 @@
        String menuId = menuMapping.getMenuId();
        SysMenu menu = menuService.selectById(menuId);
        String preParentId = menu.getParentId();
        menu.setName(menuMapping.getName()).updateById();

        String themeId = menuMapping.getThemeId();
//        if (!preParentId.equalsIgnoreCase(themeId)) {
////            menu.setParentId(themeId);
////            menu.updateById();
////        }
        if (!preParentId.equalsIgnoreCase(themeId)) {
            menu.setParentId(themeId);
            menu.updateById();
        }
        boolean updated = menuMapping.updateById();
        if (updated) {



            TUser user = DbUtils.getUser(request);
            if (menu != null) {
                LinkedHashSet<String> parentIdSet = new LinkedHashSet<>();

 src/main/java/com/highdatas/mdm/controller/SettleController.java

New file
@@ -0,0 +1,772 @@
package com.highdatas.mdm.controller;



import com.alibaba.druid.pool.DruidPooledConnection;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONArray;

import com.alibaba.fastjson.JSONObject;



import com.highdatas.mdm.entity.TUser;

import com.highdatas.mdm.pojo.kettle.UnBigDataDataSourceInfo;

import com.highdatas.mdm.pojo.kettle.KettleDBTrans;

import com.highdatas.mdm.pojo.kettle.TableColumn;

import org.pentaho.di.core.KettleClientEnvironment;

import org.pentaho.di.core.database.Database;

import org.pentaho.di.core.database.DatabaseMeta;

import org.pentaho.di.core.logging.LoggingObjectInterface;

import org.pentaho.di.core.logging.LoggingObjectType;

import org.pentaho.di.core.logging.SimpleLoggingObject;

import org.pentaho.di.core.row.RowMetaInterface;

import org.pentaho.di.trans.Trans;

import org.pentaho.di.trans.TransHopMeta;

import org.pentaho.di.trans.TransMeta;

import org.pentaho.di.trans.step.StepMeta;

import org.pentaho.di.trans.steps.dummytrans.DummyTransMeta;



import org.pentaho.di.trans.steps.tableinput.TableInputMeta;

import org.pentaho.di.trans.steps.tableoutput.TableOutputMeta;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;



import javax.servlet.http.HttpServletResponse;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;



@Controller

@RequestMapping("/database")

//http://localhost:8080/users/addUser

public class SettleController {



	
    @Autowired

    private UnBigDataDataSourceInfo dataSourceConn;

	
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");

    private String STEP_READ_FROM_TABLE = "Read data from table";

    private String STEP_INSERT_UPDATE = "Insert or update";

    private String STEP_DUMMY = "Dummy";

	


    /**

     * 提取mongodb数据

     * @param response

     * @param transData

     * @return

     * @throws

     */

//    @RequestMapping("/drawMongoDB")

//    @ResponseBody

//    public String drawMongoDB(HttpServletResponse response, @RequestBody JSONObject transData) {

//        String returnStr = "";

//        try {

//             KettleClientEnvironment.init();

//

//             TransMeta transMeta = new TransMeta();

//             transMeta.setName("抽取mongodb数据");

//             //导出数据的数据库连接

//             DatabaseMeta dataBaseOutput = new DatabaseMeta("Output", dataSourceConn.getDbType(), "Native", dataSourceConn.getDbHostName(), dataSourceConn.getDbName(), dataSourceConn.getDbPort(),

//                                                            dataSourceConn.getUsername(), dataSourceConn.getPassword());

//             transMeta.addDatabase(dataBaseOutput);

//

//                 MongoDbInputMeta mongoDbInputMeta = new MongoDbInputMeta();

//                 mongoDbInputMeta.setHostnames(transData.getString("hostName"));

//                 mongoDbInputMeta.setAuthenticationDatabaseName(transData.getString("authDBName"));

//                 mongoDbInputMeta.setPort(transData.getString("portNum"));

//                 mongoDbInputMeta.setAuthenticationUser(transData.getString("userName"));

//                 mongoDbInputMeta.setAuthenticationPassword(transData.getString("pwd"));

//                 mongoDbInputMeta.setDbName(transData.getString("dbName"));

//                 mongoDbInputMeta.setCollection(transData.getString("collection"));

//                 //得到抽取字段

//                 ArrayList<String> fieldList = new ArrayList<String>(transData.getString("drawfield").split(",").length);

//                 Collections.addAll(fieldList, transData.getString("drawfield").split(","));

//                 //设置不取JSON字段

//                 mongoDbInputMeta.setOutputJson(false);

//             //设置提取字段名称、path、type

//             List<MongoField> normalList = new ArrayList<MongoField>();

//             for (String fieldStr : fieldList) {

//                  MongoField newField = new MongoField();

//                  newField.m_fieldName = fieldStr;

//                  newField.m_fieldPath = "$." + fieldStr;

//                  newField.m_kettleType = "String";

//                  normalList.add(newField);

//             }

//             //设置mongodb提取字段

//             mongoDbInputMeta.setMongoFields(normalList);

//             //设置mogodb步骤元

//             StepMeta inputMongoDBStep = new StepMeta(STEP_READ_FROM_TABLE, mongoDbInputMeta);

//             inputMongoDBStep.setLocation(50, 50);

//             inputMongoDBStep.setDraw(true);

//             //将mogodb步骤元加入转化中

//             transMeta.addStep(inputMongoDBStep);

//

//             //设置mysql元

//             TableOutputMeta tableOutputMeta = new TableOutputMeta();

//             //设置数据库元

//             tableOutputMeta.setDatabaseMeta(transMeta.findDatabase("Output"));

//             //mongodb中数据库表/集合,就是表名

//             tableOutputMeta.setTableName(transData.getString("collection"));

//             //将mysql元加入步骤元

//             StepMeta insertUpdateStep = new StepMeta(STEP_INSERT_UPDATE, tableOutputMeta);

//             insertUpdateStep.setLocation(150, 50);

//             insertUpdateStep.setDraw(true);

//

//             transMeta.addStep(insertUpdateStep);

//

//             //增加个空元，

//             DummyTransMeta dummyMeta = new DummyTransMeta();

//

//             //将空元加入步骤元

//             StepMeta dummyStep = new StepMeta(STEP_DUMMY,dummyMeta);

//             dummyStep.setLocation(200, 50);

//             dummyStep.setDraw(true);

//

//             transMeta.addStep(dummyStep);

//

//             //设置步骤直接的关系

//             TransHopMeta hop = new TransHopMeta(inputMongoDBStep, insertUpdateStep);

//             transMeta.addTransHop(hop);

//             TransHopMeta hop2 = new TransHopMeta(insertUpdateStep, dummyStep);

//             transMeta.addTransHop(hop2);

//

//             //开始执行数据抽取

//             //将转化元实例化转换

//             Trans trans = new Trans(transMeta);

//             trans.prepareExecution(null);

//

//             trans.startThreads();

//             trans.waitUntilFinished();

//

//             if (trans.getErrors() > 0) {

//                 System.out.println(">>>>>>>>>> ERROR");

//                 returnStr = "{result:\"fail\"}";

//             }

//             else {

//                 System.out.println(">>>>>>>>>> SUCCESS ");

//                 returnStr = "{result:\"success\"}";

//             }

//        } catch(Exception e) {

//             return "{result:\"fail\"}";

//        }

//        return returnStr;

//    }

//

//    /**

//     * 提取mongodb数据

//     * @param response

//     * @param transData

//     * @return

//     * @throws

//     */

//    @RequestMapping("/drawHbase")

//    @ResponseBody

//    public String drawHbase(HttpServletResponse response, @RequestBody JSONObject transData) {

//        String returnStr = "";

//        try {

//            KettleClientEnvironment.init();

//

//            TransMeta transMeta = new TransMeta();

//            transMeta.setName("抽取Hbase数据");

//            //导出数据的数据库连接

//            DatabaseMeta dataBaseOutput = new DatabaseMeta("Output", dataSourceConn.getDbType(), "Native", dataSourceConn.getDbHostName(), dataSourceConn.getDbName(), dataSourceConn.getDbPort(),

//                    dataSourceConn.getUsername(), dataSourceConn.getPassword());

//            transMeta.addDatabase(dataBaseOutput);

//            //HBaseInputMeta hBaseInputMeta= new HBaseInputMeta()

//

//            MongoDbInputMeta mongoDbInputMeta = new MongoDbInputMeta();

//            mongoDbInputMeta.setHostnames(transData.getString("hostName"));

//            mongoDbInputMeta.setAuthenticationDatabaseName(transData.getString("authDBName"));

//            mongoDbInputMeta.setPort(transData.getString("portNum"));

//            mongoDbInputMeta.setAuthenticationUser(transData.getString("userName"));

//            mongoDbInputMeta.setAuthenticationPassword(transData.getString("pwd"));

//            mongoDbInputMeta.setDbName(transData.getString("dbName"));

//            mongoDbInputMeta.setCollection(transData.getString("collection"));

//            //得到抽取字段

//            ArrayList<String> fieldList = new ArrayList<String>(transData.getString("drawfield").split(",").length);

//            Collections.addAll(fieldList, transData.getString("drawfield").split(","));

//            //设置不取JSON字段

//            mongoDbInputMeta.setOutputJson(false);

//            //设置提取字段名称、path、type

//            List<MongoField> normalList = new ArrayList<MongoField>();

//            for (String fieldStr : fieldList) {

//                MongoField newField = new MongoField();

//                newField.m_fieldName = fieldStr;

//                newField.m_fieldPath = "$." + fieldStr;

//                newField.m_kettleType = "String";

//                normalList.add(newField);

//            }

//            //设置mongodb提取字段

//            mongoDbInputMeta.setMongoFields(normalList);

//            //设置mogodb步骤元

//            StepMeta inputMongoDBStep = new StepMeta(STEP_READ_FROM_TABLE, mongoDbInputMeta);

//            inputMongoDBStep.setLocation(50, 50);

//            inputMongoDBStep.setDraw(true);

//            //将mogodb步骤元加入转化中

//            transMeta.addStep(inputMongoDBStep);

//

//            //设置mysql元

//            TableOutputMeta tableOutputMeta = new TableOutputMeta();

//            //设置数据库元

//            tableOutputMeta.setDatabaseMeta(transMeta.findDatabase("Output"));

//            //mongodb中数据库表/集合,就是表名

//            tableOutputMeta.setTableName(transData.getString("collection"));

//            //将mysql元加入步骤元

//            StepMeta insertUpdateStep = new StepMeta(STEP_INSERT_UPDATE, tableOutputMeta);

//            insertUpdateStep.setLocation(150, 50);

//            insertUpdateStep.setDraw(true);

//

//            transMeta.addStep(insertUpdateStep);

//

//            //增加个空元，

//            DummyTransMeta dummyMeta = new DummyTransMeta();

//

//            //将空元加入步骤元

//            StepMeta dummyStep = new StepMeta(STEP_DUMMY,dummyMeta);

//            dummyStep.setLocation(200, 50);

//            dummyStep.setDraw(true);

//

//            transMeta.addStep(dummyStep);

//

//            //设置步骤直接的关系

//            TransHopMeta hop = new TransHopMeta(inputMongoDBStep, insertUpdateStep);

//            transMeta.addTransHop(hop);

//            TransHopMeta hop2 = new TransHopMeta(insertUpdateStep, dummyStep);

//            transMeta.addTransHop(hop2);

//

//            //开始执行数据抽取

//            //将转化元实例化转换

//            Trans trans = new Trans(transMeta);

//            trans.prepareExecution(null);

//

//            trans.startThreads();

//            trans.waitUntilFinished();

//

//            if (trans.getErrors() > 0) {

//                System.out.println(">>>>>>>>>> ERROR");

//                returnStr = "{result:\"fail\"}";

//            }

//            else {

//                System.out.println(">>>>>>>>>> SUCCESS ");

//                returnStr = "{result:\"success\"}";

//            }

//        } catch(Exception e) {

//            return "{result:\"fail\"}";

//        }

//        return returnStr;

//    }



    /**

     * 测试数据库连接

     * @param response

     * @param transData

     * @return

     * @throws Exception

     */

    @RequestMapping("/connectionDB")

    @ResponseBody

    public String connectionDB(HttpServletResponse response, @RequestBody JSONObject transData, TUser users) throws Exception {

        //userService.addUser(users);

        KettleClientEnvironment.init();

        DatabaseMeta dataMeta = new DatabaseMeta("KettleDBRep", transData.getString("type"), "Native", transData.getString("hostName"), transData.getString("dbName"), transData.getString("portNum"),

                                                 transData.getString("userName"), transData.getString("pwd"));

        LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

        Database ds = new Database(loggingObject, dataMeta);

        ds.normalConnect(null);

        Connection conn = ds.getConnection(); 
/*        PreparedStatement stmt = conn.prepareStatement("select * from usr");

        ResultSet rslt = stmt.executeQuery();

        while (rslt.next()) {

            System.out.println(rslt.getString("username"));

        }*/

        ds.disconnect();

        return "{result:\"success\"}";

    }

	
    /**

     * 创建SQL中tablename

     * 返回表名

     */

    public String createSQLTable(DruidPooledConnection connSys, ResultSet rslt) throws Exception {

        List<TableColumn> columnNameAndType = new ArrayList<TableColumn>();

        ResultSetMetaData md = rslt.getMetaData();

        for (int i = 1; i <= md.getColumnCount(); i++) {

             TableColumn tableColumn = new TableColumn();

             tableColumn.setColumnName(md.getColumnName(i));

             tableColumn.setColumnType(md.getColumnTypeName(i));

             tableColumn.setColumnLength(String.valueOf(md.getColumnDisplaySize(i)));

             columnNameAndType.add(tableColumn);			 
        }

        //创建表

        String SQLStr = "", tableName = "";

        if (!columnNameAndType.isEmpty()) {

            tableName = "SQL_" + sdf.format(new Date());

            SQLStr = splicingSQL(tableName, columnNameAndType);

            PreparedStatement stmt = connSys.prepareStatement(SQLStr);

            stmt.execute();	
        }

        return tableName;	    
    }

	
    /**

     * 通过SQL提取数据

     */

    @RequestMapping("/sqlPick")

    @ResponseBody

    public String sqlPick(@RequestBody JSONObject dbData) {

        try {

             String tableName = "", sqlStr = "";



             Database dsInput = null;

             Database dsOutput = null;

             TableInputMeta tableInputMeta = new TableInputMeta();

             TableOutputMeta talbeOutputMeta = new TableOutputMeta();

             TransMeta transMeta = new TransMeta();

             KettleDBTrans kettleDBTrans = new KettleDBTrans();

             kettleDBTrans.setDsInput(dsInput);

             kettleDBTrans.setDsOutput(dsOutput);

             kettleDBTrans.setTableInputMeta(tableInputMeta);

             kettleDBTrans.setTalbeOutputMeta(talbeOutputMeta);

             kettleDBTrans.setTransMeta(transMeta);

			 
             kettleDBConn(kettleDBTrans);

		     
             //SQL提取数据

             tableName = "SQL_" + sdf.format(new Date());

             sqlStr = dbData.getString("sqlStr");

             dataExtraction(tableName, sqlStr, kettleDBTrans);

             kettleDBTrans.getDsInput().disconnect();

             kettleDBTrans.getDsOutput().disconnect();

        } catch(Exception e) {

             return "{result:\"fail\"}";	
        }

        return "{result:\"success\"}";

    }

    /**

     * 抽取SQL数据

     */

    public void  extractSQLData(DruidPooledConnection connSys, ResultSet rslt, String tableName) throws Exception {

        PreparedStatement stmtDes;

        int columnCount;

        String SQLStr = "", valueStr = "";

        columnCount = rslt.getMetaData().getColumnCount();

        SQLStr = " insert into "+tableName+" ( ";

        valueStr = " values (";

        for(int i = 0; i < columnCount; i++) {

            SQLStr = SQLStr + rslt.getMetaData().getColumnName(i+1) + ", ";

            valueStr = valueStr + "?, ";

        }

        SQLStr = SQLStr.substring(0, SQLStr.length() - 2) + ")";

        valueStr = valueStr.substring(0, valueStr.length() - 2) + ")";

        SQLStr = SQLStr + valueStr;

        stmtDes = connSys.prepareStatement(SQLStr);

        while (rslt.next()) {

               for(int i = 0; i < columnCount; i++) {

                   stmtDes.setString(i + 1, rslt.getString(i+1));

               }

               stmtDes.addBatch();

        }

        stmtDes.executeBatch();		
    }

    /**

     * 测试SQL语句正确性

     */

    @RequestMapping("/sqlTest")

    @ResponseBody

    public String sqlTest(@RequestBody JSONObject dbData) {

		
        try {

             //连接数据库

             String dbConn = dbData.getString("DBConn");

             JSONObject DBParam = JSONArray.parseObject(dbConn);

			 
             KettleClientEnvironment.init();

             DatabaseMeta dataMeta = new DatabaseMeta("KettleDBRep", DBParam.getString("type"), "Native", DBParam.getString("hostName"), DBParam.getString("dbName"), DBParam.getString("portNum"),

                                                       DBParam.getString("userName"), DBParam.getString("pwd"));

             LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

             Database ds = new Database(loggingObject, dataMeta);

             ds.connect();

             Connection conn = ds.getConnection();

             String sqlStr = dbData.getString("sqlStr");

             PreparedStatement stmt = conn.prepareStatement(sqlStr);

             stmt.executeQuery();	
             ds.disconnect();

        } catch(Exception e) {

             return "{result:\"fail\"}";	
        }

        return "{result:\"success\"}";		
    }

    /**

     * 当选中数据表选项卡，显示数据表及视图名称

     * @param response

     * @param transData

     * @return

     * @throws Exception

     */

    @RequestMapping("/showTableAndView")

    @ResponseBody

    public String showTableAndView(HttpServletResponse response, @RequestBody JSONObject transData) throws Exception {

        KettleClientEnvironment.init();

        DatabaseMeta dataMeta = new DatabaseMeta("KettleDBRep", transData.getString("type"), "Native", transData.getString("hostName"), transData.getString("dbName"), transData.getString("portNum"),

                                                 transData.getString("userName"), transData.getString("pwd"));

		
        LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

        Database ds = new Database(loggingObject, dataMeta);

        //ds.normalConnect(null);

        ds.connect();

        Connection conn = ds.getConnection();

        List<String> UTable = new ArrayList<String>();

        List<String> VTable = new ArrayList<String>();

        //得到数据库中的表

//        PreparedStatement stmt = conn.prepareStatement("select name from sysobjects where xtype='U'");

//        ResultSet rslt = stmt.executeQuery();

//        while (rslt.next()) {

//               UTable.add(rslt.getString("name"));

//        }

//        String[] UTableArray = ds.getTablenames("dbo", true);

//        for (int i = 0; i < UTableArray.length; i++) {

//             UTable.add(UTableArray[i].replace("dbo.", ""));

//        }

        String[] UTableArray = ds.getTablenames(true);

        for (int i = 0; i < UTableArray.length; i++) {

             int lastHao = UTableArray[i].lastIndexOf(".");

             String uTable = UTableArray[i];

             if (lastHao > 0) {

                 UTable.add(uTable.substring(lastHao + 1, uTable.length()));

             }

             else {

                 UTable.add(UTableArray[i]);

             }

		     
        }		
        String tableJson = JSON.toJSONString(UTable);

        //得到数据库中的视图

//        stmt = conn.prepareStatement("select name from sysobjects where xtype='V'");

//        rslt = stmt.executeQuery();

//        while (rslt.next()) {

//               VTable.add(rslt.getString("name"));

//        }	
        String[] VTableArray = ds.getViews("dbo", true);

        for (int i = 0; i < VTableArray.length; i++) {

             VTable.add(VTableArray[i].replace("dbo.", ""));

        }			
        String viewJson = JSON.toJSONString(VTable);

        ds.disconnect();

        return "{result:\"success\",table:["+tableJson+"],view:["+viewJson+"]}";

    }

    /**

     * 使用kettle创建表 
     */

    public void createTable(Database dsOutput, RowMetaInterface rm, String tableName) {

       try {

            System.out.println("开始创建表:" + tableName);

            String dbProName = dsOutput.getConnection().getMetaData().getDatabaseProductName();

            System.out.println("数据库类型:" + dbProName);

            String sql = dsOutput.getDDL(tableName, rm);

            dsOutput.execStatement(sql.replace(";", ""));

            System.out.println("创建表成功");		   
       } catch(Exception e) {

            System.out.println("创建表失败");

       }



    }

    /**

     * 新版抽取数据

     * dataExtraction(String tableName, String sqlStr, TransMeta transMeta, Database dsInput, Database dsOutput, TableInputMeta tableInputMeta, TableOutputMeta tableOutputMeta) throws Exception {

       tableInputMeta.setSQL(sqlStr);

     */

    public void dataExtraction(String tableName, String sqlStr, KettleDBTrans kettleDBTrans) throws Exception {

       kettleDBTrans.getTableInputMeta().setSQL(sqlStr);

	   
       StepMeta inputStep = new StepMeta(STEP_READ_FROM_TABLE, kettleDBTrans.getTableInputMeta());

       inputStep.setLocation(50, 50);

       inputStep.setDraw(true);

       kettleDBTrans.getTransMeta().addStep(inputStep);

	   
       //判断目标数据库中，是否存在表，如:存在重新命名表名，用新表名创建表，如:不存在,直接创建表

       boolean hasTable = kettleDBTrans.getDsOutput().checkTableExists(tableName);

       if (hasTable) {

           tableName = tableName + "_" + sdf.format(new Date());

       }

       //得到原始表结构

       PreparedStatement stmt = null;

       RowMetaInterface rm = null;

       stmt = kettleDBTrans.getDsInput().getConnection().prepareStatement(sqlStr);

       stmt.executeQuery();

       rm = kettleDBTrans.getDsInput().getQueryFields(sqlStr, false);

       //创建数据表

       createTable(kettleDBTrans.getDsOutput(), rm, tableName);

	   
       kettleDBTrans.getTalbeOutputMeta().setTableName(tableName);

	   
       StepMeta insertUpdateStep = new StepMeta(STEP_INSERT_UPDATE, kettleDBTrans.getTalbeOutputMeta());

       insertUpdateStep.setLocation(150, 50);

       insertUpdateStep.setDraw(true);

       kettleDBTrans.getTransMeta().addStep(insertUpdateStep);

	   
       DummyTransMeta dummyMeta = new DummyTransMeta();

	   
       StepMeta dummyStep = new StepMeta(STEP_DUMMY, dummyMeta);

       dummyStep.setLocation(200, 50);

       dummyStep.setDraw(true);

	   
       kettleDBTrans.getTransMeta().addStep(dummyStep);

	   
       //设置步骤直接的关系

       TransHopMeta hop = new TransHopMeta(inputStep, insertUpdateStep);

       kettleDBTrans.getTransMeta().addTransHop(hop);

       TransHopMeta hop2 = new TransHopMeta(insertUpdateStep, dummyStep);

       kettleDBTrans.getTransMeta().addTransHop(hop2);

	   
       //开始执行

       Trans trans = new Trans(kettleDBTrans.getTransMeta());

       trans.prepareExecution(null);

	   
       trans.startThreads();

	   
       trans.waitUntilFinished();

	   
       if (trans.getErrors() > 0) {

           System.out.println(">>>>>>>>>> ERROR");

       }

       else {

           System.out.println(">>>>>>>>>> SUCCESS ");

       }

    }

    /**

     * 创建集成方法

     */

    public void kettleDBConn(KettleDBTrans kettleDBTrans) throws Exception {

        //连接数据库

//        String dbConn = kettleDBTrans.getAssemble().getString("DBConn");\

        String dbConn= "";

        JSONObject DBParam = JSONArray.parseObject(dbConn);

        //初始化kettle环境

        KettleClientEnvironment.init();

        KettleClientEnvironment.init();

        //导入数据的数据库连接

        DatabaseMeta dataMetaInput = new DatabaseMeta("Input", DBParam.getString("type"), "Native", DBParam.getString("hostName"), DBParam.getString("dbName"), DBParam.getString("portNum"),

                                                      DBParam.getString("userName"), DBParam.getString("pwd"));

        //导出数据的数据库连接

        DatabaseMeta dataMetaOutput = new DatabaseMeta("Output", dataSourceConn.getDbType(), "Native", dataSourceConn.getDbHostName(), dataSourceConn.getDbName(), dataSourceConn.getDbPort(),

                                                       dataSourceConn.getUsername(), dataSourceConn.getPassword());

        //导出数据库连接

        LoggingObjectInterface loggingObject = new SimpleLoggingObject("Database factory", LoggingObjectType.GENERAL, null );

        kettleDBTrans.setDsInput(new Database(loggingObject, dataMetaInput));

        kettleDBTrans.getDsInput().connect();

        Connection connInput = kettleDBTrans.getDsInput().getConnection();

        //导入数据库连接

        kettleDBTrans.setDsOutput(new Database(loggingObject, dataMetaOutput));

        kettleDBTrans.getDsOutput().connect();

        Connection connOutput = kettleDBTrans.getDsOutput().getConnection();

		
        kettleDBTrans.getTransMeta().setName("数据抽取");

		
        kettleDBTrans.getTransMeta().addDatabase(dataMetaInput);

        kettleDBTrans.getTransMeta().addDatabase(dataMetaOutput);

		
        //导出数据

        kettleDBTrans.getTableInputMeta().setDatabaseMeta(kettleDBTrans.getTransMeta().findDatabase("Input"));

        //导入数据

        kettleDBTrans.getTalbeOutputMeta().setDatabaseMeta(kettleDBTrans.getTransMeta().findDatabase("Output"));		
    }

    /**

     * 1.得到要提取数据的表与视图名称

     * 2.在程序数据库中创建要提取数据的表与视图的表的名称

     * 3.将要提取表与视图中的数据存储到系统的实体表中

     * 4.最后，返回结果

     */

    //提取表、视图中的数据

    @RequestMapping("/extractDBData")

    @ResponseBody

    public String extractDBData(HttpServletResponse response, @RequestBody JSONObject dbData) throws Exception {

        //表

        int k = 0;

        String sqlStr = "", tableName = "";

		
        Database dsInput = null;

        Database dsOutput = null;

        TableInputMeta tableInputMeta = new TableInputMeta();

        TableOutputMeta talbeOutputMeta = new TableOutputMeta();

        TransMeta transMeta = new TransMeta();

        KettleDBTrans kettleDBTrans    = new KettleDBTrans();

//        kettleDBTrans.setDbData(dbData);

        kettleDBTrans.setDsInput(dsInput);

        kettleDBTrans.setDsOutput(dsOutput);

        kettleDBTrans.setTableInputMeta(tableInputMeta);

        kettleDBTrans.setTalbeOutputMeta(talbeOutputMeta);

        kettleDBTrans.setTransMeta(transMeta);

		
        kettleDBConn(kettleDBTrans);

		
        JSONArray uTable = dbData.getJSONArray("UTable");

        //循环实体表

        if (!uTable.isEmpty()) {

            for(k = 0; k < uTable.size(); k++) {

                tableName = uTable.getString(k);

                sqlStr = " select * from " + tableName;

                dataExtraction(tableName, sqlStr, kettleDBTrans);

            }

        }

		
        JSONArray vTable = dbData.getJSONArray("VTable");

        //循环视图

        if (!vTable.isEmpty()) {

            for(k = 0; k < vTable.size(); k++) {

                tableName = vTable.getString(k);

                sqlStr = " select * from " + tableName;

                dataExtraction(tableName, sqlStr, kettleDBTrans);

            }

        }		
        //关闭数据库连接

        kettleDBTrans.getDsInput().disconnect();

        kettleDBTrans.getDsOutput().disconnect();

        return "{result: \"success\"}";

    }

	
    /**

     *     抽取数据

     * extractData(connSys, realTableName, conn, tableName);

     * connSys 系统数据库

     * realTableName 系统数据库表名

     * conn 提取数据库

     * tableName 提取数据库表名 
     */

    public void extractData(DruidPooledConnection connSys, String tableNameDes, Connection conn, String tableNameSrc) throws Exception {

        PreparedStatement stmt, stmtDes;

        ResultSet rslt;

        int columnCount;

        String SQLStr = "", valueStr = "";

		
        SQLStr = " select * from "+tableNameSrc+" ";

        stmt = conn.prepareStatement(SQLStr);

        rslt = stmt.executeQuery();

        columnCount = rslt.getMetaData().getColumnCount();

        SQLStr = " insert into "+tableNameDes+" ( ";

        valueStr = " values (";

        for(int i = 0; i < columnCount; i++) {

            SQLStr = SQLStr + rslt.getMetaData().getColumnName(i+1) + ", ";

            valueStr = valueStr + "?, ";

        }

        SQLStr = SQLStr.substring(0, SQLStr.length() - 2) + ")";

        valueStr = valueStr.substring(0, valueStr.length() - 2) + ")";

        SQLStr = SQLStr + valueStr;

        stmtDes = connSys.prepareStatement(SQLStr);

        while (rslt.next()) {

               for(int i = 0; i < columnCount; i++) {

                   stmtDes.setString(i + 1, rslt.getString(i+1));

               }

               stmtDes.addBatch();

        }

        stmtDes.executeBatch();

    }

	
    /**

     * 根据数据库类型转换对应类型

     * 
     */

    public String getColumnStr(TableColumn tableColumn) throws Exception {

        StringBuffer sqlStr = new StringBuffer();

        String returnStr = "";

        if (tableColumn.getColumnType().contains("varchar")) {

            sqlStr.append(tableColumn.getColumnName() + " varchar(" + tableColumn.getColumnLength() + "),");

        }

        else if (tableColumn.getColumnType().contains("int")) {

            sqlStr.append(tableColumn.getColumnName() + " int(" + tableColumn.getColumnLength() + "),");

        }

        else if (tableColumn.getColumnType().contains("date")) {

            sqlStr.append(tableColumn.getColumnName() + " date,");

        }

        else if (tableColumn.getColumnType().contains("nvarchar")) {

            sqlStr.append(tableColumn.getColumnName() + " varchar(" + tableColumn.getColumnLength() + "),");

        }

        else if (tableColumn.getColumnType().contains("nchar")) {

            sqlStr.append(tableColumn.getColumnName() + " varchar(" + tableColumn.getColumnLength() + "),");

        }	
        return sqlStr.toString();

    }

	
    /**

     * 拼接创建新表的语句

     * 1.系统数据库是mysql,所以，需要将其它数据库的类型，转换成mysql可以识别的类型

     */

    public String splicingSQL(String tableName,  List<TableColumn> columnNameAndType) throws Exception {

        String sqlStr = "";

        //第一步,类型 识别类型

        sqlStr = "create table " + tableName + " (";

        StringBuffer columnStr = new StringBuffer();

        columnStr.append(sqlStr);

        for (TableColumn tableColumn : columnNameAndType) {

             columnStr.append(getColumnStr(tableColumn));

        }

        sqlStr = columnStr.toString();

        return sqlStr.substring(0, sqlStr.length() - 1) + ")";

    }

    /**

     * 创建表

     * 1.需要判段,系统数据库中是否已存在表名(1.有的话重新命名,tableName + 年月日时分秒

     */

    public String createTable(DruidPooledConnection connSys, String tableName, List<TableColumn> columnNameAndType) throws Exception {

        String SQLStr = "";

        if (!columnNameAndType.isEmpty()) {

            PreparedStatement stmt;

            ResultSet rslt;

			
            SQLStr = " select count(table_name) as tableNum "

                   + " from information_schema.tables "

                   + " where table_schema='ssm' and table_name='"+tableName+"'";

            stmt = connSys.prepareStatement(SQLStr);

            rslt = stmt.executeQuery();

            rslt.next();

            if (rslt.getInt("tableNum") > 0) {

                tableName = tableName + "_" + sdf.format(new Date());

            }

            SQLStr = splicingSQL(tableName, columnNameAndType);

            stmt = connSys.prepareStatement(SQLStr);

            stmt.execute();	
        }

        return tableName;

    }

	
	
    //得到抽取数据库表的字段名称及字段类型

    public List<TableColumn> getColumnNameAndType(Connection conn, String tableName, String type) throws Exception {

        List<TableColumn> columnNameAndType = new ArrayList<TableColumn>();

        //得到数据库中的表

        String SQLStr = " select c.name As ColumnsName , t.name as ColumnsType, c.length as ColumnsLength "

                       + " from SysObjects As o "

                       + " left join SysColumns As c on o.id=c.id "

                       + " left join SysTypes As t on c.xtype=t.xusertype "

                       + " where o.type = '"+type+"' and o.name='"+tableName+"' ";

	    
        PreparedStatement stmt = conn.prepareStatement(SQLStr);

        ResultSet rslt = stmt.executeQuery();

        while (rslt.next()) {

               TableColumn tableColumn = new TableColumn();

               tableColumn.setColumnName(rslt.getString("ColumnsName"));

               tableColumn.setColumnType(rslt.getString("ColumnsType"));

               tableColumn.setColumnLength(rslt.getString("ColumnsLength"));

               columnNameAndType.add(tableColumn);

        }

	    
        return columnNameAndType;

    }

	
	


/*    protected void sendJsonData(HttpServletResponse response) throws Exception{

        response.setContentType("text/javascript;charset=UTF-8");

        PrintWriter out = response.getWriter();

        out.println("alert(\"数据库连接成功!!!\")");

        out.flush();

        out.close();

    }*/	
	
}


 src/main/java/com/highdatas/mdm/entity/SysField.java

@@ -313,10 +313,10 @@
        if (!StringUtils.isEmpty(alias)) {
            hash += alias.hashCode();
        }
        if (visible != null) {
        if (visible == null) {
            hash += visible.hashCode();
        }
        if (orderNo != null) {
        if (orderNo == null) {
            hash += orderNo.hashCode();
        }
        if (!StringUtils.isEmpty(code)) {

 src/main/java/com/highdatas/mdm/mapper/TableInfoMapper.java

@@ -30,18 +30,18 @@

    List<Map<String,Object>> selectDistinct(@Param("tableName") String tableName, @Param("fields") String fields, @Param("where") String where);

    List<Map<String,Object>> selectByPageByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields,@Param("A1fields") String A1fields, @Param("tempFields") String tempFields,@Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo, @Param("where") String where, @Param("limit") String limit);
    List<Map<String,Object>> selectByPageByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields, @Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo, @Param("maintainId") String maintainId, @Param("where") String where, @Param("limit") String limit);

    List<Map<String,Object>> selectByPageByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("A1fields") String A1fields, @Param("tempFields") String tempFields, @Param("fromOrderNo") Integer fromOrderNo,   @Param("where") String where, @Param("limit") String limit);
    List<Map<String,Object>> selectByPageByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields, @Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,@Param("maintainId") String maintainId,  @Param("where") String where, @Param("limit") String limit);


    List<Map<String,Object>> select(@Param("tableName") String tableName, @Param("fields") String fields, @Param("where") String where);

    Long getCount(@Param("tableName") String tableName,  @Param("where") String where);

    Long getCountByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("A1fields") String A1fields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,  @Param("where") String where);
    Long getCountByVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields,@Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,@Param("maintainId") String maintainId,  @Param("where") String where);

    Long getCountByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("A1fields") String A1fields, @Param("fromOrderNo") Integer fromOrderNo, @Param("where") String where);
    Long getCountByMaxVersion(@Param("tableName") String tableName,@Param("tableTempName") String tableTempName, @Param("fields") String fields, @Param("tempFields") String tempFields,@Param("Hfields") String Hfields,@Param("A1fields") String A1fields, @Param("A2fields") String A2fields, @Param("tempHFields") String tempHFields, @Param("fromOrderNo") Integer fromOrderNo, @Param("toOrderNo") Integer toOrderNo,@Param("maintainId") String maintainId, @Param("where") String where);

    void insert(@Param("tableName") String tableName, @Param("fields") String fields, @Param("values") String values);


 src/main/java/com/highdatas/mdm/pojo/CodeMsg.java

@@ -44,7 +44,6 @@
    public static CodeMsg ADDQUEUE_OVER = new CodeMsg(4012,"分发队列已满，暂不能添加");
    public static CodeMsg ADDQUEUE_FAIL = new CodeMsg(4011,"添加分发队列失败");
    public static CodeMsg MAINTAIN_UNFOUND_ERROR = new CodeMsg(4005,"未查到版本数据，或无权限");
    public static CodeMsg ACT_RUN_ERROR = new CodeMsg(4006,"已有版本审批中");

    public CodeMsg(int code, String msg) {
        this.code = code;

 src/main/java/com/highdatas/mdm/pojo/kettle/KettleDBTrans.java

New file
@@ -0,0 +1,72 @@
package com.highdatas.mdm.pojo.kettle;



import com.alibaba.fastjson.JSONObject;

import com.highdatas.mdm.entity.SysAssemble;

import org.pentaho.di.core.database.Database;

import org.pentaho.di.trans.TransMeta;

import org.pentaho.di.trans.steps.tableinput.TableInputMeta;

import org.pentaho.di.trans.steps.tableoutput.TableOutputMeta;



public class KettleDBTrans {



    private SysAssemble assemble;

    private TransMeta transMeta;

    private Database dsInput;

    private Database dsOutput;

    private TableInputMeta tableInputMeta;

    private TableOutputMeta talbeOutputMeta;



    public SysAssemble getAssemble() {

        return assemble;

    }



    public void setAssemble(SysAssemble assemble) {

        this.assemble = assemble;

    }



    public TransMeta getTransMeta() {

        return transMeta;

    }

	
    public void setTransMeta(TransMeta transMeta) {

        this.transMeta = transMeta;

    }

	
    public Database getDsInput() {

        return dsInput;

    }

	
    public void setDsInput(Database dsInput) {

        this.dsInput = dsInput;

    }

	
    public Database getDsOutput() {

        return dsOutput;

    }

	
    public void setDsOutput(Database dsOutput) {

        this.dsOutput = dsOutput;

    }

	
    public TableInputMeta getTableInputMeta() {

        return tableInputMeta;

    }

	
    public void setTableInputMeta(TableInputMeta tableInputMeta) {

        this.tableInputMeta = tableInputMeta;

    }

	
    public TableOutputMeta getTalbeOutputMeta() {

        return talbeOutputMeta;

    }

	
    public void setTalbeOutputMeta(TableOutputMeta talbeOutputMeta) {

        this.talbeOutputMeta = talbeOutputMeta;

    }

	
}












 src/main/java/com/highdatas/mdm/process/canvas/ProcessDiagramCanvas.java

@@ -1,129 +1,129 @@
package com.highdatas.mdm.process.canvas;



import org.activiti.bpmn.model.AssociationDirection;

import org.activiti.bpmn.model.GraphicInfo;

import org.activiti.image.impl.DefaultProcessDiagramCanvas;



import java.awt.*;

import java.awt.geom.Line2D.Double;

import java.awt.geom.RoundRectangle2D;





public class ProcessDiagramCanvas extends DefaultProcessDiagramCanvas {

	
    protected static Color HIGHLIGHT_COLOR = new Color(62,173,252);

    private static Color RUNNING_COLOR = Color.RED;

    private static Color HISTORY_COLOR = Color.GREEN;

    protected static int ICON_PADDING = 3;

    private String annotationFontName;

	
    public ProcessDiagramCanvas(int width, int height, int minX, int minY,

            String imageType) {

		
        super(width, height, minX, minY, imageType);

        this.activityFontName = "宋体";

        this.labelFontName = "宋体";

        this.annotationFontName = "宋体";

        initialize(imageType);

    }

    @Override

    public void drawHighLight(int x, int y, int width, int height) {

        Paint originalPaint = g.getPaint();

        Stroke originalStroke = g.getStroke();

        g.setPaint(HIGHLIGHT_COLOR);

        g.setStroke(THICK_TASK_BORDER_STROKE);

        RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);

        g.draw(rect);

        g.setPaint(originalPaint);

        g.setStroke(originalStroke);

    }

	
    @Override

     public void drawConnection(int[] xPoints, int[] yPoints, boolean conditional, boolean isDefault, String connectionType, AssociationDirection associationDirection, boolean highLighted, double scaleFactor)

      {

        Paint originalPaint = this.g.getPaint();

        Stroke originalStroke = this.g.getStroke();



        this.g.setPaint(CONNECTION_COLOR);

        if (connectionType.equals("association")) {

          this.g.setStroke(ASSOCIATION_STROKE);

        } else if (highLighted) {

          this.g.setPaint(HIGHLIGHT_COLOR);

          this.g.setStroke(HIGHLIGHT_FLOW_STROKE);

        }



        for (int i = 1; i < xPoints.length; ++i) {

          Integer sourceX = Integer.valueOf(xPoints[(i - 1)]);

          Integer sourceY = Integer.valueOf(yPoints[(i - 1)]);

          Integer targetX = Integer.valueOf(xPoints[i]);

          Integer targetY = Integer.valueOf(yPoints[i]);

          // e.g.(0,0) --->  (10,20)     (0,20)  (10,20)

          Double line1 = new Double(sourceX.intValue(), sourceY.intValue(), sourceX.intValue(), targetY.intValue());

          Double line2 = new Double(sourceX.intValue(), targetY.intValue(), targetX.intValue(), targetY.intValue());

          //Line2D.Double line = new Line2D.Double(sourceX.intValue(), sourceY.intValue(), targetX.intValue(), targetY.intValue());

          this.g.draw(line1);

          this.g.draw(line2);

        }

        Double line;

        if (isDefault) {

          line = new Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);

          drawDefaultSequenceFlowIndicator(line, scaleFactor);

        }



        if (conditional) {

          line = new Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);

          drawConditionalSequenceFlowIndicator(line, scaleFactor);

        }



        if ((associationDirection.equals(AssociationDirection.ONE)) || (associationDirection.equals(AssociationDirection.BOTH))) {

          line = new Double(xPoints[(xPoints.length - 2)], yPoints[(xPoints.length - 2)], xPoints[(xPoints.length - 1)], yPoints[(xPoints.length - 1)]);

          drawArrowHead(line, scaleFactor);

        }

        if (associationDirection.equals(AssociationDirection.BOTH)) {

          line = new Double(xPoints[1], yPoints[1], xPoints[0], yPoints[0]);

          drawArrowHead(line, scaleFactor);

        }

        this.g.setPaint(originalPaint);

        this.g.setStroke(originalStroke);

      }

		
    @Override

    protected void drawTask(String name, GraphicInfo graphicInfo, boolean thickBorder){

        Paint originalPaint = this.g.getPaint();

        int x = (int)graphicInfo.getX();

        int y = (int)graphicInfo.getY();

        int width = (int)graphicInfo.getWidth();

        int height = (int)graphicInfo.getHeight();



        this.g.setPaint(TASK_BOX_COLOR);



        int arcR = 6;

        if (thickBorder) {

          arcR = 3;

        }



        RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 10, 10);

        this.g.fill(rect);

        this.g.setPaint(TASK_BORDER_COLOR);



        if (thickBorder) {

          Stroke originalStroke = this.g.getStroke();

          this.g.setStroke(THICK_TASK_BORDER_STROKE);

          this.g.draw(rect);

          this.g.setStroke(originalStroke);

        } else {

          this.g.draw(rect);

        }



        this.g.setPaint(originalPaint);



        if ((name != null) && (name.length() > 0)) {

          int boxWidth = width - 6;

          int boxHeight = height - 16 - ICON_PADDING - ICON_PADDING - 12 - 2 - 2;

          int boxX = x + width / 2 - (boxWidth / 2);

          int boxY = y + height / 2 - (boxHeight / 2) + ICON_PADDING + ICON_PADDING - 2 - 2;



          drawMultilineCentredText(name, boxX, boxY, boxWidth, boxHeight);

        }

      }	 
}

package com.highdatas.mdm.process.canvas;

import org.activiti.bpmn.model.AssociationDirection;
import org.activiti.bpmn.model.GraphicInfo;
import org.activiti.image.impl.DefaultProcessDiagramCanvas;

import java.awt.*;
import java.awt.geom.Line2D.Double;
import java.awt.geom.RoundRectangle2D;


public class ProcessDiagramCanvas extends DefaultProcessDiagramCanvas {
	
    protected static Color HIGHLIGHT_COLOR = new Color(62,173,252);
    private static Color RUNNING_COLOR = Color.RED;
    private static Color HISTORY_COLOR = Color.GREEN;
    protected static int ICON_PADDING = 3;
    private String annotationFontName;
	
    public ProcessDiagramCanvas(int width, int height, int minX, int minY,
            String imageType) {
		
        super(width, height, minX, minY, imageType);
        this.activityFontName = "宋体";
        this.labelFontName = "宋体";
        this.annotationFontName = "宋体";
        initialize(imageType);
    }
    @Override
    public void drawHighLight(int x, int y, int width, int height) {
        Paint originalPaint = g.getPaint();
        Stroke originalStroke = g.getStroke();
        g.setPaint(HIGHLIGHT_COLOR);
        g.setStroke(THICK_TASK_BORDER_STROKE);
        RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 20, 20);
        g.draw(rect);
        g.setPaint(originalPaint);
        g.setStroke(originalStroke);
    }
	
    @Override
     public void drawConnection(int[] xPoints, int[] yPoints, boolean conditional, boolean isDefault, String connectionType, AssociationDirection associationDirection, boolean highLighted, double scaleFactor)
      {
        Paint originalPaint = this.g.getPaint();
        Stroke originalStroke = this.g.getStroke();

        this.g.setPaint(CONNECTION_COLOR);
        if (connectionType.equals("association")) {
          this.g.setStroke(ASSOCIATION_STROKE);
        } else if (highLighted) {
          this.g.setPaint(HIGHLIGHT_COLOR);
          this.g.setStroke(HIGHLIGHT_FLOW_STROKE);
        }

        for (int i = 1; i < xPoints.length; ++i) {
          Integer sourceX = Integer.valueOf(xPoints[(i - 1)]);
          Integer sourceY = Integer.valueOf(yPoints[(i - 1)]);
          Integer targetX = Integer.valueOf(xPoints[i]);
          Integer targetY = Integer.valueOf(yPoints[i]);
          // e.g.(0,0) --->  (10,20)     (0,20)  (10,20)
          Double line1 = new Double(sourceX.intValue(), sourceY.intValue(), sourceX.intValue(), targetY.intValue());
          Double line2 = new Double(sourceX.intValue(), targetY.intValue(), targetX.intValue(), targetY.intValue());
          //Line2D.Double line = new Line2D.Double(sourceX.intValue(), sourceY.intValue(), targetX.intValue(), targetY.intValue());
          this.g.draw(line1);
          this.g.draw(line2);
        }
        Double line;
        if (isDefault) {
          line = new Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
          drawDefaultSequenceFlowIndicator(line, scaleFactor);
        }

        if (conditional) {
          line = new Double(xPoints[0], yPoints[0], xPoints[1], yPoints[1]);
          drawConditionalSequenceFlowIndicator(line, scaleFactor);
        }

        if ((associationDirection.equals(AssociationDirection.ONE)) || (associationDirection.equals(AssociationDirection.BOTH))) {
          line = new Double(xPoints[(xPoints.length - 2)], yPoints[(xPoints.length - 2)], xPoints[(xPoints.length - 1)], yPoints[(xPoints.length - 1)]);
          drawArrowHead(line, scaleFactor);
        }
        if (associationDirection.equals(AssociationDirection.BOTH)) {
          line = new Double(xPoints[1], yPoints[1], xPoints[0], yPoints[0]);
          drawArrowHead(line, scaleFactor);
        }
        this.g.setPaint(originalPaint);
        this.g.setStroke(originalStroke);
      }
		
    @Override
    protected void drawTask(String name, GraphicInfo graphicInfo, boolean thickBorder){
        Paint originalPaint = this.g.getPaint();
        int x = (int)graphicInfo.getX();
        int y = (int)graphicInfo.getY();
        int width = (int)graphicInfo.getWidth();
        int height = (int)graphicInfo.getHeight();

        this.g.setPaint(TASK_BOX_COLOR);

        int arcR = 6;
        if (thickBorder) {
          arcR = 3;
        }

        RoundRectangle2D rect = new RoundRectangle2D.Double(x, y, width, height, 10, 10);
        this.g.fill(rect);
        this.g.setPaint(TASK_BORDER_COLOR);

        if (thickBorder) {
          Stroke originalStroke = this.g.getStroke();
          this.g.setStroke(THICK_TASK_BORDER_STROKE);
          this.g.draw(rect);
          this.g.setStroke(originalStroke);
        } else {
          this.g.draw(rect);
        }

        this.g.setPaint(originalPaint);

        if ((name != null) && (name.length() > 0)) {
          int boxWidth = width - 6;
          int boxHeight = height - 16 - ICON_PADDING - ICON_PADDING - 12 - 2 - 2;
          int boxX = x + width / 2 - (boxWidth / 2);
          int boxY = y + height / 2 - (boxHeight / 2) + ICON_PADDING + ICON_PADDING - 2 - 2;

          drawMultilineCentredText(name, boxX, boxY, boxWidth, boxHeight);
        }
      }	 
}

 src/main/java/com/highdatas/mdm/process/canvas/ProcessDiagramGenerator.java

@@ -1,285 +1,285 @@
package com.highdatas.mdm.process.canvas;



import org.activiti.bpmn.model.*;

import org.activiti.bpmn.model.Process;

import org.activiti.image.impl.DefaultProcessDiagramCanvas;

import org.activiti.image.impl.DefaultProcessDiagramGenerator;



import java.util.Iterator;

import java.util.List;



public class ProcessDiagramGenerator extends DefaultProcessDiagramGenerator{

	
   
    @Override

    protected ProcessDiagramCanvas generateProcessDiagram(BpmnModel bpmnModel, String imageType, List<String> highLightedActivities, List<String> highLightedFlows, String activityFontName, String labelFontName,String annotationFontName,  ClassLoader customClassLoader, double scaleFactor){

      prepareBpmnModel(bpmnModel);



      ProcessDiagramCanvas processDiagramCanvas = initProcessDiagramCanvas(bpmnModel, imageType, activityFontName, labelFontName, customClassLoader);



      for (Pool pool : bpmnModel.getPools()) {

        GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(pool.getId());

        processDiagramCanvas.drawPoolOrLane(pool.getName(), graphicInfo);

      }

      Process process;

      for (Iterator<Process> iter = bpmnModel.getProcesses().iterator(); iter.hasNext(); ) {

        process = (Process)iter.next();

        for (Lane lane : process.getLanes()) {

          GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(lane.getId());

          processDiagramCanvas.drawPoolOrLane(lane.getName(), graphicInfo);

        }



      }



        List<Process> processes = bpmnModel.getProcesses();

        if (!processes.isEmpty()) {



            for (FlowNode flowNode : ((Process) bpmnModel.getProcesses().get(0)).findFlowElementsOfType(FlowNode.class)) {

                drawActivity(processDiagramCanvas, bpmnModel, flowNode, highLightedActivities, highLightedFlows, scaleFactor);

            }

        }

      
      for (Iterator<Process> iter = bpmnModel.getProcesses().iterator(); iter.hasNext(); ) { process = (Process)iter.next();

        for (Artifact artifact : process.getArtifacts()) {

          drawArtifact(processDiagramCanvas, bpmnModel, artifact);

        }

      }



      return processDiagramCanvas;

    }

    
    protected static ProcessDiagramCanvas initProcessDiagramCanvas(BpmnModel bpmnModel, String imageType, String activityFontName, String labelFontName, ClassLoader customClassLoader){

        double minX = 1.7976931348623157E+308D;

        double maxX = 0.0D;

        double minY = 1.7976931348623157E+308D;

        double maxY = 0.0D;



        for (Pool pool : bpmnModel.getPools()) {

          GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(pool.getId());

          minX = graphicInfo.getX();

          maxX = graphicInfo.getX() + graphicInfo.getWidth();

          minY = graphicInfo.getY();

          maxY = graphicInfo.getY() + graphicInfo.getHeight();

        }



        List<FlowNode> flowNodes = gatherAllFlowNodes(bpmnModel);

        for (FlowNode flowNode : flowNodes)

        {

          GraphicInfo flowNodeGraphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());



          if (flowNodeGraphicInfo.getX() + flowNodeGraphicInfo.getWidth() > maxX) {

            maxX = flowNodeGraphicInfo.getX() + flowNodeGraphicInfo.getWidth();

          }

          if (flowNodeGraphicInfo.getX() < minX) {

            minX = flowNodeGraphicInfo.getX();

          }



          if (flowNodeGraphicInfo.getY() + flowNodeGraphicInfo.getHeight() > maxY) {

            maxY = flowNodeGraphicInfo.getY() + flowNodeGraphicInfo.getHeight();

          }

          if (flowNodeGraphicInfo.getY() < minY) {

            minY = flowNodeGraphicInfo.getY();

          }



          for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {

            List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());

            if (graphicInfoList != null) {

              for (GraphicInfo graphicInfo : graphicInfoList)

              {

                if (graphicInfo.getX() > maxX) {

                  maxX = graphicInfo.getX();

                }

                if (graphicInfo.getX() < minX) {

                  minX = graphicInfo.getX();

                }



                if (graphicInfo.getY() > maxY) {

                  maxY = graphicInfo.getY();

                }

                if (graphicInfo.getY() < minY) {

                  minY = graphicInfo.getY();

                }

              }

            }

          }

        }

        GraphicInfo graphicInfo;

        List<Artifact> artifacts = gatherAllArtifacts(bpmnModel);

        for (Artifact artifact : artifacts)

        {

          GraphicInfo artifactGraphicInfo = bpmnModel.getGraphicInfo(artifact.getId());



          if (artifactGraphicInfo != null)

          {

            if (artifactGraphicInfo.getX() + artifactGraphicInfo.getWidth() > maxX) {

              maxX = artifactGraphicInfo.getX() + artifactGraphicInfo.getWidth();

            }

            if (artifactGraphicInfo.getX() < minX) {

              minX = artifactGraphicInfo.getX();

            }



            if (artifactGraphicInfo.getY() + artifactGraphicInfo.getHeight() > maxY) {

              maxY = artifactGraphicInfo.getY() + artifactGraphicInfo.getHeight();

            }

            if (artifactGraphicInfo.getY() < minY) {

              minY = artifactGraphicInfo.getY();

            }

          }



          List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(artifact.getId());

        
          if (graphicInfoList != null) {

        	
            for (Iterator<GraphicInfo> iterator = graphicInfoList.iterator(); iterator.hasNext(); ) { graphicInfo = (GraphicInfo)iterator.next();



              if (graphicInfo.getX() > maxX) {

                maxX = graphicInfo.getX();

              }

              if (graphicInfo.getX() < minX) {

                minX = graphicInfo.getX();

              }



              if (graphicInfo.getY() > maxY) {

                maxY = graphicInfo.getY();

              }

              if (graphicInfo.getY() < minY) {

                minY = graphicInfo.getY();

              }

            }

          }



        }



       
        int nrOfLanes = 0;

        for (Process process : bpmnModel.getProcesses()) {

          for (Lane l : process.getLanes())

          {

            ++nrOfLanes;



            graphicInfo = bpmnModel.getGraphicInfo(l.getId());



            if (graphicInfo.getX() + graphicInfo.getWidth() > maxX) {

              maxX = graphicInfo.getX() + graphicInfo.getWidth();

            }

            if (graphicInfo.getX() < minX) {

              minX = graphicInfo.getX();

            }



            if (graphicInfo.getY() + graphicInfo.getHeight() > maxY) {

              maxY = graphicInfo.getY() + graphicInfo.getHeight();

            }

            if (graphicInfo.getY() < minY) {

              minY = graphicInfo.getY();

            }

          }



        }



        if ((flowNodes.isEmpty()) && (bpmnModel.getPools().isEmpty()) && (nrOfLanes == 0))

        {

          minX = 0.0D;

          minY = 0.0D;

        }

        return  new ProcessDiagramCanvas((int) maxX + 10, (int) maxY + 10,

                (int) minX, (int) minY, imageType);

    }

    
    @Override

    protected void drawActivity(DefaultProcessDiagramCanvas processDiagramCanvas, BpmnModel bpmnModel, FlowNode flowNode, List<String> highLightedActivities, List<String> highLightedFlows, double scaleFactor){

         ActivityDrawInstruction drawInstruction = (ActivityDrawInstruction)this.activityDrawInstructions.get(flowNode.getClass());

         if (drawInstruction != null)

         {

           drawInstruction.draw(processDiagramCanvas, bpmnModel, flowNode);



           boolean multiInstanceSequential = false; boolean multiInstanceParallel = false; boolean collapsed = false;

           if (flowNode instanceof Activity) {

             Activity activity = (Activity)flowNode;

             MultiInstanceLoopCharacteristics multiInstanceLoopCharacteristics = activity.getLoopCharacteristics();

             if (multiInstanceLoopCharacteristics != null) {

               multiInstanceSequential = multiInstanceLoopCharacteristics.isSequential();

               multiInstanceParallel = !(multiInstanceSequential);

             }



           }



           GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());

           if (flowNode instanceof SubProcess)

             collapsed = (graphicInfo.getExpanded() != null) && (!(graphicInfo.getExpanded().booleanValue()));

           else if (flowNode instanceof CallActivity) {

             collapsed = true;

           }



           if (scaleFactor == 1.0D)

        {

            processDiagramCanvas.drawActivityMarkers((int)graphicInfo.getX(), (int)graphicInfo.getY(), (int)graphicInfo.getWidth(), (int)graphicInfo.getHeight(), multiInstanceSequential, multiInstanceParallel, collapsed);

        }



            if (highLightedActivities != null && highLightedActivities.contains(flowNode.getId())) {

                processDiagramCanvas.drawHighLight((int)graphicInfo.getX(), (int)graphicInfo.getY(), (int)graphicInfo.getWidth(), (int)graphicInfo.getHeight());

            }



         }



         for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {

             boolean highLighted = false;

            if (highLightedFlows != null) {

                highLighted = highLightedFlows.contains(sequenceFlow.getId());

            }



              String defaultFlow = null;

              if (flowNode instanceof Activity)

                defaultFlow = ((Activity)flowNode).getDefaultFlow();

              else if (flowNode instanceof Gateway) {

                defaultFlow = ((Gateway)flowNode).getDefaultFlow();

              }



              boolean isDefault = false;

              if ((defaultFlow != null) && (defaultFlow.equalsIgnoreCase(sequenceFlow.getId()))) {

                isDefault = true;

              }

              boolean drawConditionalIndicator = (sequenceFlow.getConditionExpression() != null) && (!(flowNode instanceof Gateway));



              String sourceRef = sequenceFlow.getSourceRef();

              String targetRef = sequenceFlow.getTargetRef();

              FlowElement sourceElement = bpmnModel.getFlowElement(sourceRef);

              FlowElement targetElement = bpmnModel.getFlowElement(targetRef);

              List graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());

              if ((graphicInfoList != null) && (graphicInfoList.size() > 0)) {

                graphicInfoList = connectionPerfectionizer(processDiagramCanvas, bpmnModel, sourceElement, targetElement, graphicInfoList);

                int[] xPoints = new int[graphicInfoList.size()];

                int[] yPoints = new int[graphicInfoList.size()];



                for (int i = 1; i < graphicInfoList.size(); ++i) {

                  GraphicInfo graphicInfo = (GraphicInfo)graphicInfoList.get(i);

                  GraphicInfo previousGraphicInfo = (GraphicInfo)graphicInfoList.get(i - 1);



                  if (i == 1) {

                    xPoints[0] = (int)previousGraphicInfo.getX();

                    yPoints[0] = (int)previousGraphicInfo.getY();

                  }

                  xPoints[i] = (int)graphicInfo.getX();

                  yPoints[i] = (int)graphicInfo.getY();

                }



                processDiagramCanvas.drawSequenceflow(xPoints, yPoints, drawConditionalIndicator, isDefault, highLighted, scaleFactor);



                GraphicInfo labelGraphicInfo = bpmnModel.getLabelGraphicInfo(sequenceFlow.getId());

                if (labelGraphicInfo != null) {

                  processDiagramCanvas.drawLabel(sequenceFlow.getName(), labelGraphicInfo, false);

                }

                else {

                    GraphicInfo lineCenter = getLineCenter(graphicInfoList);

                    processDiagramCanvas.drawLabel(sequenceFlow.getName(), lineCenter, false);

                }

           }

     }



     if (flowNode instanceof FlowElementsContainer)

       for (FlowElement nestedFlowElement : ((FlowElementsContainer)flowNode).getFlowElements())

         if (nestedFlowElement instanceof FlowNode)

           drawActivity(processDiagramCanvas, bpmnModel, (FlowNode)nestedFlowElement, highLightedActivities, highLightedFlows, scaleFactor);

    	
    }

    
}

package com.highdatas.mdm.process.canvas;

import org.activiti.bpmn.model.*;
import org.activiti.bpmn.model.Process;
import org.activiti.image.impl.DefaultProcessDiagramCanvas;
import org.activiti.image.impl.DefaultProcessDiagramGenerator;

import java.util.Iterator;
import java.util.List;

public class ProcessDiagramGenerator extends DefaultProcessDiagramGenerator{
	
   
    @Override
    protected ProcessDiagramCanvas generateProcessDiagram(BpmnModel bpmnModel, String imageType, List<String> highLightedActivities, List<String> highLightedFlows, String activityFontName, String labelFontName,String annotationFontName,  ClassLoader customClassLoader, double scaleFactor){
      prepareBpmnModel(bpmnModel);

      ProcessDiagramCanvas processDiagramCanvas = initProcessDiagramCanvas(bpmnModel, imageType, activityFontName, labelFontName, customClassLoader);

      for (Pool pool : bpmnModel.getPools()) {
        GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(pool.getId());
        processDiagramCanvas.drawPoolOrLane(pool.getName(), graphicInfo);
      }
      Process process;
      for (Iterator<Process> iter = bpmnModel.getProcesses().iterator(); iter.hasNext(); ) {
        process = (Process)iter.next();
        for (Lane lane : process.getLanes()) {
          GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(lane.getId());
          processDiagramCanvas.drawPoolOrLane(lane.getName(), graphicInfo);
        }

      }

        List<Process> processes = bpmnModel.getProcesses();
        if (!processes.isEmpty()) {

            for (FlowNode flowNode : ((Process) bpmnModel.getProcesses().get(0)).findFlowElementsOfType(FlowNode.class)) {
                drawActivity(processDiagramCanvas, bpmnModel, flowNode, highLightedActivities, highLightedFlows, scaleFactor);
            }
        }
      
      for (Iterator<Process> iter = bpmnModel.getProcesses().iterator(); iter.hasNext(); ) { process = (Process)iter.next();
        for (Artifact artifact : process.getArtifacts()) {
          drawArtifact(processDiagramCanvas, bpmnModel, artifact);
        }
      }

      return processDiagramCanvas;
    }
    
    protected static ProcessDiagramCanvas initProcessDiagramCanvas(BpmnModel bpmnModel, String imageType, String activityFontName, String labelFontName, ClassLoader customClassLoader){
        double minX = 1.7976931348623157E+308D;
        double maxX = 0.0D;
        double minY = 1.7976931348623157E+308D;
        double maxY = 0.0D;

        for (Pool pool : bpmnModel.getPools()) {
          GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(pool.getId());
          minX = graphicInfo.getX();
          maxX = graphicInfo.getX() + graphicInfo.getWidth();
          minY = graphicInfo.getY();
          maxY = graphicInfo.getY() + graphicInfo.getHeight();
        }

        List<FlowNode> flowNodes = gatherAllFlowNodes(bpmnModel);
        for (FlowNode flowNode : flowNodes)
        {
          GraphicInfo flowNodeGraphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());

          if (flowNodeGraphicInfo.getX() + flowNodeGraphicInfo.getWidth() > maxX) {
            maxX = flowNodeGraphicInfo.getX() + flowNodeGraphicInfo.getWidth();
          }
          if (flowNodeGraphicInfo.getX() < minX) {
            minX = flowNodeGraphicInfo.getX();
          }

          if (flowNodeGraphicInfo.getY() + flowNodeGraphicInfo.getHeight() > maxY) {
            maxY = flowNodeGraphicInfo.getY() + flowNodeGraphicInfo.getHeight();
          }
          if (flowNodeGraphicInfo.getY() < minY) {
            minY = flowNodeGraphicInfo.getY();
          }

          for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
            List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());
            if (graphicInfoList != null) {
              for (GraphicInfo graphicInfo : graphicInfoList)
              {
                if (graphicInfo.getX() > maxX) {
                  maxX = graphicInfo.getX();
                }
                if (graphicInfo.getX() < minX) {
                  minX = graphicInfo.getX();
                }

                if (graphicInfo.getY() > maxY) {
                  maxY = graphicInfo.getY();
                }
                if (graphicInfo.getY() < minY) {
                  minY = graphicInfo.getY();
                }
              }
            }
          }
        }
        GraphicInfo graphicInfo;
        List<Artifact> artifacts = gatherAllArtifacts(bpmnModel);
        for (Artifact artifact : artifacts)
        {
          GraphicInfo artifactGraphicInfo = bpmnModel.getGraphicInfo(artifact.getId());

          if (artifactGraphicInfo != null)
          {
            if (artifactGraphicInfo.getX() + artifactGraphicInfo.getWidth() > maxX) {
              maxX = artifactGraphicInfo.getX() + artifactGraphicInfo.getWidth();
            }
            if (artifactGraphicInfo.getX() < minX) {
              minX = artifactGraphicInfo.getX();
            }

            if (artifactGraphicInfo.getY() + artifactGraphicInfo.getHeight() > maxY) {
              maxY = artifactGraphicInfo.getY() + artifactGraphicInfo.getHeight();
            }
            if (artifactGraphicInfo.getY() < minY) {
              minY = artifactGraphicInfo.getY();
            }
          }

          List<GraphicInfo> graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(artifact.getId());
        
          if (graphicInfoList != null) {
        	
            for (Iterator<GraphicInfo> iterator = graphicInfoList.iterator(); iterator.hasNext(); ) { graphicInfo = (GraphicInfo)iterator.next();

              if (graphicInfo.getX() > maxX) {
                maxX = graphicInfo.getX();
              }
              if (graphicInfo.getX() < minX) {
                minX = graphicInfo.getX();
              }

              if (graphicInfo.getY() > maxY) {
                maxY = graphicInfo.getY();
              }
              if (graphicInfo.getY() < minY) {
                minY = graphicInfo.getY();
              }
            }
          }

        }

       
        int nrOfLanes = 0;
        for (Process process : bpmnModel.getProcesses()) {
          for (Lane l : process.getLanes())
          {
            ++nrOfLanes;

            graphicInfo = bpmnModel.getGraphicInfo(l.getId());

            if (graphicInfo.getX() + graphicInfo.getWidth() > maxX) {
              maxX = graphicInfo.getX() + graphicInfo.getWidth();
            }
            if (graphicInfo.getX() < minX) {
              minX = graphicInfo.getX();
            }

            if (graphicInfo.getY() + graphicInfo.getHeight() > maxY) {
              maxY = graphicInfo.getY() + graphicInfo.getHeight();
            }
            if (graphicInfo.getY() < minY) {
              minY = graphicInfo.getY();
            }
          }

        }

        if ((flowNodes.isEmpty()) && (bpmnModel.getPools().isEmpty()) && (nrOfLanes == 0))
        {
          minX = 0.0D;
          minY = 0.0D;
        }
        return  new ProcessDiagramCanvas((int) maxX + 10, (int) maxY + 10,
                (int) minX, (int) minY, imageType);
    }
    
    @Override
    protected void drawActivity(DefaultProcessDiagramCanvas processDiagramCanvas, BpmnModel bpmnModel, FlowNode flowNode, List<String> highLightedActivities, List<String> highLightedFlows, double scaleFactor){
         ActivityDrawInstruction drawInstruction = (ActivityDrawInstruction)this.activityDrawInstructions.get(flowNode.getClass());
         if (drawInstruction != null)
         {
           drawInstruction.draw(processDiagramCanvas, bpmnModel, flowNode);

           boolean multiInstanceSequential = false; boolean multiInstanceParallel = false; boolean collapsed = false;
           if (flowNode instanceof Activity) {
             Activity activity = (Activity)flowNode;
             MultiInstanceLoopCharacteristics multiInstanceLoopCharacteristics = activity.getLoopCharacteristics();
             if (multiInstanceLoopCharacteristics != null) {
               multiInstanceSequential = multiInstanceLoopCharacteristics.isSequential();
               multiInstanceParallel = !(multiInstanceSequential);
             }

           }

           GraphicInfo graphicInfo = bpmnModel.getGraphicInfo(flowNode.getId());
           if (flowNode instanceof SubProcess)
             collapsed = (graphicInfo.getExpanded() != null) && (!(graphicInfo.getExpanded().booleanValue()));
           else if (flowNode instanceof CallActivity) {
             collapsed = true;
           }

           if (scaleFactor == 1.0D)
        {
            processDiagramCanvas.drawActivityMarkers((int)graphicInfo.getX(), (int)graphicInfo.getY(), (int)graphicInfo.getWidth(), (int)graphicInfo.getHeight(), multiInstanceSequential, multiInstanceParallel, collapsed);
        }

            if (highLightedActivities != null && highLightedActivities.contains(flowNode.getId())) {
                processDiagramCanvas.drawHighLight((int)graphicInfo.getX(), (int)graphicInfo.getY(), (int)graphicInfo.getWidth(), (int)graphicInfo.getHeight());
            }

         }

         for (SequenceFlow sequenceFlow : flowNode.getOutgoingFlows()) {
             boolean highLighted = false;
            if (highLightedFlows != null) {
                highLighted = highLightedFlows.contains(sequenceFlow.getId());
            }

              String defaultFlow = null;
              if (flowNode instanceof Activity)
                defaultFlow = ((Activity)flowNode).getDefaultFlow();
              else if (flowNode instanceof Gateway) {
                defaultFlow = ((Gateway)flowNode).getDefaultFlow();
              }

              boolean isDefault = false;
              if ((defaultFlow != null) && (defaultFlow.equalsIgnoreCase(sequenceFlow.getId()))) {
                isDefault = true;
              }
              boolean drawConditionalIndicator = (sequenceFlow.getConditionExpression() != null) && (!(flowNode instanceof Gateway));

              String sourceRef = sequenceFlow.getSourceRef();
              String targetRef = sequenceFlow.getTargetRef();
              FlowElement sourceElement = bpmnModel.getFlowElement(sourceRef);
              FlowElement targetElement = bpmnModel.getFlowElement(targetRef);
              List graphicInfoList = bpmnModel.getFlowLocationGraphicInfo(sequenceFlow.getId());
              if ((graphicInfoList != null) && (graphicInfoList.size() > 0)) {
                graphicInfoList = connectionPerfectionizer(processDiagramCanvas, bpmnModel, sourceElement, targetElement, graphicInfoList);
                int[] xPoints = new int[graphicInfoList.size()];
                int[] yPoints = new int[graphicInfoList.size()];

                for (int i = 1; i < graphicInfoList.size(); ++i) {
                  GraphicInfo graphicInfo = (GraphicInfo)graphicInfoList.get(i);
                  GraphicInfo previousGraphicInfo = (GraphicInfo)graphicInfoList.get(i - 1);

                  if (i == 1) {
                    xPoints[0] = (int)previousGraphicInfo.getX();
                    yPoints[0] = (int)previousGraphicInfo.getY();
                  }
                  xPoints[i] = (int)graphicInfo.getX();
                  yPoints[i] = (int)graphicInfo.getY();
                }

                processDiagramCanvas.drawSequenceflow(xPoints, yPoints, drawConditionalIndicator, isDefault, highLighted, scaleFactor);

                GraphicInfo labelGraphicInfo = bpmnModel.getLabelGraphicInfo(sequenceFlow.getId());
                if (labelGraphicInfo != null) {
                  processDiagramCanvas.drawLabel(sequenceFlow.getName(), labelGraphicInfo, false);
                }
                else {
                    GraphicInfo lineCenter = getLineCenter(graphicInfoList);
                    processDiagramCanvas.drawLabel(sequenceFlow.getName(), lineCenter, false);
                }
           }
     }

     if (flowNode instanceof FlowElementsContainer)
       for (FlowElement nestedFlowElement : ((FlowElementsContainer)flowNode).getFlowElements())
         if (nestedFlowElement instanceof FlowNode)
           drawActivity(processDiagramCanvas, bpmnModel, (FlowNode)nestedFlowElement, highLightedActivities, highLightedFlows, scaleFactor);
    	
    }
    
}

 src/main/java/com/highdatas/mdm/service/IMaintainService.java

@@ -64,6 +64,4 @@
    JSONObject compareField(String maintainId1, String maintainId2);

    Map<String, Object> getPreInfo(Maintain maintain, String id);

    boolean getCanAct(String tableName);
}

 src/main/java/com/highdatas/mdm/service/act/impl/IdentityServiceImpl.java

@@ -136,9 +136,6 @@
        }
        try {
            User user = identityService.newUser(id);

            identityService.saveUser(user);
            user.setFirstName("");
            identityService.saveUser(user);
            return Result.success(null);
        }catch (Exception e){
@@ -165,8 +162,6 @@
        try {
            Group group = identityService.newGroup(id);
            identityService.saveGroup(group);
            group.setName("");
            identityService.saveGroup(group);
            return Result.success(null);
        }catch (Exception e){
            e.printStackTrace();
@@ -190,16 +185,11 @@
            if (user == null) {
                return Result.error(new CodeMsg(3001, "当前用户不存在,请先创建用户"));
            }
            Group group = identityService.createGroupQuery().groupId(roleId).singleResult();
            if (group == null) {
                return Result.error(new CodeMsg(3001, "当前角色不存在,请先创建用户"));
            }

            Map<String, String> memberShip = tableInfoMapper.selectActMemberShip(userId, roleId);
            Map<String, String> memberShip = tableInfoMapper.selectActMemberShip(userId, roleId);
            if (memberShip != null) {
                return Result.success(null);
            }

            identityService.createMembership(userId,roleId);
            return Result.success(null);
        }
@@ -286,6 +276,7 @@
    @Transactional(rollbackFor = {RuntimeException.class, Error.class})
    public Result deleteUserRole(String roleId, String userId) {
        try {

            Map<String, String> memberShip = tableInfoMapper.selectActMemberShip(userId, roleId);
            if (memberShip == null) {
                return Result.success(null);

 src/main/java/com/highdatas/mdm/service/impl/FlowsServiceImpl.java

@@ -144,8 +144,8 @@
            if (flows.getBusinessType().equals(ActivitiBusinessType.maintain)){
                String maintainId = flows.getBusinessId();
                log.info("flow-maintain:" + maintainId);
                //masterModifiedService.dealFlow(maintainId, flows.getStatus());
               //log.info("flow-masterModifiedService end");
                masterModifiedService.dealFlow(maintainId, flows.getStatus());
                log.info("flow-masterModifiedService end");
                maintainService.dealFlow(maintainId, flows.getStatus());
                log.info("flow-maintainService end");
                viewService.dealFlow(maintainId, flows.getStatus());

 src/main/java/com/highdatas/mdm/service/impl/MaintainServiceImpl.java

@@ -142,7 +142,7 @@
                return;
            }
            String fields = masterDataService.getTempFields(null, tableName);
            String tempFields = masterDataService.getFields(tableName + Constant.RECORD, Constant.T);
            String tempFields = masterDataService.getFields(tableName + Constant.RECORD);

            String tableTempName = tableName + Constant.RECORD;
            // insert 2 std
@@ -563,20 +563,6 @@
            }
        }
        return result;
    }

    @Override
    public boolean getCanAct(String tableName) {
        List<Maintain> maintainList = selectList(new EntityWrapper<Maintain>().eq("table_name", tableName));

        long count = maintainList.stream()
                .filter(one -> one.getFlowId() != null)
                .filter(one -> flowsService.getStatusByBusinessId(one.getId()).equals(ActivitiStatus.working)).count();
        if (count == 0) {
            return true;
        } else {
            return false;
        }
    }



 src/main/java/com/highdatas/mdm/service/impl/MasterAuthorServiceImpl.java

@@ -334,7 +334,7 @@
            //user 获取role
            Set<String> roleIdSet = DbUtils.getRoleByUser(characterId, uuid);
            if (roleIdSet.isEmpty()) {
                return new ArrayList<>(); 
                return new ArrayList<>();
            }else {
                Wrapper<MasterAuthor> roleWrapper = new EntityWrapper<MasterAuthor>().eq(Constant.TYPE, MasterAuthorType.role).in(MasterAuthorController.character_id, roleIdSet);
                if (maintainField != null) {

 src/main/java/com/highdatas/mdm/service/impl/SysAssembleServiceImpl.java

@@ -137,15 +137,6 @@
            }
        }

        String tableNameByMenu = menuMappingService.getTableNameByMenu(assemble.getMenuId());
        boolean canAct = maintainService.getCanAct(tableNameByMenu);
        if (!canAct) {
            XxlJobLogger.log("当前有流程正在运行,暂时无法汇集下次数据");
            assemble.setPreMsg("当前有流程正在运行,暂时无法汇集下次数据");
            assemble.updateById();
            return  Result.error(new CodeMsg(6009,"当前有流程正在运行,暂时无法汇集下次数据"));
        }

        Boolean bigData = assemble.getBigdata();
        Date scheduleDate = new Date();
        XxlJobLogger.log("log info:  start assemble");
@@ -608,6 +599,8 @@

    private Result checkTempData(SysAssemble assemble) {
        try {


            SysAssembleCheckType checkType = assemble.getCheckType();
            if (checkType == null) {
                return Result.error(new CodeMsg(6009, "规则校验类型为空"));

 src/main/java/com/highdatas/mdm/service/impl/SysDispenseLogsServiceImpl.java

@@ -73,12 +73,10 @@
                .setTopicId(mqEntity.getMsgTopicName())
                .setTagId(mqEntity.getMsgTagName())
                .setKeyId(mqEntity.getMsgKey());

        int totalSize = mqEntity.getTotalSize();
        if (totalSize > 0) {
            sysDispenseLogs.setTotal(totalSize);
        }

        AtomicInteger pageNo = mqEntity.getPageNo();
        if (pageNo != null) {
            sysDispenseLogs.setPageNo(pageNo.get());

 src/main/java/com/highdatas/mdm/service/impl/SysViewServiceImpl.java

@@ -96,10 +96,7 @@
            int length = tableSchemaResult.getLength();
            totalLength += length;
        }
        int pageSize = 20;
       if (totalLength != 0) {
           pageSize = Constant.MaxDispenseSize / totalLength;
       }
        int pageSize = Constant.MaxDispenseSize / totalLength;
        page.setPageSize(pageSize);
        Long viewCount = getViewCount(sysView);
        if (viewCount == 0) {

 src/main/java/com/highdatas/mdm/util/Constant.java

@@ -140,5 +140,4 @@
    String MT = "mt";
    String IDX_TEMPLATE = "IDX_{0}_{1}";

    String T = "t";
}

 src/main/java/com/highdatas/mdm/util/HttpUtils.java

@@ -53,14 +53,13 @@
        if (mediaType == null){
            headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
            MultiValueMap<String, String> vals = new LinkedMultiValueMap();
            if (formParams != null) {
                Set<String> keySet = formParams.keySet();
                for (String key : keySet) {
                    String s = formParams.get(key);
                    List<String> strings = new ArrayList<>();
                    strings.add(s);
                    vals.put(key,strings);
                }

            Set<String> keySet = formParams.keySet();
            for (String key : keySet) {
                String s = formParams.get(key);
                List<String> strings = new ArrayList<>();
                strings.add(s);
                vals.put(key,strings);
            }

            requestEntity = new HttpEntity<MultiValueMap<String, String>>(vals, headers);
@@ -120,7 +119,7 @@
        }
        String s = sb.toString();
        if (s.endsWith("&")) {
            s = org.apache.commons.lang3.StringUtils.substringBeforeLast(s, "&");
            s = org.apache.commons.lang.StringUtils.substringBeforeLast(s, "&");
        }
        return s;
    }

 src/main/java/com/highdatas/mdm/util/RuleClient.java

@@ -14,7 +14,6 @@
import org.springframework.http.client.SimpleClientHttpRequestFactory;

import org.springframework.http.converter.StringHttpMessageConverter;

import org.springframework.stereotype.Component;

import org.springframework.util.MultiValueMap;

import org.springframework.util.StringUtils;

import org.springframework.web.client.RestTemplate;



@@ -40,11 +39,10 @@
    public HashMap<String,Boolean> execuImmeForCollect(String tableName,String userId) {

        //TODO

        String url = this.url + prefix + "execuImmeForCollect";

        HashMap<String, Object> params = new HashMap<>();

        HashMap<String, String> params = new HashMap<>();

        params.put("tableName",tableName);

        params.put("createUserId",userId);

        String urlParamsByMap = HttpUtils.getUrlParamsByMap(params);

        String s = HttpUtils.HttpRestClient(url, HttpMethod.POST, null, urlParamsByMap, null);

        params.put("createUserId",tableName);

        String s = HttpRestClient(url, HttpMethod.POST, params, null, null);

        JSONObject result = (JSONObject) JSON.parse(s);

        String sucess = result.getString(Constant.Success);

        JSONObject dataObject = result.getJSONObject(Constant.Data);

@@ -80,7 +78,7 @@
        params.put("tableName",tableName);

        params.put("pageNum",pageNo.toString());

        params.put("pageSize",pageSize.toString());

        String s = HttpUtils.HttpRestClient(url, HttpMethod.POST, params, null, null);

        String s = HttpRestClient(url, HttpMethod.POST, params, null, null);

        JSONObject result = (JSONObject) JSON.parse(s);

        String sucess = result.getString(Constant.Success);

        if (StringUtils.isEmpty(sucess) || !Boolean.valueOf(sucess)) {

@@ -96,7 +94,7 @@
        params.put("tableName",tableName);

        params.put("isTemp",isTemp);



        String s = HttpUtils.HttpRestClient(url, HttpMethod.POST, params,null, MediaType.APPLICATION_JSON);

        String s = HttpRestClient(url, HttpMethod.POST, params,null, MediaType.APPLICATION_JSON);

        JSONObject result = (JSONObject) JSON.parse(s);

        boolean sucess = result.getBoolean(Constant.Success);

        if (!sucess) {

@@ -122,7 +120,7 @@
    }





    public String HttpRestClient(String url, HttpMethod method, MultiValueMap<String, String> formParams, String getParams,  MediaType mediaType) {

    public String HttpRestClient(String url, HttpMethod method, HashMap<String, String> formParams, String getParams,  MediaType mediaType) {

        if (!StringUtils.isEmpty(getParams)) {

            url = url + Constant.QUESTION + getParams;

        }

@@ -138,7 +136,7 @@
            headers.setContentType(mediaType);

        }



        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(formParams, headers);

        HttpEntity<HashMap<String, String>> requestEntity = new HttpEntity<HashMap<String, String>>(formParams, headers);

        //  执行HTTP请求

        ResponseEntity<String> response = client.exchange(url, method, requestEntity, String.class);




 src/main/java/com/highdatas/mdm/util/pool/MqEntity.java

@@ -178,7 +178,6 @@
            }

            Date createTime = logByMqEntity.getCreateTime();

            long schedule = new Date().getTime() - createTime.getTime();

            schedule = Math.abs(schedule);

            logByMqEntity.setSchedule(schedule);

            logByMqEntity.updateById();

        }


 src/main/java/com/highdatas/mdm/util/pool/MqMessage.java

@@ -109,7 +109,6 @@
            object.fluentPut("pages", page.getPageCount());

            object.fluentPut("current", page.getPageNo());

            object.fluentPut("records", maps);

            mqEntity.getMsgBody().setTotal(Long.valueOf(page.getRecordCount()).intValue());

            content = JSONObject.toJSONString(object);

        } else {

            Result result = DbUtils.masterDataService.selectListByPageByVersion(user, maintain.getTableName(), fieldList, filter, pageNo.get(), pageSize.get(), maintain.getVersion(), false);

@@ -122,7 +121,6 @@
            object.fluentPut("current", grid.get("current"));

            object.fluentPut("records", grid.get("record"));



            mqEntity.getMsgBody().setTotal(grid.getInteger("total"));

            content = JSONObject.toJSONString(object);



        }

@@ -166,7 +164,6 @@
    private void sendOneViewPackage(AtomicInteger pageNo, AtomicInteger pageSize, SysView sysView) throws Exception {

        Result viewData = DbUtils.viewService.getViewData(sysView, pageNo.get(), pageSize.get());

        JSONObject object = (JSONObject) viewData.getData();

        mqEntity.getMsgBody().setTotal(object.getInteger("total"));

        String content = JSONObject.toJSONString(object);

        sendMqBody(pageSize.get(), content);

    }

@@ -193,7 +190,7 @@
//        String mqBody = content;

        MqEntity.MsgBodyBean msgBody = mqEntity.getMsgBody();

        msgBody.setData(mqBody);



        msgBody.setTotal(pageSize);

        mqEntity.setMsgBody(msgBody);

//        Thread.sleep(1000 * 60 * 3);

        mqEntity.send2Mq();


 src/main/resources/application-dev.yml

@@ -1,5 +1,5 @@
server:
  port: 9998
  port: 9999
#url: jdbc:mysql://180.169.94.250:8306/data_admin?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&nullCatalogMeansCurrent=true
img:
  url: D:/mdm/process

 src/main/resources/application-pro.yml

@@ -32,7 +32,7 @@
        max-active: 100
        max-wait: 1000
  activiti:
    database-schema-update: true
    database-schema-update: flase

  thymeleaf:
    cache: false
@@ -60,7 +60,7 @@
  url: http://127.0.0.1:9107

user:
  url: http://180.169.94.250:9107
  url: http://127.0.0.1:9107
mq:
  url: http://127.0.0.1:9107

@@ -92,6 +92,7 @@
    admin:
      addresses: http://127.0.0.1:8090/xxl-job-admin


master:
  unbigdata:
    db:

 src/main/resources/mapping/MenuMappingMapper.xml

@@ -20,7 +20,7 @@

    <select id="getMapping" resultType="java.util.Map">
        SELECT
        m.id,m.code, m.name, system_id as systemId, m.audit as audit, m.desc,
        m.id,m.code, m.name, system_id as systemId, m.audit as audit,

        c2.name as cname1, c2.id as cid1, c1.name as cname2, c1.id as cid2, c.name as cname3, c.id as cid3,
        start_time as startTime, end_time as endTime, m.create_time as createTime, m.update_time as updateTime,

 src/main/resources/mapping/TableInfoMapper.xml

@@ -6,8 +6,7 @@
        show TABLES like #{tableName}
    </select>

    <select id="selectIdxByTableName" parameterType="java.lang.String" resultType="java.util.Map"
            statementType="STATEMENT">
    <select id="selectIdxByTableName" parameterType="java.lang.String"   resultType="java.util.Map" statementType="STATEMENT">
        SELECT * FROM mysql.`innodb_index_stats` a WHERE  a.table_name =  ${tableName}
    </select>

@@ -15,307 +14,393 @@
        select COLUMN_NAME as fieldName,DATA_TYPE as dbType, character_maximum_length as length from information_schema.COLUMNS where table_name = #{tableName} and table_schema = (select database())
    </select>

    <select id="getTableFieldFromDb" parameterType="com.highdatas.mdm.entity.TableSchema"
            resultType="com.highdatas.mdm.entity.TableSchemaResult">
    <select id="getTableFieldFromDb" parameterType="com.highdatas.mdm.entity.TableSchema" resultType="com.highdatas.mdm.entity.TableSchemaResult">
        select COLUMN_NAME as fieldName,DATA_TYPE as dbType,character_maximum_length as length from information_schema.COLUMNS where table_name = #{tableName} and table_schema = #{dbName}
    </select>

    <select id="selectByPage" resultType="java.util.Map" statementType="STATEMENT">
    <select id="selectByPage" resultType="java.util.Map" statementType="STATEMENT" >
        select ${fields} from ${tableName} where ${where}  ${limit}
    </select>

    <select id="selectDistinct" resultType="java.util.Map" statementType="STATEMENT">
    <select id="selectDistinct" resultType="java.util.Map" statementType="STATEMENT" >
        select DISTINCT ${fields} from ${tableName} where ${where}
    </select>

    <select id="selectByPageByVersion" resultType="java.util.Map" statementType="STATEMENT">
    <select id="selectByPageByVersion" resultType="java.util.Map" statementType="STATEMENT" >
        <![CDATA[
         SELECT ${fields}
FROM
    (SELECT ${A1fields}
    FROM ${tableName} a1
    LEFT JOIN
        (SELECT DISTINCT mt1.std_id
        FROM ${tableTempName} mt1
        LEFT JOIN maintain_detail md
            ON md.pre_merge_id = mt1.id
        LEFT JOIN maintain m
            ON m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo}
                AND m.order_no > ${toOrderNo}
                AND m.table_name = '${tableName}'
                AND (operate = 'create'
                OR operate = 'update') ) v
            ON v.std_id = a1.id
        WHERE v.std_id IS NULL
        UNION
        SELECT ${tempFields}
        FROM
            (SELECT mt.*,
         m.order_no
            FROM ${tableTempName} mt
            LEFT JOIN maintain_detail md
                ON md.pre_merge_id = mt.id
            LEFT JOIN maintain m
                ON md.parent_id = m.id
            WHERE m.order_no <= ${fromOrderNo}
                    AND m.order_no > ${toOrderNo}
                    AND m.table_name = '${tableName}'
                    AND operate = 'update' ) AS a1
            INNER JOIN
                (SELECT std_id,
         min(order_no) AS order_no
                FROM
                    (SELECT mt.id,
         std_id,
         m.order_no
                    FROM ${tableTempName} mt
                    LEFT JOIN maintain_detail md
                        ON md.pre_merge_id = mt.id
                    LEFT JOIN maintain m
                        ON md.parent_id = m.id
                    WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                            AND m.table_name = '${tableName}'
                            AND operate = 'update'
                            AND NOT EXISTS
                        (SELECT mt1.id
                        FROM ${tableTempName} mt1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = mt1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                                AND m.table_name = '${tableName}'
                                AND operate = 'create'
                                AND mt1.std_id = mt.std_id ) ) AS gz
                        GROUP BY  std_id ) AS zb
                            ON a1.std_id = zb.std_id
                                AND a1.order_no = zb.order_no
                        UNION
                        SELECT DISTINCT ${tempFields}
                        FROM ${tableTempName} a1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = a1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        LEFT JOIN
                            (SELECT DISTINCT mt1.std_id
                            FROM ${tableTempName} mt1
                            LEFT JOIN maintain_detail md
                                ON md.pre_merge_id = mt1.id
                            LEFT JOIN maintain m
                                ON m.id = md.parent_id
                            WHERE m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}'
                                    AND (operate = 'create'
                                    OR operate = 'update') ) zb
                                ON zb.std_id = a1.std_id
                            WHERE zb.std_id is null
                                    AND md.operate = 'delete'
                                    AND m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}' ) a
                        WHERE ${where} ${limit}
        ]]>
    </select>

    <select id="selectByPageByMaxVersion" resultType="java.util.Map" statementType="STATEMENT">
         <![CDATA[

       select  ${fields},operate, status from (
       SELECT ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        select  ${fields} from (
        SELECT
         ${A1fields} from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and operate = 'create'
          AND tm.std_id = m.id
          AND f.status = 'open'
          and maintain.table_name = '${tableName}'
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        UNION
        SELECT  ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'

        union
        SELECT  ${A1fields}, '', '' from ${tableName} a1
        LEFT JOIN
        (
        SELECT DISTINCT std_id from ${tableTempName} mt
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT DISTINCT std_id  from ${tableTempName} mt
        SELECT
         ${A2fields}
        from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and operate = 'create'
          AND f.status = 'open'
          AND tm.std_id = m.id
          and maintain.table_name = '${tableName}'
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'
        ) a on a.std_id  = a1.id where a.std_id is null
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
            UNION
        SELECT ${tempFields} FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo} AND operate = 'delete'
         AND f.status = 'open'
         and  maintain.table_name = '${tableName}'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            LEFT JOIN flows f on maintain.flow_id = f.id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'create'
            AND f.status = 'open'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where} ${limit}

        ]]>
         ]]>
    </select>

    <select id="select" resultType="java.util.Map" statementType="STATEMENT">
    <select id="selectByPageByMaxVersion" resultType="java.util.Map" statementType="STATEMENT" >
         <![CDATA[
        select  ${fields},operate, status from (
        SELECT
         ${A1fields}, '' as operate, '' as status from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          AND tm.std_id = m.id
          and  maintain.table_name = '${tableName}'
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT
         ${A2fields}, 'update' as operate, a2.status as status
        from (
        SELECT ${fields} from ${tableName} m
        ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields}, f.status from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
        UNION
        SELECT ${tempFields}, 'create' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo} AND operate = 'create'
        and  maintain.table_name = '${tableName}'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'delete'
            AND mt.std_id = mt1.std_id
            and maintain.table_name = '${tableName}'
        )
        UNION
        SELECT ${tempFields}, 'delete' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo} AND operate = 'delete'
         and maintain.table_name = '${tableName}'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'create'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where} ${limit}
         ]]>
    </select>

    <select id="select" resultType="java.util.Map" statementType="STATEMENT" >
        select ${fields} from ${tableName} where ${where}
    </select>

    <select id="tempDeal" statementType="STATEMENT" resultType="java.lang.Integer">
         UPDATE ${tableTempName} mt
        INNER JOIN (
        SELECT pre_merge_id from
        maintain_detail
        WHERE maintain_detail.parent_id = ${maintainId}
        )md on mt.id = md.pre_merge_id
        set mt.deal = 1
    <select id="tempDeal"  statementType="STATEMENT" resultType="java.lang.Integer">


        UPDATE ${tableTempName} t
        SET deal = 1
        where EXISTS (
        SELECT pre_merge_id from maintain_detail WHERE parent_id = ${maintainId}
        and maintain_detail.pre_merge_id = t.id
        )
        </select>

    <select id="getCount" resultType="java.lang.Long" statementType="STATEMENT">
    <select id="getCount" resultType="java.lang.Long" statementType="STATEMENT" >
        select count(1) from ${tableName} where ${where}
    </select>

    <select id="getCountByVersion" resultType="java.lang.Long" statementType="STATEMENT">
    <select id="getCountByVersion" resultType="java.lang.Long" statementType="STATEMENT" >
        <![CDATA[
       SELECT count(1)
FROM
    (SELECT ${A1fields}
    FROM ${tableName} a1
    LEFT JOIN
        (SELECT DISTINCT mt1.std_id
        FROM ${tableTempName} mt1
        LEFT JOIN maintain_detail md
            ON md.pre_merge_id = mt1.id
        LEFT JOIN maintain m
            ON m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo}
                AND m.order_no > ${toOrderNo}
                AND m.table_name = '${tableName}'
                AND (operate = 'create'
                OR operate = 'update') ) v
            ON v.std_id = a1.id
        WHERE v.std_id IS NULL
        UNION
        SELECT ${tempFields}
        FROM
            (SELECT mt.*,
         m.order_no
            FROM ${tableTempName} mt
            LEFT JOIN maintain_detail md
                ON md.pre_merge_id = mt.id
            LEFT JOIN maintain m
                ON md.parent_id = m.id
            WHERE m.order_no <= ${fromOrderNo}
                    AND m.order_no > ${toOrderNo}
                    AND m.table_name = '${tableName}'
                    AND operate = 'update' ) AS a1
            INNER JOIN
                (SELECT std_id,
         min(order_no) AS order_no
                FROM
                    (SELECT mt.id,
         std_id,
         m.order_no
                    FROM ${tableTempName} mt
                    LEFT JOIN maintain_detail md
                        ON md.pre_merge_id = mt.id
                    LEFT JOIN maintain m
                        ON md.parent_id = m.id
                    WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                            AND m.table_name = '${tableName}'
                            AND operate = 'update'
                            AND NOT EXISTS
                        (SELECT mt1.id
                        FROM ${tableTempName} mt1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = mt1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        WHERE m.order_no <= ${fromOrderNo}
                                AND m.order_no > ${toOrderNo}
                                AND m.table_name = '${tableName}'
                                AND operate = 'create'
                                AND mt1.std_id = mt.std_id ) ) AS gz
                        GROUP BY  std_id ) AS zb
                            ON a1.std_id = zb.std_id
                                AND a1.order_no = zb.order_no
                        UNION
                        SELECT DISTINCT ${tempFields}
                        FROM ${tableTempName} a1
                        LEFT JOIN maintain_detail md
                            ON md.pre_merge_id = a1.id
                        LEFT JOIN maintain m
                            ON m.id = md.parent_id
                        LEFT JOIN
                            (SELECT DISTINCT mt1.std_id
                            FROM ${tableTempName} mt1
                            LEFT JOIN maintain_detail md
                                ON md.pre_merge_id = mt1.id
                            LEFT JOIN maintain m
                                ON m.id = md.parent_id
                            WHERE m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}'
                                    AND (operate = 'create'
                                    OR operate = 'update') ) zb
                                ON zb.std_id = a1.std_id
                            WHERE zb.std_id is null
                                    AND md.operate = 'delete'
                                    AND m.order_no <= ${fromOrderNo}
                                    AND m.order_no > ${toOrderNo}
                                    AND m.table_name = '${tableName}' ) a
                        WHERE ${where}

        ]]>
    </select>

    <select id="getCountByMaxVersion" resultType="java.lang.Long" statementType="STATEMENT">
       <![CDATA[

       select  count(1) from (
       SELECT ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        select count(1) from (
        SELECT
         ${A1fields}
        from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and  maintain.table_name = '${tableName}'
          AND f.status = 'open'
          and operate = 'create'
          AND tm.std_id = m.id
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        UNION
        SELECT  ${tempFields}, md.operate, f.`status` from ${tableTempName} a1
        LEFT JOIN maintain_detail md on md.pre_merge_id = a1.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'

        union
        SELECT  ${A1fields}, '', '' from ${tableName} a1
        LEFT JOIN
        (
        SELECT DISTINCT std_id from ${tableTempName} mt
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.id is null
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo} and  m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT DISTINCT std_id  from ${tableTempName} mt
        SELECT
         ${A2fields}
        from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          LEFT JOIN flows f on maintain.flow_id = f.id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
           and maintain.table_name = '${tableName}'
           AND f.status = 'open'
          and operate = 'create'
          AND tm.std_id = m.id
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT MIN(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on flow_id = f.id
        WHERE order_no > ${fromOrderNo} and f.`status` = 'working'
        ) a on a.std_id  = a1.id where a.std_id is null
        LEFT JOIN flows f on m.flow_id = f.id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo}  and m.table_name = '${tableName}'
        and operate = 'update'
        AND f.status = 'open'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
        UNION
        SELECT ${tempFields} FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
        and  maintain.table_name = '${tableName}'
        AND f.status = 'open'
        AND operate = 'delete'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            LEFT JOIN flows f on maintain.flow_id = f.id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'create'
            AND f.status = 'open'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where}

        ]]>
         ]]>
    </select>

    <insert id="insert" statementType="STATEMENT">
    <select id="getCountByMaxVersion" resultType="java.lang.Long" statementType="STATEMENT" >
       <![CDATA[
        select count(1) from (
        SELECT
         ${A1fields}, '' as operate, '' as status from (
        SELECT ${fields} from ${tableName} m
        WHERE NOT EXISTS (
          SELECT std_id FROM  ${tableTempName} tm
          LEFT JOIN maintain_detail ON tm.id = maintain_detail.pre_merge_id
          LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
          WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
          and  maintain.table_name = '${tableName}'
          AND tm.std_id = m.id
          ) ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields} from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo}
        and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is null
        UNION
        SELECT
         ${A2fields}, 'update' as operate, a2.status as status
        from (
        SELECT ${fields} from ${tableName} m
        ) a1
        LEFT JOIN
        (
        SELECT   ${tempHFields}, f.status from ${tableTempName} h
        LEFT JOIN maintain_detail md on md.pre_merge_id = h.id
        LEFT JOIN maintain m on m.id = md.parent_id
        LEFT JOIN flows f on m.flow_id = f.id
        INNER JOIN (
        SELECT max(m.order_no) as order_no, mt.std_id FROM ${tableTempName} mt
        LEFT JOIN maintain_detail md on md.pre_merge_id = mt.id
        LEFT JOIN maintain m on m.id = md.parent_id
        WHERE m.order_no <= ${fromOrderNo} and m.order_no > ${toOrderNo}
        and  m.table_name = '${tableName}'
        and operate = 'update'
        GROUP BY mt.std_id
        ) a on a.order_no = m.order_no and a.std_id = h.std_id
        )a2 on a1.id = a2.id WHERE  a2.id is not null
        UNION
        SELECT ${tempFields}, 'create' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
        AND   maintain.table_name = '${tableName}'
        AND operate = 'create'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'delete'
            AND mt.std_id = mt1.std_id
            AND   maintain.table_name = '${tableName}'
        )
        UNION
        SELECT ${tempFields}, 'delete' as operate, f.status as status FROM maintain_detail md
        LEFT JOIN maintain ON maintain.id = md.parent_id
        LEFT JOIN flows f on maintain.flow_id = f.id
        LEFT JOIN ${tableTempName} mt on mt.id = md.pre_merge_id
        WHERE maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
         AND   maintain.table_name = '${tableName}'
         AND operate = 'delete'
        AND NOT EXISTS (
            SELECT * FROM maintain_detail
            LEFT JOIN maintain ON maintain.id = maintain_detail.parent_id
            LEFT JOIN ${tableTempName} mt1 on mt1.id = maintain_detail.pre_merge_id
            WHERE  maintain.order_no <= ${fromOrderNo} and maintain.order_no > ${toOrderNo}
            AND operate = 'create'
            AND mt.std_id = mt1.std_id
            and  maintain.table_name = '${tableName}'
        )
        )a where  ${where}
         ]]>
    </select>

    <insert id="insert"  statementType="STATEMENT" >
       INSERT INTO ${tableName} (${fields}) VALUES ${values}
    </insert>

    <insert id="insertOneSelect" statementType="STATEMENT">
    <insert id="insertOneSelect"  statementType="STATEMENT" >
        INSERT INTO ${tableName} (${fields})
        select ${selectFields} from (${selectSql}) a
    </insert>
@@ -342,19 +427,27 @@


    <delete id="deleteTempByMaintainId">
        DELETE tm FROM ${tableTempName} tm , maintain_detail md WHERE tm.id = md.pre_merge_id
        and md.parent_id = ${maintainId};
        DELETE FROM ${tableTempName}  where EXISTS (
        SELECT pre_merge_id from maintain_detail d
        where parent_id = ${maintainId} and d.pre_merge_id = ${tableTempName}.id
        )
    </delete>

    <!-- temp 2 standrad-->
    <insert id="tempCreate2std" statementType="STATEMENT">
    <insert id="tempCreate2std" statementType="STATEMENT"  >
        INSERT INTO ${tableName}
        SELECT
        ${tempFields}
         from ${tableTempName} t
         inner join maintain_detail md on t.id = md.pre_merge_id
         where  md.parent_id = ${maintainId} and md.operate = 'create'

         where
         EXISTS
        (
        SELECT  std_id from ${tableTempName} tm
        LEFT JOIN maintain_detail on tm.id = maintain_detail.pre_merge_id
        WHERE maintain_detail.parent_id = ${maintainId}
        and operate = 'create'
        and tm.id = t.id
        )
    </insert>

    <select id="getTempIdByStdId" statementType="STATEMENT" resultType="java.lang.String">
@@ -364,7 +457,7 @@

    </select>

    <insert id="insertMatintainDetailFromTemp" statementType="STATEMENT">
    <insert id="insertMatintainDetailFromTemp" statementType="STATEMENT" >

        INSERT INTO maintain_detail
        SELECT md5(uuid()) as id, ${maintainId} as parent_id, ${operate} as operate, id as pre_merge_id, NOW() as create_time
@@ -372,7 +465,7 @@

    </insert>

    <insert id="insertMatintainDetailFromStandrad" statementType="STATEMENT">
    <insert id="insertMatintainDetailFromStandrad" statementType="STATEMENT" >

        INSERT INTO maintain_detail
        SELECT md5(uuid()) as id, ${maintainId} as parent_id, 'delete' as operate, id as pre_merge_id, NOW() as create_time
@@ -380,14 +473,14 @@

    </insert>

    <update id="updateStdId" statementType="STATEMENT">
    <update id="updateStdId" statementType="STATEMENT" >

        update ${tableTempName}
        set std_id = md5(uuid()) WHERE deal = 0

    </update>

    <insert id="insertRecordFromStandrad" statementType="STATEMENT">
    <insert id="insertRecordFromStandrad" statementType="STATEMENT" >
         INSERT INTO ${recordTableName}
        SELECT ${tempFieldList}, 0 as deal
        from  ${tableName}
@@ -398,13 +491,18 @@
        SELECT
        ${fields}
        from ${tableTempName} t
        inner join maintain_detail md on md.pre_merge_id = t.id
        where md.parent_id = ${maintainId}
        where
        EXISTS
        (
        SELECT  pre_merge_id from maintain_detail
        LEFT JOIN maintain on maintain.id = maintain_detail.parent_id
        WHERE maintain.id = ${maintainId}
        and operate = ${operate}

        and maintain_detail.pre_merge_id = t.id
        )
    </select>

    <update id="updateRecordByMaintainId" statementType="STATEMENT">
    <update id="updateRecordByMaintainId" statementType="STATEMENT" >
         update ${tableTempName}
        INNER JOIN maintain_detail on ${tableTempName}.id = maintain_detail.pre_merge_id
        set ${updateSegment}
@@ -412,7 +510,7 @@

    </update>

    <delete id="deleteRecordByMaintainId" statementType="STATEMENT">
    <delete id="deleteRecordByMaintainId" statementType="STATEMENT" >
        DELETE  ${tableTempName} from  ${tableTempName}
        INNER JOIN maintain_detail on maintain_detail.pre_merge_id =  ${tableTempName}.id
        WHERE maintain_detail.parent_id = ${maintainId} and  ${tableTempName}.std_id = ${stdId}
@@ -428,32 +526,36 @@
        select * from ACT_ID_MEMBERSHIP where USER_ID_ = #{userId}
    </select>

    <select id="getOneTempFieldDataByMaintainExtent" statementType="STATEMENT" resultType="java.util.Map">
    <select id="getOneTempFieldDataByMaintainExtent" statementType="STATEMENT"   resultType="java.util.Map">
         <![CDATA[

        SELECT DISTINCT ${field} FROM  ${tempTableName} t
        LEFT JOIN maintain_detail md on md.pre_merge_id = t.id
        LEFT JOIN maintain m on m.id = md.parent_id

        WHERE
         m.table_name = ${tableName}
         AND m.order_no >= ${fromOrderNo}
         AND m.order_no <  ${toOrderNo}
        SELECT DISTINCT ${field} FROM  ${tempTableName} t  WHERE  EXISTS (
          SELECT pre_merge_id  FROM ( SELECT  pre_merge_id FROM  maintain_detail  WHERE EXISTS (
            SELECT  id  FROM  ( SELECT  id  FROM  `maintain`  WHERE
              table_name = ${tableName}
              AND order_no >= ${fromOrderNo}
              AND order_no <  ${toOrderNo}
              ) a
            WHERE
            a.id = maintain_detail.parent_id  )
          ) a
        WHERE t.id = a.pre_merge_id)

        ]]>
    </select>

    <select id="getTempDataByMaintainExtent" statementType="STATEMENT" resultType="java.util.Map">
    <select id="getTempDataByMaintainExtent" statementType="STATEMENT"   resultType="java.util.Map">
        <![CDATA[
     SELECT  t.* FROM  ${tempTableName} t
            LEFT JOIN maintain_detail md on md.pre_merge_id = t.id
            LEFT JOIN maintain m on m.id = md.parent_id

        SELECT *  FROM  ${tempTableName} t  WHERE  EXISTS (
          SELECT pre_merge_id  FROM ( SELECT  pre_merge_id FROM  maintain_detail  WHERE EXISTS (
            SELECT  id  FROM  ( SELECT  id  FROM  `maintain`  WHERE
              table_name = ${tableName}
              AND order_no >= ${fromOrderNo}
              AND order_no <  ${toOrderNo}
              ) a
            WHERE
             m.table_name = ${tableName}
             AND m.order_no >= ${fromOrderNo}
             AND m.order_no <  ${toOrderNo}

            a.id = maintain_detail.parent_id  )
          ) a
        WHERE t.id = a.pre_merge_id)

        ]]>
    </select>