admin_manage.git

parent: 6cffbe37 | 补丁 | 提交 | ignore whitespace

longyvfengyun

2022-02-23 895c518d885b0ec768849fd522c6ade4bff87d2c

新增校验规则

1个文件已添加

4个文件已修改

	src/assets/js/const/const_rules.js	12 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/components/battGroupMager/AddBattGroup.vue	214 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/components/battGroupMager/EditBattGroup.vue	185 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/pages/dataMager/dialog/AddPowerMager.vue	78 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史
	src/pages/dataMager/dialog/EditPowerMager.vue	78 ●●●●● 补丁 \| 查看 \| 原始文档 \| blame \| 历史

 src/assets/js/const/const_rules.js

New file
@@ -0,0 +1,12 @@
export default {
  isValidIp: {
    pattern: /(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)/,
    regVal: false,
    msg: "IP地址格式不正确",
  },
  noSpecialChar: {
    pattern: /^[^`~!@$%&*?<>/\\|=+^{}\[\]\'\"【】‘’￥——、，。；：？《》！]*$/i,
    regVal: false,
    msg: "存在特殊字符"
  }
}

 src/components/battGroupMager/AddBattGroup.vue

@@ -302,7 +302,7 @@
    LinkagePlus, regEquipType,
    testVal
} from '../../assets/js/tools'

import const_rules from "@/assets/js/const/const_rules";
    import {
        const_province_city_county,
        const_battGroup,
@@ -330,6 +330,7 @@
        },
        data() {
            let rules = const_battGroup.rules;
            let constRules = const_rules;
            let devTypes = const_devType.batt;
            let batteryTypes = const_battery_type.types;
            return {
@@ -399,32 +400,68 @@
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName2: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName5: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName3: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    StationName4: [{
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName4: [
                      {
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    FBSDeviceName: [{
                      },
                      {
                        validator(rule, value, callback) {
                          testVal(rule, value, callback, constRules.noSpecialChar)
                        },
                        trigger: 'change'
                      },
                    ],
                    FBSDeviceName: [
                      {
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                      },
                      {
                        validator(rule, value, callback) {
                          testVal(rule, value, callback, constRules.noSpecialChar)
                        },
                        trigger: 'change'
                      },
                    ],
                    FbsDeviceIp: [{
                        required: true,
                        validator(rule, value, callback) {
@@ -446,101 +483,208 @@
                        },
                        trigger: 'change'
                    }, ],
                    GroupIndexInFBSDevice: [{
                    GroupIndexInFBSDevice: [
                      {
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    tmp_id: [{
                      required: true,
                      message: '请先录入电价分布模板',
                      trigger: 'change'
                    }, ],
                    BattGroupNum: [{
                      },
                      {
                        validator(rule, value, callback) {
                          testVal(rule, value, callback, constRules.noSpecialChar)
                        },
                        trigger: 'change'
                      },
                    ],
                    tmp_id: [
                      {
                        required: true,
                        message: '请先录入电价分布模板',
                        trigger: 'change'
                      },
                      {
                        validator(rule, value, callback) {
                          testVal(rule, value, callback, constRules.noSpecialChar)
                        },
                        trigger: 'change'
                      },
                    ],
                    BattGroupNum: [
                      {
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    FloatVolLevel: [{
                      },
                      {
                        validator(rule, value, callback) {
                          testVal(rule, value, callback, constRules.noSpecialChar)
                        },
                        trigger: 'change'
                      },
                    ],
                    FloatVolLevel: [
                      {
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                      },
                      {
                        validator(rule, value, callback) {
                          testVal(rule, value, callback, constRules.noSpecialChar)
                        },
                        trigger: 'change'
                      },
                    ],
                    OfflineVolLevel: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattFloatCurrent: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonResStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonSerStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonVolLowToAvg: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    DisCurrMax: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattGroupName: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonVolStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonCapStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    Load_curr: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattProducer: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattModel: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattProductDate: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattInUseDate: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonCount: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ]
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },]
                },
                linkage: {
                    province: '',

 src/components/battGroupMager/EditBattGroup.vue

@@ -280,7 +280,7 @@
    LinkagePlus, regEquipType
} from '../../assets/js/tools'


import const_rules from "@/assets/js/const/const_rules";
    import {
        const_province_city_county,
        const_battGroup,
@@ -303,6 +303,7 @@
        },
        data() {
            let rules = const_battGroup.rules;
            let constRules = const_rules;
            let batteryTypes = const_battery_type.types;
            return {
                layout: {
@@ -370,37 +371,72 @@
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName2: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName5: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName3: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    StationName4: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    FBSDeviceId: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    FBSDeviceName: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    FbsDeviceIp: [{
                        required: true,
                        validator(rule, value, callback) {
@@ -426,97 +462,192 @@
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    tmp_id: [{
                      required: true,
                      message: '请先录入电价分布模板',
                      trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattGroupNum: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    FloatVolLevel: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    OfflineVolLevel: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattFloatCurrent: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonResStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonSerStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonVolLowToAvg: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    DisCurrMax: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattGroupName: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonVolStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonCapStd: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    Load_curr: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattProducer: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattModel: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattProductDate: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    BattInUseDate: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ],
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },],
                    MonCount: [{
                        required: true,
                        message: '不能为空',
                        trigger: 'change'
                    }, ]
                    }, {
                      validator(rule, value, callback) {
                        testVal(rule, value, callback, constRules.noSpecialChar)
                      },
                      trigger: 'change'
                    },]
                },
                linkage: {
                    province: '',

 src/pages/dataMager/dialog/AddPowerMager.vue

@@ -184,7 +184,7 @@
    const_province_city_county,
    const_devType
} from '@/assets/js/const'

import const_rules from "@/assets/js/const/const_rules";
let devType = const_devType.power;
let agreements = const_devType.agreements;
let moduleNames = const_devType.moduleNames;
@@ -198,6 +198,7 @@
        },
    },
    data() {
        let constRules = const_rules;
        return {
            devType,      // 设备类型
            agreements,   // 协议
@@ -238,76 +239,151 @@
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName2: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName5: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName3: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName4: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationIP: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.isValidIp)
                  },
                  trigger: 'change'
                },],
                powerDeviceId: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerDeviceIp: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.isValidIp)
                  },
                  trigger: 'change'
                },],
                powerDeviceName: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                protocolName: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                deviceId: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerProducer: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerProductDate: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerInUseDate: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                runCompany: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
            },
            linkage: {

 src/pages/dataMager/dialog/EditPowerMager.vue

@@ -168,7 +168,7 @@
import {
    const_province_city_county
} from '@/assets/js/const'

import const_rules from "@/assets/js/const/const_rules";
export default {
    props: {
        batt: {
@@ -179,6 +179,7 @@
        },
    },
    data() {
        let constRules = const_rules;
        return {
            layout: {
                span: 8,
@@ -213,76 +214,151 @@
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName2: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName5: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName3: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationName4: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                stationIP: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.isValidIp)
                  },
                  trigger: 'change'
                },],
                powerDeviceId: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerDeviceIp: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.isValidIp)
                  },
                  trigger: 'change'
                },],
                powerDeviceName: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                protocolName: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                deviceId: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerProducer: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerProductDate: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                powerInUseDate: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
                runCompany: [{
                    required: true,
                    message: '不能为空',
                    trigger: 'change'
                },{
                  validator(rule, value, callback) {
                    testVal(rule, value, callback, constRules.noSpecialChar)
                  },
                  trigger: 'change'
                },],
            },
            linkage: {

New file
			@@ -0,0 +1,12 @@
			export default {
			isValidIp: {
			pattern: /(25[0-5]\|2[0-4]\d\|[0-1]\d{2}\|[1-9]?\d)\.(25[0-5]\|2[0-4]\d\|[0-1]\d{2}\|[1-9]?\d)\.(25[0-5]\|2[0-4]\d\|[0-1]\d{2}\|[1-9]?\d)\.(25[0-5]\|2[0-4]\d\|[0-1]\d{2}\|[1-9]?\d)/,
			regVal: false,
			msg: "IP地址格式不正确",
			},
			noSpecialChar: {
			pattern: /^[^`~!@$%&?<>/\\\|=+^{}\[\]\'\"【】‘’￥——、，。；：？《》！]$/i,
			regVal: false,
			msg: "存在特殊字符"
			}
			}

			@@ -302,7 +302,7 @@
			LinkagePlus, regEquipType,
			testVal
			} from '../../assets/js/tools'

			import const_rules from "@/assets/js/const/const_rules";
			import {
			const_province_city_county,
			const_battGroup,
			@@ -330,6 +330,7 @@
			},
			data() {
			let rules = const_battGroup.rules;
			let constRules = const_rules;
			let devTypes = const_devType.batt;
			let batteryTypes = const_battery_type.types;
			return {
			@@ -399,32 +400,68 @@
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName2: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName5: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName3: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			StationName4: [{
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName4: [
			{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			FBSDeviceName: [{
			},
			{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},
			],
			FBSDeviceName: [
			{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			},
			{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},
			],
			FbsDeviceIp: [{
			required: true,
			validator(rule, value, callback) {
			@@ -446,101 +483,208 @@
			},
			trigger: 'change'
			}, ],
			GroupIndexInFBSDevice: [{
			GroupIndexInFBSDevice: [
			{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			tmp_id: [{
			required: true,
			message: '请先录入电价分布模板',
			trigger: 'change'
			}, ],
			BattGroupNum: [{
			},
			{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},
			],
			tmp_id: [
			{
			required: true,
			message: '请先录入电价分布模板',
			trigger: 'change'
			},
			{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},
			],
			BattGroupNum: [
			{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			FloatVolLevel: [{
			},
			{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},
			],
			FloatVolLevel: [
			{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			},
			{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},
			],
			OfflineVolLevel: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattFloatCurrent: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonResStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonSerStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonVolLowToAvg: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			DisCurrMax: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattGroupName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonVolStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonCapStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			Load_curr: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattProducer: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattModel: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattProductDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattInUseDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonCount: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ]
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},]
			},
			linkage: {
			province: '',

			@@ -280,7 +280,7 @@
			LinkagePlus, regEquipType
			} from '../../assets/js/tools'


			import const_rules from "@/assets/js/const/const_rules";
			import {
			const_province_city_county,
			const_battGroup,
			@@ -303,6 +303,7 @@
			},
			data() {
			let rules = const_battGroup.rules;
			let constRules = const_rules;
			let batteryTypes = const_battery_type.types;
			return {
			layout: {
			@@ -370,37 +371,72 @@
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName2: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName5: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName3: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			StationName4: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			FBSDeviceId: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			FBSDeviceName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			FbsDeviceIp: [{
			required: true,
			validator(rule, value, callback) {
			@@ -426,97 +462,192 @@
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			tmp_id: [{
			required: true,
			message: '请先录入电价分布模板',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattGroupNum: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			FloatVolLevel: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			OfflineVolLevel: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattFloatCurrent: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonResStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonSerStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonVolLowToAvg: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			DisCurrMax: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattGroupName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonVolStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonCapStd: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			Load_curr: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattProducer: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattModel: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattProductDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			BattInUseDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ],
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			MonCount: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			}, ]
			}, {
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},]
			},
			linkage: {
			province: '',

			@@ -184,7 +184,7 @@
			const_province_city_county,
			const_devType
			} from '@/assets/js/const'

			import const_rules from "@/assets/js/const/const_rules";
			let devType = const_devType.power;
			let agreements = const_devType.agreements;
			let moduleNames = const_devType.moduleNames;
			@@ -198,6 +198,7 @@
			},
			},
			data() {
			let constRules = const_rules;
			return {
			devType, // 设备类型
			agreements, // 协议
			@@ -238,76 +239,151 @@
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName2: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName5: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName3: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName4: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationIP: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.isValidIp)
			},
			trigger: 'change'
			},],
			powerDeviceId: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerDeviceIp: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.isValidIp)
			},
			trigger: 'change'
			},],
			powerDeviceName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			protocolName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			deviceId: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerProducer: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerProductDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerInUseDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			runCompany: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			},
			linkage: {

			@@ -168,7 +168,7 @@
			import {
			const_province_city_county
			} from '@/assets/js/const'

			import const_rules from "@/assets/js/const/const_rules";
			export default {
			props: {
			batt: {
			@@ -179,6 +179,7 @@
			},
			},
			data() {
			let constRules = const_rules;
			return {
			layout: {
			span: 8,
			@@ -213,76 +214,151 @@
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName2: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName5: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName3: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationName4: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			stationIP: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.isValidIp)
			},
			trigger: 'change'
			},],
			powerDeviceId: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerDeviceIp: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.isValidIp)
			},
			trigger: 'change'
			},],
			powerDeviceName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			protocolName: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			deviceId: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerProducer: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerProductDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			powerInUseDate: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			runCompany: [{
			required: true,
			message: '不能为空',
			trigger: 'change'
			},{
			validator(rule, value, callback) {
			testVal(rule, value, callback, constRules.noSpecialChar)
			},
			trigger: 'change'
			},],
			},
			linkage: {