package com.product.data.sync.service;

import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.product.admin.service.CodeService;
import com.product.admin.service.SystemMenusService;
import com.product.common.lang.StringUtils;
import com.product.core.cache.DataPoolRefreshCache;
import com.product.core.config.Global;
import com.product.core.connection.ConnectionManager;
import com.product.core.dao.BaseDao;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.entity.RequestParameterEntity;
import com.product.core.exception.BaseException;
import com.product.core.service.support.AbstractBaseService;
import com.product.core.spring.context.SpringMVCContextHolder;
import com.product.core.util.CodeUtil;
import com.product.data.sync.config.CmnConst;
import com.product.data.sync.config.SystemCode;
import com.product.data.sync.service.ide.ISyFeDataService;
import com.product.data.sync.service.media.GdMediaUtil;
import com.product.data.sync.util.BusinessDataSync;
import com.product.data.sync.util.DataManipulationUtils;
import com.product.file.service.FileManagerService;
import com.product.file.util.CreateDocumentIndexThread;
import com.product.module.sys.service.UserService;
import com.product.util.BaseDaoServiceImpl;
import com.product.util.BaseUtil;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.File;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Copyright LX
 *
 * @Title: SyFeDataService
 * @Project: product-server
 * @date: 2021-09-30 14:19
 * @author: zm
 * @Description: fe数据移植到产品
 */
@Service
public class SyFeDataService extends AbstractBaseService implements ISyFeDataService {
    private static Logger logger = LoggerFactory.getLogger(SyFeDataService.class);
    @Autowired
    public BaseDao baseDao;
    @Autowired
    public FunctionSynchrService functionSynchrService;
    @Autowired
    FileManagerService fileManagerService;
    @Autowired
    SystemMenusService systemMenusService;
    @Autowired
    GdMediaUtil gdMediaUtil;
    //公司fe id 对应 产品uuid
    Map<String, FieldSetEntity> OrgIdUUIDmap = Maps.newHashMap();
    //金格主目录
    String jinGePath = "D:\\OA\\FEGOV\\Media";
    //暂存文件目录
    String TSPath = "D:\\filePackage";
    @Autowired
    private UserService userService;
    @Autowired
    private CodeService codeService;
    @Autowired
    private FeDataDSService feDataDSService;
    //fe 人员id 对应  userid
    private JSONObject userIdJson = new JSONObject();
    //fe 公司部门id 对应 机构uuid
    private JSONObject groupJson = new JSONObject();
    //字段类型关联
    private JSONObject fieldTypeJson = new JSONObject();
    //流程nodes fe id 对应 产品uuid
    private JSONObject nodesIdUUID = new JSONObject();
    //源数据表名  本数据表名
    private JSONObject originalTable = new JSONObject();
    //唯一字段
    private String pk;
    //表唯一标识   和本表uuid
    private JSONObject pxMap = new JSONObject();
    //已开发公共功能 公告管理 系统参数(没有)  问卷管理  考勤管理 车辆管理  协同办公
    private String[] funTable = {"FE_APP5.PUB_NOTICE", "FE_BASE5.RESEARCH_TOPIC", "FE_APP5.HR_ATTENDANCE", "FE_APP5.CAR_INFO", "FE_BASE5.SYS_COLLABORATIVE"};
    //我们产品的功能权限
    private String[] functionCode = {"001-004-000-000","001-004-000-001","001-004-000-002"};
    //本产品按钮uuid
    private List<String> buttonUuid = Lists.newArrayList();

    //已同步表结构
    private JSONObject dataTableObject = new JSONObject();

    public Boolean isStr(String str) {
        boolean a = false;
        for (int i = 0; i < funTable.length; i++) {
            if (str.equals(funTable[i])) {
                a = true;
            }
        }
        return a;
    }

    //公告管理1  系统参数  问卷管理  考勤管理  车辆管理  协同办公
    @Override
    public String saveSyncFedata(FieldSetEntity fs) throws SQLException, ClassNotFoundException {
        //同步组织架构
        DataTableEntity dataTableEntity = baseDao.listTable("product_sys_users");
        String clientUUID = "4d4679ed-c4c3-41b8-abfe-451a66fd4043";
        if (dataTableEntity.getRows() < 10) {
            String uuid = feDataDSService.FEDataMigration();
            if(!BaseUtil.strIsNull(uuid)){
               clientUUID = uuid;
            }
        }
        //封装两边人员关联和部门关联
//        packageDepartmentPersonnel();
        String tricode_fun = Global.getSystemConfig("data.synchronism.function", "");
        if(BaseUtil.strIsNull(tricode_fun)){
            return null;
        }
        String[] tricode_funs = tricode_fun.split(",");
//        String[] tricode_funs = fs.getString("tricode_fun").split(",");
        //封装本产品需赋权限的按钮uuid
//        this.packageButton();
//        Connection conn = functionSynchrService.getConnection(fs);
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < tricode_funs.length; i++) {
            //获取jdbc连接
            BusinessDataSync async = new BusinessDataSync(tricode_funs[i]);
            async.setBaseDao(baseDao);
            async.setFileManagerService(fileManagerService);
            async.setSystemMenusService(systemMenusService);
            async.setFeDataDSService(feDataDSService);
            async.setGdMediaUtil(gdMediaUtil);
            async.setClientUUID(clientUUID);
            Thread t = new Thread(async);
            exec.submit(t);
//            nodesIdUUID = new JSONObject();
//            //同步表及基础数据
//            String sf28 = this.synchronizeTablesData(conn, tricode_funs[i]);
//            String table_name = sf28.split("\\.")[1];
//            String moduleUUID;
//            if (!isStr(sf28)) {
//                //同步mvc
//                moduleUUID = this.synchronizationModuleName(conn, tricode_funs[i], sf28);
//            } else {
//                //已有功能的表就不同步mvc  查询该功能的模块uuid
//                StringBuffer sql = new StringBuffer();
//                sql.append(" tricode = (\n")
//                        .append("SELECT tricode_parent FROM product_sys_functions a LEFT JOIN \n")
//                        .append("product_sys_datamodel_table b on a.table_uuid = b.uuid \n")
//                        .append("WHERE b.table_name = ? GROUP BY tricode_parent\n")
//                        .append(") AND function_type_uuid = 0");
//                FieldSetEntity fieldSetEntity = baseDao.getFieldSetEntityByFilter("product_sys_functions", sql.toString(), new String[]{this.originalTable.getString(table_name)}, false);
//                moduleUUID = fieldSetEntity.getUUID();
//            }
//            //迁移 wf_model流程模块表
////            this.syncModel(tricode_funs[i], conn, moduleUUID, sf28, null, SpringMVCContextHolder.getCurrentUser().getUser_id(), false);
//            //根据要求流程要同步两次
//            //查询主公司uuid
//            FieldSetEntity fieldSetEntity = baseDao.getFieldSetByFilter(CmnConst.PRODUCT_SYS_ORG_LEVELS, " org_level_code = ? ", new String[]{"001"},false);
//            FieldSetEntity user = baseDao.getFieldSetByFilter("product_sys_org_manager" , " manager_type = ? ", new String[]{"2"}, false);
//            this.syncModel(tricode_funs[i], conn, moduleUUID, sf28, fieldSetEntity.getUUID(), user.getInteger("user_id"), true);
        }
        //同时开始执行
        exec.shutdown();
        while (true) {
            if (exec.isTerminated()) {
                //System.out.println("所有的子线程都结束了！");
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        systemMenusService.initSystemMenu();
        System.out.println("=================同步成功===============");

        return "OK";
    }

    /**
     * 附件添加索引
     */
    public void dataSyncCreateIndexUtil() {
        String sql="SELECT uuid attachment_uuid,function_uuid FROM product_sys_attachments WHERE function_uuid IS NOT NULL AND function_uuid!=''";
        DataTableEntity dtAttachment=baseDao.listTable(sql, new Object[] {});
        if (!BaseUtil.dataTableIsEmpty(dtAttachment)) {
            for (int i = 0; i < dtAttachment.getRows(); i++) {
                FieldSetEntity fseAttachment=dtAttachment.getFieldSetEntity(i);
                CreateDocumentIndexThread.getInstance().appendAttaInfo(fseAttachment);
            }
        }
    }

    /**
     * 封装单位部门 人员对应Json
     */
    public void packageDepartmentPersonnel() {
        DataTableEntity staffsData = baseDao.listTable("product_sys_staffs");
        for (int i = 0; i < staffsData.getRows(); i++) {
            //数据源用户id
            userIdJson.put(staffsData.getString(i, "remark"), staffsData.getString(i, "user_id"));
        }
        DataTableEntity orgData = baseDao.listTable("product_sys_org_levels");
        for (int i = 0; i < orgData.getRows(); i++) {
            //源数据id
            groupJson.put(orgData.getString(i, "sequence"), orgData.getString(i, "uuid"));
        }
    }

    /**
     * 封装本产品的按钮uuid
     */
    public void packageButton(){
        StringBuffer sql = new StringBuffer();
        String tricodeIn = BaseUtil.buildQuestionMarkFilter("tricode", this.functionCode, true);
        sql.append(" SELECT uuid FROM product_sys_function_buttons WHERE function_uuid IN ( ")
                .append(" SELECT uuid FROM product_sys_functions WHERE ")
                .append(tricodeIn).append(" ) ");
        DataTableEntity dataTableEntity = baseDao.listTable(sql.toString(),new String[]{});
        for (int i = 0; i < dataTableEntity.getRows(); i++) {
            this.buttonUuid.add(dataTableEntity.getString(i,"uuid"));
        }
    }

    /**
     * 同步表及表数据
     *
     * @param conn    连接
     * @param funCode 功能code
     * @throws SQLException
     */
    private String synchronizeTablesData(Connection conn, String funCode) throws SQLException {
        FieldSetEntity Orlfs = null;
        try {
            logger.info("功能code" + funCode);
            Orlfs = BaseDaoServiceImpl.getFieldSet(conn, "fe_base5.SYS_FUNCTION", "SF05=?", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        String sf28 = Orlfs.getString("sf28");
        //功能如果未关联基础表 查询流程表
        if (BaseUtil.strIsNull(sf28) || sf28.indexOf(".") == -1) {
            FieldSetEntity modelFse;
            try {
                //查询流程是否绑定表
                modelFse = BaseDaoServiceImpl.getFieldSet(conn, "fe_base5.wf_model", "wm05=(SELECT se16  FROM fe_base5.SYS_EVENT where se01=? and se08 = 1)", new Object[]{funCode
                });
            } catch (Exception e) {
                DataManipulationUtils.close(null, null, conn);
                throw e;
            }
            if (modelFse == null) {
                return null;
            }
            String wm04 = modelFse.getString("wm04");
            if (BaseUtil.strIsNull(wm04) || wm04.indexOf(".") == -1) {
                return null;
            } else {
                sf28 = wm04;
            }
        }
        //判断是否存在已开发功能的表
        //如果是已开发功能定义 通过自己定义的数据关联 同步数据
        String[] sf28s = sf28.split("\\.");
        boolean flag = true;
        if (isStr(sf28)) {
            flag = false;
        }
        this.syncTable(sf28s, flag, null, conn);
        return sf28;
    }

    /**
     * 同步公告表数据
     *
     * @param conn
     * @param tableName
     * @throws SQLException
     */
    private void syncNotice(Connection conn, String tableName) throws SQLException {
        //判断是否是已经同步过的表
        DataTableEntity dataTable = baseDao.listTable("product_oa_announcement");
        if (!BaseUtil.dataTableIsEmpty(dataTable)) {
            return;
        }
        DataTableEntity noticeDt = null;
        try {
            noticeDt = BaseDaoServiceImpl.getDataTable(conn, tableName, "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < noticeDt.getRows(); i++) {
            FieldSetEntity feFs = noticeDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_oa_announcement");
            fs.setValue("title", feFs.getString("title"));
            fs.setValue("content", feFs.getString("content"));
            fs.setValue("type", feFs.getString("notice_category"));
            //Set 转换为字符串逗号分隔
            //写方法判断是多人还是部门，若是部门转换为人
            fs.setValue("extent", this.getUserIds(feFs.getString("receivers")));
            fs.setValue("expiration_date", feFs.getDate("displayed_date"));
            fs.setValue("status", feFs.getString("is_reminded"));
            fs.setValue("publish_status", feFs.getString("status"));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());

            String uuid = baseDao.add(fs);
            //重新获取jdbc连接
            Connection connection = null;
            try {
                connection = feDataDSService.getJDBC();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            DataTableEntity subFeFs = getSubDt(connection, "FE_APP5.PUB_NOTICE_RECEIVER", "NOTICE_ID", feFs.getString("id"));
            for (int j = 0; j < subFeFs.getRows(); j++) {
                FieldSetEntity fsSubFe = subFeFs.getFieldSetEntity(j);
                FieldSetEntity fsSub = new FieldSetEntity();
                fsSub.setTableName("product_oa_announcement_role");
                String userId = userIdJson.getString(fsSubFe.getString("receiver"));
                if (null == userId) {
                    continue;
                }
                fsSub.setValue("user_id", userId);
                fsSub.setValue("status", fsSubFe.getString("readed"));
                fsSub.setValue("announcement_uuid", uuid);
                baseDao.add(fsSub);
            }
            DataManipulationUtils.close(null, null, connection);
        }
    }

    /**
     * 获取userId
     *
     * @param receivers 字段值
     */
    public String getUserIds(String receivers) throws SQLException {
        String[] receiversArr = receivers.split(",");
        Connection conn = null;
        Set<String> extentArr = new HashSet<>();
        try {
            //查询公司部门表数据
            conn = feDataDSService.getJDBC();
            for (int j = 0; j < receiversArr.length; j++) {
                if (receiversArr[j].contains("[")) {
                    String companyId = receiversArr[j].replace("[", "").replace("]", "");
                    StringBuffer sql = new StringBuffer();
                    sql.append(" SELECT * FROM FE_BASE5.sys_users WHERE SU03 like CONCAT(CONCAT('%',(SELECT SG03 FROM fe_base5.sys_group WHERE SG00 = " + companyId + ")), '%') ");
                    //人员数据
                    DataTableEntity dataTableEntity = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{});
                    String[] remark = new String[dataTableEntity.getRows()];
                    for (int i = 0; i < dataTableEntity.getRows(); i++) {
                        remark[i] = dataTableEntity.getString(i, "su00");
                    }

                    DataTableEntity userData = baseDao.listTable("product_sys_staffs", BaseUtil.buildQuestionMarkFilter("remark", remark.length, true), remark);

                    if (!BaseUtil.dataTableIsEmpty(userData)) {
                        for (int i = 0; i < userData.getRows(); i++) {
                            extentArr.add(userData.getString(i, "user_id"));
                        }
                    }
                    //{岗位}
                } else if (receiversArr[j].contains("{")) {
                    String postId = receiversArr[j].replace("{", "").replace("}", "");
                    StringBuffer sql = new StringBuffer();
                    sql.append(" SELECT * FROM FE_BASE5.sys_users WHERE SU34 = " + postId);
                    //人员数据
                    DataTableEntity dataTableEntity = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{});
                    String[] remark = new String[dataTableEntity.getRows()];
                    for (int i = 0; i < dataTableEntity.getRows(); i++) {
                        remark[i] = dataTableEntity.getString(i, "su00");
                    }

                    DataTableEntity userData = baseDao.listTable("product_sys_staffs", BaseUtil.buildQuestionMarkFilter("remark", remark.length, true), remark);

                    if (!BaseUtil.dataTableIsEmpty(userData)) {
                        for (int i = 0; i < userData.getRows(); i++) {
                            extentArr.add(userData.getString(i, "user_id"));
                        }
                    }
                } else {
                    String userId = userIdJson.getString(receiversArr[j]);
                    if (null == userId) {
                        continue;
                    }
                    extentArr.add(userId);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new BaseException(e.getMessage(), e.toString());
        }
        DataManipulationUtils.close(null, null, conn);
        return StringUtils.join(extentArr, ",");
    }

    /**
     * 查询子表信息
     *
     * @param conn
     * @param subTableName 子表名
     * @param fieldName    字段名
     * @param field        字段值
     * @return
     * @throws SQLException
     */
    private DataTableEntity getSubDt(Connection conn, String subTableName, String fieldName, String field) throws SQLException {
        DataTableEntity noticeDt = null;
        try {
            noticeDt = BaseDaoServiceImpl.getDataTable(conn, subTableName, fieldName + "=?", new Object[]{field});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        return noticeDt;
    }

    /**
     * 同步问卷调查 0
     *
     * @param conn
     * @param tableName
     * @throws SQLException
     */
    private void syncResearchTopic(Connection conn, String tableName) throws SQLException {
        //判断是否是已经同步过的表
        DataTableEntity dataTable = baseDao.listTable("product_oa_questionnaire");
        if (!BaseUtil.dataTableIsEmpty(dataTable)) {
            return;
        }
        DataTableEntity researchTopicDt = null;
        try {
            researchTopicDt = BaseDaoServiceImpl.getDataTable(conn, tableName, "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        JSONObject qSubIdUUIDMap = new JSONObject();
        JSONObject qSubOptionIdUUIDMap = new JSONObject();

        for (int i = 0; i < researchTopicDt.getRows(); i++) {
            FieldSetEntity feFs = researchTopicDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            //问卷管理
            fs.setTableName("product_oa_questionnaire");
            //问卷标题
            fs.setValue("questionnaire_title", feFs.getString("rt01"));
            //问卷说明
            fs.setValue("questionnaire_explain", feFs.getString("rt01"));
            //问卷内容
            fs.setValue("questionnaire_content", feFs.getString("rt02"));
            //是否匿名（1.是、0.否）
            fs.setValue("is_anonymous", feFs.getString("rt06"));
            String[] RT13Arr = feFs.getString("rt13").split(",");
            ArrayList<String> votersArr = new ArrayList<>();
            for (int j = 0; j < RT13Arr.length; j++) {
                RT13Arr[j] = RT13Arr[j].replace("[", "");
                RT13Arr[j] = RT13Arr[j].replace("]", "");
                String userId = userIdJson.getString(RT13Arr[j]);
            }
            if (votersArr.size() == 0) {
                continue;
            }
            //参与投票人
            fs.setValue("voters", StringUtils.join(votersArr, ","));
            //调查截止日期
            fs.setValue("deadline", feFs.getString("rt04"));
            String[] RT15Arr = feFs.getString("rt15").split(",");
            String[] resultViewerArr = new String[RT15Arr.length];
            for (int j = 0; j < RT15Arr.length; j++) {
                resultViewerArr[j] = userIdJson.getString(RT15Arr[j]);
            }
            //结果查看人
            fs.setValue("result_viewer", StringUtils.join(resultViewerArr, ","));
            //发布人
            fs.setValue("publisher", userIdJson.getString(feFs.getString("rt08")));
            //发布时间
            fs.setValue("pubdate", feFs.getDate("rt03"));
            //是否发布
            fs.setValue("is_publish", feFs.getString("rt05"));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            //主表uuid
            String uuid = baseDao.add(fs);
            DataTableEntity subFeFs = getSubDt(conn, "FE_BASE5.RESEARCH_SUB", "RS01", feFs.getString("rt00"));
            for (int j = 0; j < subFeFs.getRows(); j++) {
                FieldSetEntity feSubFs = subFeFs.getFieldSetEntity(i);
                FieldSetEntity subFs = new FieldSetEntity();
                //问卷管理子表
                subFs.setTableName("product_oa_questionnaire_sub");
                // 主表uuid
                subFs.setValue("questionnaire_uuid", uuid);
                //内容类型（1.单选题目、2.复选题目、3.简答题）
                subFs.setValue("content_type", feSubFs.getInteger("rs04") + 1);
                //选项题目
                subFs.setValue("option_topic", feSubFs.getString("rs02"));
                //题目说明
                subFs.setValue("title_description", feSubFs.getString("rs03"));
                //多选择类型（1.最多、2.最少、3.必选）
                subFs.setValue("option_type", feSubFs.getString("rs07"));
                //可选择项数
                subFs.setValue("option_num", feSubFs.getString("rs06"));
                String subUUID = baseDao.add(subFs);
                qSubIdUUIDMap.put(subUUID, feSubFs.getString("rs00"));
                if (feSubFs.getInteger("rs04") != 2) {
                    DataTableEntity subFeFsto = getSubDt(conn, "fe_base5.RESEARCH_OPTION", "RO01", feSubFs.getString("RS00"));
                    for (int k = 0; k < subFeFsto.getRows(); k++) {
                        FieldSetEntity feSubFsto = subFeFsto.getFieldSetEntity(i);
                        FieldSetEntity subFsto = new FieldSetEntity();
                        subFsto.setTableName("product_oa_questionnaire_sub_option");
                        //问卷管理子表uuid
                        subFsto.setValue("parent_uuid", subUUID);
                        //选项内容
                        subFsto.setValue("option_content", feSubFsto.getString("ro02"));
                        //是否可填（1.是、0.否）
                        subFsto.setValue("is_write", feSubFsto.getString("ro04"));
                        //选项序号
                        subFsto.setValue("option_num", numberToLetter(k + 1));
                        String subUUIDto = baseDao.add(subFsto);
                        qSubOptionIdUUIDMap.put(feSubFsto.getString("ro00"), subUUIDto);
                    }
                }
            }
            DataTableEntity vFeFs = getSubDt(conn, "fe_base5.RESEARCH_VOTER", "rv01", feFs.getString("rt00"));
            for (int j = 0; j < vFeFs.getRows(); j++) {
                FieldSetEntity feSubFs = vFeFs.getFieldSetEntity(j);
                FieldSetEntity subFs = new FieldSetEntity();
                subFs.setTableName("product_oa_questionnaire_mine");
                subFs.setValue("questionnaire_uuid", uuid);
                subFs.setValue("voting_status", feSubFs.getString("rv06"));
                logger.info("用户user_id:" + userIdJson.getString(feSubFs.getString("rv04")));
                subFs.setValue("vote_user", userIdJson.getString(feSubFs.getString("rv04")));
                subFs.setValue("subject_uuid", qSubIdUUIDMap.getString(feSubFs.getString("rv02")));
                subFs.setValue("option_answer_uuid", qSubOptionIdUUIDMap.getString(feSubFs.getString("rv03")));
                subFs.setValue("answer_contents", feSubFs.getString("rv07"));
                baseDao.add(subFs);
            }
        }
    }

    //数字转字母 1-26 ： A-Z
    private String numberToLetter(int num) {
        if (num <= 0) {
            return null;
        }
        String letter = "";
        num--;
        do {
            if (letter.length() > 0) {
                num--;
            }
            letter = ((char) (num % 26 + (int) 'A')) + letter;
            num = (int) ((num - num % 26) / 26);
        } while (num > 0);

        return letter;
    }

    //车辆基本信息表
    private void syncCarInfo(Connection conn, String tableName) throws SQLException {
        //判断是否是已经同步过的表
        DataTableEntity dataTable = baseDao.listTable("product_oa_car_driver_info");
        if (!BaseUtil.dataTableIsEmpty(dataTable)) {
            return;
        }
        //同步司机信息
        DataTableEntity driverInfoDt = null;
        try {
            driverInfoDt = BaseDaoServiceImpl.getDataTable(conn, "fe_app5.CHAUFFEUR_INFO", "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }

        JSONObject driverIdUUIDMap = new JSONObject();

        for (int i = 0; i < driverInfoDt.getRows(); i++) {
            FieldSetEntity fsFe = driverInfoDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_oa_car_driver_info");
            fs.setValue("name", fsFe.getString("CHAUFFEUR_NAME"));
            fs.setValue("driver_license_num", fsFe.getString("LICENCE_NO"));
            fs.setValue("IDCard_num", fsFe.getString("IDENTITY_CARD_NO"));
            fs.setValue("driving_model", carType(fsFe.getString("DRIVE_CAR_MODEL")));
            fs.setValue("driving_experience", fsFe.getString("DRIVE_YEAR"));
            fs.setValue("phone_num", fsFe.getString("HANDSET_NO"));
            fs.setValue("address", fsFe.getString("ADDRESS"));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            String uuid = baseDao.add(fs);
            driverIdUUIDMap.put("ID", uuid);
        }
        //同步车辆基本信息
        DataTableEntity researchTopicDt = null;
        try {
            researchTopicDt = BaseDaoServiceImpl.getDataTable(conn, tableName, "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        JSONObject carBrandUUIDMap = new JSONObject();
        JSONObject carIdUUIDMap = new JSONObject();

        for (int i = 0; i < researchTopicDt.getRows(); i++) {
            FieldSetEntity fsFe = researchTopicDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_oa_car_info");
            fs.setValue("plate_number", fsFe.getString("CAR_BRAND_NO"));
            fs.setValue("vehicle_status", fsFe.getString("CAR_STATE"));
//            fs.setValue("org_level_uuid", OrgIdUUIDmap.getString(fsFe.getString("CAR_BRAND_NO")));
            fs.setValue("vehicle_type", carType(fsFe.getString("CAR_TYPE")));
            fs.setValue("leaders", userIdJson.getString(fsFe.getString("FROM_LEADER")));
            fs.setValue("purchase_date", fsFe.getDate("BUY_DATE"));
            fs.setValue("brand_series", fsFe.getString("ROAD_BRIDGE_CHARGE"));
            fs.setValue("purchase_price", fsFe.getString("BUY_PRICE"));
            fs.setValue("vehicle_use", fsFe.getString("OIL_CHARGE"));
            fs.setValue("seats_num", fsFe.getString("SEAT_AMOUNT"));
            fs.setValue("fuel_type", fsFe.getString("OIL_TYPE"));
            fs.setValue("owner_name", fsFe.getString("MASTER_NAME"));
            fs.setValue("vehicle_certificate", fsFe.getString("CAR_PAPER"));
            //附件
//            fs.setValue("attachment_uuid",);
            if (!fsFe.getString("DRIVER").isEmpty()) {
                fs.setValue("driver_id", driverIdUUIDMap.getString(fsFe.getString("DRIVER")));
            }
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            String uuid = baseDao.add(fs);
            carBrandUUIDMap.put(fsFe.getString("CAR_BRAND_NO"), uuid);
            carIdUUIDMap.put(fsFe.getString("ID"), uuid);
        }
        //同步车辆出险事故信息表
        DataTableEntity carSlipDt = null;
        try {
            carSlipDt = BaseDaoServiceImpl.getDataTable(conn, "fe_app5.CAR_SLIP", "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < carSlipDt.getRows(); i++) {
            FieldSetEntity fsFe = carSlipDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_oa_car_accident_record");
            fs.setValue("vehicle_info_uuid", carBrandUUIDMap.getString(fsFe.getString("CAR_BRAND_NO")));
            fs.setValue("accident_time", fsFe.getDate("SLIP_DATE"));
            fs.setValue("driver_info_uuid", driverIdUUIDMap.getString(fsFe.getString("DRIVE_PERSON")));
            fs.setValue("accident_location", fsFe.getDate("SLIP_ADDRESS"));
            fs.setValue("accident_cause", fsFe.getDate("SLIP_REASON"));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            fs.setValue("flow_flag", 2);
            baseDao.add(fs);
        }
        //同步车辆申请信息表
        DataTableEntity carApplicationDt = null;
        try {
            carApplicationDt = BaseDaoServiceImpl.getDataTable(conn, "fe_app5.CAR_APPLICATION", "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < carApplicationDt.getRows(); i++) {
            FieldSetEntity fsFe = carApplicationDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_oa_car_application");
            fs.setValue("applicant", userIdJson.getString(fsFe.getString("PROPOSER")));
//            fs.setValue("org_level_uuid", OrgIdUUIDmap.getString(fsFe.getString("SECTION_DEPARTMENT")));
            fs.setValue("applicattion_time", fsFe.getDate("APPLICATION_DATE"));
            fs.setValue("start_place", fsFe.getString("START_END_ADDRESS"));
            fs.setValue("person_board", fsFe.getString("FOLLOW_PERSON"));
            fs.setValue("vehicle_line", fsFe.getString("CAR_LINE"));
            fs.setValue("scheduled_start_time", fsFe.getDate("USE_START_DATE"));
            fs.setValue("scheduled_end_time", fsFe.getDate("USE_END_DATE"));
            fs.setValue("project_name", fsFe.getString("USE_END_DATE"));
            fs.setValue("use_reason", fsFe.getString("USE_REASON"));
            if (!fsFe.getString("DRIVER").isEmpty()) {
                fs.setValue("driver_info_uuid", driverIdUUIDMap.getString(fsFe.getString("DRIVER")));
            }
            fs.setValue("status", fsFe.getString("STATUS"));
            fs.setValue("driving_time", fsFe.getString("START_DATE"));
            fs.setValue("return_time", fsFe.getString("RETURN_DATE"));
            fs.setValue("actual_line", fsFe.getString("FACT_WAY"));
            fs.setValue("repair_cost", fsFe.getString("id04"));
            fs.setValue("fuel_charge", fsFe.getString("OIL_CHARGE"));
            fs.setValue("toll", fsFe.getString("id05"));
            fs.setValue("other_expenses", fsFe.getString("id01"));
            fs.setValue("total_cost", fsFe.getString("id02"));
            fs.setValue("manager_confirmation", fsFe.getString("id08"));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            fs.setValue("flow_flag", 2);
            baseDao.add(fs);
        }
    }

    private String carType(String type) {
        String reType = "";
        switch (type) {
            case "轿车":
                reType = "1";
                break;
            case "货车":
                reType = "2";
                break;
            default:
                reType = "3";
        }
        return reType;
    }

    /**
     * 同步已开发功能数据
     *
     * @param tableName 表名
     * @return
     * @throws SQLException
     */
    private void syncFunTable(Connection conn, String tableName) throws SQLException {
        //公告表
        if (tableName.equals("FE_APP5.PUB_NOTICE")) {
            syncNotice(conn, tableName);
            //两个表建立关联
            this.originalTable.put("PUB_NOTICE", "product_oa_announcement");
        }
        //同步问卷调查
        if (tableName.equals("FE_BASE5.RESEARCH_TOPIC")) {
            syncResearchTopic(conn, tableName);
            this.originalTable.put("RESEARCH_TOPIC", "product_oa_questionnaire");
        }
        //考勤表
        if (tableName.equals("FE_APP5.APP_KQLRB")) {
            this.synchronousClock(conn, tableName);
        }
        //车辆基本信息表  为空
        if (tableName.equals("FE_APP5.CAR_INFO")) {
            syncCarInfo(conn, tableName);
            this.originalTable.put("CAR_INFO", "product_oa_car_driver_info");
        }
        //协同办公  不管
        if (tableName.equals("FE_BASE5.SYS_COLLABORATIVE")) {
            syncCcooperates(conn, tableName);
            this.originalTable.put("SYS_COLLABORATIVE", "product_oa_cooperates");
        }

        //会议室申请
        if (tableName.equals("FE_APP5.BS_MEETING_FLOW")) {

        }
        //会议室管理
        if (tableName.equals("FE_APP5.BS_MEETINGROOM")) {

        }
    }

    /**
     * 同步考勤数据
     */
    private void synchronousClock(Connection conn ,String tableName) throws SQLException {
        DataTableEntity clockDt = null;
        try {
            clockDt = BaseDaoServiceImpl.getDataTable(conn, tableName, "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        if(!BaseUtil.dataTableIsEmpty(clockDt)){
            for (int i = 0; i < clockDt.getRows(); i++) {
                FieldSetEntity fse = clockDt.getFieldSetEntity(i);
                FieldSetEntity fieldSetEntity = new FieldSetEntity();
                fieldSetEntity.setTableName("product_oa_punch_record");
                //公司部门id
                String dept = fse.getString("dept");

                //mac地址
                String mac = fse.getString("mac");
            }
        }

    }

    /**
     * 会议室申请
     *
     * @param conn
     * @param tableName
     */
    private void ConferenceRoomApplication(Connection conn, String tableName) throws SQLException {
        //判断是否是已经同步过的表
        DataTableEntity dataTable = baseDao.listTable("product_oa_conference_apply");
        if (!BaseUtil.dataTableIsEmpty(dataTable)) {
            return;
        }
        DataTableEntity ccooperatesDt = null;
        try {
            ccooperatesDt = BaseDaoServiceImpl.getDataTable(conn, tableName, "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
    }

    //同步协同办公
    private void syncCcooperates(Connection conn, String tableName) throws SQLException {
        //判断是否是已经同步过的表
        DataTableEntity dataTable = baseDao.listTable("product_oa_cooperates");
        if (!BaseUtil.dataTableIsEmpty(dataTable)) {
            return;
        }
        DataTableEntity ccooperatesDt = null;
        try {
            ccooperatesDt = BaseDaoServiceImpl.getDataTable(conn, tableName, "", new Object[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }

        DataTableEntity accessoryData = this.getTableNameAttachment(conn, tableName);
        for (int i = 0; i < ccooperatesDt.getRows(); i++) {
            FieldSetEntity feFs = ccooperatesDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_oa_cooperates");
            //标题
            fs.setValue("title", feFs.getString("title"));
            String content = feFs.getString("content");
            if (BaseUtil.strIsNull(content)) {
                content = "";
            }
            //内容
            fs.setValue("content", content);
            String important = feFs.getString("important");
            if (!BaseUtil.strIsNull(important)) {
                //紧急程度（1.平件、2.急件、3.特急、4.特提）
                fs.setValue("emergency_degree", emergencyDegreeType(important));
            } else {
                //为空就放0
                fs.setValue("emergency_degree", 0);
            }
            //附件hiddenidea
            // fs.setValue("attachment",);
            //发起时间
            fs.setValue("start_time", feFs.getString("stime"));
            //是否允许转发（1.是、0.否）
            fs.setValue("is_forward", feFs.getString("repeating"));
            //是否允许加签（1.是、0.否）
            fs.setValue("is_countersign", feFs.getString("modifyflow"));
            //是否允许跟踪（1.是、0.否）
            fs.setValue("is_track", feFs.getString("track"));
            //是否隐藏回复意见（1.是、0.否）
            fs.setValue("is_hide_comments", feFs.getString("hiddenidea"));
            //状态（0.待发、1.已发）
            fs.setValue("status", 1);
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            Map<String, List<String>> fileMaps = this.synchronizationAttachments(conn, accessoryData, feFs, fs.getTableName());
            List<String> value = fileMaps.get("COL_MDL_CONTENT_MEDIA");
            //存入附件uuid
            fs.setValue("attachment", StringUtils.join(value, ","));
            String uuid = baseDao.add(fs);

            DataTableEntity coNodeDt = null;
            try {
                //flowcode 流程字段
                coNodeDt = BaseDaoServiceImpl.getDataTable(conn, "SELECT a.NAME receiver_name,a.VALUE receiver,b.NAME sender_name,b.VALUE sender,a.STATUS ,a.PARENTGUID PARENTGUID ,a.MGUID MGUID FROM WF_CO_NODE a LEFT JOIN WF_CO_NODE b on a.PARENTGUID=b.GUID where a.MGUID=?", new Object[]{feFs.getString("flowcode")});
            } catch (Exception e) {
                DataManipulationUtils.close(null, null, conn);
                throw e;
            }
            JSONObject grade = new JSONObject();
            for (int j = 0; j < coNodeDt.getRows(); j++) {
                FieldSetEntity subfsFe = coNodeDt.getFieldSetEntity(j);
                FieldSetEntity subfs = new FieldSetEntity();
                //协同办公流程表
                subfs.setTableName("product_oa_cooperate_flow_node");
                grade.put(subfsFe.getString("guid"), 1);
                //办理人层级
                subfs.setValue("grade", 1);
                //关联协同表uuid
                subfs.setValue("cooperate_uuid", uuid);
                //接收人（关联用户表id）
                subfs.setValue("receiver", subfsFe.getString("receiver"));
                //接收人姓名
                subfs.setValue("receiver_name", subfsFe.getString("receiver_name"));
                //发送人（关联用户表id）
                subfs.setValue("sender", subfsFe.getString("sender"));
                //发送人姓名
                subfs.setValue("sender_name", subfsFe.getString("sender_name"));
                //0:未收未办 1:已收未 2:已收已办
                subfs.setValue("status", subfsFe.getInteger("status") == 1 ? 2 : 0);
                //0:暂存 1:加签 2:转发 3:退回4:送办 5:终止 6:撤销
                subfs.setValue("type", 0);


                String uuids = baseDao.add(subfs);
//                DataTableEntity IDEAMANAGEDt = null;
//                try {
//                    IDEAMANAGEDt = BaseDaoServiceImpl.getDataTable(conn, "select c.ID02 ID02,c.ID03 ID03,c.ID04 ID04,c.ID08 ID08 from FE_BASE5.WF_TASK a  JOIN FE_BASE5.WF_INFOR b  on a.WT00=b.WI01  JOIN  FE_BASE5.IDEAMANAGE c on b.WI21= c.ID06  where a. WT13=? ", new Object[]{subfsFe.getString("mguid")});
//                } catch (Exception e) {
//                    DataManipulationUtils.close(null, null, conn);
//                    throw e;
//                }
//                for (int k = 0; k < IDEAMANAGEDt.getRows(); k++) {
//                    FieldSetEntity subfsFeto = coNodeDt.getFieldSetEntity(i);
//                    FieldSetEntity subfsto = new FieldSetEntity();
//                    //协同办公留言表
//                    subfsto.setTableName("product_oa_cooperate_flow_reply");
//                    //关联product_oa_cooperate_flow_node表uuid
//                    subfsto.setValue("parent_uuid", uuids);
//                    //回复内容
//                    subfsto.setValue("reply_content", subfsFeto.getString("id04"));
//                    //回复时间
//                    subfsto.setValue("reply_datetime", subfsFeto.getString("id03"));
//                    //回复人，关联user表id
//                    subfsto.setValue("reply_user", this.getUserId(subfsFeto.getInteger("id02")));
//                    baseDao.add(subfsto);
//                    //附件
////                    subfsto.setValue("reply_attachment",);
//                }
            }
        }
    }

    private String emergencyDegreeType(String type) {
        String reType = "";
        switch (type) {
            case "平件":
                reType = "1";
                break;
            case "加急":
                reType = "2";
                break;
            case "特急":
                reType = "3";
                break;
            case "特提":
                reType = "4";
                break;
            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + type);

        }
        return reType;
    }

    /**
     * 迁移功能权限许可
     *
     * @param conn      JDBC连接
     * @param funUUID   方法uuid
     * @param funCode   功能code
     * @param buttonMap 按钮map
     * @throws SQLException
     */
    public void syncFunctionPermission(Connection conn, String funUUID, String funCode, JSONObject buttonMap) throws SQLException {
        DataTableEntity permissionDt = null;
        try {
            permissionDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_FUNCTION_USER", "FU02=?", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        Map<String, DataTableEntity> funUsers = Maps.newHashMap();
        for (int i = 0; i < permissionDt.getRows(); i++) {
            FieldSetEntity permissionFs = permissionDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_sys_function_permission");
            fs.setValue("function_uuid", funUUID);
            //角色id
            String fu01 = permissionFs.getString("fu01");
            //该权限管理的是用户表（SYS_USERS）  并非角色表
            if ("U".equals(permissionFs.getString("fu03"))) {
                String fu04 = permissionFs.getString("fu04");
                DataTableEntity data = funUsers.get(fu04);
                if (BaseUtil.dataTableIsEmpty(data)) {
                    data = new DataTableEntity();
                }
                data.addFieldSetEntity(permissionFs);
                funUsers.put(fu04, data);
                continue;
            }
            //获取角色数据
            FieldSetEntity roleFse = baseDao.getFieldSetEntityByFilter("product_sys_role", " sequence = ? ", new String[]{fu01}, true);
//            String orgLevelUuid = roleFse.getString("org_level_uuid");
            fs.setValue("role_uuid", roleFse.getUUID());
            String fu04 = permissionFs.getString("fu04");
            //获取权限里的按钮
            List<String> buttonIdType = new ArrayList<>();
            buttonIdType.add(funCode);
            for (int j = 0; j < fu04.length(); j++) {
                String type = String.valueOf(fu04.charAt(j));
                if (type.equals("1")) {
                    //放入值的下标
                    buttonIdType.add(buttonTypeRole(j));
                }
            }
            if (buttonIdType.size() == 1) {
                continue;
            }
            DataTableEntity eventDt = null;
            try {
                StringBuffer where = new StringBuffer();
                where.append(" SE01=? ").append(" and ( ").append(BaseUtil.buildQuestionMarkFilter("SE12", buttonIdType.size() - 1, true)).append(" or SE08=1) ");
                eventDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_EVENT", where.toString(), buttonIdType.toArray());
            } catch (Exception e) {
                DataManipulationUtils.close(null, null, conn);
                throw e;
            }
            List<String> buttonId = new ArrayList<>();
            for (int j = 0; j < eventDt.getRows(); j++) {
                buttonId.add(buttonMap.getString(eventDt.getString(j, "se00")));
            }
            buttonId.addAll(this.buttonUuid);
            fs.setValue("button_uuid", StringUtils.join(buttonId, ","));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            baseDao.add(fs);
        }
        //同步每个功能权限后   还要同步客户权限
        this.customerPermission(funUUID, buttonMap);
    }

    /**
     * 同步客户权限
     * @param funUUID 功能权限
     * @param buttonMap 案例uuid map
     */
    public void customerPermission(String funUUID,JSONObject buttonMap){
        FieldSetEntity fs = new FieldSetEntity();
        fs.setTableName("product_sys_function_permission");
        fs.setValue("function_uuid", funUUID);
        //客户uuid
        fs.setValue("role_uuid", "8dddd416-a790-4a4e-8418-8c032d5f2394");
        List<String> buttonUuid = new ArrayList<>();
        for (String key : buttonMap.keySet()) {
            buttonUuid.add(buttonMap.getString(key));
        }
        //若没有按钮 直接退出
        if(buttonUuid.size() == 0){
            return;
        }
        fs.setValue("button_uuid", StringUtils.join(buttonUuid, ","));
        fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
        fs.setValue("created_utc_datetime", new Date());
        baseDao.add(fs);
    }

    /**
     * 创建一个功能下的角色
     * 把直接关联功能的用户放入角色下
     *
     * @param conn         连接
     * @param map          k 为按钮权限，u 为关联用户权限的data
     * @param funUUID      功能uuid
     * @param funCode      功能code
     * @param buttonJson   按钮json
     * @param orgLevelUuid 公司uuid
     */
    public void newFunctionRole(Connection conn, Map<String, DataTableEntity> map, String funUUID, String funCode, JSONObject buttonJson, String orgLevelUuid) {
        for (Map.Entry<String, DataTableEntity> m : map.entrySet()) {
            List<String> buttonIdType = new ArrayList<>();
            buttonIdType.add(funCode);
            String key = m.getKey();
            for (int j = 0; j < key.length(); j++) {
                String type = String.valueOf(key.charAt(j));
                if (type.equals("1")) {
                    //放入值的下标
                    buttonIdType.add(buttonTypeRole(j));
                }
            }
            //查询这条功能数据
            FieldSetEntity funFse = baseDao.getFieldSetEntity("product_sys_function", funUUID, false);
            //功能名称
            String functionName = funFse.getString("function_name");
            //创建角色
            FieldSetEntity lxRoleFs = new FieldSetEntity();
            lxRoleFs.setTableName("product_sys_role");
            if (BaseUtil.strIsNull(orgLevelUuid)) {
                orgLevelUuid = SpringMVCContextHolder.getCurrentUser().getOrg_level_uuid();
            }
            lxRoleFs.setValue("org_level_uuid", orgLevelUuid);

            String name = functionName + "功能下角色";
            lxRoleFs.setValue("role_name", name);
            lxRoleFs.setValue("role_description", name);
            lxRoleFs.setValue("is_used", 1);
            feDataDSService.userAndTime(lxRoleFs);
            baseDao.add(lxRoleFs);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_sys_function_permission");
            fs.setValue("function_uuid", funUUID);
            StringBuffer where = new StringBuffer();
            where.append(" SE01=? ").append(" and ( ").append(BaseUtil.buildQuestionMarkFilter("SE12", buttonIdType.size() - 1, true)).append(" or SE08=1) ");
            DataTableEntity eventDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_EVENT", where.toString(), buttonIdType.toArray());
            List<String> buttonId = new ArrayList<>();
            for (int j = 0; j < eventDt.getRows(); j++) {
                buttonId.add(buttonJson.getString(eventDt.getString(j, "se00")));
            }
            fs.setValue("button_uuid", StringUtils.join(buttonId, ","));
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            //创建角色
            String uuid = baseDao.add(fs);
            //角色关联用户uuid
            DataTableEntity dataTableEntity = map.get(key);
            //获取关联用户
            for (int i = 0; i < dataTableEntity.getRows(); i++) {
                String userId = dataTableEntity.getString(i, "fu01");
                //获取用户
                FieldSetEntity fieldSetEntity = baseDao.getFieldSetEntityByFilter("product_sys_staffs", " remark = ? ", new String[]{userId}, false);
                String roleUuids = fieldSetEntity.getString("role_uuids");
                if (BaseUtil.strIsNull(roleUuids)) {
                    fieldSetEntity.setValue("role_uuids", uuid);
                } else {
                    roleUuids = roleUuids + "," + uuid;
                    fieldSetEntity.setValue("role_uuids", roleUuids);
                }
                //保存修改角色权限后的用户
                baseDao.add(fieldSetEntity);
            }

        }
    }

    private String buttonTypeRole(int type) {
        String button_category_uuid = "";
        switch (type) {
            case 0:
                button_category_uuid = "01";
                break;
            case 1:
                button_category_uuid = "02";
                break;
            case 2:
                button_category_uuid = "03";
                break;
            case 3:
                button_category_uuid = "04";
                break;
            case 4:
                button_category_uuid = "05";
                break;
            case 5:
                button_category_uuid = "06";
                break;
            case 6:
                button_category_uuid = "07";
                break;
            case 7:
                button_category_uuid = "08";
                break;
            case 8:
                button_category_uuid = "09";
                break;
            case 9:
                button_category_uuid = "10";
                break;
            case 10:
                button_category_uuid = "11";
                break;
            case 11:
                button_category_uuid = "12";
                break;
            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + type);
        }
        return button_category_uuid;
    }

    /**
     * 迁移功能下的按钮页面
     *
     * @param conn
     * @param funUUID
     * @param funCode
     * @throws SQLException
     */
    public JSONObject syncButtonsPage(Connection conn, String funUUID, String funCode) throws SQLException {
        DataTableEntity buttonsDt = null;
        try {//获取显示按钮
            buttonsDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_EVENT", "SE30 = '1' AND SE01= ? ", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        String flow_uuid = null;
        String sendButton = null;
        JSONObject map = new JSONObject();
        //名字为k 的json
        Map<String, FieldSetEntity> nameButtonMap = Maps.newHashMap();
        for (int i = 0; i < buttonsDt.getRows(); i++) {
            FieldSetEntity buttonsFs = buttonsDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            //页面表
            fs.setTableName("product_sys_function_buttons");
            fs.setValue("function_uuid", funUUID);
            //按钮名称
            fs.setValue("button_name", buttonsFs.getString("se02"));
            //按钮标题 如果为空  就用描述
            String buttonsFsString = buttonsFs.getString("se31");
            if (BaseUtil.strIsNull(buttonsFsString) || " ".equals(buttonsFsString)) {
                buttonsFsString = buttonsFs.getString("se09");
            }
            fs.setValue("button_title", buttonsFsString);
            //按钮描述
            fs.setValue("button_description", buttonsFs.getString("se09"));
            //点击触发按钮事件的类型：1: 入口，2:普通按钮  若为入口可能会绑定流程
            if (buttonsFs.getInteger("se08") == 1) {
                fs.setValue("button_type", 1);
                //绑定的流程
                String se16 = buttonsFs.getString("se16");
                //不为空 单独处理流程关联
                if (!BaseUtil.strIsNull(se16)) {
                    flow_uuid = se16;
                }
            } else {
                fs.setValue("button_type", 2);
            }
            fs.setValue("button_type", buttonsFs.getInteger("se08") == 1 ? 1 : 2);
            //是否启用
            fs.setValue("status_uuid", 1);
            String type;
            if(buttonsFs.getInteger("se08") == 1){
                //是否为功能入口，1=是，0=否
                fs.setValue("is_main", 1);
                type = "main";
            }else {
                type = buttonType(buttonsFs.getString("se12"));
                fs.setValue("is_main", 0);
            }
            //按钮分类：关联字典表(新增，修改，删除，查看，列表，导入，导出，送审)

            fs.setValue("button_category_uuid", type);
            //是删除按钮   都多选
            if ("delete".equals(type)) {
                //是否多选  1 是
                fs.setValue("multiple_choice", 1);
                //是否提醒
                fs.setValue("is_warn", 1);
            } else {
                //是否多选  1 是
                fs.setValue("multiple_choice", 0);
                fs.setValue("is_warn", 0);
            }
            //客户端类型：关联数据字典
            fs.setValue("client_type_uuid", "Web");
            //位置top
            fs.setValue("top_location", buttonsFs.getInteger("se11") + "px");
            //位置left
            fs.setValue("left_location", buttonsFs.getInteger("se10") + "px");
            //事件前 fron_event 1000
            fs.setValue("fron_event", buttonsFs.getString("se03"));
            //逻辑方法 logical_method  800
            fs.setValue("logical_method", buttonsFs.getString("se04"));
            //事件后 event_after  900
            fs.setValue("event_after", buttonsFs.getString("se05"));
            //脚本类型 event_type 250
            fs.setValue("event_type", buttonsFs.getString("se15"));
            //引入脚本 script_method 暂不插入
//            System.out.println("se14:" + buttonsFs.getString("se14"));
//            fs.setValue("script_method", buttonsFs.getString("se14"));
            //路由名称
            fs.setValue("route_name", BaseUtil.getPageCode());
            String uuid = baseDao.add(fs);
            //09为送办按钮
            if ("09".equals(buttonsFs.getString("se12")) && !BaseUtil.strIsNull(buttonsFs.getString("se14"))) {
                sendButton = uuid;
            }
            map.put(buttonsFs.getString("se00"), uuid);
            //名字唯一
            nameButtonMap.put(buttonsFs.getString("se09"), fs);
        }

        DataTableEntity pageDt = null;
        try {
            pageDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_PAGE", "SP01=?", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        JSONObject pageMap = new JSONObject();
        Map<String, FieldSetEntity> pageNameMap = Maps.newHashMap();
        for (int i = 0; i < pageDt.getRows(); i++) {
            FieldSetEntity pageFs = pageDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            //页面表
            fs.setTableName("product_sys_mvc_page");
            fs.setValue("function_uuid", funUUID);
            //页面名称
            String sp02 = pageFs.getString("sp02");
            fs.setValue("page_name", sp02);
            //禁用页面元素
            fs.setValue("page_element_disabled", 0);
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());
            //位置top
            fs.setValue("top_location", pageFs.getString("sp07"));
            //位置left
            fs.setValue("left_location", pageFs.getString("sp06"));
            //表单类型 名称带有列表都是列表类型
            if (sp02.contains("列表")) {
                fs.setValue("page_type", 1);
            } else {
                fs.setValue("page_type", 0);
            }
            //页面是否可修改
            fs.setValue("page_element_disabled", pageFs.getInteger("sp08") == 1 ? 0 : 1);
            //页面路径暂存   fe引入js代码路径
            fs.setValue("page_url", pageFs.getString("sp09"));
            //先存入流程id    迁移流程后再替换
            fs.setValue("flow_uuid", pageFs.getString("sp09"));
            //打开方式
            fs.setValue("page_open_with", 0);
            String uuid = baseDao.add(fs);
            pageMap.put(pageFs.getString("sp00"), uuid);
            pageNameMap.put(sp02, fs);
        }
        DataTableEntity pageButtonDt = null;
        try {
            pageButtonDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_EVENT_PAGE", "SEP06=?", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < pageButtonDt.getRows(); i++) {
            FieldSetEntity pageButtonFs = pageButtonDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_sys_link");
            fs.setValue("function_uuid", funUUID);
            //连线类型
            fs.setValue("link_type", 0);
            //起始uuid
            String pageUuid = pageMap.getString(pageButtonFs.getString("sep01"));
            fs.setValue("line_from", pageUuid);
            //起始类型 页面
            fs.setValue("from_type", 2);
            //截止uuid
            String buttonUuid = map.getString(pageButtonFs.getString("sep02"));
            //为空表示关联失效的按钮  ，就不搬
            if (BaseUtil.strIsNull(buttonUuid)) {
                continue;
            }
            fs.setValue("line_to", buttonUuid);
            //相等说明为送办   找到页面uuid存入流程
            if (!BaseUtil.strIsNull(flow_uuid) && buttonUuid != null && buttonUuid.equals(sendButton)) {
                if (pageUuid != null) {
                    FieldSetEntity fse = baseDao.getFieldSetEntity("product_sys_mvc_page", pageUuid, false);
                    fse.setValue("flow_uuid", flow_uuid);
                    baseDao.update(fse);
                }
            }
            //截止类型
            fs.setValue("to_type", 1);
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());

            baseDao.add(fs);
        }
        DataTableEntity buttonPageDt = null;
        try {
            //按钮连页面   按钮连按钮
            buttonPageDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.SYS_REDIRECT", "SR06=?", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < buttonPageDt.getRows(); i++) {
            FieldSetEntity buttonPageFs = buttonPageDt.getFieldSetEntity(i);
            FieldSetEntity fs = new FieldSetEntity();
            fs.setTableName("product_sys_link");
            fs.setValue("function_uuid", funUUID);
            fs.setValue("link_type", 0);
            //按钮与页面或者按钮与页面关系字段
            String sr05 = buttonPageFs.getString("sr05");
            String[] sr05s = sr05.split("-->");
            FieldSetEntity buttonFse = nameButtonMap.get(sr05s[0]);
            if (buttonFse == null) {
                continue;
            }
            //判断是否是入口
            if (1 == buttonFse.getInteger("is_main")) {
                //起始类型 0 入口 1 按钮 2 页面
                fs.setValue("from_type", 0);
            } else {
                //起始类型 0 入口 1 按钮 2 页面
                fs.setValue("from_type", 1);
            }
            fs.setValue("line_from", buttonFse.getUUID());
            //获取按钮信息
            //连接类型  1按钮连按钮   0按钮连页面
            Integer sr02 = buttonPageFs.getInteger("sr02");
            //连接的是按钮
            if (1 == sr02) {
                //获取按钮fse 1
                FieldSetEntity buttonFse2 = nameButtonMap.get(sr05s[1]);
                if (buttonFse2 == null) {
                    continue;
                }
                //判断是否是入口
                if (1 == buttonFse2.getInteger("is_main")) {
                    //结束类型 0 入口 1 按钮 2 页面
                    fs.setValue("to_type", 0);
                } else {
                    fs.setValue("to_type", 1);
                }
                fs.setValue("line_to", buttonFse2.getUUID());
            } else {
                //连接的是页面
                //获取页面fse 0
                FieldSetEntity pageFse = pageNameMap.get(sr05s[1]);
                if (pageFse == null) {
                    continue;
                }
                //页面类型
                fs.setValue("to_type", 2);
                //页面uuid
                fs.setValue("line_to", pageFse.getUUID());
            }
            fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            fs.setValue("created_utc_datetime", new Date());

            baseDao.add(fs);
        }
        return map;
    }

    /**
     * 按钮类型转换
     *
     * @param type
     * @return
     */
    private String buttonType(String type) {
        String button_category_uuid = "";
        if (type == null) {
            button_category_uuid = "main";
            return button_category_uuid;
        }
        switch (type) {
            case "01":
                button_category_uuid = "add";
                break;
            case "02":
                button_category_uuid = "update";
                break;
            case "03":
                button_category_uuid = "delete";
                break;
            case "04":
                button_category_uuid = "view";
                break;
            case "05":
                button_category_uuid = "print";
                break;
            case "06":
                button_category_uuid = "import";
                break;
            case "07":
                button_category_uuid = "custom";
                break;
            case "08":
                button_category_uuid = "custom";
                break;
            case "09":
                button_category_uuid = "audit";
                break;
            case "10":
                button_category_uuid = "custom";
                break;
            case "11":
                button_category_uuid = "custom";
                break;
            case "12":
                button_category_uuid = "custom";
                break;
            default:
                button_category_uuid = "custom";

        }
        return button_category_uuid;
    }

    /**
     * @param funFs
     * @param moduleCode 模块code
     * @throws SQLException
     */
    public void syncFunctions(FieldSetEntity funFs, String moduleCode, String sf28) throws SQLException, ClassNotFoundException {
        System.out.println(funFs.getString("sf28"));
        if(!BaseUtil.strIsNull(funFs.getString("sf28"))){
            sf28 = funFs.getString("sf28");
        }
        String table = sf28.split("\\.")[1].toLowerCase();
        FieldSetEntity product_sys_datamodel_table = baseDao.getFieldSetEntityByFilter("product_sys_datamodel_table", "table_name=?", new String[]{table}, false);
        //迁移功能
        FieldSetEntity fs = new FieldSetEntity();
        fs.setTableName("product_sys_functions");
        //表uuid
        fs.setValue("table_uuid",product_sys_datamodel_table.getString("uuid"));
        //功能名称
        fs.setValue("function_name", funFs.getString("sf03"));
        //功能描述
        fs.setValue("function_description", funFs.getString("sf03"));
        //上级code    上级模块code
        fs.setValue("tricode_parent", moduleCode);
        //功能code
        String funCode = CodeUtil.getNewCodeByTemp(CmnConst.PRODUCT_SYS_FUNCTIONS, CmnConst.TRICODE, moduleCode);
        fs.setValue("tricode", funCode);
        //功能短编码
        fs.setValue("function_shortcode", "feqy");
        fs.setValue("status_uuid", "1");
        fs.setValue("function_type_uuid", "1");
        fs.setValue("client_type_uuid", "Web");
        fs.setValue("version_uuid", "001");
        fs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
        fs.setValue("created_utc_datetime", new Date());
        fs.setValue("data_type", 1);
        String funUUID = baseDao.add(fs);

        String sf05 = funFs.getString("sf05");
        //获取jdbc连接
        Connection conn = feDataDSService.getJDBC();
        //迁移MVC
        JSONObject buttonMap = this.syncButtonsPage(conn, funUUID, sf05);
        //迁移菜单
        try {
            this.synchronizationMenu(conn, funFs.getString("sf05"), funUUID);
        }catch (Exception e){
            e.getStackTrace();
        }
        //迁移功能权限许可
        this.syncFunctionPermission(conn, funUUID, sf05, buttonMap);
        //关闭连接
        DataManipulationUtils.close(null, null, conn);
    }

    /**
     * 同步模块名称
     *
     * @param conn    连接
     * @param funCode 功能code
     */
    public String synchronizationModuleName(Connection conn, String funCode, String sf28) throws SQLException {
        FieldSetEntity funFse = null;
        try {
            //通过
            funFse = BaseDaoServiceImpl.getFieldSet(conn, "fe_base5.SYS_FUNCTION", "  SF05 = ? ", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        if (funFse == null) {
            return null;
        }
        //模块名称
        String sf01 = funFse.getString("sf01");

        //同步模块名称
        FieldSetEntity moduleFs = baseDao.getFieldSetEntityByFilter("product_sys_functions", " function_name = ? ", new String[]{sf01}, false);
        String moduleCode = null;
        String moduleUUID = null;
        if (moduleFs == null) {
            moduleFs = new FieldSetEntity();
            moduleFs.setTableName("product_sys_functions");
            //产品uuid
            moduleFs.setValue("table_uuid", "ff44dc40-5fa6-4b99-a0c6-463fd5fb5c5b85");
            moduleFs.setValue("function_name", sf01);
            moduleFs.setValue("function_description", sf01);
            //产品code
            moduleFs.setValue("tricode_parent", "001");
            moduleCode = CodeUtil.getNewCodeByTemp(CmnConst.PRODUCT_SYS_FUNCTIONS, CmnConst.TRICODE, "001");
            moduleFs.setValue("tricode", moduleCode);
            moduleFs.setValue("function_shortcode", "feqymk");
            moduleFs.setValue("status_uuid", "1");
            moduleFs.setValue("function_type_uuid", "0");
            moduleFs.setValue("function_icon", "0");
            moduleFs.setValue("client_type_uuid", "Web");
            moduleFs.setValue("version_uuid", "001");
            moduleFs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            moduleFs.setValue("created_utc_datetime", new Date());
            moduleFs.setValue("data_type", 2);
            //新增一个fe迁移总模块
            moduleUUID = baseDao.add(moduleFs);
        } else {
            moduleCode = moduleFs.getString("tricode");
            moduleUUID = moduleFs.getUUID();
        }
        //同步模块下的功能
        try {
            this.syncFunctions(funFse, moduleCode, sf28);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //同步菜单
        return moduleUUID;
    }

    /**
     * 同步菜单 如果没有上级目录 创建上级目录
     * @param conn jdbc连接
     * @param funCode 同步code
     */
    public void synchronizationMenu(Connection conn, String funCode, String funUUID) throws SQLException,BaseException{
        //根据功能code获取菜单
        FieldSetEntity menuFse = null;
        try {
            //菜单信息
            menuFse = BaseDaoServiceImpl.getFieldSet(conn, "FE_BASE5.DESKTOP_MENU_MANAGEMENT", "  URL = ? ", new Object[]{funCode});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        //查询是否有菜单和目录名称
        FieldSetEntity fieldSetEntity = baseDao.getFieldSetEntityByFilter("product_sys_menus"," menu_name = ? ",new String[] {menuFse.getString("temp")}, false);
        //创建菜单
        FieldSetEntity fieldSet = new FieldSetEntity();
        fieldSet.setTableName("product_sys_menus");
        //是否目录 0否、1是
        fieldSet.setValue("is_catalog", 0);
        //是否显示 0:不显示、 1:显示
        fieldSet.setValue("is_show", "1");
        //关联功能
        fieldSet.setValue("function_uuid", funUUID);
        //菜单描述
        fieldSet.setValue("menu_description", menuFse.getString("name"));
        //菜单名称
        fieldSet.setValue("menu_name",  menuFse.getString("name"));
        //排列顺序 方源菜单id
        fieldSet.setValue("sequence", menuFse.getString("id"));
        //图标
        fieldSet.setValue("menu_icon", "form");
        String menuCode;
        //没有就创建菜单目录
        if(fieldSetEntity == null){
            FieldSetEntity menuFieldSet = new FieldSetEntity();
            menuFieldSet.setTableName("product_sys_menus");
            //是否目录 0否、1是
            menuFieldSet.setValue("is_catalog", 1);
            //是否显示 0:不显示、 1:显示
            menuFieldSet.setValue("is_show", "1");
            //关联功能为空
            menuFieldSet.setValue("function_uuid", "");
            //图标
            menuFieldSet.setValue("menu_icon", "clipboard");
            //菜单描述
            menuFieldSet.setValue("menu_description",  menuFse.getString("temp"));
            //菜单名称
            menuFieldSet.setValue("menu_name", menuFse.getString("temp"));
            //排列顺序 方源菜单目录id
            menuFieldSet.setValue("sequence", menuFse.getString("fatherid"));
            menuCode = CodeUtil.getNewCodeByTemp("product_sys_menus", "tricode", "");
            //编码
            menuFieldSet.setValue("tricode", menuCode);
            //父级编码
            menuFieldSet.setValue("tricode_parent", "");
            baseDao.add(menuFieldSet);
        }else {
            menuCode = fieldSetEntity.getString("tricode");
        }
        //生成的菜单编码
        fieldSet.setValue("tricode", CodeUtil.getNewCodeByTemp("product_sys_menus", "tricode", menuCode));
        //父级编码
        fieldSet.setValue("tricode_parent", menuCode);
        baseDao.add(fieldSet);
    }

    /**
     * 迁移业务数据表
     *
     * @param sf28s 库名和表名
     * @param conn  连接
     * @return
     * @throws SQLException
     */
    public void syncTable(String[] sf28s, boolean isNew, String subField, Connection conn) throws SQLException {
        FieldSetEntity Orlfs;
        //表名
        String taName = sf28s[1];
        String masterTableName = "";
        //获取主表的表名
        if (sf28s.length == 3) {
            masterTableName = sf28s[2];
        }
        try {
            Orlfs = BaseDaoServiceImpl.getFieldSet(conn, "fe_base5.SYS_TABLE", "ST03=?", new Object[]{taName});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        Map<String, String> map = null;

        //是否是新表
        if (isNew) {
            //判断是否是已经同步过的表
            FieldSetEntity fieldSetEntity = baseDao.getFieldSetEntityByFilter("product_sys_datamodel_table", " table_name = ? ", new String[]{taName.toLowerCase()}, false);
            if (fieldSetEntity == null) {
                //同步表结构  及字段信息
                map = this.syncTableField(conn, Orlfs, sf28s, subField);
                //刷新table 表
                DataPoolRefreshCache.getInstance().put("product_sys_datamodel_table");
                //刷新field 表
                DataPoolRefreshCache.getInstance().put("product_sys_datamodel_field");
                try {
                    Thread.sleep(7000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                return;
            }
        } else {
            //已有表
            this.syncFunTable(conn, sf28s[0] + '.' + sf28s[1]);
            return;
        }
        //迁移表里面数据
        DataTableEntity dataDt = null;
        try {
            dataDt = BaseDaoServiceImpl.getDataTable(conn, sf28s[0] + "." + sf28s[1], null, new String[]{});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        //查询该表字有没有附件字段  media attachment
        DataTableEntity accessoryData = this.getTableFieldAttachment(Orlfs.getString("st00"));
        Boolean syncAttachments = false;
        if (!BaseUtil.dataTableIsEmpty(accessoryData)) {
            syncAttachments = true;
        }

        //业务表 fe的id  对应UUID
        for (int i = 0; i < dataDt.getRows(); i++) {
            FieldSetEntity dataFs = dataDt.getFieldSetEntity(i);
            FieldSetEntity tableFs = new FieldSetEntity();
            tableFs.setTableName(this.originalTable.getString(taName));
            //key 为本表字段   value 为数据源字段
            for (String key : map.keySet()) {
                //单关联的用户user_id
                if ("USER".equals(fieldTypeJson.getString(key))) {
                    tableFs.setValue(key, userIdJson.getString(dataFs.getString(map.get(key))));
                    //单关联的组织架构uuid
                } else if ("GROUP".equals(fieldTypeJson.getString(key))) {
                    tableFs.setValue(key, groupJson.get(dataFs.getString(map.get(key))));
                    //多选组织架构  转换为用户user_ids
                } else if ("USERSGROUPS".equals(fieldTypeJson.getString(map.get(key)))) {
                    tableFs.setValue(key, this.getUserIds(dataFs.getString(map.get(key))));
                } else {
                    //是否有字段关联主表
                    if (subField != null && subField.equals(map.get(key))) {
                        //表名加下标 唯一
                        tableFs.setValue(key, pxMap.getString(masterTableName + dataFs.getString(map.get(key))));
                    } else {
                        tableFs.setValue(key, dataFs.getString(map.get(key)));
                    }
                }
            }
            //同步附件
            if (syncAttachments) {
                Map<String, List<String>> fileMaps = this.synchronizationAttachments(conn, accessoryData, dataFs, taName);
                if (fileMaps.size() > 0) {
                    for (String fieldName : fileMaps.keySet()) {
                        List<String> value = fileMaps.get(fieldName);
                        tableFs.setValue(fieldName, StringUtils.join(value, ","));
                    }
                }
            }
//            if("app_notice_urge".equals(tableFs.getTableName())){
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
            String uuid = baseDao.add(tableFs);
            //表唯一id  对应uuid
            pxMap.put(taName + dataFs.getString(this.pk), uuid);
        }
        //同步完一张表数据后清空json数据
        fieldTypeJson.clear();
        DataTableEntity subTble = null;
        try {
            //查询是否有子表
            subTble = BaseDaoServiceImpl.getDataTable(conn, "SELECT  a.SF01, a.SF10,b.ST02 ST02,b.ST03 ST03 FROM FE_BASE5.SYS_FIELD a INNER JOIN FE_BASE5.SYS_TABLE b on a.SF00=b.ST00 WHERE a.SF10 LIKE ? ", new String[]{"%" + sf28s[1] + "%"});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < subTble.getRows(); i++) {
            FieldSetEntity sf = subTble.getFieldSetEntity(i);
            String a[] = {sf.getString("st02"), sf.getString("st03"), taName};
            if (isStr(sf.getString("st02") + "\\." + sf.getString("st03"))) {
                isNew = false;
            }
            this.syncTable(a, isNew, sf.getString("sf01").toLowerCase(), conn);
        }
    }

    /**
     * 判断是否是引用数据 是就要转换（如人员id，机构id）
     *
     * @param tableName 表名点.字段名
     * @return
     */
    public void transformReferenceData(Connection conn, String tableName, String fieldName, FieldSetEntity fieldSetEntity) throws SQLException {
        DataTableEntity dataTable;
        try {
            StringBuffer sql = new StringBuffer();
            sql.append(" SELECT * FROM fe_base5.SYS_FACEITEM A FULL JOIN fe_base5.SYS_FACE B ")
                    .append(" ON A.SI01 = B.SF00 LEFT JOIN FE_BASE5.SYS_FACECTRLPROP C ON A.SI00 = C.SP00 ")
                    .append(" WHERE SI04 = ? AND B.SF01 = ( SELECT st00 FROM fe_base5.sys_table WHERE st03 = ?) AND C.SP01 = 'prompt' AND SP02 = '[100001]' ");
            dataTable = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new String[]{fieldName, tableName});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        //是否是关联单个人员控件
        if (BaseUtil.dataTableIsEmpty(dataTable)) {
            try {
                //是否是关联单个单位部门控件
                StringBuffer sql = new StringBuffer();
                sql.append(" SELECT * FROM fe_base5.SYS_FACEITEM A FULL JOIN fe_base5.SYS_FACE B ")
                        .append(" ON A.SI01 = B.SF00 LEFT JOIN FE_BASE5.SYS_FACECTRLPROP C ON A.SI00 = C.SP00 ")
                        .append(" WHERE SI04 = ? AND B.SF01 = ( SELECT st00 FROM fe_base5.sys_table WHERE st03 = ?) AND C.SP01 = 'orgtype' AND SP02 = 'A11' ");

                dataTable = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new String[]{tableName, fieldName});
            } catch (Exception e) {
                DataManipulationUtils.close(null, null, conn);
                throw e;
            }
            if (BaseUtil.dataTableIsEmpty(dataTable)) {
                try {
                    //是否是关联部门岗位人员多选控件
                    StringBuffer sql = new StringBuffer();
                    sql.append(" SELECT * FROM fe_base5.SYS_FACEITEM A FULL JOIN fe_base5.SYS_FACE B ")
                            .append(" ON A.SI01 = B.SF00 LEFT JOIN FE_BASE5.SYS_FACECTRLPROP C ON A.SI00 = C.SP00 ")
                            .append(" WHERE SI04 = ? AND B.SF01 = ( SELECT st00 FROM fe_base5.sys_table WHERE st03 = ?) AND C.SP01 = 'prompt' AND SP02 = '[111110]' ");

                    dataTable = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new String[]{tableName, fieldName});
                } catch (Exception e) {
                    DataManipulationUtils.close(null, null, conn);
                    throw e;
                }
                //如果是多选控件
                if (!BaseUtil.dataTableIsEmpty(dataTable)) {
                    fieldTypeJson.put(fieldName.toLowerCase(), "USERSGROUPS");
                }
            } else {
                fieldTypeJson.put(fieldName.toLowerCase(), "GROUP");
            }
        } else {
            fieldTypeJson.put(fieldName.toLowerCase(), "USER");
            fieldSetEntity.setValue("field_reference", "user_name_by_user_id");
        }
    }

    /**
     * 同步附件
     *
     * @param accessoryData 附件字段data
     * @param tableFs       数据值
     */
    public Map<String, List<String>> synchronizationAttachments(Connection conn, DataTableEntity accessoryData, FieldSetEntity tableFs, String table) {
        Map<String, List<String>> filesMap = Maps.newHashMap();
        for (int i = 0; i < accessoryData.getRows(); i++) {
            //类型
            String type = accessoryData.getString(i, "si02");
            //字段
            String field = accessoryData.getString(i, "si04").toLowerCase();
            //获取附件值
            String attachmentsValue = tableFs.getString(field);
            if (!BaseUtil.strIsNull(attachmentsValue)) {
                List<String> fileUuids = Lists.newArrayList();
                //普通附件
                if ("attachment".equals(type)) {
                    //取出附件表数据
                    fileUuids = this.synchronizeCommonAccessories(conn, field, table, attachmentsValue);
                    //金格附件
                } else if ("media".equals(type)) {
                    //附件值
                    //通过金格标识拼装全路径this.jinGePath
                    String path1 = attachmentsValue.substring(0, 4);
                    String path2 = attachmentsValue.substring(4, 6);
                    String path3 = attachmentsValue.substring(6, 8);
                    String path4 = attachmentsValue.substring(0, 14);
                    StringBuffer fullPath = new StringBuffer();
                    fullPath.append(this.jinGePath).append("\\")
                            .append(path1).append("\\")
                            .append(path2).append("\\")
                            .append(path3).append("\\")
                            .append(path4);
                    Map<String, String> fileTimeName = feDataDSService.getFilesFolder(fullPath.toString());
                    if (fileTimeName == null) {
                        //未找到附件直接跳过
                        continue;
                    }
                    DataTableEntity mediaSortInfo = this.getMediaSortInfo(attachmentsValue);
                    //循环金格控件表数据   与文件数据配置
                    if (!BaseUtil.dataTableIsEmpty(mediaSortInfo)) {
                        fileUuids = Lists.newArrayList();
                        for (int j = 0; j < mediaSortInfo.getRows(); j++) {
                            //最新修改时间
                            String time = mediaSortInfo.getString(j, "wms04");
                            //创建时间
                            String name = mediaSortInfo.getString(j, "wms01");
                            //获取要移动的文件名称
                            String fileName = fileTimeName.get(time);
                            if (BaseUtil.strIsNull(fileName)) {
                                continue;
                            }
                            String filePath = fullPath.toString() + "\\" + fileName;
                            String newPath = this.TSPath + "\\" + name;
                            //复制到临时目录下
                            if (feDataDSService.copyFile(filePath, newPath)) {
                                //通过路径获取File
                                File file = new File(newPath);
                                RequestParameterEntity rpe = new RequestParameterEntity();
                                Map<String, File> fileMap = Maps.newHashMap();
                                //文件名  文件file
                                fileMap.put(name, file);
                                FieldSetEntity fieldSetEntity = new FieldSetEntity();
                                fieldSetEntity.setTableName(tableFs.getTableName());
                                fieldSetEntity.setValue(field, name);
                                rpe.setFiles(fileMap);
                                rpe.setFormData(fieldSetEntity);
                                FieldSetEntity fileFse = fileManagerService.uploadFile(rpe);
                                fileUuids.add(fileFse.getUUID());
                            }
                        }
                    }
                }
                if(fileUuids != null && fileUuids.size() > 0){
                    filesMap.put(field, fileUuids);
                }

            }
        }
        return filesMap;
    }

    /**
     * 同步普通附件方法
     * @param conn 连接
     * @param field 本字段名
     * @param table 本表名
     * @param attachmentsValue 源关联值
     * @return
     */
    public List<String> synchronizeCommonAccessories(Connection conn, String field, String table, String attachmentsValue) {
        //取出附件表数据
        DataTableEntity attachmentsData = this.getOrdinaryAttachments(conn, attachmentsValue);
        if (!BaseUtil.dataTableIsEmpty(attachmentsData)) {
            List<String> fileUuids = Lists.newArrayList();
            for (int j = 0; j < attachmentsData.getRows(); j++) {
                //保存名称
                String sa02 = attachmentsData.getString(j, "sa02");
                //显示名称
                String sa03 = attachmentsData.getString(j, "sa03");
                //保存路径
                String sa04 = attachmentsData.getString(j, "sa04");
                String filePath = sa04 + "\\" + sa02;
                String newPath = this.TSPath + "\\" + sa03;
                //复制到临时目录下
                if (feDataDSService.copyFile(filePath, newPath)) {
                    RequestParameterEntity rpe = new RequestParameterEntity();
                    Map<String, File> fileMap = Maps.newHashMap();
                    //通过路径获取File
                    File file = new File(newPath);
                    //文件名  文件file
                    fileMap.put(sa03, file);
                    FieldSetEntity fieldSetEntity = new FieldSetEntity();
                    fieldSetEntity.setTableName(table);
                    fieldSetEntity.setValue(field, sa03);
                    rpe.setFiles(fileMap);
                    rpe.setFormData(fieldSetEntity);
                    FieldSetEntity fileFse = fileManagerService.uploadFile(rpe);
                    fileUuids.add(fileFse.getUUID());
                }
            }
            return fileUuids;
        } else {
            return null;
        }
    }

    /**
     * 获取普通附件信息
     *
     * @param value 附件标识
     * @return
     */
    public DataTableEntity getOrdinaryAttachments(Connection conn, String value) {
        DataTableEntity dataTableEntity = null;
        StringBuffer sql = new StringBuffer();
        sql.append(" SELECT * FROM FE_BASE5.SYS_ATTACHMENT WHERE SA01 = ? ");
        System.out.println(value);
        dataTableEntity = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{value});
        return dataTableEntity;
    }

    /**
     * 获取金格附件信息
     *
     * @param value 附件标识
     * @return
     */
    public DataTableEntity getMediaSortInfo(String value) {
        DataTableEntity dataTableEntity = null;
        Connection conn = null;
        try {
            conn = feDataDSService.getJDBC();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        StringBuffer sql = new StringBuffer();
        sql.append(" SELECT * FROM FE_APP5.WF_MEDIA_SORT WHERE WMS02 = ? ");
        dataTableEntity = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{value});
        try {
            DataManipulationUtils.close(null, null, conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return dataTableEntity;
    }

    /**
     * 通过表名获取同步的附件字段
     *
     * @param tableName 表名
     * @return
     */
    public DataTableEntity getTableNameAttachment(Connection conn, String tableName) {
        DataTableEntity dataTableEntity = null;
        String[] names = tableName.split("\\.");
        StringBuffer sql = new StringBuffer();
        sql.append(" SELECT A.SI02,A.SI04 FROM fe_base5.SYS_FACEITEM A FULL JOIN fe_base5.SYS_FACE B ")
                .append(" ON A.SI01 = B.SF00 WHERE B.SF01 = ( SELECT st00 FROM fe_base5.sys_table WHERE st03 = ?) ")
                .append("AND (A.SI02 = 'media' OR A.SI02 = 'attachment') GROUP BY A.SI04,A.SI02 ");

        dataTableEntity = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{names[1]});
        return dataTableEntity;
    }

    /**
     * 通过表id获取同步的附件字段
     *
     * @param tableId 表id
     * @return
     */
    public DataTableEntity getTableFieldAttachment(String tableId) {
        DataTableEntity dataTableEntity = null;
        Connection conn = null;
        try {
            conn = feDataDSService.getJDBC();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        StringBuffer sql = new StringBuffer();
        sql.append(" SELECT A.SI02,A.SI04 FROM fe_base5.SYS_FACEITEM A FULL JOIN fe_base5.SYS_FACE B ")
                .append(" ON A.SI01 = B.SF00 WHERE B.SF01 = ? AND (A.SI02 = 'media' OR A.SI02 = 'attachment') GROUP BY A.SI04,A.SI02 ");
        dataTableEntity = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{tableId});
        try {
            DataManipulationUtils.close(null, null, conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return dataTableEntity;
    }

    /**
     * 迁移"product_sys_datamodel_field 和"product_sys_datamodel_table表
     *
     * @throws SQLException
     */
    public Map<String, String> syncTableField(Connection conn, FieldSetEntity Orlfs, String[] tableName, String subField) throws SQLException {
        Map<String, String> map = Maps.newHashMap();
        FieldSetEntity tableFs = new FieldSetEntity();
        tableFs.setTableName("product_sys_datamodel_table");
        String table_name = Orlfs.getString("st03");
        this.originalTable.put(table_name, table_name.toLowerCase());
        tableFs.setValue("table_name", table_name.toLowerCase());
        tableFs.setValue("table_description", Orlfs.getString("st04"));
        tableFs.setValue("table_primary_key", "uuid");
        tableFs.setValue("table_type", "1");
        tableFs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
        tableFs.setValue("created_utc_datetime", new Date());
        tableFs.setValue("sequence", 1);
        baseDao.saveFieldSetEntity(tableFs);
        DataTableEntity Orldt = null;
        try {
            Orldt = BaseDaoServiceImpl.getDataTable(conn, "select a.*,b.DATA_TYPE from SYS_FIELD a LEFT JOIN (select * from all_tab_columns where TABLE_NAME=? and OWNER =?) b on a.SF01=b.COLUMN_NAME where SF00=(select ST00 from SYS_TABLE where ST03=?)", new String[]{tableName[1], tableName[0], tableName[1]});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        DataTableEntity dt = new DataTableEntity();
        String table_uuid = tableFs.getString("uuid");
        boolean is_pk = false;
        for (int i = 0; i < Orldt.getRows(); i++) {
            FieldSetEntity rowFs = Orldt.getFieldSetEntity(i);
            FieldSetEntity fieldFs = new FieldSetEntity();
            fieldFs.setTableName("product_sys_datamodel_field");
            fieldFs.setValue("table_uuid", table_uuid);
            //判断字段是否引用了用户字段  或 单位部门字段
            String sf01 = rowFs.getString("sf01");
            // 判断是否是引用数据 是就要转换（如人员id，机构id）
            transformReferenceData(conn, table_name, sf01, fieldFs);
            map.put(sf01.toLowerCase(), sf01.toLowerCase());
            fieldFs.setValue("field_name", sf01.toLowerCase());
            fieldFs.setValue("field_description", rowFs.getString("sf02"));
            fieldFs.setValue("field_show_name", rowFs.getString("sf02"));
            String type = this.fieldTypeFE(rowFs.getString("sf03"));
            //是否有字段关联主表
            if ("pk".equals(type)) {
                //如果已经有pk
                if(is_pk){
                    type = "string";
                }else {
                    this.pk = sf01.toLowerCase();
                    is_pk = true;
                }
            }
            fieldFs.setValue("field_type", type);
            if ("GUID".equals(rowFs.getString("sf03"))) {
                fieldFs.setValue("is_unique", 1);
            } else {
                fieldFs.setValue("is_unique", 0);
            }
            if ("NATIVE".equals(rowFs.getString("sf03"))) {
                fieldFs.setValue("NATIVE", 1);
            }
            if ("UNITCODE".equals(rowFs.getString("sf03"))) {
                fieldFs.setValue("UNITCODE", 1);
            }
            //如果是关联主表字段 长度改为64
            if (subField != null && subField.equals(sf01.toLowerCase())) {
                fieldFs.setValue("field_type", "string");
                fieldFs.setValue("field_length", 64);
            } else {
                fieldFs.setValue("field_length", rowFs.getString("sf04"));
            }
            fieldFs.setValue("field_unit", rowFs.getString("sf05"));
            fieldFs.setValue("is_required", 0);
            fieldFs.setValue("is_filter", 1);
            if (null != rowFs.getString("sf10") && "".equals(rowFs.getString("sf10"))) {
                fieldFs.setValue("field_type", "parentuuid");
                fieldFs.setValue("field_relation_table", rowFs.getString("sf10").split("\\.")[1]);
            }
            baseDao.saveFieldSetEntity(fieldFs);
            dt.addFieldSetEntity(fieldFs);
        }
        //如果没有自增主键  创建一个
        if (!is_pk) {
            //添加自增主键
            FieldSetEntity fieldFs = new FieldSetEntity();
            fieldFs.setTableName("product_sys_datamodel_field");
            fieldFs.setValue("table_uuid", table_uuid);
            fieldFs.setValue("field_name", tableFs.getString("table_name") + "_id");
            fieldFs.setValue("field_description", "自增主键");
            fieldFs.setValue("field_type", "pk");
            fieldFs.setValue("field_length", 11);
            fieldFs.setValue("is_required", 0);
            fieldFs.setValue("is_unique", 1);
            fieldFs.setValue("is_international", 0);
            fieldFs.setValue("created_by", 1);
            fieldFs.setValue("created_utc_datetime", new Date());
            fieldFs.setValue("field_show_name", "自增主键");
            baseDao.saveFieldSetEntity(fieldFs);
            dt.addFieldSetEntity(fieldFs);
        }
        //添加uuid唯一标识
        FieldSetEntity fieldFs = new FieldSetEntity();
        fieldFs.setTableName("product_sys_datamodel_field");
        fieldFs.setValue("table_uuid", table_uuid);
        fieldFs.setValue("field_name", "uuid");
        fieldFs.setValue("field_description", "唯一标识");
        fieldFs.setValue("field_type", "string");
        fieldFs.setValue("field_length", 80);
        fieldFs.setValue("field_unit", 0);
        fieldFs.setValue("is_required", 0);
        fieldFs.setValue("is_unique", 0);
        fieldFs.setValue("is_international", 0);
        fieldFs.setValue("created_by", 1);
        fieldFs.setValue("created_utc_datetime", new Date());
        fieldFs.setValue("field_show_name", "唯一标识");

        baseDao.saveFieldSetEntity(fieldFs);
        dt.addFieldSetEntity(fieldFs);
        //创建表方法
        StringBuilder createStatement = createTable(createFields(dt), Orlfs.getString("st03"), Orlfs.getString("st04"));
        //创建表方法
        execute(createStatement.toString());
        return map;
    }

    /**
     * //迁移 wf_model流程模块表
     *
     * @param conn
     * @throws SQLException
     */
    public void syncModel(String tricode_funs, Connection conn, String module_uuid, String sf28, String org_level_uuid, int created_by, boolean flag) throws SQLException {
        FieldSetEntity Orlfs = null;
        try {
            //通过
            Orlfs = BaseDaoServiceImpl.getFieldSet(conn, "fe_base5.wf_model", "wm05=(SELECT se16  FROM fe_base5.SYS_EVENT where se01=? and se08 = 1)", new Object[]{tricode_funs
            });
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        if (Orlfs == null) {
            return;
        }
        FieldSetEntity modelFs = new FieldSetEntity();
        //flow流程表
        modelFs.setTableName("product_sys_flow_model");
        //名称
        modelFs.setValue("title", Orlfs.getString("wm01"));
        //描述
        modelFs.setValue("flow_model_describe", Orlfs.getString("wm02"));
        //关联模块表
        modelFs.setValue("module_uuid", module_uuid);
        //流程关联主表名称
        String wm04 = Orlfs.getString("wm04");
        //流程表没有就从功能表里面查询
        if (BaseUtil.strIsNull(wm04) || wm04.indexOf(".") == -1) {
            try {
                //通过
                FieldSetEntity funFse = BaseDaoServiceImpl.getFieldSet(conn, "fe_base5.SYS_FUNCTION", "  SF05 = ? ", new Object[]{tricode_funs});
                wm04 = funFse.getString("sf28");
                if (BaseUtil.strIsNull(wm04) || wm04.indexOf(".") == -1) {
                    return;
                }
            } catch (Exception e) {
                DataManipulationUtils.close(null, null, conn);
                throw e;
            }
            //如果功能表和流程表绑定的数据表不相同  以流程表为主
        } else if (!wm04.equals(sf28)) {
            String[] wm04s = wm04.split("\\.");
            this.syncTable(wm04s, false, null, conn);
        }

        String[] wm04s = wm04.split("\\.");
        String table_name = wm04s[1].toLowerCase();
        //主表表名
        modelFs.setValue("table_uuid", table_name);
        //生成uuid
        String typeCode = UUID.randomUUID().toString();
        modelFs.setValue("type_code", typeCode);

        modelFs.setValue("org_level_uuid", org_level_uuid);
        modelFs.setValue("created_by", created_by);
        modelFs.setValue("created_utc_datetime", new Date());
        String modelUuid = baseDao.add(modelFs);
        //wm05 为流程编码    查询存有编码的mvc页面   改为流程uuid
        String wm05 = Orlfs.getString("wm05");
        FieldSetEntity mvcPageFse = baseDao.getFieldSetEntityByFilter("product_sys_mvc_page", " flow_uuid = ?", new String[]{wm05}, false);
        if (mvcPageFse != null) {
            //mvc页面绑定流程uuid
            mvcPageFse.setValue("flow_uuid", typeCode);
            baseDao.update(mvcPageFse);
        }

        //迁移WF_NODES 流程节点表
        JSONObject nodesUUID = this.syncNodes(tricode_funs, conn, modelUuid);
        //迁移WF_NODES 流程节点表 到"product_sys_flow_processor 处理器迁移
        this.syncProcessor(tricode_funs, conn, modelUuid);
        //迁移WF_LINKS
        this.syncLinks(tricode_funs, conn, modelUuid);
        if(flag) {
            //迁移 WF_TASK
            JSONObject taskIdUUID = this.syncTask(tricode_funs, conn, modelUuid);
            //迁移wf_infor 节点任务处理情况表
            Map<String, String> stateMap = this.syncDetail(tricode_funs, conn, nodesUUID, sf28, modelUuid, taskIdUUID);
            //同步消息
            try {
                this.synchronizingProcessMessages(conn,tricode_funs,stateMap);
            }catch (BaseException e){
                e.printStackTrace();
            }
            //源数据id 与 本数据uuid 关联
            pxMap.clear();
        }
    }

    /**
     * 迁移 flow处理器
     *
     * @throws SQLException
     */
    public void syncProcessor(String tricode_funs, Connection conn, String modelUUID) throws SQLException {
        DataTableEntity OrlDt = null;
        try {
            OrlDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.wf_nodes", " WN01=(select wm00 from fe_base5.wf_model where wm05=(SELECT se16  FROM fe_base5.SYS_EVENT where se01=? and se08 = 1)) and WN04 ='5'", new Object[]{tricode_funs
            });
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity Orlfs = OrlDt.getFieldSetEntity(i);
            FieldSetEntity processorFs = new FieldSetEntity();
            // flow处理器
            processorFs.setTableName("product_sys_flow_processor");
            processorFs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            processorFs.setValue("created_utc_datetime", new Date());
            //标题
            processorFs.setValue("title", Orlfs.getString("wn02"));
            //类型：1-java，2-sql     WN47   1 sql   2 java
            processorFs.setValue("processor_type", Orlfs.getInteger("wn47") == 1 ? 2 : 1);
            //详细内容
            processorFs.setValue("content", Orlfs.getString("wn48"));
            //关联"product_sys_flow_model
            processorFs.setValue("flow_uuid", modelUUID);
            //坐标，节点到上边界的垂直距离
            processorFs.setValue("location_top", Orlfs.getInteger("wn38") + "px");
            //坐标，节点到左边界的垂直距离
            processorFs.setValue("location_left", Orlfs.getInteger("wn37") + "px");
            String uuid = baseDao.add(processorFs);
            //顺序号
            nodesIdUUID.put(Orlfs.getString("wn00"), uuid);
        }
    }

    public JSONObject syncNodes(String tricode_funs, Connection conn, String modelUUID) throws SQLException {
        DataTableEntity OrlDt = null;
        try {
            OrlDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.wf_nodes", " WN01=(select wm00 from fe_base5.wf_model where wm05=(SELECT se16  FROM fe_base5.SYS_EVENT where se01=? and se08 = 1)) and WN04 !='5'", new Object[]{tricode_funs
            });
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        JSONObject map = new JSONObject();
        nodesIdUUID = new JSONObject();

        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity Orlfs = OrlDt.getFieldSetEntity(i);
            FieldSetEntity nodeFs = new FieldSetEntity();


//            WN62 关联表单字段  WN63 1 人员  2岗位
            //flow节点表
            nodeFs.setTableName("product_sys_flow_node");
            //创建人
            nodeFs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            //创建时间
            nodeFs.setValue("created_utc_datetime", new Date());
            //标题
            nodeFs.setValue("title", Orlfs.getString("wn02"));
            //描述
            nodeFs.setValue("flow_node_describe", Orlfs.getString("wn03"));
            //组件类型：1-开始节点，2-处理节点，0-结束节点
            //1开始 99结束; 3普通 4子任务  5处理器 6或处理7与处理8 会签
            String module_type = "2";
            if ("1".equals(Orlfs.getString("wn04"))) {
                module_type = "1";
            } else if ("99".equals(Orlfs.getString("wn04"))) {
                module_type = "0";
            }
            nodeFs.setValue("module_type", module_type);
            //是否多人处理
            String wn26 = Orlfs.getString("wn26");
            nodeFs.setValue("is_multiperson", wn26);
            if ("1".equals(wn26)) {
                //处理类型
                String wn25 = Orlfs.getString("wn25");
                // 类型：0-等待处理，1-竞争处理，2-顺序处理 先A 后b  。。。下一个节点
                //  WN25 0 无  1多人办理等待   2 竞争处理
                if (!BaseUtil.strIsNull(wn25)) {
                    if ("2".equals(wn25)) {
                        nodeFs.setValue("deal_type", 1);
                    } else {
                        nodeFs.setValue("deal_type", 0);
                    }
                }
            } else if ("0".equals(wn26)) {
                nodeFs.setValue("deal_type", 0);
            }

            //默认送直属领导
            nodeFs.setValue("is_default_direct_supervisor", Orlfs.getString("wn34"));
            //是否允许加签
            nodeFs.setValue("is_allow_add", Orlfs.getString("wn15"));
            //是否允许退回
            nodeFs.setValue("is_allow_back", Orlfs.getString("wn13"));

            //wn48 结束节点调用的方法
            String wn48 = Orlfs.getString("wn48");
            if (!BaseUtil.strIsNull(wn48)) {
                //其他消息推送方法，调用java代码   暂存于此
                nodeFs.setValue("msg_push_sp_func", wn48);
            }
            //节点权限关联表单字段同步
            //WN62 关联表单字段
            String wn62 = Orlfs.getString("wn62");
            if (!BaseUtil.strIsNull(wn62)) {
                //WN63 1 人员  2岗位
                String wn63 = Orlfs.getString("wn63");
                if (BaseUtil.strIsNull(wn63)) {
                    if ("1".equals(wn63)) {
                        //人员
                        nodeFs.setValue("default_form_field_user", wn62.toLowerCase());
                    } else {
                        //岗位
                        nodeFs.setValue("default_form_field_post", wn62.toLowerCase());
                    }
                }
            }
            //获取人员岗位单位部门   存入流程节点的人员 岗位 单位部门权限设置
            Map<String, String> map1 = this.syncNodeInstitutions(Orlfs);
            if (map1 != null && map1.size() > 0) {
                String userList = map1.get("userList");
                //人员id
                if (!BaseUtil.strIsNull(userList)) {
                    nodeFs.setValue("default_users", userList);
                }
                String postList = map1.get("postList");
                //岗位uuid
                if (!BaseUtil.strIsNull(postList)) {
                    nodeFs.setValue("default_posts", postList);
                }
                String deptList = map1.get("deptList");
                //单位部门uuid
                if (!BaseUtil.strIsNull(deptList)) {
                    nodeFs.setValue("default_depts", deptList);
                }
            }
            //需要在数据源表里面插入一个部门  所有直接关联单位都改为这个部门
            //坐标，节点到上边界的垂直距离
            nodeFs.setValue("location_top", Orlfs.getInteger("wn38") + "px");
            //坐标，节点到左边界的水平距离
            nodeFs.setValue("location_left", Orlfs.getInteger("wn37") + "px");
            //关联"product_sys_flow_model
            nodeFs.setValue("flow_uuid", modelUUID);
            //关联附件
            nodeFs.setValue("node_attachment_upload", 1);
            //下载附件
            nodeFs.setValue("node_attachment_download", 0);
            //预览附件
            nodeFs.setValue("node_attachment_preview", 1);
            String uuid = baseDao.add(nodeFs);
            //节点唯一号
            map.put(Orlfs.getString("wn53"), uuid);
            //顺序号
            nodesIdUUID.put(Orlfs.getString("wn00"), uuid);
        }
        return map;
    }

    /**
     * 同步节点配置的组织架构
     *
     * @param fieldSetEntity
     */
    public Map<String, String> syncNodeInstitutions(FieldSetEntity fieldSetEntity) {
        String wn00 = fieldSetEntity.getString("wn00");
        DataTableEntity OrlDt = null;
        try {
            Connection conn = feDataDSService.getJDBC();
            OrlDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.WF_ROLES", " WR01 = ? ", new Object[]{wn00});
            DataManipulationUtils.close(null, null, conn);
        } catch (Exception e) {
            e.getStackTrace();
        }
        if (BaseUtil.dataTableIsEmpty(OrlDt)) {
            return null;
        }
        //用户
        List<String> userList = Lists.newArrayList();
        //部门
        List<String> deptList = Lists.newArrayList();
        //岗位
        List<String> postList = Lists.newArrayList();
        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity fse = OrlDt.getFieldSetEntity(i);
            String wr04 = fse.getString("wr04");
            String wr03 = fse.getString("wr03");
            //用户
            if ("X".equals(wr04)) {
                userList.add(wr03);
                //角色 岗位
            } else if ("Y".equals(wr04)) {
                postList.add(wr03);
                //机构
            } else if ("Z".equals(wr04)) {
                deptList.add(wr03);
            }
        }
        Map<String, String> map = Maps.newHashMap();
        //查询人员
        if (userList.size() > 0) {
            DataTableEntity staffData = baseDao.listTable("product_sys_staffs", BaseUtil.buildQuestionMarkFilter("remark", userList.toArray(), true));
            if (!BaseUtil.dataTableIsEmpty(staffData)) {
                userList.clear();
                for (int i = 0; i < staffData.getRows(); i++) {
                    userList.add(staffData.getString(i, "user_id"));
                }
                map.put("userList", StringUtils.join(userList, ","));
            }
        }
        //查询岗位
        if (postList.size() > 0) {
            DataTableEntity postData = baseDao.listTable("product_sys_job_posts", BaseUtil.buildQuestionMarkFilter("sequence", postList.toArray(), true));
            if (!BaseUtil.dataTableIsEmpty(postData)) {
                postList.clear();
                for (int i = 0; i < postData.getRows(); i++) {
                    postList.add(postData.getString(i, "uuid"));
                }
                map.put("postList", StringUtils.join(postList, ","));
            }
        }
        //查询机构(单位部门)
        if (deptList.size() > 0) {
            DataTableEntity orgData = baseDao.listTable("product_sys_org_levels", BaseUtil.buildQuestionMarkFilter("sequence", deptList.toArray(), true));
            if (!BaseUtil.dataTableIsEmpty(orgData)) {
                deptList.clear();
                for (int i = 0; i < orgData.getRows(); i++) {
                    deptList.add(orgData.getString(i, "uuid"));
                }
                map.put("deptList", StringUtils.join(deptList, ","));
            }
        }
        return map;
    }

    /**
     * @param conn
     * @param UUIDMap   流程节点node表fe uuid 对应 产品uuid
     * @param tableName 表名
     * @return
     * @throws SQLException
     */
    public Map<String, String> syncDetail(String tricode_funs, Connection conn, JSONObject UUIDMap, String tableName, String modelUUID, JSONObject taskIdUUID) throws SQLException {
        tableName = tableName.split("\\.")[1];
        OrgIdUUIDmap = Maps.newHashMap();
        DataTableEntity OrlDt = null;

        try {
            StringBuffer sql = new StringBuffer();
            sql.append(" SELECT * FROM fe_base5.wf_infor where WI01 in (SELECT WT00 FROM fe_base5.wf_task where WT13= " +
                    "(SELECT se16 FROM fe_base5.SYS_EVENT WHERE SE08 = 1 AND SE01 = ?))  ORDER BY WI01,WI00 ");
            OrlDt = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new String[]{tricode_funs});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        Map<String, String> stateMap = Maps.newHashMap();
        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity Orlfs = OrlDt.getFieldSetEntity(i);
            FieldSetEntity DetailFs = new FieldSetEntity();
            //flow明细表
            DetailFs.setTableName("product_sys_flow_detail");

            if (null == Orlfs.getString("wi02")) {
                //标题
                DetailFs.setValue("title", "无标题");
            } else {
                DetailFs.setValue("title", Orlfs.getString("wi02"));
            }
            //节点名称
            DetailFs.setValue("node_title", Orlfs.getString("wi04"));
            //预期处理人
            DetailFs.setValue("expect_person", userIdJson.getString(Orlfs.getString("wi05")));
            //接收时间
            Date wi08 = Orlfs.getDate("wi08");
            DetailFs.setValue("accept_time",wi08);
            //创建时间
            DetailFs.setValue("created_utc_datetime", wi08);
            String wi12 = userIdJson.getString(Orlfs.getString("wi12"));
            //实际处理人
            DetailFs.setValue("actual_person", wi12);
            //修改人为实际处理人
            DetailFs.setValue("updated_by", wi12);
            //处理时间
            Date wi11 = Orlfs.getDate("wi11");
            DetailFs.setValue("deal_time",wi11);
            DetailFs.setValue("updated_utc_datetime", wi11);
            //源uuid，关联本表
            FieldSetEntity fieldSetEntity = OrgIdUUIDmap.get(Orlfs.getString("wi14"));
            if(fieldSetEntity != null){
                DetailFs.setValue("source_uuid", fieldSetEntity.getUUID());
            }
            //创建人 上个节点处理人
            DetailFs.setValue("created_by", userIdJson.getString(Orlfs.getString("wi15")));
            //节点标识（0-普通，1-加签，2-退回）
            DetailFs.setValue("node_sign", 0);
            String node_uuid = UUIDMap.getString(Orlfs.getString("wi62"));
            if (BaseUtil.strIsNull(node_uuid)) {
                continue;
            }
            //关联节点表
            DetailFs.setValue("node_uuid", node_uuid);
            //意见
            DetailFs.setValue("opinion", Orlfs.getString("wi20"));
            //预期处理时间（小时）
            DetailFs.setValue("expect_deal_time", Orlfs.getString("wi09"));
            //完成标识（0-未收，1-已收未办，2-已办，3-终止，4-竞争失败）
//            DetailFs.setValue("node_deal_sign", nodeDealType(Orlfs.getString("wi07")));
            //办理状态（0-未收，1-已收未办，2-已办，3-终止，4-竞争失败）
            String nodeState = nodeDealType(Orlfs.getString("wi13"));
            DetailFs.setValue("node_deal_sign", nodeState);
            //关联表
            DetailFs.setValue("table_name", this.originalTable.getString(tableName));
            //关联业务UUID
            DetailFs.setValue("record_uuid", this.pxMap.getString(tableName + Orlfs.getString("wi29")));
            //关联流程表uuid
            DetailFs.setValue("flow_uuid", modelUUID);
            String task_uuid = taskIdUUID.getString(Orlfs.getString("wi01"));
            if (BaseUtil.strIsNull(task_uuid)) {
                continue;
            }
            String attachmentsValue = Orlfs.getString("attachment");
            //如果附件字段有值  同步附件
            if(!BaseUtil.strIsNull(attachmentsValue)){
                List<String> fileUuids = this.synchronizeCommonAccessories(conn, "flow_attachment", DetailFs.getTableName(), attachmentsValue);
                //存入附件uuid
                DetailFs.setValue("flow_attachment", StringUtils.join(fileUuids, ","));
            }
            //关联流程任务表
            DetailFs.setValue("task_uuid", task_uuid);
            baseDao.add(DetailFs);
            String wi00 = Orlfs.getString("wi00");
            OrgIdUUIDmap.put(wi00, DetailFs);
            stateMap.put(wi00, nodeState);
        }
        return stateMap;
    }

    /**
     *     同步流程消息表
     */
    public void synchronizingProcessMessages(Connection conn,String tricode_funs, Map<String, String> stateMap) throws SQLException {
        DataTableEntity OrlDt = null;
        try {
            StringBuffer sql = new StringBuffer();
            sql.append(" SELECT * FROM FE_BASE5.MESSAGEINFOR WHERE ME14 IN ( ")
                    .append("SELECT WI00 FROM fe_base5.wf_infor where WI01 in (SELECT WT00 FROM fe_base5.wf_task where WT13= ")
                    .append("(SELECT se16 FROM fe_base5.SYS_EVENT WHERE SE08 = 1 AND SE01 = ?))) ORDER BY ME14");

            OrlDt = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new String[]{tricode_funs});
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        String id = null;
        String message_uuid = null;
        String state = null;
        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity fs = OrlDt.getFieldSetEntity(i);
            //流程节点id
            String me14 = fs.getString("me14");
            String sendUserId;
            //业务uuid
            FieldSetEntity fieldSet = OrgIdUUIDmap.get(fs.getString("me14"));
            String source_uuid = null;
            if(fieldSet != null){
                source_uuid = fieldSet.getUUID();
            }else {
                continue;
            }
            if(!me14.equals(id)){
                //不一样创建消息主表
                id = me14;
                FieldSetEntity message = new FieldSetEntity();
                //消息主表
                message.setTableName("product_sys_message");
                //消息主题
                message.setValue("title", fs.getString("me01"));
                //消息内容
                message.setValue("content", fs.getString("me02"));
                //是否需要发送邮件
                message.setValue("is_send_mail", 0);
                //消息类型21 流程消息都为任务消息
                message.setValue("message_type", 21);
                //是否需要发送短信 0不发;1为强制;2为被动
                System.out.println(fs.getString("me20"));
                message.setValue("is_send_sms","0".equals(fs.getString("me20")) ? 0:1);
                //发送时间
                String me07 = fs.getString("me07");
                message.setValue("send_time", me07);
                //创建时间
                message.setValue("created_utc_datetime", me07);
                //发送人
                sendUserId = userIdJson.getString(fs.getString("me03"));
                if(BaseUtil.strIsNull(sendUserId)){
                    //流程infor 数据创建人为发送人
                    sendUserId  = fieldSet.getString("created_by");
                }
                message.setValue("send_user_id", sendUserId);
                //创建人及发送人
                message.setValue("created_by", sendUserId);
                //	业务表
                message.setValue("source_table", "product_sys_flow_detail");

                message.setValue("source_uuid",source_uuid);
                //url 业务地址
                //获取当前节点状态
                state = stateMap.get(fs.getString("me14"));
                //办理页面
                if("0".equals(state) || "1".equals(state)){
                    message.setValue("url", "162132180172861usZ0N439?uuid="+source_uuid);
                //查询原文页面
                }else if("2".equals(state)){
                    message.setValue("url", "1621321824686868oKWL726?uuid="+source_uuid);
                }
                message_uuid = baseDao.add(message);
            }

            FieldSetEntity message_user = new FieldSetEntity();
            message_user.setTableName("product_sys_message_user");
            //关联lx_sys_message表UUID
            message_user.setValue("message_uuid", message_uuid);
            //mail_send	是否发送邮件
            message_user.setValue("mail_send", 0);
            // 	是否阅读  节点状态为未读
            //0未读
            if("0".equals(state)){
                message_user.setValue("read_type", 0);
            }else {
                message_user.setValue("read_type", 1);
            }
            //read_time	阅读时间 暂时为空

            //receive_time	接收时间 无字段
            //sms_send	是否发送短信
            message_user.setValue("sms_send", 0);
            //user_id	消息接收人
            String user_id = userIdJson.getString(fs.getString("me05"));
            //找不到发送人就放接收人
            if(BaseUtil.strIsNull(user_id)){
                user_id = userIdJson.getString(fs.getString("me03"));
                if(BaseUtil.strIsNull(user_id)){
                    continue;
                }
            }
            message_user.setValue("user_id",user_id);
            baseDao.add(message_user);
        }
    }


    //迁移WF_LINKS  连线表
    public void syncLinks(String tricode_funs, Connection conn, String modelUUID) throws SQLException {
        DataTableEntity OrlDt = null;
        try {
            StringBuilder sql = new StringBuilder();
            sql.append("select a.WL04 WL04,a.WL05 WL05,a.WL06 WL06,(SELECT WN04 FROM fe_base5.WF_NODES where WN00=a.WL05) source_type,");
            sql.append("(select wa01 from fe_base5.WF_ACTION  where wa00=a.WL03) WL03S,(SELECT WN04 FROM fe_base5.WF_NODES where WN00=(select wa01 from fe_base5.WF_ACTION  where wa00=a.WL03)) ");
            sql.append(" target_type from fe_base5.wf_links a  where WL05 in (select wn00 from fe_base5.wf_nodes where WN01=(select wm00 from fe_base5.wf_model where wm05=(SELECT se16  FROM fe_base5.SYS_EVENT where se01=? and se08 = 1)))");

            OrlDt = BaseDaoServiceImpl.getDataTable(conn, sql.toString(), new Object[]{tricode_funs
            });
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity Orlfs = OrlDt.getFieldSetEntity(i);
            FieldSetEntity linksFs = new FieldSetEntity();
            linksFs.setTableName("product_sys_flow_link");
            linksFs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            linksFs.setValue("created_utc_datetime", new Date());
            //标题
            linksFs.setValue("title", Orlfs.getString("wl04"));
            //连线起始位置uuid"product_sys_flow_node uuid 若为空则跳过
            if(Orlfs.getString("wl03s") == null){
                continue;
            }
            linksFs.setValue("source_uuid", nodesIdUUID.getString(Orlfs.getString("wl03s")));
            //连线起点类型：1-节点，2-处理器
            linksFs.setValue("source_type", "5".equals(Orlfs.getString("target_type")) ? 2 : 1);
            //连线截止位置uuid"product_sys_flow_node uuid
            System.out.println(Orlfs.getString("wl05"));
            System.out.println(nodesIdUUID.getString(Orlfs.getString("wl05")));
            linksFs.setValue("target_uuid", nodesIdUUID.getString(Orlfs.getString("wl05")));
            //连线截止类型：1-节点，2-处理器
            linksFs.setValue("target_type", "5".equals(Orlfs.getString("source_type")) ? 2 : 1);
            //线的判定条件
            linksFs.setValue("judge", Orlfs.getString("wl06"));
            //关联"product_sys_flow_model
            linksFs.setValue("flow_uuid", modelUUID);
            baseDao.add(linksFs);
        }
    }

    /**
     * 通过数据源表序列号   获取当前员工user_id
     */
//    public Integer getUserId(Integer id){
//        FieldSetEntity userFse = baseDao.getFieldSetEntityByFilter("product_sys_staffs", " remark = ? ",new Integer[]{id},false);
//        if(userFse == null){
//            return null;
//        }
//        return userFse.getInteger("user_id");
//    }

    /**
     * 同步task 表
     *
     * @param conn
     * @param modelUUID 流程模块uuid
     * @return
     * @throws SQLException
     */
    public JSONObject syncTask(String tricode_funs, Connection conn, String modelUUID) throws SQLException {
        DataTableEntity OrlDt = null;
        try {
            OrlDt = BaseDaoServiceImpl.getDataTable(conn, "fe_base5.WF_TASK", "WT13=(SELECT se16  FROM fe_base5.SYS_EVENT where se01=? and se08 = 1)", new Object[]{tricode_funs
            });
        } catch (Exception e) {
            DataManipulationUtils.close(null, null, conn);
            throw e;
        }
        JSONObject map = new JSONObject();

        for (int i = 0; i < OrlDt.getRows(); i++) {
            FieldSetEntity Orlfs = OrlDt.getFieldSetEntity(i);
            FieldSetEntity taskFs = new FieldSetEntity();
            taskFs.setTableName("product_sys_flow_task");
            if (null == Orlfs.getString("wt05")) {
                //标题
                taskFs.setValue("title", "无标题");
            } else {
                taskFs.setValue("title", Orlfs.getString("wt05"));
            }
            // 发起人
            //wt07用户id  获取用户id
            String id = userIdJson.getString(Orlfs.getString("wt07"));
            //发送人为空   就跳过
            if (id == null) {
                continue;
            }
            taskFs.setValue("sender", id);
            //发起时间
            taskFs.setValue("send_time", Orlfs.getDate("wt09"));
            //结束时间
            taskFs.setValue("finish_time", Orlfs.getDate("wt10"));
            //关联流程表
            taskFs.setValue("flow_uuid", modelUUID);
            //完成标识（1-在办，2-正常结束，3-终止）
            taskFs.setValue("finish_type", finishType(Orlfs.getString("wt16")));
            //关联表
            String tbName = Orlfs.getString("wt03").split("\\.")[1];

            taskFs.setValue("table_name", this.originalTable.getString(tbName));
            //当前环节节点uuid
            taskFs.setValue("cur_node_uuid", Orlfs.getString("wt00"));
            //关联业务UUID
            String record_uuid = pxMap.getString(tbName + Orlfs.getString("wt04"));
            if (BaseUtil.strIsNull(record_uuid)) {
                continue;
            }
            taskFs.setValue("record_uuid", record_uuid);
            taskFs.setValue("created_by", SpringMVCContextHolder.getCurrentUser().getUser_id());
            taskFs.setValue("created_utc_datetime", new Date());
            String uuid = baseDao.add(taskFs);
            map.put(Orlfs.getString("wt00"), uuid);
        }
        return map;
    }

    /**
     * 创建表语句
     *
     * @param sb
     * @param table_name
     * @param table_description
     * @return
     * @throws BaseException
     */
    private StringBuilder createTable(StringBuilder sb, String table_name, String table_description) throws BaseException {
        StringBuilder createStatement = new StringBuilder();
        createStatement.append(" create table `" + table_name + "` ( ");
        createStatement.append("\n");
        createStatement.append(sb);
        createStatement.append("\n");
        createStatement.append(" ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='" + table_description + "'");
        return createStatement;
    }

    /**
     * 组装字段信息
     *
     * @param dt
     * @throws BaseException
     */
    private StringBuilder createFields(DataTableEntity dt) throws BaseException {
        StringBuilder table = new StringBuilder();
        if (!BaseUtil.dataTableIsEmpty(dt)) {
            for (int i = 0; i < dt.getRows(); i++) {
                FieldSetEntity fse = dt.getFieldSetEntity(i);
                //字段类型
                String field_type = fse.getString(CmnConst.FIELD_TYPE);
                //字段名
                String field_name = fse.getString(CmnConst.FIELD_NAME);
                //字段描述
                String field_description = fse.getString(CmnConst.FIELD_DESCRIPTION);
                //字段长度
                Integer field_length = fse.getInteger(CmnConst.FIELD_LENGTH);
                //小数位数
                Integer field_unit = fse.getInteger(CmnConst.FIELD_UNIT);
                //是否必填
                Boolean is_required = fse.getBoolean(CmnConst.IS_REQUIRED);
                //是否唯一
                Boolean is_unique = fse.getBoolean(CmnConst.IS_UNIQUE);

                //是否为主键
                Boolean is_primary_key = "pk".equals(field_type) ? true : false;
                String field = newField(field_name, field_description, field_type, is_required, field_length, field_unit, is_primary_key, is_unique);
                if (table.length() > 0) {
                    table.append(",\n\t");
                }
                table.append(field);
            }
        }
        return table;
    }

    /**
     * 新字段组装
     *
     * @param field_name        字段名称
     * @param field_description 字段描述
     * @param field_type        字段类型
     * @param is_required       是否必填
     * @param field_length      字段长度
     * @param field_unit        小数长度
     * @param is_primary_key    是否自增主键
     * @param is_unique         是否唯一
     * @return
     */
    private String newField(String field_name, String field_description, String field_type, boolean is_required, Integer field_length, Integer field_unit, boolean is_primary_key, boolean is_unique) {
        StringBuilder sql = new StringBuilder();
        sql.append(" `" + field_name + "` ");
        sql.append(" " + fieldType(field_type));
        sql.append(" (" + field_length);
        if ("decimal".equals(field_type) && field_unit != null && field_unit > 0) {
            sql.append("," + field_unit);
        }
        sql.append(") " + (!is_required && !is_primary_key ? " DEFAULT NULL " : " NOT NULL "));
        if (is_primary_key) {
            sql.append(" AUTO_INCREMENT ");
        }
        sql.append(" COMMENT '" + (field_description == null ? "" : field_description)).append("'");
        if (is_primary_key) {
            sql.append(" ,\t\n PRIMARY KEY (`" + field_name + "`) USING BTREE ");
        } else if (CmnConst.UUID.equals(field_name) || is_unique) {
            sql.append(" ,\t\nUNIQUE KEY `" + field_name + "` (`" + field_name + "`) USING BTREE");
        }
        return sql.toString();
    }

    /**
     * 流程节点类型 1、开始 2、处理节点 0、结束
     *
     * @param field_type
     * @return
     */
    private String nodeType(String field_type) {
        String type = "";
        switch (field_type) {
            case "1":
                type = "1";
                break;
            case "99":
                type = "0";
                break;
            case "5":
                type = "2";
                break;
            case "3":
                type = "3";
            case "4":
                type = "3";
                break;
            case "6":
                type = "3";
                break;
            case "7":
                type = "3";
                break;
            case "8":
                type = "3";
                break;
            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + field_type);
        }
        return type;
    }

    /**
     * 流程完成状态
     *
     * @param field_type
     * @return
     */
    private String finishType(String field_type) {
        String finishType = "";
        switch (field_type) {
            case "0":
                finishType = "1";
                break;
            case "1":
                finishType = "2";
                break;
            case "2":
                finishType = "3";
                break;
            case "3":
                finishType = "3";
                break;

            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + field_type);
        }
        return finishType;
    }

    /**
     * 办理状态
     *
     * @param field_type
     * @return
     */
    private String nodeDealType(String field_type) {
        //源数据        0：已办；1：已收在办；2：未收未办;3 终止;4 冻结
        //本数据 完成标识（0-未收，1-已收未办，2-已办，3-终止，4-竞争失败）
        String finishType = "";
        switch (field_type) {
            case "0":
                finishType = "2";
                break;
            case "1":
                finishType = "1";
                break;
            case "2":
                finishType = "0";
                break;
            case "3":
                finishType = "3";
                break;
            case "4":
                finishType = "3";
                break;
            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + field_type);
        }
        return finishType;
    }

    /**
     * 字段类型对照
     *
     * @param field_type
     * @return
     */
    private String fieldType(String field_type) {
        String mysql_field_type = "";
        switch (field_type) {
            case "string":
                mysql_field_type = "varchar";
                break;
            case "code":
                mysql_field_type = "varchar";
                break;
            case "flowsign":
                mysql_field_type = "int";
                break;
            case "datetime":
                mysql_field_type = "datetime";
                break;
            case "file":
                mysql_field_type = "varchar";
                break;
            case "int":
                mysql_field_type = "int";
                break;
            case "pk":
                mysql_field_type = "bigint";
                break;
            case "parentuuid":
                mysql_field_type = "varchar";
                break;
            case "uuid":
                mysql_field_type = "varchar";
                break;
            case "userid":
                mysql_field_type = "bigint";
                break;
            case "orgUuid":
                mysql_field_type = "varchar";
                break;
            case "number":
                mysql_field_type = "decimal";
                break;
            case "serialNumber":
                mysql_field_type = "varchar";
                break;
            case "email":
                mysql_field_type = "varchar";
                break;
            case "idcard":
                mysql_field_type = "int";
                break;
            case "url":
                mysql_field_type = "varchar";
                break;
            case "mac":
                mysql_field_type = "varchar";
                break;
            case "table_name":
                mysql_field_type = "varchar";
                break;
            case "field_name":
                mysql_field_type = "varchar";
                break;
            case "text":
                mysql_field_type = "text";
                break;
            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + field_type);
        }
        return mysql_field_type;
    }

    /**
     * 字段类型对照
     *
     * @param field_type
     * @return
     */
    private String fieldTypeFE(String field_type) {
        String mysql_field_type = "";
        switch (field_type) {
            //主键不设唯一不舍必填
            case "AUTO":
                mysql_field_type = "pk";
                break;
            case "NUMERIC":
                mysql_field_type = "number";
                break;
            case "DATETIME":
                mysql_field_type = "datetime";
                break;
            case "STRING":
                mysql_field_type = "string";
                break;
            case "NATIVE":
                mysql_field_type = "string";
                break;
            case "CDATETIME":
                mysql_field_type = "string";
                break;
            case "PROMPT":
                mysql_field_type = "string";
                break;
            case "SORT":
                mysql_field_type = "string";
                break;
            case "MEDIA":
                mysql_field_type = "string";
                break;
            case "SPFLAG":
                mysql_field_type = "flowsign";
                break;
            case "IMAGE":
                mysql_field_type = "text";
                break;
            case "TEXT":
                mysql_field_type = "text";
                break;
            case "UNITCODE":
                mysql_field_type = "string";
                break;
            case "FLOWCODE":
                mysql_field_type = "string";
                break;
            case "GUID":
                mysql_field_type = "string";
                break;
            default:
                throw new BaseException(SystemCode.FIELD_TYPE_FIAL.getValue(), SystemCode.FIELD_TYPE_FIAL.getText() + "_" + field_type);
        }
        return mysql_field_type;
    }

    private synchronized void execute(String sql) throws BaseException {
        try {
            Connection connection = ConnectionManager.getInstance().getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.execute();
        } catch (Exception e) {
            SpringMVCContextHolder.getSystemLogger().error(e);
            throw new BaseException(SystemCode.SQL_START_FAILED.getValue(), SystemCode.SQL_START_FAILED.getText() + e.getMessage());
        }
    }
}