Source/UBCS-WEB/src/components/code-dialog-page/referConfigFormDialog.vue

@@ -1,11 +1,15 @@
<template>
    <!-- 第二层对话框,属性码段，公式编辑框弹窗 -->
    <el-dialog
      :close-on-click-modal="false"
      title="参照配置"
      append-to-body
      :visible.sync="isShowReferConfigForm"
      width="90%"
      id="refer-config-form"
      top="0"
      class= "avue-dialog avue-dialog--top"
      destroy-on-close
      @close="recoveryDataAndForm('initData')"
      style="height: 115vh; margin-top: -14vh; overflow-y: hidden">
        <div style="width: 100%; overflow-y: auto; height: 70vh">
@@ -15,7 +19,7 @@
                        <el-input :disabled="disabled"
                            :size="size"
                            v-model="form.referTypeName"
                            ref="referTypeName" 
                            ref="referTypeName"
                            placeholder="请选择 参照的业务类型"
                            prefix-icon="el-icon-search"
                            readonly="true"
@@ -27,7 +31,7 @@
                        <el-input :disabled="disabled"
                            :size="size"
                            v-model="form.sortField"
                            ref="sortField" 
                            ref="sortField"
                            placeholder="请选择 排序字段"
                            prefix-icon="el-icon-search"
                            readonly="true"
@@ -47,7 +51,7 @@
                                    <el-input :disabled="disabled"
                                        :size="size"
                                        v-model="form.sortField"
                                        ref="sortField" 
                                        ref="sortField"
                                        placeholder="请选择 排序字段"
                                        prefix-icon="el-icon-search"
                                        readonly="true"
@@ -64,7 +68,7 @@
                                class="crud-attr"
                                :option="attrOption"
                                @cell-click="clickAttrEdit"
                                :data="attrData">
                                :data="codeShowFieldConfigVOS">
                                <!-- 表格内操作按钮 -->
                                <template slot="menu" slot-scope="scope">
                                    <el-button type="text"
@@ -90,7 +94,7 @@
                                    </el-button>
                                    <div class="tag-group" style="display: inline">
                                        <el-tag
                                            v-for="item in attrData"
                                            v-for="item in codeShowFieldConfigVOS"
                                            v-show="item.isquery && item.title!=''"
                                            style="margin-left: 3px"
                                            :key="item.title"
@@ -105,12 +109,12 @@
                        </el-row>
                    </el-tab-pane>
                    <el-tab-pane name="second">
                        <span slot="label"><i class="el-icon-search"></i>查询条件添加</span>
                        <span slot="label"><i class="el-icon-search"></i>添加查询条件</span>
                        <avue-crud
                            ref="crudAddCondition"
                            :option="addSearchCondtionOption" 
                            :option="addSearchCondtionOption"
                            @cell-click="clickAddSearchCondtionEdit"
                            :data="addSearchCondtionData">
                            :data="form.codeSrchCondConfigVOS">
                            <!-- 表格内操作按钮 -->
                            <template slot="menu" slot-scope="scope">
                                <el-button type="text"
@@ -141,38 +145,14 @@
            <el-button @click="isShowReferConfigForm = false">取 消</el-button>
        </div>

        <el-dialog title="为【参照的业务类型】选取值"
            append-to-body
            :visible.sync="isShowReferBtmType"
            width="70%"
            destroy-on-close
            @close="clearTableRowSelection('referType')"
            style="height: 110vh; margin-top: -12vh; overflow-y: hidden">
            <avue-crud :option="selectionReferBtmTypeOption"
                :table-loading="selectReferBtmTypeLoading"
                :data="selectReferBtmTypeData"
                :page.sync="selectReferBtmTypePage"
                ref="selectReferBtmTypeCrud"
                class="referBtmType-crud"
                @row-click="referBtmTypeRowClick"
                @search-change="referBtmTypeSearchChange"
                @search-reset="referBtmTypeSearchReset"
                @current-change="referBtmTypeCurrentChange"
                @size-change="referBtmTypeSizeChange">
                <template #radio="{row}">
                    <el-radio v-model="referBtmTypeSelectRow"
                        :label="row.$index">
                        &nbsp;
                    </el-radio>
                </template>
            </avue-crud>
            <div slot="footer" class="dialog-footer">
                <el-button type="primary" @click="selectedReferBtmType">确 定</el-button>
                <el-button @click="isShowReferBtmType = false">取 消</el-button>
            </div>
        </el-dialog>
        <!-- 对话框,为【参照引用的业务类型】选取值对话框 -->
        <refer-btm-type-crud-dialog
            :visible.sync="referBtmDialogParams.selectReferBtmSettingBox"
            :ref="referBtmDialogParams.ref"
            @echoReferBtmType="echoReferBtmType">
        </refer-btm-type-crud-dialog>

        <el-dialog title="为【排序字段】选取值"
        <!-- <el-dialog title="为【排序字段】选取值"
            append-to-body
            :visible.sync="isShowSortField"
            width="70%"
@@ -200,7 +180,14 @@
                <el-button type="primary" @click="selectedSortField">确 定</el-button>
                <el-button @click="isShowSortField = false">取 消</el-button>
            </div>
        </el-dialog>
        </el-dialog> -->

        <refer-select-btm-attr-dialog
            title="为【排序字段】选取值"
            :visible.sync="selectedBtmTypeAttrParams.selectedBtmTypeAttrSettingBox"
            :ref="selectedBtmTypeAttrParams.ref"
            @echoSelectedAttr="echoSelectedAttr">
        </refer-select-btm-attr-dialog>

        <el-dialog title="选择显示字段"
            append-to-body
@@ -247,12 +234,13 @@
    </el-dialog>

</template>
    

<script>
    import func from "@/util/func";
    export default {
        name: "referConfigDialog",
        name: "referConfigFormDialog",
        props: {

        },
        data() {
            let element = '';
@@ -261,6 +249,7 @@
                labelWidth: '150',   // 标题宽度
                isShowReferConfigForm: false,  // 第一层对话框显示隐藏控制
                referTypeIsReadOnly: false,

                // 表单对象
                form: {
                    referTypeName: '', //显示的值
@@ -276,7 +265,12 @@
                    paramForFormKey: '',
                    isMuti: false,
                    mapFields: '',
                     // 查询条件列表
                    isOpenGlobal: true, //是否开启全局
                    codeSrchCondConfigVOS: [],
                    isPersistence: true, // 是否持久化
                    id: '',
                    name: '',
                    // 查询条件列表
                    // limit: '15',
                    // sortField: '',
                    // sortType: 'asc',
@@ -288,7 +282,21 @@
                    // loadType: 'all',
                    // onlyLeaf: false,
                },
                attrData: [],
                // type切换时对form表单属性进行移除
                removeFormAttr: [
                    'limit',
                    'sortField',
                    'sortType',
                    'parentFieldName',
                    'parentUsedField',
                    'parentValue',
                    'loadType',
                    'onlyLeaf',
                    'sortType',
                    'referContent',
                    'displayTable',
                ],
                codeShowFieldConfigVOS: [],
                attrOption: {
                    height:'180',
                    tip: false,
@@ -307,20 +315,20 @@
                    dialogClickModal: false,
                    highlightCurrentRow: true,
                    indexFixed: false,
                    menuFixed: false,  
                    menuFixed: false,
                    column: [
                        {
                            label: "列字段(*)",
                            prop: "field",
                            cell: true,
                            clearable: false,
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "列名(*)",
                            prop: "title",
                            cell: true,
                            clearable: false,
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "字段类型(*)",
                            prop: "fieldTypeText",
@@ -341,7 +349,7 @@
                            }, {
                                value: 'textarea', label: '文本域'
                            }],
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "列表可排序",
                            prop: "sort",
@@ -350,38 +358,38 @@
                            type:"switch",
                            width: '80px',
                            value: true,
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "排序字段",
                            prop: "sortField",
                            prop: "attrSortField",
                            cell: true,
                            clearable: false,
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "字段宽度",
                            prop: "width",
                            cell: true,
                            clearable: false,
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "列固定位置",
                            prop: "fixedText",
                            prop: "fixedPosition",
                            cell: true,
                            type:"select",
                            clearable: false,
                            value: 'noFixed',
                            dicData: [{value: 'noFixed', label: '不固定'}, {value: 'left', label: '左边'}, {value: 'right', label: '右边'}],
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },{
                            label: "js显示代码",
                            prop: "templet",
                            cell: true,
                            clearable: false,
                            blur: (value) => this.updateAttrBlur(value),
                            // blur: (value) => this.updateAttrBlur(value),
                        },
                    ]
                },
                addSearchCondtionData: [],
                // addSearchCondtionData: [],
                addSearchCondtionOption: {
                    height:'150',
                    tip: false,
@@ -411,21 +419,21 @@
                            type: "select",
                            cell: true,
                            clearable: false,
                            dicData: [{
                                value: 'like', label: '包含'
                            }, {
                                value: '=', label: '等于'
                            }, {
                                value: '>', label: '大于'
                            }, {
                                value: '<', label: '小于'
                            }, {
                                value: '!=', label: '不等于'
                            }, {
                                value: '>=', label: '大于等于'
                            }, {
                                value: '<=', label: '小于等于'
                            }]
                            dicData: [
                                {
                                    value: '_like', label: '包含'
                                },{
                                    value: "_notlike", label: "不包含",
                                }, {
                                    value: '_equal', label: '等于'
                                }, {
                                    value: '_notequal', label: '不等于'
                                }, {
                                    value: '_ge', label: '大于'
                                }, {
                                    value: '_le', label: '小于'
                                }
                            ]
                        },{
                            label: "筛选值",
                            prop: "filterValue",
@@ -434,6 +442,7 @@
                        }
                    ]
                },
                // 两个表单的ref
                formRefs: ['form','otherForm'],

                // tabs控制
@@ -441,212 +450,21 @@
                activeName: 'first', //当前活动的tabs


                //为【参照的业务类型】选取值对话框
                selectionReferBtmTypeOption: {
                    border: true,
                    height: '260',
                    tip: false,
                    //searchShow: false,
                    index: true,
                    selection: false,
                    menu: false,
                    addBtn: false,
                    refreshBtn: false,
                    searchShowBtn: false,
                    columnBtn: false,
                    dialogClickModal: false,
                    highlightCurrentRow: true,
                    align: 'center',
                    menuAlign: 'center',
                    column: [{
                        label: '-',
                        prop: 'radio',
                        width: 60,
                        hide: false
                    },{
                        label: '业务类型编号',
                        width: 120,
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'id'
                    },{
                        label: '业务类型名称',
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'name'
                    },{
                        label: '描述',
                        search: false,
                        prop: 'description'
                    }],
                /** 参照引用的业务类型对话框相关参数 */
                referBtmDialogParams: {
                    ref: 'crudReferBtm',
                    selectReferBtmSettingBox: false,
                },
                selectReferBtmTypeLoading: false,
                selectReferBtmTypeData: [],
                selectReferBtmTypePage: {
                    pageSize: 10,
                    currentPage: 1,
                    total: 0
                /** 选择关联的业务类型属性相关的对话框相关参数 */
                selectedBtmTypeAttrParams: {
                    ref: 'selectedBtmTypeAttrCrud',
                    selectedBtmTypeAttrSettingBox: false,
                },
                referBtmTypeQuery: {},
                isShowReferBtmType: false,
                referBtmTypeSelectRowData: '',
                referBtmTypeSelectRow: '',


                // 为【排序字段】选取值对话框
                isShowSortField: false,
                selectionSortFieldOption: {
                    border: true,
                    height: '220px',
                    tip: false,
                    //searchShow: false,
                    index: true,
                    selection: false,
                    addBtn: false,
                    menu: false,
                    refreshBtn: false,
                    searchShowBtn: false,
                    columnBtn: false,
                    dialogClickModal: false,
                    highlightCurrentRow: true,
                    align: 'center',
                    menuAlign: 'center',
                    border: true,
                    column: [{
                        label: '-',
                        prop: 'radio',
                        width: 60,
                        hide: false
                    },{
                        label: '属性英文编号',
                        width: 120,
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'id'
                    },{
                        label: '属性中文名称',
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'name'
                    },{
                        label: '属性长度',
                        search: false,
                        prop: 'attrLength'
                    },{
                        label: '属性类型',
                        search: false,
                        prop: 'attrType'
                    }],
                seletedBtmTypeAttrOptions: {
                    title: '', //对话框显示的标题
                    condition: '',  //当前打开对话框的类型
                    btmTypeId: '', //查询条件，业务类型id
                },
                selectSortFieldLoading: false,
                selectSortFieldData: [],
                selectSortFieldPage: {
                    pageSize: 10,
                    currentPage: 1,
                    total: 0
                },
                sortFieldQuery: {},
                sortFieldSelectRow: '',
                sortFieldSelectRowData: '',


                //选择显示字段
                isShowShowField: false,
                selectionShowFieldOption:  {
                    border: true,
                    height: '220px',
                    tip: false,
                    //searchShow: false,
                    index: true,
                    selection: true,
                    addBtn: false,
                    menu: false,
                    refreshBtn: false,
                    searchShowBtn: false,
                    columnBtn: false,
                    dialogClickModal: false,
                    highlightCurrentRow: true,
                    align: 'center',
                    menuAlign: 'center',
                    border: true,
                    column: [{
                        label: '属性英文编号',
                        width: 120,
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'id'
                    },{
                        label: '属性中文名称',
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'name'
                    },{
                        label: '属性长度',
                        search: false,
                        prop: 'attrLength'
                    },{
                        label: '属性类型',
                        search: false,
                        prop: 'attrType'
                    }],
                },
                showFieldQuery: {},
                selectShowFieldLoading: false,
                selectShowFieldData: [],
                showFieldSelectList: [],

                //添加查询条件
                isShowSearchCondition: false,
                selectionSearchConditionOption: {
                    border: true,
                    height: '220px',
                    tip: false,
                    //searchShow: false,
                    index: true,
                    selection: true,
                    addBtn: false,
                    menu: false,
                    refreshBtn: false,
                    searchShowBtn: false,
                    columnBtn: false,
                    dialogClickModal: false,
                    highlightCurrentRow: true,
                    align: 'center',
                    menuAlign: 'center',
                    border: true,
                    column: [{
                        label: '属性英文编号',
                        width: 120,
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'id'
                    },{
                        label: '属性中文名称',
                        search: true,
                        searchSpan: 8,
                        searchLabelWidth: 100,
                        prop: 'name'
                    },{
                        label: '属性长度',
                        search: false,
                        prop: 'attrLength'
                    },{
                        label: '属性类型',
                        search: false,
                        prop: 'attrType'
                    }],
                },
                selectSearchConditionLoading: false,
                selectSearchConditionData: [],
                searchConditionQuery: {},
                searchConditionSelectList: [],

                //上一次点击的行编辑数据
                preClickAttrRow: '',
@@ -671,13 +489,13 @@
                    emptyBtn: false,
                    labelWidth: '145', //默认标签宽度
                    group: [
                        {   
                        {
                            // 基础表单信息展示区域
                            //display: this.form.type=='default'||this.form.type=='grid',
                            icon: 'el-icon-info',
                            label: '必填的参照配置',
                            collapse: true,
                            labelWidth: '110',
                            labelWidth: '115',
                            prop: 'groupDdefaultOrGrid',
                            column: [
                                {
@@ -769,23 +587,11 @@
                                        trigger: "blur",
                                    }],
                                    change: ({ value, column }) => {
                                        // console.log("start",value);
                                        // 复原表单,因为其他分组中如果存在值，在切换时,会保留输入的字段值所以需要还原
                                        let oldForm = this.form;
                                        this.form = {};  // 表单对象赋空
                                        this.form.referType = oldForm.referType
                                        this.form.textField = oldForm.textField
                                        this.form.valueField = oldForm.valueField
                                        this.form.type = oldForm.type //参照窗口类型
                                        this.form.url =  oldForm.url
                                        this.form.backPath =  oldForm.backPath
                                        this.form.method =  oldForm.method
                                        this.form.height =  oldForm.height
                                        this.form.useFormKey =  oldForm.useFormKey
                                        this.form.paramForFormKey =  oldForm.paramForFormKey
                                        this.form.isMuti =  oldForm.isMuti
                                        this.form.mapFields =  oldForm.mapFields
                                        let addFrom = {};  //根据类型需要添加的不同属性
                                        this.activeName = 'first';
                                        let addFrom = {};
                                        this.activeName = 'first'; // 默认切换至第一个tab
                                        //根据类型对form表单属性进行调整
                                        if(value == 'stand'){
                                            addFrom = {
                                                referContent: '',
@@ -794,7 +600,7 @@
                                            this.isDisabledTabs = false;
                                        } else if(value == 'default' || value == 'grid'){
                                            addFrom = {
                                                limit: '15',
                                                limit: 15,
                                                sortField: '',
                                                sortType: 'asc',
                                            };
@@ -809,72 +615,111 @@
                                                sortField: '',
                                                sortType: 'asc',
                                            };
                                            console.log('tree');
                                            // 不知道为什么type为tree的时候会触发两次change事件
                                            // 导致type切换失败
                                            this.form.type = 'tree';
                                            this.isDisabledTabs = false;
                                        }else {
                                            this.isDisabledTabs = true;
                                            this.activeName = 'second';
                                        }
                                       // 类型切换时，对不需要的属性进行筛除
                                        this.removeFormAttr.forEach(attr=>{
                                            // console.log(attr);
                                            this.$delete(this.form,attr)
                                        })
                                        // 合并两个表单
                                        this.form = Object.assign(addFrom,this.form);
                                        //console.log(this.form);
                                        // console.log("endFilter",this.form.type);
                                        // console.log(this.form);
                                    },
                                },{
                                    label: '是否持久化参照配置',
                                    prop: 'isPersistence',
                                    labelWidth: '142',
                                    tip: 'true:开启持久化，对当前定义的参照配置进行持久化存储，下次可直接选取；false:仅对当前次码段新增生效。',
                                    tipPlacement: 'bottom',
                                    span: 6,
                                    type: 'switch',
                                },{
                                    display: this.form.isPersistence || this.form.isPersistence=='true',
                                    label: '参照配置编号',
                                    prop: 'id',
                                    tip: '设置该参照配置持久化存储时的编号。',
                                    rules: [{
                                        required: true,
                                        message: "(开启持久化时编号)必填项不能为空",
                                        trigger: "blur",
                                    }],
                                    span: 6,
                                },{
                                    display: this.form.isPersistence || this.form.isPersistence=='true',
                                    label: '参照配置名称',
                                    prop: 'name',
                                    tip: '设置该参照配置持久化存储时的名称。',
                                    rules: [{
                                        required: true,
                                        message: "(开启持久化时名称)必填项不能为空",
                                        trigger: "blur",
                                    }],
                                    span: 6,
                                }

                            ]
                        },
                        {   
                            //display: this.form.type=='default'||this.form.type=='grid',
                        {
                            icon: 'el-icon-info',
                            label: '页面参数配置',
                            collapse: false,
                            prop: 'webConfig',
                            column: [{
                                label: '窗口显示的高度',
                                prop: 'height',
                                tip: '默认空着，设置后表示强制显示这样的高度',
                                tipPlacement: 'right',
                                span: 7,
                                rules:[{
                                    validator: validateNumber,
                                    message: "窗口显示的高度必须为数值类型",
                                    trigger: "blur",
                                }]
                            },{
                                label: '过滤(级联)属性',
                                prop: 'useFormKey',
                                tip: '获取表单上的其他属性的属性的值来过滤,或者使用某个属性来级联选择',
                                tipPlacement: 'right',
                                span: 7,
                            },{
                                label: '过滤属性请求参数',
                                prop: 'paramForFormKey',
                                tip: '使用过滤属性时，发送给后台的请求参数',
                                tipPlacement: 'right',
                                span: 7,
                            },{
                                label: '映射其他属性',
                                prop: 'mapFields',
                                tip: '选择数据后，将选择的数据拷贝到表单里的其他属性，书写格式为{当前表单上的属性:选择数据里的属性,XXXXx:yyyy}',
                                tipPlacement: 'right',
                                span: 7,
                            },{
                                label: '是否开启全局',
                                prop: 'isOpenGlobal',
                                tip: '开启全局之后对全部参照配置数据进行查询，默认根据租户进行查询。',
                                tipPlacement: 'right',
                                type: 'switch',
                                span: 7,
                            },{
                                label: '是否多选',
                                type: 'switch',
                                prop: 'isMuti',
                                value: false,
                                span: 7,
                                row: true,
                            }]
                            column: [
                                {
                                    label: '窗口显示的高度',
                                    prop: 'height',
                                    tip: '默认空着，设置后表示强制显示这样的高度',
                                    tipPlacement: 'right',
                                    span: 7,
                                    rules:[{
                                        validator: validateNumber,
                                        message: "窗口显示的高度必须为数值类型",
                                        trigger: "blur",
                                    }]
                                },{
                                    label: '过滤(级联)属性',
                                    prop: 'useFormKey',
                                    tip: '获取表单上的其他属性的属性的值来过滤,或者使用某个属性来级联选择',
                                    tipPlacement: 'right',
                                    span: 7,
                                },{
                                    label: '过滤属性请求参数',
                                    prop: 'paramForFormKey',
                                    tip: '使用过滤属性时，发送给后台的请求参数',
                                    tipPlacement: 'right',
                                    span: 7,
                                },{
                                    label: '映射其他属性',
                                    prop: 'mapFields',
                                    tip: '选择数据后，将选择的数据拷贝到表单里的其他属性，书写格式为{当前表单上的属性:选择数据里的属性,XXXXx:yyyy}',
                                    tipPlacement: 'right',
                                    span: 7,
                                },{
                                    label: '是否开启全局',
                                    prop: 'isOpenGlobal',
                                    tip: '开启全局之后对全部参照配置数据进行查询，默认根据租户进行查询。',
                                    tipPlacement: 'right',
                                    type: 'switch',
                                    span: 7,
                                },{
                                    label: '是否多选',
                                    type: 'switch',
                                    prop: 'isMuti',
                                    value: false,
                                    span: 7,
                                    row: true,
                                }
                            ]
                        },
                        {   
                            //display: this.form.type=='default'||this.form.type=='grid',
                        {
                            icon: 'el-icon-info',
                            label: '后台参数配置',
                            collapse: false,
@@ -883,32 +728,32 @@
                                {
                                label: '自定义的后台路径',
                                prop: 'url',
                                tip: '通常为空;如果是列表，后台必须返回DataGrid，如果是树，后台必须返回List<Tree>',
                                tip: '通常为空;如果是列表，后台必须返回DataGrid，如果是树，后台必须返回List<Theme>',
                                tipPlacement: 'right',
                                span: 7,
                            },{
                                label: '服务的地址',
                                prop: 'backPath',
                                tip: '通常为空，在支持微服务或者分布式部署的时候才配置',
                                tipPlacement: 'right',
                                span: 7,
                            },{
                                label: '请求后台的协议方式',
                                prop: 'method',
                                tip: 'HTTP的协议方式，支持POST,PUT,GET，一般都是GET',
                                tipPlacement: 'right',
                                span: 7,
                                value: 'GET',
                                type: 'select',
                                dicData: [{
                                    label:'GET',value: "GET"
                                },{
                                    label:'PUT',value: "PUT"
                                    label: '服务的地址',
                                    prop: 'backPath',
                                    tip: '通常为空，在支持微服务或者分布式部署的时候才配置',
                                    tipPlacement: 'right',
                                    span: 7,
                                },{
                                    label: '请求后台的协议方式',
                                    prop: 'method',
                                    tip: 'HTTP的协议方式，支持POST,PUT,GET，一般都是GET',
                                    tipPlacement: 'right',
                                    span: 7,
                                    value: 'GET',
                                    type: 'select',
                                    dicData: [{
                                        label:'GET',value: "GET"
                                    },{
                                        label:'PUT',value: "PUT"
                                    },
                                    {
                                        label:'POST',value: "POST"
                                    }],
                                },
                                {
                                    label:'POST',value: "POST"
                                }],
                            },
                            ]
                        },
                    ]
@@ -921,7 +766,7 @@
                    emptyBtn: false,
                    labelWidth: '145', //默认标签宽度
                    group: [
                        {   
                        {
                            display: this.form.type=='default'||this.form.type=='grid',
                            icon: 'el-icon-info',
                            label: this.form.type=='default' ? '默认参照的配置(下方列表)':'列表参照的配置（下方列表)',
@@ -931,21 +776,21 @@
                                {
                                    label: '每页显示条数',
                                    prop: 'limit',
                                    span: 7,
                                    span: 8,
                                    tip: '分页时每页显示的数量，不分页填-1',
                                    //value: 15,
                                    value: 15,
                                    tipPlacement: 'right',
                                },{
                                    label: '排序字段',
                                    prop: 'sortField',
                                    span: 7,
                                    span: 8,
                                    tip: '查询数据时的排序字段',
                                    //clearable: false,
                                    tipPlacement: 'right',
                                },{
                                    label: '排序类型',
                                    prop: 'sortType',
                                    span: 7,
                                    span: 8,
                                    dicData: [{
                                        label: '升序', value: 'asc'
                                    }, {
@@ -958,7 +803,7 @@
                                }
                            ]
                        },
                        {   
                        {
                            display: this.form.type=='stand',
                            icon: 'el-icon-info',
                            label: 'stand(平台配置)参照',
@@ -968,20 +813,20 @@
                                {
                                    label: '参考的UI上下文',
                                    prop: 'referContent',
                                    span: 7,
                                    span: 8,
                                    tip: '只有参照窗口类型是stand时才必须设置,且在stand类型下才能生效',
                                    tipPlacement: 'right',
                                },
                                {
                                    label: '平台的表格编号',
                                    prop: 'displayTable',
                                    span: 7,
                                    span: 8,
                                    tip: '与参照的UI上下文互斥，只有参照窗口类型是stand时才必须设置，且在stand类型下才能生效',
                                    tipPlacement: 'right',
                                },
                            ]
                        },
                        {   
                        {
                            display: this.form.type=='tree',
                            icon: 'el-icon-info',
                            label: '树形参照信息',
@@ -1056,19 +901,15 @@
            },
        },
        mounted() {
            // 麻的这个地方调死我了
            // 事件监听，实现表格行编辑点击表格区域外内容时退出编辑状态
            this.element = document.getElementById('refer-config-form');
            this.element.addEventListener("click", (e) => {
                //<table cellspacing="0" cellpadding="0" border="0" class="el-table__body" style="width: 911px;">
                //console.log(e.target);
                // console.log(this.$refs.crudAttr);
                // console.log(this.$refs.crudAttr.$el.contains(e.target));
                //console.log(!this.$refs.crudAttr.$el.contains(e.target) && this.preClickAttrRow != null);
                if (!this.$refs.crudAttr.$el.contains(e.target) && 
                if (!this.$refs.crudAttr.$el.contains(e.target) &&
                   this.preClickAttrRow != '') {
                   this.preClickAttrRow.$cellEdit = false;
                }
                if (!this.$refs.crudAddCondition.$el.contains(e.target) && 
                if (!this.$refs.crudAddCondition.$el.contains(e.target) &&
                   this.preClickAddSearchConditionRow != '') {
                   this.preClickAddSearchConditionRow.$cellEdit = false;
                }
@@ -1076,58 +917,22 @@
        },
        watch: {
            // 贼坑，切换类型时表格，隐藏再显示就会出现表格错位问题，
            'form.type'(val) {
                //console.log(val);
            'form.type'(value) {
                this.onloadAttrData();
            },
            // 监听父组件传的窗口显示隐藏的值
            isShowReferConfigForm (){
                if(this.isShowReferConfigForm && this.codeShowFieldConfigVOS.length <= 0){
                    this.onloadAttrData();
                }
            }
        },
        methods: {

            // 单击表格实现表格行编辑
            clickAttrEdit(row, column, event){
                if(this.preClickAttrRow && this.preClickAttrRow != row){
                    //console.log(this.attrData[this.preClickAttrRow.$index]);
                    this.attrData[this.preClickAttrRow.$index].$cellEdit = false;
                }
                row.$cellEdit = true;
                this.preClickAttrRow = row;
            },
            // 属性表格行编辑失去焦点时保存方法
            // updateAttrBlur(value){
                //console.log(this.attrData[0]);
                
            // },
            // 单击表格实现表格行编辑
            clickAddSearchCondtionEdit(row, column, event){
                if(this.preClickAddSearchConditionRow && this.preClickAddSearchConditionRow != row){
                    //console.log(this.attrData[this.preClickAttrRow.$index]);
                    this.addSearchCondtionData[this.preClickAddSearchConditionRow.$index].$cellEdit = false;
                }
                row.$cellEdit = true;
                this.preClickAddSearchConditionRow = row;
            },
            //上一个页面已经选中参照应用的业务类型的情况，和上一次已经配置过参照配置的情况下进行页面初始化渲染
            initPageData(val){
                console.log(val);
                if(func.notEmpty(val.referConfig)){
                    this.form = JSON.parse(val.referConfig);
                    //console.log(val);
                    this.referTypeIsReadOnly = true;
                    return;
                }
                if(func.notEmpty(val.referType)){
                    this.form.referTypeName = val.referTypeName;
                    this.form.referType = val.referType;
                    this.referTypeIsReadOnly = true;
                    return;
                }
                //console.log(localStorage.getItem("userId"));
            },
            // 选择完参照配置之后点击保存按钮触发
            async selectedListReferConfig(){
                // 标记所有表单是否通过校验的变量
                let isValid = true;
                
                // 遍历表单数组，依次对每个表单进行校验
                await this.formRefs.forEach(ref => {
                    this.$refs[ref].validate((valid, done, msg) => {
@@ -1138,31 +943,77 @@
                            }
                            isValid = false;
                            //console.log(valid);
                        }                            
                        }
                        done();
                    })
                })
                
                // 如果所有表单都校验通过，执行提交操作
                if (isValid) {
                    // 根据类型对form表单中的参数进行过滤，只保留非空且需要的属性
                    let submitForm = this.filterForm();
                    //console.log(submitForm);
                    // console.log(submitForm);
                    this.$emit('echoReferConfig', submitForm) // 触发update:data将子组件值传递给父组件
                    this.isShowReferConfigForm = false;
                }
            },
            // 单击表格实现表格行编辑
            clickAttrEdit(row, column, event){
                if(this.preClickAttrRow && this.preClickAttrRow != row){
                    //console.log(this.codeShowFieldConfigVOS[this.preClickAttrRow.$index]);
                    this.codeShowFieldConfigVOS[this.preClickAttrRow.$index].$cellEdit = false;
                }
                row.$cellEdit = true;
                this.preClickAttrRow = row;
            },
            // 属性表格行编辑失去焦点时保存方法
            // updateAttrBlur(value){
                //console.log(this.codeShowFieldConfigVOS[0]);

            // },

            // 单击表格实现表格行编辑
            clickAddSearchCondtionEdit(row, column, event){
                if(this.preClickAddSearchConditionRow && this.preClickAddSearchConditionRow != row){
                    //console.log(this.codeShowFieldConfigVOS[this.preClickAttrRow.$index]);
                    this.form.codeSrchCondConfigVOS[this.preClickAddSearchConditionRow.$index].$cellEdit = false;
                }
                row.$cellEdit = true;
                this.preClickAddSearchConditionRow = row;
            },
            //上一个页面已经选中参照应用的业务类型的情况，和上一次已经配置过参照配置的情况下进行页面初始化渲染
            initPageData(val){
                // console.log(val.referConfig);
                if(func.notEmpty(val.referConfig)){
                    this.form = JSON.parse(val.referConfig);
                    this.form.isPersistence = this.form.isPersistence == 'true'||this.form.isPersistence ? true:false;
                    // 参照引用的业务类型不可选
                    // this.referTypeIsReadOnly = true;
                    if((this.form.type == 'default' || this.form.type  == 'grid') && (this.form.codeShowFieldConfigVOS != undefined && this.form.codeShowFieldConfigVOS.length > 0)){
                        this.codeShowFieldConfigVOS = this.form.codeShowFieldConfigVOS;
                    }
                    return;
                }else {
                    this.onloadAttrData()
                }
                if(func.notEmpty(val.referType)){
                    this.form.referTypeName = val.referTypeName;
                    this.form.referType = val.referType;
                    this.referTypeIsReadOnly = true;
                    return;
                }
                //console.log(localStorage.getItem("userId"));
            },
            /** 其实选取属性表格的默认数据不需要加载，
             但是弹窗打开会有表格错行问题所以需要在这调用doLayout方法*/
            onloadAttrData(){
                this.attrData = [
                this.codeShowFieldConfigVOS = [
                    {
                        field: 'id',
                        title: '编号',
                        fieldType: 'text',
                        fieldTypeText: '文本框',
                        sort: true,
                        sortField: 'id',
                        attrSortField: 'id',
                        width: '150',
                        isquery: true,
                        $cellEdit: false
@@ -1172,23 +1023,23 @@
                        fieldType: 'text',
                        fieldTypeText: '文本框',
                        sort: true,
                        sortField: 'name',
                        attrSortField: 'name',
                        width: '180',
                        isquery: true,
                        $cellEdit: false
                    }
                ];
                this.$nextTick(() => {
                    this.$refs.crudAttr.doLayout()
                })
                // this.$nextTick(() => {
                //     this.$refs.crudAttr.doLayout()
                // })
            },
            // 属性选择表格中的移除按钮功能
            removeCurrentRow(row,condition){
                if(condition=='removeAttr'){
                    this.$delete(this.attrData, row.$index);
                    this.$delete(this.codeShowFieldConfigVOS, row.$index);
                    return;
                }
                this.$delete(this.addSearchCondtionData, row.$index);
                this.$delete(this.form.codeSrchCondConfigVOS, row.$index);
            },
            // 该界面的数据进行初始化复原
            recoveryDataAndForm(condition){
@@ -1201,11 +1052,13 @@
                    // this.form.displayTable = '';
                    return;
                }
                Object.assign(this.$data,this.$options.data());    
                Object.assign(this.$data,this.$options.data());
                //this.preClickAttrRow.$cellEdit = false;
                //console.log(this.preClickAttrRow.$cellEdit);
                // 移除绑定在该页面对话框上的全局监听事件
                if(this.element != ''){
                   let te = window.removeEventListener('click', this.element)
                }     
                }
            },
            // 提交表单之前过滤掉空或不需要的表单数据
            filterForm(){
@@ -1223,8 +1076,10 @@
                    'useFormKey',
                    'paramForFormKey',
                    'isMuti',
                    'mapFields', 
                    'searchCondition', 
                    'mapFields',
                    'codeSrchCondConfigVOS',
                    'isOpenGlobal', //是否开启全局
                    'isPersistence',
                ];
                let addArray = [];
                let newForm ={};
@@ -1235,33 +1090,37 @@
                    addArray = ['limit', 'sortField', 'sortType'];
                } else if(oldForm.type == 'tree'){
                    addArray = [
                        "parentFieldName", 
                        "parentFieldName",
                        'parentUsedField',
                        'parentValue', 
                        'parentValue',
                        'loadType',
                        'onlyLeaf',
                        'sortField',
                        'sortType'
                    ];
                }
                // 开启持久化参照配置
                if(oldForm.isPersistence=='true' || oldForm.isPersistence){
                    submittDefaultForm =  submittDefaultForm.concat(['id','name'])
                }
                submittDefaultForm = submittDefaultForm.concat(addArray);
                if(!this.checkArrayIsUndefined(this.addSearchCondtionData)){
                if(!this.checkArrayIsUndefined(this.form.codeSrchCondConfigVOS)){
                    newForm = {
                        searchCondition: this.addSearchCondtionData,
                        codeSrchCondConfigVOS: this.form.codeSrchCondConfigVOS,
                    }
                }
                if((oldForm.type == 'default' || oldForm.type  == 'grid') && (this.attrData.length >= 0 && !this.checkArrayIsUndefined(this.addSearchCondtionData))){
                    newForm = Object.assign(newForm,{attrData:this.attrData});
                if((oldForm.type == 'default' || oldForm.type  == 'grid') && (this.codeShowFieldConfigVOS.length >= 0 && !this.checkArrayIsUndefined(this.codeShowFieldConfigVOS))){
                    newForm = Object.assign(newForm,{codeShowFieldConfigVOS:this.codeShowFieldConfigVOS});
                }
                // 过滤出空值属性和不需要的属性
                submittDefaultForm.forEach(item=>{
                    // console.log(!this.checkStringIsEmpty(oldForm[item]) || !this.checkArrayIsUndefined(oldForm[item]));
                    if((item == 'isMuti' || item == 'onlyLeaf') || (!this.checkStringIsEmpty(oldForm[item]) || !this.checkArrayIsUndefined(oldForm[item]))){
                        //console.log(item,oldForm[item]);
                        newForm = Object.assign(newForm,{[item]:oldForm[item]});  
                        newForm = Object.assign(newForm,{[item]:oldForm[item]});
                    }
                });
                // console.log(newForm);
                //console.log(newForm);
                return newForm;
            },
            /**
@@ -1287,28 +1146,7 @@
            checkArrayIsUndefined(val){
                return typeof val === 'array' && (val.length === 0 ||val === null || typeof val === 'undefined');
            },
            // 打开表格选择框
            openSelectionTable(condition){
                if (condition == 'referType'){
                    this.isShowReferBtmType = true;
                    this.referBtmTypeOnLoad();
                }else if (condition == 'sortField'){
                    this.isShowSortField = true;
                    this.sortFieldOnLoad();
                }else {
                    if(this.form.referType == '' || this.form.referType == null){
                        this.$message.warning("请输入参照的业务类型")
                        return;
                    }
                    if(condition == 'addSearchCondition'){
                        this.isShowSearchCondition = true;
                        this.selectSearchConditionDataOnload();
                    }else {
                        this.isShowShowField = true;
                        this.selectShowFieldDataOnload();
                    }
                }
            },

            // 清空表格选择框
            clearSelectionTable(condition){
                if(condition == 'referType'){
@@ -1318,255 +1156,85 @@
                    this.form.sortField = '';
                }
            },
            // 关闭对话框时对选中内容进行清空，并解绑全局监听事件
            clearTableRowSelection(condition){
            // 打开表格选择框
            openSelectionTable(condition){
                // 打开选择参照引用对话框
                if (condition == 'referType'){
                    this.referBtmDialogParams.selectReferBtmSettingBox = true;
                    // console.log(this.referBtmDialogParams.ref);
                    // 调用子组件刷新表格数据
                    this.$refs[this.referBtmDialogParams.ref].referBtmOnLoad();
                    return;
                }
                // 提示
                if(this.form.referType == '' || this.form.referType == null){
                    this.$message.warning("请输入参照的业务类型")
                    return;
                }
                let params = this.seletedBtmTypeAttrOptions;
                params.btmTypeId = this.form.referType
                // 选择排序字段
                if(condition == 'sortField'){
                    this.sortFieldSelectRow = ''; 
                    this.sortFieldSelectRowData = '';
                }else if(condition == 'referType'){
                    this.referBtmTypeSelectRow='';
                    this.referBtmTypeSelectRowData = '';
                    params.title = '为【排序字段】选取值对话框';
                    params.condition = 'sortField';
                }else if(condition == 'addSearchCondition'){
                    // 选择查询条件
                    params.title = '选择查询条件';
                    params.condition = 'addSearchCondition';
                }else{
                    // 选择属性
                    params.title = '选择显示字段';
                    params.condition = 'selectAttr';
                }
                
                this.$refs[this.selectedBtmTypeAttrParams.ref].selectedBtmTypeAttrOnLoad(params);
                this.selectedBtmTypeAttrParams.selectedBtmTypeAttrSettingBox = true;
            },

            // 为【参照的业务类型】选取值
            referBtmTypeOnLoad(page, params = {}){
                this.selectReferBtmTypeLoading = true;
                // 调用api请求
                const data = {
                    total: 2,
                    data: [{
                        id: 't2',
                        name: 'test2',
                        description: 'test2',
                    }, {
                        id: 't3',
                        name: 'test3',
                        description: 'test3',
                    }]
            /** 为【参照引用的业务类型】选取值之后的内容回显时调用 */
            echoReferBtmType(content){
                // 实现回显
                this.form.referTypeName = content.name || content.id;
                this.form.referType = content.id || '';
            },
            /** 排序字段、显示的属性、查询条件的表格行选择之后回显 */
            echoSelectedAttr(data){
                // console.log(data);
                // 为【排序字段】选取值
                if(data.condition === 'sortField'){
                    this.form.sortField = data.selectedArrary[0].id;
                }else if(data.condition === 'addSearchCondition') {
                    data.selectedArrary.forEach(item => {
                        this.form.codeSrchCondConfigVOS.push(
                            {
                                filterField: item.id,
                                filterType: '_equal',
                                filterTypeText: item.name,
                                filterValue: '',
                                $cellEdit: false
                            }
                        )
                    })
                }else{
                    // 选择显示字段
                    data.selectedArrary.forEach(item => {
                        // console.log(item);
                        this.codeShowFieldConfigVOS.push(
                            {
                                field: item.id,
                                title: item.name,
                                // fieldType: item.attrType,
                                // fieldTypeText: item.attrTypeText,
                                fieldType: 'text',
                                fieldTypeText: '文本框',
                                sort: false,
                                attrSortField: item.id,
                                width: item.attributeLength,
                                isquery: false,
                                $cellEdit: false
                            }
                        )
                    })
                }
                this.selectReferBtmTypeData = data.data;
                this.selectReferBtmTypePage.total = data.total;
                this.selectReferBtmTypeLoading = false;
            },
            referBtmTypeSizeChange(pageSize){
                this.selectReferBtmTypePage.pageSize = pageSize;
            },
            referBtmTypeSearchChange(params, done){
                this.referBtmTypeQuery = params;
                this.selectReferBtmTypePage.currentPage = 1;
                this.referBtmTypeOnLoad(this.page, params);
                done();
            },
            referBtmTypeSearchReset(){
                this.referBtmTypeQuery = {};
                this.referBtmTypeOnLoad(this.selectReferBtmTypePage);
            },
            referBtmTypeRowClick(row){
                this.referBtmTypeSelectRowData = row;
                this.referBtmTypeSelectRow = row.$index
                //console.log( this.referBtmTypeSelectRowData);
            },
            referBtmTypeCurrentChange(currentPage){
                this.selectReferBtmTypePage.currentPage = currentPage;
            },
            selectedReferBtmType(){
                if(!this.referBtmTypeSelectRowData) {
                    this.$message.warning("请选择一条数据");
                    return;
                }
                this.form.referTypeName = this.referBtmTypeSelectRowData.name;
                this.form.referType = this.referBtmTypeSelectRowData.id;
                this.isShowReferBtmType = false;
            },

            // 为【排序字段】选取值
            sortFieldOnLoad(page, params = {}){
                this.selectSortFieldLoading = true;
                // 调用api请求
                const data = {
                    total: 2,
                    data: [{
                        id: 'test',
                        name: '测试',
                        attrLength: 11,
                        attrType: '字符串'
                    }, {
                        id: 'test1',
                        name: '测试1',
                        attrLength: 12,
                        attrType: '数字'
                    }]
                }
                this.selectSortFieldData = data.data;
                this.selectSortFieldPage.total = data.total;
                this.selectSortFieldLoading = false;
            },
            sortFieldSizeChange(pageSize){
                this.selectSortFieldPage.pageSize = pageSize;
            },
            sortFieldSearchChange(params, done){
                this.sortFieldQuery = params;
                this.selectSortFieldPage.currentPage = 1;
                this.sortFieldOnLoad(this.page, params);
                done();
            },
            sortFieldSearchReset(){
                this.sortFieldQuery = {};
                this.sortFieldOnLoad(this.selectSortFieldPage);
            },
            sortFieldRowClick(row){
                this.sortFieldSelectRowData = row;
                this.sortFieldSelectRow = row.$index
                //console.log( this.sortFieldSelectRowData);
            },
            sortFieldCurrentChange(currentPage){
                this.selectReferBtmTypePage.currentPage = currentPage;
            },
            selectedSortField(){
                if(!this.sortFieldSelectRowData) {
                    this.$message.warning("请选择一条数据");
                    return;
                }
                this.form.sortField = this.sortFieldSelectRowData.id;
                this.isShowSortField = false;
            },

            // 选择显示字段
            selectShowFieldDataOnload(params = {}){
                this.selectShowFieldLoading = true;
                // 调用api请求
                const data = {
                    total: 2,
                    data: [{
                        id: 'test',
                        name: '测试',
                        attrLength: 11,
                        attrType: 'text',
                        attrTypeText: '文本框'
                    }, {
                        id: 'test1',
                        name: '测试1',
                        attrLength: 12,
                        attrType: 'number',
                        attrTypeText: '数字'
                    }, {
                        id: 'test2',
                        name: '测试2',
                        attrLength: 13,
                        attrType: 'date',
                        attrTypeText: '日期'
                    }]
                }
                this.selectShowFieldData = data.data;
                this.selectShowFieldLoading = false;
            },
            selectionShowFieldDataChange(list){
                this.showFieldSelectList = list;
                this.$refs.selectShowFieldCrud.setCurrentRow(this.showFieldSelectList[list.length-1]);
            },
            showFieldRowClick(row){
                //this.showFieldSelectList.push(row);
                this.$refs.selectShowFieldCrud.setCurrentRow(row);
                this.$refs.selectShowFieldCrud.toggleRowSelection(row); //选中当前行
            },
            showFieldSearchChange(params, done){
                this.showFieldQuery = params;
                this.selectShowFieldDataOnload(params);
                done();
            },
            showFieldSearchReset(){
                this.showFieldQuery = {};
                this.sortFieldOnLoad();
            },
            selectedShowField(){
                //console.log(this.showFieldSelectList);
                if(this.showFieldSelectList.length <= 0) {
                    this.$message.warning("请至少选择一条数据");
                    return;
                }
                //this.showFieldSelectList;
                this.showFieldSelectList.forEach(item => {
                    this.attrData.push(
                        {
                            field: item.id,
                            title: item.id,
                            fieldType: item.attrType,
                            fieldTypeText: item.attrTypeText,
                            sort: false,
                            sortField: item.id,
                            width: item.attrLength,
                            isquery: false,
                            $cellEdit: false
                        }
                    )
                    
                })
                this.isShowShowField = false;
            },


            // 选择查询条件
            selectSearchConditionDataOnload(params = {}){
                this.selectSearchConditionLoading = true;
                // 调用api请求
                this.selectSearchConditionData = [{
                        id: 'test',
                        name: '测试',
                        attrLength: 11,
                        attrType: '字符串',
                        $cellEdit: false,
                    }, {
                        id: 'test1',
                        name: '测试1',
                        attrLength: 12,
                        attrType: '数字',
                        $cellEdit: false,
                    }, {
                        id: 'test2',
                        name: '测试2',
                        attrLength: 13,
                        attrType: '日期',
                        $cellEdit: false,
                }];
                this.selectSearchConditionLoading = false;
            },
            searchConditionRowClick(row){
                this.$refs.selectSearchConditionCrud.setCurrentRow(row);
                this.$refs.selectSearchConditionCrud.toggleRowSelection(row); //选中当前行
            },
            searchConditionDataChange(list){
                this.searchConditionSelectList = list;
                this.$refs.selectSearchConditionCrud.setCurrentRow(this.searchConditionSelectList[list.length-1]);
            },
            searchConditionSearchChange(params, done){
                this.searchConditionQuery = params;
                this.selectSearchConditionDataOnload(params);
                done();
            },
            searchConditionSearchReset(){
                this.searchConditionQuery = {};
                this.sortFieldOnLoad();
            },
            selectedSearchCondition(){
                console.log(this.searchConditionSelectList);
                if(this.searchConditionSelectList.length <= 0) {
                    this.$message.warning("请至少选择一条数据");
                    return;
                }
                this.searchConditionSelectList.forEach(item => {
                    this.addSearchCondtionData.push(
                        {
                            filterField: item.id,
                            filterType: '=',
                            filterValue: '',
                            $cellEdit: false
                        }
                    )
                    
                })
                this.isShowSearchCondition = false;
            },

        }
@@ -1590,5 +1258,5 @@
        -webkit-transition:opacity .0s !important;
        transition:opacity .0s !important;
    }
    
</style>

</style>