jnpf-java-boot-v6x/jnpf-visualdev/jnpf-visualdev-base/jnpf-visualdev-base-biz/target/classes/jnpf/base/util/VisualDevTableCre.java

package jnpf.base.util;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import jnpf.base.model.dbtable.vo.DbFieldVO;
import jnpf.base.model.form.VisualTableModel;
import jnpf.constant.GenerateConstant;
import jnpf.constant.MsgCode;
import jnpf.database.constant.DbFieldConst;
import jnpf.database.datatype.viewshow.constant.DtViewConst;
import jnpf.database.model.dbfield.DbFieldModel;
import jnpf.database.model.dbtable.DbTableFieldModel;
import jnpf.database.model.entity.DbLinkEntity;
import jnpf.database.source.DbBase;
import jnpf.database.util.DataSourceUtil;
import jnpf.exception.DataException;
import jnpf.exception.WorkFlowException;
import jnpf.model.visualJson.FieLdsModel;
import jnpf.model.visualJson.TableFields;
import jnpf.model.visualJson.TableModel;
import jnpf.model.visualJson.analysis.FormAllModel;
import jnpf.model.visualJson.analysis.FormColumnTableModel;
import jnpf.model.visualJson.analysis.FormEnum;
import jnpf.util.*;
import jnpf.util.visiual.JnpfKeyConsts;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author ：JNPF开发平台组
 * @version: V3.1.0
 * @copyright 引迈信息技术有限公司
 * @date ：2022/3/25 9:30
 */
@Slf4j
@Component
public class VisualDevTableCre {
    @Autowired
    private ServiceBaseUtil serviceUtil;
    @Autowired
    private DataSourceUtil dataSourceUtil;

    /**
     * 表单赋值tableName
     *
     * @param jsonArray
     * @param tableModels
     */
    private void fieldsTableName(JSONArray jsonArray, List<TableModel> tableModels, Map<String, String> tableNameList) {
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = (JSONObject) jsonArray.get(i);
            String jnpfkey = jsonObject.getJSONObject("__config__").getString("jnpfKey");
            List<String> childrenListAll = new ArrayList() {{
                add(FormEnum.card.getMessage());
                add(FormEnum.row.getMessage());
                add(FormEnum.tab.getMessage());
                add(FormEnum.collapse.getMessage());
                add(FormEnum.collapseItem.getMessage());
                add(FormEnum.tabItem.getMessage());
                add(FormEnum.tableGrid.getMessage());
                add(FormEnum.tableGridTr.getMessage());
                add(FormEnum.tableGridTd.getMessage());
                add(FormEnum.STEPS.getMessage());
                add(FormEnum.STEP_ITEM.getMessage());
            }};
            if (childrenListAll.contains(jnpfkey) || StringUtil.isEmpty(jnpfkey)) {
                JSONArray childArray = jsonObject.getJSONObject("__config__").getJSONArray("children");
                this.fieldsTableName(childArray, tableModels, tableNameList);
                jsonObject.getJSONObject("__config__").put("children", childArray);
            } else if (FormEnum.table.getMessage().equals(jnpfkey)) {
                JSONArray childrenList = new JSONArray();
                JSONArray children = jsonObject.getJSONObject("__config__").getJSONArray("children");
                String tableModel = tableNameList.get(jsonObject.getString("__vModel__"));
                for (int k = 0; k < children.size(); k++) {
                    JSONObject childrenObject = (JSONObject) children.get(k);
                    this.fieldsModel(childrenObject, tableModels);
                    if (StringUtil.isEmpty(tableModel)) {
                        tableModel = childrenObject.getJSONObject("__config__").getString("relationTable");
                    }
                    childrenList.add(childrenObject);
                }
                jsonObject.getJSONObject("__config__").put("tableName", tableModel);
                jsonObject.getJSONObject("__config__").put("children", childrenList);
            } else {
                this.fieldsModel(jsonObject, tableModels);
            }
        }
    }

    /**
     * 赋值table
     *
     * @param jsonObject
     * @param tableModels
     */
    private TableModel fieldsModel(JSONObject jsonObject, List<TableModel> tableModels) {
        String vModel = jsonObject.getString("__vModel__");
        String relationField = StringUtil.isNotEmpty(jsonObject.getString("relationField")) ? jsonObject.getString("relationField") : "";
        String jnpfkey = jsonObject.getJSONObject("__config__").getString("jnpfKey");
        TableModel tableName = tableModels.stream().filter(t -> "1".equals(t.getTypeId())).findFirst().orElse(null);
        if (tableName != null) {
            jsonObject.getJSONObject("__config__").put("tableName", tableName.getTable());
        }
        List<TableModel> childTableAll = tableModels.stream().filter(t -> "0".equals(t.getTypeId())).collect(Collectors.toList());
        TableModel childTableaa = childTableAll.stream().filter(t -> t.getFields().stream().filter(k -> k.getField().equals(vModel)).count() > 0).findFirst().orElse(null);
        if (childTableaa != null) {
            jsonObject.getJSONObject("__config__").put("relationTable", childTableaa.getTable());
        }
        if (FormEnum.relationFormAttr.getMessage().equals(jnpfkey) || FormEnum.popupAttr.getMessage().equals(jnpfkey)) {
            if (StringUtil.isNotEmpty(relationField)) {
                Boolean isSubTable = jsonObject.getJSONObject("__config__").getBooleanValue("isSubTable");
                String model = relationField.split("_jnpfTable_")[0];
                jsonObject.put("relationField", model + "_jnpfTable_" + tableName.getTable() + (isSubTable ? "0" : "1"));
            }
        }
        if (JnpfKeyConsts.BILLRULE.equals(jnpfkey)) {
            if (StringUtil.isNotEmpty(relationField)) {
                Boolean isSubTable = jsonObject.getJSONObject("__config__").getBooleanValue("isSubTable");
                String model = relationField.split("_jnpfTable_")[0];
                jsonObject.put("relationField", model + "_jnpfTable_" + tableName.getTable() + (isSubTable ? "0" : "1"));
            }
        }
        return childTableaa;
    }

    /**
     * 验证表名合规性
     *
     * @param tableName
     * @param dbLinkId
     * @return
     * @throws Exception
     */
    public void checkName(String tableName, String dbLinkId) throws Exception {
        if (!RegexUtils.checkName(tableName)) {
            throw new DataException(MsgCode.VS030.get());
        }
        if (tableName.length() > 30) {
            throw new DataException(MsgCode.VS031.get());
        }
        if (serviceUtil.isExistTable(dbLinkId, tableName)) {
            throw new DataException(MsgCode.VS032.get());
        }
        if (GenerateConstant.containKeyword(tableName)) {
            throw new DataException(MsgCode.SYS128.get(tableName));
        }
    }

    /**
     * 创建表
     *
     * @return
     */
    public List<TableModel> tableList(VisualTableModel visualTableModel) throws Exception {
        JSONArray jsonArray = visualTableModel.getJsonArray();
        List<FormAllModel> formAllModel = visualTableModel.getFormAllModel();
        String table = visualTableModel.getTable();
        String linkId = visualTableModel.getLinkId();
        String fullName = visualTableModel.getFullName();
        int primaryKey = visualTableModel.getPrimaryKey();
        List<TableModel> tableModelList = new LinkedList<>();
        Map<String, String> tableNameList = new HashMap<>();
        DbLinkEntity dbLink = serviceUtil.getDbLink(linkId);
        String type = dbLink != null ? dbLink.getDbType() : dataSourceUtil.getDbType();
        boolean isUpperCase = (DbBase.DM.equals(type) || DbBase.ORACLE.equals(type));
        boolean isLowerCase = (DbBase.POSTGRE_SQL.equals(type) || DbBase.KINGBASE_ES.equals(type));
        table = tableName(table, isUpperCase, isLowerCase);

        String relationField = tableName(TableFeildsEnum.FID.getField(), isUpperCase, isLowerCase);
        String tableField = tableName(TableFeildsEnum.FOREIGN.getField(), isUpperCase, isLowerCase);
        List<String> checkNameList = new ArrayList<>();
        checkNameList.add(table);
        try {
            List<DbFieldModel> fieldList = new ArrayList<>();
            Map<String, List<DbFieldModel>> tableListAll = new HashMap<>();
            for (FormAllModel model : formAllModel) {
                if (FormEnum.mast.getMessage().equals(model.getJnpfKey())) {
                    FieLdsModel fieLdsModel = model.getFormColumnModel().getFieLdsModel();
                    this.fieldList(fieLdsModel, table, fieldList);
                } else if (FormEnum.table.getMessage().equals(model.getJnpfKey())) {
                    String tableName = "ct" + RandomUtil.uuId();
                    tableName = tableName(tableName, isUpperCase, isLowerCase);

                    FormColumnTableModel fieLdsModel = model.getChildList();
                    if (StringUtil.isNotEmpty(fieLdsModel.getTableName())) {
                        tableName = fieLdsModel.getTableName();
                        checkName(tableName, linkId);
                        if (checkNameList.contains(tableName)) {
                            throw new DataException(MsgCode.VS032.get());
                        } else {
                            checkNameList.add(tableName);
                        }
                    }
                    List<DbFieldModel> tableList = new ArrayList<>();
                    String tableModel = fieLdsModel.getTableModel();
                    List<FieLdsModel> fieldsList = fieLdsModel.getChildList().stream().map(t -> t.getFieLdsModel()).collect(Collectors.toList());
                    for (FieLdsModel tableFieLdsModel : fieldsList) {
                        this.fieldList(tableFieLdsModel, tableName, tableList);
                    }
                    this.dbTableField(tableList, true, primaryKey, isLowerCase, tableField, relationField);
                    tableNameList.put(tableModel, tableName);
                    tableListAll.put(tableModel, tableList);
                }
            }

            this.dbTableField(fieldList, false, primaryKey, isLowerCase, tableField, relationField);
            fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.TENANTID, isUpperCase, isLowerCase));
            fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.FLOWID, isUpperCase, isLowerCase));
            fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.VERSION, isUpperCase, isLowerCase));
            fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.FLOWTASKID, isUpperCase, isLowerCase));
            fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.FLOWSTATE, isUpperCase, isLowerCase));
            if (visualTableModel.getLogicalDelete()) {//删除标志字段
                fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.DELETEMARK, isUpperCase, isLowerCase));
                fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.DELETETIME, isUpperCase, isLowerCase));
                fieldList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.DELETEUSERID, isUpperCase, isLowerCase));
            }
            List<DbTableFieldModel> dbTableList = new ArrayList<>();
            //创建子表
            for (String key : tableListAll.keySet()) {
                String tableName = tableName(tableNameList.get(key), isUpperCase, isLowerCase);
                List<DbFieldModel> datableList = tableListAll.get(key);
                datableList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.TENANTID, isUpperCase, isLowerCase));
                if (visualTableModel.getLogicalDelete()) {//删除标志字段
                    datableList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.DELETEMARK, isUpperCase, isLowerCase));
                    datableList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.DELETETIME, isUpperCase, isLowerCase));
                    datableList.add(ConcurrencyUtils.getDbFieldModel(TableFeildsEnum.DELETEUSERID, isUpperCase, isLowerCase));
                }
                DbTableFieldModel dbTable = this.dbTable(linkId, tableName, datableList, true, fullName);
                dbTableList.add(dbTable);
                this.tableModel(tableModelList, datableList, tableName, table, true, tableField, relationField);
            }
            this.tableModel(tableModelList, fieldList, table, table, false, tableField, relationField);
            DbTableFieldModel dbTable = this.dbTable(linkId, table, fieldList, false, fullName);
            dbTableList.add(dbTable);
            serviceUtil.createTable(dbTableList);
            this.fieldsTableName(jsonArray, tableModelList, tableNameList);
        } catch (DataException e) {
            e.printStackTrace();
            log.error("表新增错误:{}", e.getMessage());
            throw new DataException(e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            log.error("表新增错误:{}", e.getMessage());
            throw new WorkFlowException(MsgCode.FM013.get(e.getMessage()), e);
        }
        return tableModelList;
    }

    /**
     * 表名
     *
     * @param tableName
     * @param isUpperCase
     * @param isLowerCase
     * @return
     */
    private String tableName(String tableName, boolean isUpperCase, boolean isLowerCase) {
        String resultName = isUpperCase ? tableName.toUpperCase() : isLowerCase ? tableName.toLowerCase() : tableName;
        return resultName;
    }

    /**
     * 获取表单字段
     *
     * @param fieLdsModel
     * @param tableList
     */
    private void fieldList(FieLdsModel fieLdsModel, String table, List<DbFieldModel> tableList) {
        String vmodel = fieLdsModel.getVModel();
        String lable = fieLdsModel.getConfig().getLabel();
        String jnpfkey = fieLdsModel.getConfig().getJnpfKey();
        fieLdsModel.getConfig().setTableName(table);
        if (StringUtil.isNotEmpty(vmodel)) {
            DbFieldModel fieldForm = new DbFieldModel();
            fieldForm.setNullSign(DbFieldConst.NULL);
            fieldForm.setDataType(DtViewConst.VARCHAR);
            fieldForm.setLength("255");
            fieldForm.setIsPrimaryKey(false);
            if (StringUtil.isNotEmpty(fieLdsModel.getVModel())) {
                if (JnpfKeyConsts.getTextField().contains(jnpfkey)) {
                    fieldForm.setDataType(DtViewConst.TEXT);
                }
                List<String> date = new ArrayList() {{
                    add(JnpfKeyConsts.MODIFYTIME);
                    add(JnpfKeyConsts.CREATETIME);
                    add(JnpfKeyConsts.DATE);
                    add(JnpfKeyConsts.DATE_CALCULATE);
                }};
                if (date.contains(jnpfkey)) {
                    fieldForm.setDataType(DtViewConst.DATE_TIME);
                }
                if (JnpfKeyConsts.NUM_INPUT.equals(jnpfkey) || JnpfKeyConsts.CALCULATE.equals(jnpfkey) || JnpfKeyConsts.SLIDER.equals(jnpfkey)) {
                    fieldForm.setDataType(DtViewConst.DECIMAL);
                    String precision = "15";
                    if (fieLdsModel.getPrecision() != null) {
                        precision = String.valueOf(fieLdsModel.getPrecision());
                    }
                    fieldForm.setLength("38," + precision);
                    //mysql 最大长度65，Oracle和postgresql最大长度38，精度0-最大长度内取值，当前系统默认给15最大
                }

                if (JnpfKeyConsts.RATE.equals(jnpfkey)) {
                    fieldForm.setDataType(DtViewConst.DECIMAL);
                    fieldForm.setLength("38,1");
                }

                if (JnpfKeyConsts.LOCATION.equals(jnpfkey)) {
                    fieldForm.setLength("500");
                }
                fieldForm.setField(vmodel);
                fieldForm.setComment(lable);
                tableList.add(fieldForm);
            }
        }
    }

    /**
     * 创建主外键字段
     *
     * @param tableList
     * @param isforeign
     */
    private void dbTableField(List<DbFieldModel> tableList, boolean isforeign, int primaryKey, boolean isPostgreOrKingbase, String tableField, String relationField) {
        //是否自增 true自增
        boolean autoPrimaryKey = primaryKey == 2;
        String dataType = autoPrimaryKey ? isPostgreOrKingbase ? DtViewConst.INT : DtViewConst.BIGINT : DtViewConst.VARCHAR;
        DbFieldModel tableKey = new DbFieldModel();
        tableKey.setNullSign(DbFieldConst.NOT_NULL);
        tableKey.setDataType(dataType);
        tableKey.setLength(TableFeildsEnum.FID.getLength());
        tableKey.setIsPrimaryKey(true);
        tableKey.setField(relationField);
        tableKey.setIsAutoIncrement(autoPrimaryKey);
        tableKey.setComment(TableFeildsEnum.FID.getComment());
        tableList.add(tableKey);
        if (isforeign) {
            DbFieldModel tableForeignKey = new DbFieldModel();
            tableForeignKey.setNullSign(DbFieldConst.NULL);
            tableForeignKey.setDataType(dataType);
            tableForeignKey.setLength(TableFeildsEnum.FOREIGN.getLength());
            tableForeignKey.setIsPrimaryKey(false);
            tableForeignKey.setField(tableField);
            tableForeignKey.setComment(TableFeildsEnum.FOREIGN.getComment());
            tableList.add(tableForeignKey);
        }
    }

    /**
     * 组装字段list
     *
     * @param tableModelList
     * @param dbtable
     * @param table
     * @param mastTable
     * @param isforeign
     */
    private void tableModel(List<TableModel> tableModelList, List<DbFieldModel> dbtable, String table, String mastTable, boolean isforeign, String tableField, String relationField) {
        TableModel tableModel = new TableModel();
        tableModel.setRelationField(isforeign ? relationField : "");
        tableModel.setRelationTable(isforeign ? mastTable : "");
        tableModel.setTable(table);
        tableModel.setComment(isforeign ? "子表" : "主表");
        tableModel.setTableField(isforeign ? tableField : "");
        tableModel.setTypeId(isforeign ? "0" : "1");
        List<DbFieldVO> voList = dbtable.stream().map(DbFieldVO::new).collect(Collectors.toList());
        tableModel.setFields(JsonUtil.getJsonToList(voList, TableFields.class));
        tableModelList.add(tableModel);
    }

    /**
     * 组装创表字段
     *
     * @param linkId
     * @param tableName
     * @param tableFieldList
     * @param isforeign
     * @return
     */
    private DbTableFieldModel dbTable(String linkId, String tableName, List<DbFieldModel> tableFieldList, boolean isforeign, String fullName) {
        DbTableFieldModel dbTable = new DbTableFieldModel();
        dbTable.setDbLinkId(linkId);
        dbTable.setTable(tableName);
        dbTable.setDbFieldModelList(tableFieldList);
        String s = isforeign ? "子表" : "主表";
        if (fullName.contains("&")) {//自动生成表备注的时候带&符号创建不成功问题
            fullName = fullName.replace("&", " ");
        }
        dbTable.setComment(String.format("%s-%s", fullName, s));
        return dbTable;
    }
}