package jnpf.base.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import jnpf.base.entity.VisualdevEntity;
import jnpf.base.entity.VisualdevReleaseEntity;
import jnpf.base.mapper.FlowFormDataMapper;
import jnpf.base.mapper.VisualdevMapper;
import jnpf.base.model.PaginationVisualdev;
import jnpf.base.model.dbtable.vo.DbFieldVO;
import jnpf.base.model.form.VisualTableModel;
import jnpf.base.service.*;
import jnpf.base.util.ConcurrencyUtils;
import jnpf.base.util.VisualDevTableCre;
import jnpf.base.util.VisualUtils;
import jnpf.constant.CodeConst;
import jnpf.constant.JnpfConst;
import jnpf.constant.MsgCode;
import jnpf.database.constant.DbAliasConst;
import jnpf.database.model.dbfield.DbFieldModel;
import jnpf.database.model.dbfield.base.DbFieldModelBase;
import jnpf.database.model.dbtable.DbTableFieldModel;
import jnpf.database.model.entity.DbLinkEntity;
import jnpf.database.util.ConnUtil;
import jnpf.database.util.DataSourceUtil;
import jnpf.database.util.DynamicDataSourceUtil;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.TaskEntity;
import jnpf.model.OnlineDevData;
import jnpf.model.visualJson.*;
import jnpf.model.visualJson.analysis.FormAllModel;
import jnpf.model.visualJson.analysis.FormEnum;
import jnpf.model.visualJson.analysis.FormMastTableModel;
import jnpf.model.visualJson.analysis.RecursionForm;
import jnpf.model.visualJson.config.ConfigModel;
import jnpf.permission.service.CodeNumService;
import jnpf.util.*;
import jnpf.util.visiual.JnpfKeyConsts;
import jnpf.workflow.service.TaskApi;
import lombok.Cleanup;
import lombok.SneakyThrows;
import org.apache.commons.collections4.CollectionUtils;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.SqlTable;
import org.mybatis.dynamic.sql.render.RenderingStrategies;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectModel;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.UpdateModel;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

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

/**
 * @author JNPF开发平台组
 * @version V3.1.0
 * @copyright 引迈信息技术有限公司（https://www.jnpfsoft.com）
 * @date 2021/3/16
 */
@Service
public class VisualdevServiceImpl extends SuperServiceImpl<VisualdevMapper, VisualdevEntity> implements VisualdevService {


    @Autowired
    private VisualDevTableCre visualDevTableCreUtil;
    @Autowired
    private ConcurrencyUtils concurrencyUtils;
    @Autowired
    private DbTableService dbTableService;
    @Autowired
    private DbLinkService dblinkService;
    @Autowired
    private DataSourceUtil dataSourceUtil;
    @Autowired
    private FilterService filterService;
    @Autowired
    private VisualdevReleaseService visualdevReleaseService;
    @Autowired
    private CodeNumService codeNumService;
    @Autowired
    private FlowFormDataMapper flowFormDataMapper;
    @Autowired
    private TaskApi taskApi;

    @Override
    public List<VisualdevEntity> getList(PaginationVisualdev paginationVisualdev) {
        // 定义变量判断是否需要使用修改时间倒序
        boolean flag = false;
        QueryWrapper<VisualdevEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(VisualdevEntity::getId, VisualdevEntity::getCategory, VisualdevEntity::getEnCode, VisualdevEntity::getFullName,
                VisualdevEntity::getCreatorTime, VisualdevEntity::getCreatorUserId, VisualdevEntity::getLastModifyTime, VisualdevEntity::getLastModifyUserId,
                VisualdevEntity::getEnabledMark, VisualdevEntity::getSortCode, VisualdevEntity::getState, VisualdevEntity::getType, VisualdevEntity::getEnableFlow,
                VisualdevEntity::getWebType, VisualdevEntity::getVisualTables, VisualdevEntity::getPlatformRelease);

        if (!StringUtil.isEmpty(paginationVisualdev.getKeyword())) {
            flag = true;
            queryWrapper.lambda().and(t -> t.like(VisualdevEntity::getFullName, paginationVisualdev.getKeyword())
                    .or().like(VisualdevEntity::getEnCode, paginationVisualdev.getKeyword()));
        }

        if (ObjectUtil.isNotEmpty(paginationVisualdev.getType())) {
            queryWrapper.lambda().eq(VisualdevEntity::getType, paginationVisualdev.getType());
        }

        if (StringUtil.isNotEmpty(paginationVisualdev.getCategory())) {
            flag = true;
            queryWrapper.lambda().eq(VisualdevEntity::getCategory, paginationVisualdev.getCategory());
        }

        //---功能类型查询
        if (paginationVisualdev.getWebType() != null) {//普通表单
            flag = true;
            //2-表单：改成查询纯表单和列表
            if (Objects.equals(paginationVisualdev.getWebType(), 2)) {
                queryWrapper.lambda().in(VisualdevEntity::getWebType, Arrays.asList(1, 2));
            } else {
                queryWrapper.lambda().eq(VisualdevEntity::getWebType, paginationVisualdev.getWebType());
            }
        }
        if (StringUtil.isNotEmpty(paginationVisualdev.getSystemId())) {//普通表单
            queryWrapper.lambda().eq(VisualdevEntity::getSystemId, paginationVisualdev.getSystemId());
        }

        //状态
        if (StringUtil.isNotEmpty(paginationVisualdev.getIsRelease())) {
            flag = true;
            List<String> releaseList = Arrays.asList(paginationVisualdev.getIsRelease().split(","));
            if (releaseList.size() > 1) {
                List<Integer> jsonToList = JsonUtil.getJsonToList(releaseList, Integer.class);
                queryWrapper.lambda().in(VisualdevEntity::getState, jsonToList);
            } else if (releaseList.size() == 1) {
                queryWrapper.lambda().eq(VisualdevEntity::getState, paginationVisualdev.getIsRelease());
            }

        }

        // 排序
        queryWrapper.lambda().orderByAsc(VisualdevEntity::getSortCode).orderByDesc(VisualdevEntity::getCreatorTime);
        if (flag) {
            queryWrapper.lambda().orderByDesc(VisualdevEntity::getLastModifyTime);
        }
        Page<VisualdevEntity> page = new Page<>(paginationVisualdev.getCurrentPage(), paginationVisualdev.getPageSize());
        IPage<VisualdevEntity> userPage = this.page(page, queryWrapper);
        return paginationVisualdev.setData(userPage.getRecords(), page.getTotal());
    }

    @Override
    public List<VisualdevEntity> getPageList(PaginationVisualdev paginationVisualdev) {
        QueryWrapper<VisualdevReleaseEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(
                VisualdevReleaseEntity::getId,
                VisualdevReleaseEntity::getFullName,
                VisualdevReleaseEntity::getType,
                VisualdevReleaseEntity::getEnableFlow,
                VisualdevReleaseEntity::getEnCode);
        //1-集成助手，查询列表， 2-流程表单查询，纯表单和列表
        if (paginationVisualdev.getWebType() != null) {
            List<Integer> webType = ImmutableList.of(1, 2, 4);
            if (Objects.equals(paginationVisualdev.getWebType(), 1)) {
                webType = ImmutableList.of(2);
            } else if (Objects.equals(paginationVisualdev.getWebType(), 2)) {
                webType = ImmutableList.of(1, 2);
            }
            queryWrapper.lambda().in(VisualdevReleaseEntity::getWebType, webType);
        }
        if (!StringUtil.isEmpty(paginationVisualdev.getKeyword())) {
            queryWrapper.lambda().like(VisualdevReleaseEntity::getFullName, paginationVisualdev.getKeyword());
        }
        if (ObjectUtil.isNotEmpty(paginationVisualdev.getType())) {
            queryWrapper.lambda().eq(VisualdevReleaseEntity::getType, paginationVisualdev.getType());
        }
        if (StringUtil.isNotEmpty(paginationVisualdev.getCategory())) {
            queryWrapper.lambda().eq(VisualdevReleaseEntity::getCategory, paginationVisualdev.getCategory());
        }
        if (StringUtil.isNotEmpty(paginationVisualdev.getSystemId())) {
            queryWrapper.lambda().eq(VisualdevReleaseEntity::getSystemId, paginationVisualdev.getSystemId());
        }
        if (Objects.equals(paginationVisualdev.getEnableFlow(), 1)) {
            queryWrapper.lambda().and(
                    t -> t.isNull(VisualdevReleaseEntity::getEnableFlow).or()
                            .eq(VisualdevReleaseEntity::getEnableFlow, 1)
            );
        }
        // 排序
        queryWrapper.lambda().orderByAsc(VisualdevReleaseEntity::getSortCode).orderByDesc(VisualdevReleaseEntity::getCreatorTime);
        Page<VisualdevReleaseEntity> page = new Page<>(paginationVisualdev.getCurrentPage(), paginationVisualdev.getPageSize());
        IPage<VisualdevReleaseEntity> userPage = visualdevReleaseService.page(page, queryWrapper);
        List<VisualdevEntity> list = JsonUtil.getJsonToList(userPage.getRecords(), VisualdevEntity.class);
        return paginationVisualdev.setData(list, page.getTotal());
    }


    @Override
    public List<VisualdevEntity> getList() {
        QueryWrapper<VisualdevEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().orderByAsc(VisualdevEntity::getSortCode).orderByDesc(VisualdevEntity::getCreatorTime);
        return this.list(queryWrapper);
    }

    @Override
    public VisualdevEntity getInfo(String id) {
        if (StringUtil.isBlank(id)) return null;
        QueryWrapper<VisualdevEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(VisualdevEntity::getId, id);
        return this.getOne(queryWrapper);
    }

    @Override
    public VisualdevEntity getReleaseInfo(String id) {
        VisualdevReleaseEntity visualdevReleaseEntity = visualdevReleaseService.getById(id);
        VisualdevEntity visualdevEntity = null;
        if (visualdevReleaseEntity != null) {
            visualdevEntity = JsonUtil.getJsonToBean(visualdevReleaseEntity, VisualdevEntity.class);
        }
        if (visualdevEntity == null) {
            visualdevEntity = getById(id);
        }
        return visualdevEntity;
    }

    @Override
    public Map<String, String> getTableMap(String formData) {
        Map<String, String> tableMap = new HashMap<>();
        if (StringUtil.isEmpty(formData)) {
            return tableMap;
        }
        FormDataModel formDataModel = JsonUtil.getJsonToBean(formData, FormDataModel.class);
        String fields = formDataModel.getFields();
        List<FieLdsModel> list = JsonUtil.getJsonToList(fields, FieLdsModel.class);
        list.forEach(item -> {
            this.solveTableName(item, tableMap);
        });
        return tableMap;
    }

    private void solveTableName(FieLdsModel item, Map tableMap) {
        ConfigModel config = item.getConfig();
        if (config != null) {
            List<FieLdsModel> children = config.getChildren();
            if ("table".equals(config.getJnpfKey())) {
                if (children != null && children.size() > 0) {
                    FieLdsModel fieLdsModel = children.get(0);
                    String parentVModel = item.getVModel();
                    String relationTable = fieLdsModel.getConfig().getRelationTable();
                    if (StringUtil.isNotBlank(relationTable)) {
                        tableMap.put(parentVModel, relationTable);
                    }
                }
            }
            if (children != null) {
                children.forEach(item2 -> {
                    this.solveTableName(item2, tableMap);
                });
            }
        }
    }

    ;


    @Override
    @SneakyThrows
    public Boolean create(VisualdevEntity entity) {
        if (StringUtil.isEmpty(entity.getId())) {
            entity.setId(RandomUtil.uuId());
        }
        if (OnlineDevData.FORM_TYPE_DEV.equals(entity.getType())) {
            FormDataModel formDataModel = JsonUtil.getJsonToBean(entity.getFormData(), FormDataModel.class);
            if (formDataModel != null) {
                //是否开启安全锁
                int primaryKeyPolicy = formDataModel.getPrimaryKeyPolicy();

                //判断是否要创表
                List<TableModel> tableModels = JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class);
                //有表
                if (tableModels.size() > 0) {
                    Map<String, String> tableMap = this.getTableMap(entity.getFormData());
                    // 保存app,pc过滤配置
                    filterService.saveRuleList(entity.getId(), entity, 1, 1, tableMap);

                    for (TableModel tableModel : tableModels) {
                        Boolean isAutoIncre = this.getPrimaryDbField(entity.getDbLinkId(), tableModel.getTable());
                        // 1:雪花ID 2:自增ID
                        if (primaryKeyPolicy == 1) {
                            if (isAutoIncre != null && isAutoIncre) {
                                throw new WorkFlowException(MsgCode.VS022.get(tableModel.getTable()));
                            }
                        } else if (primaryKeyPolicy == 2) {
                            if (isAutoIncre == null || !isAutoIncre) {
                                throw new WorkFlowException(MsgCode.VS023.get(tableModel.getTable()));
                            }
                        }
                    }

                    try {
                        String tableJsonMap = addDbFileds(entity.getDbLinkId(), tableModels, formDataModel);
                        if (StringUtil.isNotEmpty(tableJsonMap)) {
                            entity.setVisualTables(tableJsonMap);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        if (StringUtil.isEmpty(entity.getEnCode())) {
            setAutoEnCode(entity);
        }
        entity.setEnabledMark(0);
        entity.setState(0);
        entity.setCreatorTime(new Date());
        entity.setCreatorUserId(UserProvider.getLoginUserId());
        entity.setLastModifyTime(null);
        entity.setLastModifyUserId(null);
        this.setIgnoreLogicDelete().removeById(entity.getId());
        boolean result = this.setIgnoreLogicDelete().saveOrUpdate(entity);
        this.clearIgnoreLogicDelete();
        return result;
    }

    /**
     * 数据库表，添加字段
     *
     * @param dbLinkId      数据链接id
     * @param visualTables  表列表
     * @param formDataModel 表单属性
     * @throws Exception
     */
    private String addDbFileds(String dbLinkId, List<TableModel> visualTables, FormDataModel formDataModel) throws Exception {
        if (CollectionUtils.isEmpty(visualTables)) return null;

        List<Map<String, Object>> tableJsonMap = new ArrayList<>();
        Boolean concurrencyLock = formDataModel.getConcurrencyLock();
        Boolean logicalDelete = formDataModel.getLogicalDelete();
        //在各个表创建多租户字段强
        for (TableModel tableModel : visualTables) {
            boolean isMainTable = tableModel.getTypeId().equals("1");
            List<DbFieldModel> dbFieldModelList = dbTableService.getFieldList(dbLinkId, tableModel.getTable());
            List<DbFieldModelBase> fieldList = JsonUtil.getJsonToList(dbFieldModelList, DbFieldModelBase.class);
            List<DbFieldModel> addList = new ArrayList<>();
            DbLinkEntity dbLink = dblinkService.getInfo(dbLinkId);
            String type = dbLink != null ? dbLink.getDbType() : dataSourceUtil.getDbType();
            concurrencyUtils.createTenantId(fieldList, type, addList);
            if (logicalDelete) {
                concurrencyUtils.creDeleteMark(fieldList, type, addList);
            }
            if (isMainTable && concurrencyLock) {
                concurrencyUtils.createVersion(fieldList, type, addList);
            }
            if (isMainTable) {
                //流程字段强制生成
                concurrencyUtils.createFlowEngine(fieldList, type, addList);
                concurrencyUtils.createFlowTaskId(fieldList, type, addList);
                concurrencyUtils.createFlowState(fieldList, type, addList);
            }
            concurrencyUtils.addFileds(tableModel.getTable(), dbLinkId, addList);
            List<DbFieldVO> voList = new ArrayList<>();
            List<DbFieldModelBase> listAll = new ArrayList<>();
            listAll.addAll(fieldList);
            listAll.addAll(addList);
            for (DbFieldModelBase item : listAll) {
                DbFieldVO tableFields = new DbFieldVO();
                tableFields.setField(item.getField());
                tableFields.setFieldName(item.getComment());
                tableFields.setDataType(item.getDataType());
                tableFields.setDataLength(item.getLength());
                tableFields.setPrimaryKey(DbAliasConst.PRIMARY_KEY.getNum(item.getIsPrimaryKey()));
                tableFields.setAllowNull(DbAliasConst.ALLOW_NULL.getNum(item.getNullSign()));
                tableFields.setAutoIncrement(DbAliasConst.AUTO_INCREMENT.getNum(item.getIsAutoIncrement()));
                tableFields.setIdentity(DbAliasConst.AUTO_INCREMENT.getNum(item.getIsAutoIncrement()));
                voList.add(tableFields);
            }
            Map<String, Object> stringObjectMap = JsonUtil.entityToMap(tableModel);
            stringObjectMap.put("fields", voList);
            tableJsonMap.add(stringObjectMap);
        }
        return JsonUtil.getObjectToString(tableJsonMap);
    }

    @Override
    public boolean update(String id, VisualdevEntity entity) throws Exception {
        entity.setId(id);
        entity.setLastModifyUserId(UserProvider.getUser().getUserId());
        entity.setLastModifyTime(DateUtil.getNowDate());
        if (StringUtil.isEmpty(entity.getEnCode())) {
            setAutoEnCode(entity);
        }
        if (OnlineDevData.FORM_TYPE_DEV.equals(entity.getType())) {
            //代码生成修改时就要生成字段
            FormDataModel formDataModel = JsonUtil.getJsonToBean(entity.getFormData(), FormDataModel.class);
            if (formDataModel != null) {
                int primaryKeyPolicy = formDataModel.getPrimaryKeyPolicy();
                //判断是否要创表
                List<TableModel> visualTables = JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class);
                //有表
                if (visualTables.size() > 0) {
                    if (formDataModel != null) {
                        try {
                            //字段强制生成
                            String tableJsonMap = addDbFileds(entity.getDbLinkId(), visualTables, formDataModel);
                            if (StringUtil.isNotEmpty(tableJsonMap)) {
                                entity.setVisualTables(tableJsonMap);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        //判断自增是否匹配
                        concurrencyUtils.checkAutoIncrement(primaryKeyPolicy, entity.getDbLinkId(), visualTables);
                    }
                }
            }
        }
        return this.updateById(entity);
    }

    @Override
    public Boolean getObjByEncode(String encode, Integer type) {
        if (StringUtil.isEmpty(encode)) return false;
        QueryWrapper<VisualdevEntity> visualWrapper = new QueryWrapper<>();
        visualWrapper.lambda().eq(VisualdevEntity::getEnCode, encode).eq(VisualdevEntity::getType, type);

        Integer count = (int) this.count(visualWrapper);
        return count > 0;
    }

    @Override
    public void setAutoEnCode(VisualdevEntity entity) {
        if (Objects.equals(1, entity.getType())) {
            entity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.ZXBD), code -> this.getObjByEncode(code, entity.getType())));
        } else {
            entity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.BDHC), code -> this.getObjByEncode(code, entity.getType())));
        }
    }

    @Override
    public Boolean getCountByName(String name, Integer type, String systemId) {
        QueryWrapper<VisualdevEntity> visualWrapper = new QueryWrapper<>();
        visualWrapper.lambda().eq(VisualdevEntity::getFullName, name).eq(VisualdevEntity::getType, type);
        if (StringUtil.isNotEmpty(systemId)) {
            visualWrapper.lambda().eq(VisualdevEntity::getSystemId, systemId);
        }
        Integer count = (int) this.count(visualWrapper);
        return count > 0;
    }

    @Override
    public void createTable(VisualdevEntity entity) throws Exception {
        FormDataModel formDataModel = JsonUtil.getJsonToBean(entity.getFormData(), FormDataModel.class);
        //是否开启安全锁
        Boolean concurrencyLock = formDataModel.getConcurrencyLock();
        int primaryKeyPolicy = formDataModel.getPrimaryKeyPolicy();
        Boolean logicalDelete = formDataModel.getLogicalDelete();
        String dbLinkId = entity.getDbLinkId();

        Map<String, Object> formMap = JsonUtil.stringToMap(entity.getFormData());
        List<FieLdsModel> list = JsonUtil.getJsonToList(formMap.get("fields"), FieLdsModel.class);
        JSONArray formJsonArray = JsonUtil.getJsonToJsonArray(String.valueOf(formMap.get("fields")));
        List<TableModel> visualTables = JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class);

        List<FormAllModel> formAllModel = new ArrayList<>();
        RecursionForm recursionForm = new RecursionForm();
        recursionForm.setTableModelList(visualTables);
        recursionForm.setList(list);
        FormCloumnUtil.recursionForm(recursionForm, formAllModel);

        String tableName = "mt" + RandomUtil.uuId();
        if (StringUtil.isNotEmpty(formDataModel.getTableName())) {
            tableName = formDataModel.getTableName();
            visualDevTableCreUtil.checkName(tableName, dbLinkId);
        }

        VisualTableModel model = new VisualTableModel(formJsonArray, formAllModel, tableName, dbLinkId, entity.getFullName(), concurrencyLock, primaryKeyPolicy, logicalDelete);
        List<TableModel> tableModelList = visualDevTableCreUtil.tableList(model);
        formMap.put("fields", formJsonArray);
        //更新
        entity.setFormData(JsonUtil.getObjectToString(formMap));
        entity.setVisualTables(JsonUtil.getObjectToString(tableModelList));
    }

    @Override
    public Boolean getPrimaryDbField(String linkId, String table) throws Exception {
        DbTableFieldModel dbTableModel = dbTableService.getDbTableModel(linkId, table);
        List<DbFieldModel> data = dbTableModel.getDbFieldModelList();
        DbFieldModel dbFieldModel = data.stream().filter(DbFieldModel::getIsPrimaryKey).findFirst().orElse(null);
        if (dbFieldModel != null) {
            return dbFieldModel.getIsAutoIncrement() != null && dbFieldModel.getIsAutoIncrement();
        } else {
            return null;
        }
    }

    @Override
    public List<VisualdevEntity> selectorList(String systemId) {
        QueryWrapper<VisualdevEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(
                VisualdevEntity::getId,
                VisualdevEntity::getFullName,
                VisualdevEntity::getWebType,
                VisualdevEntity::getType,
                VisualdevEntity::getSystemId,
                VisualdevEntity::getCategory);
        if (StringUtil.isNotEmpty(systemId)) {
            queryWrapper.lambda().eq(VisualdevEntity::getSystemId, systemId);
        }
        return this.list(queryWrapper);
    }

    @Override
    public List<TableFields> storedFieldList(VisualdevEntity entity) {
        List<TableFields> resultList = new ArrayList<>();
        if (entity != null) {
            // 是否存在关联数据库
            try {
                DbLinkEntity linkEntity = null;
                if (StringUtil.isNotEmpty(entity.getDbLinkId())) {
                    linkEntity = dblinkService.getInfo(entity.getDbLinkId());
                }
                //获取主表
                List<TableModel> listTable = JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class);
                String mainTable = listTable.stream().filter(t -> "1".equals(t.getTypeId())).findFirst().orElse(null).getTable();
                //获取主键
                String pKeyName = VisualUtils.getpKey(linkEntity, mainTable);
                resultList.add(new TableFields(pKeyName, "表单主键"));
                FormDataModel formData = JsonUtil.getJsonToBean(entity.getFormData(), FormDataModel.class);
                List<FieLdsModel> list = JsonUtil.getJsonToList(formData.getFields(), FieLdsModel.class);
                List<FormAllModel> formAllModel = new ArrayList<>();
                RecursionForm recursionForm = new RecursionForm();
                recursionForm.setTableModelList(JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class));
                recursionForm.setList(list);
                FormCloumnUtil.recursionForm(recursionForm, formAllModel);
                List<FormAllModel> mast = formAllModel.stream().filter(t -> FormEnum.mast.getMessage().equals(t.getJnpfKey())).collect(Collectors.toList());
                //列表子表数据
                List<FormAllModel> mastTable = formAllModel.stream().filter(t -> FormEnum.mastTable.getMessage().equals(t.getJnpfKey())).collect(Collectors.toList());
                for (FormAllModel item : mast) {
                    FieLdsModel fieLdsModel = item.getFormColumnModel().getFieLdsModel();
                    addField(fieLdsModel.getVModel(), fieLdsModel, resultList);
                }
                for (FormAllModel item : mastTable) {
                    FormMastTableModel formMastTableModel = item.getFormMastTableModel();
                    FieLdsModel fieLdsModel = formMastTableModel.getMastTable().getFieLdsModel();
                    addField(formMastTableModel.getVModel(), fieLdsModel, resultList);
                }
            } catch (Exception e) {
                log.error(e.getMessage());
            }
        }
        return resultList;
    }

    /**
     * 添加字段（统一过滤条件）
     *
     * @param realVmodel
     * @param fieLdsModel
     * @param resultList
     */
    private static void addField(String realVmodel, FieLdsModel fieLdsModel, List<TableFields> resultList) {
        List<String> list = Arrays.asList(JnpfKeyConsts.COM_INPUT, JnpfKeyConsts.BILLRULE);
        if (StringUtil.isNotEmpty(fieLdsModel.getVModel()) && list.contains(fieLdsModel.getConfig().getJnpfKey())) {
            resultList.add(new TableFields(realVmodel + JnpfConst.FIELD_SUFFIX_JNPFID, fieLdsModel.getConfig().getLabel()));
        }
    }

    @Override
    @Async
    public void initFlowState(VisualdevEntity entity) {
        DbLinkEntity linkEntity = dblinkService.getInfo(entity.getDbLinkId());
        List<TableModel> visualTables = JsonUtil.getJsonToList(entity.getVisualTables(), TableModel.class);
        TableModel mainTable = visualTables.stream().filter(t -> "1".equals(t.getTypeId())).findFirst().orElse(null);
        if (mainTable == null) {
            return;
        }
        SqlTable sqlTable = SqlTable.of(mainTable.getTable());
        String flowTaskIdKey = TableFeildsEnum.FLOWTASKID.getField();
        List<String> flowTaskIdList = new ArrayList<>();
        try {
            DynamicDataSourceUtil.switchToDataSource(linkEntity);
            @Cleanup Connection connection = ConnUtil.getConnOrDefault(linkEntity);
            String databaseProductName = connection.getMetaData().getDatabaseProductName().trim();
            boolean isUpdate = databaseProductName.equalsIgnoreCase("oracle") || databaseProductName.equalsIgnoreCase("DM DBMS");

            flowTaskIdKey = isUpdate ? TableFeildsEnum.FLOWTASKID.getField().toUpperCase() : TableFeildsEnum.FLOWTASKID.getField();
            QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder where = SqlBuilder.select(sqlTable.column(flowTaskIdKey)).from(sqlTable)
                    .where(sqlTable.column(TableFeildsEnum.FLOWSTATE.getField()), SqlBuilder.isNull());
            SelectStatementProvider render = where.build().render(RenderingStrategies.MYBATIS3);
            List<Map<String, Object>> dataList = flowFormDataMapper.selectManyMappedRows(render);
            if (dataList.isEmpty()) {
                return;
            }
            //将state为空的全部修改成0
            String finalFlowTaskIdKey = flowTaskIdKey;
            flowTaskIdList = dataList.stream().map(t -> String.valueOf(t.get(finalFlowTaskIdKey))).collect(Collectors.toList());
            List<List<String>> flowTaskIds = Lists.partition(flowTaskIdList, 1000);
            UpdateDSL<UpdateModel> updateModelUpdateDSL = SqlBuilder.update(sqlTable);
            updateModelUpdateDSL.set(sqlTable.column(TableFeildsEnum.FLOWSTATE.getField())).equalTo(0);
            UpdateDSL<UpdateModel>.UpdateWhereBuilder where1 = updateModelUpdateDSL.where();
            for (List<String> item : flowTaskIds) {
                where1.or(sqlTable.column(flowTaskIdKey), SqlBuilder.isIn(item));
            }
            UpdateStatementProvider updateSP = where1.build().render(RenderingStrategies.MYBATIS3);
            flowFormDataMapper.update(updateSP);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        } finally {
            DynamicDataSourceUtil.clearSwitchDataSource();
        }
        List<TaskEntity> tasks = taskApi.getInfosSubmit(flowTaskIdList.toArray(new String[]{}), TaskEntity::getStatus, TaskEntity::getId);
        try {
            DynamicDataSourceUtil.switchToDataSource(linkEntity);
            //根据不同的流程状态分组修改
            Map<Integer, List<TaskEntity>> collect = tasks.stream().collect(Collectors.groupingBy(TaskEntity::getStatus));
            for (Integer status : collect.keySet()) {
                List<TaskEntity> taskList = collect.get(status);
                if (!taskList.isEmpty()) {
                    List<String> itemFlowTaskIds = taskList.stream().map(TaskEntity::getId).collect(Collectors.toList());
                    if (itemFlowTaskIds.isEmpty()) {
                        continue;
                    }
                    UpdateDSL<UpdateModel> updateDsl = SqlBuilder.update(sqlTable);
                    updateDsl.set(sqlTable.column(TableFeildsEnum.FLOWSTATE.getField())).equalTo(status);
                    UpdateDSL<UpdateModel>.UpdateWhereBuilder where2 = updateDsl.where();
                    List<List<String>> lists = Lists.partition(itemFlowTaskIds, 1000);
                    for (List<String> item : lists) {
                        where2.or(sqlTable.column(flowTaskIdKey), SqlBuilder.isIn(item));
                    }
                    UpdateStatementProvider updateSP1 = where2.build().render(RenderingStrategies.MYBATIS3);
                    flowFormDataMapper.update(updateSP1);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DynamicDataSourceUtil.clearSwitchDataSource();
        }
    }
}