密码策略校验bug

 Source/UBCS-WEB/src/views/system/PasswordManagement/passwords.vue

@@ -42,85 +42,11 @@
export default {
  name: "passwords.vue",
  data() {
    // 最小长度正则绑定值
    let validatePass=""
    //最大长度正则绑定值
    let validatePass1=""
    //过期时间正则绑定值
    let validatePass2=""
    //提醒时间正则绑定值
    let validatePass3=""
    //锁定次数正则绑定值
    let validatePass4=""
    //锁定时间正则绑定值
    let validatePass5=""
    //最小长度绑定value
    let values=""
    //最大长度绑定value
    let values1=""
    //最小长度正则方法
    validatePass = (rule, value,callback) => {
     values=value*1
      if(value == ""){
        callback(new Error('请输入密码最小长度'));
      // }else if(values >= values1*1){
      //   callback(new Error('密码最小长度不能大于密码最大长度'));
      }else if(/[^\d]/g.test(value)){
        callback(new Error('密码最小长度的输入类型只能为数字类型'));
      }else {
        callback();
      }
    };
    //最大长度正则方法
    validatePass1= (rule, value,callback) =>{
      values1=value*1
     if(value == ""){
        callback(new Error('请输入密码最大长度'));
      }else if(values1 <= values){
       callback(new Error('密码最大长度不能小于密码最大长度'));
     }else if(/[^\d]/g.test(value)){
       callback(new Error('密码最大长度的输入类型只能为数字类型'));
     }else {
       callback();
     }
    };
    validatePass2 = (rule, value,callback) => {
      if(value == ""){
        callback(new Error('请输入过期时间'));
      }else if(/[^\d]/g.test(value)){
        callback(new Error('过期时间的输入类型只能为数字类型'));
      }else {
        callback();
      }
    };
    validatePass3 = (rule, value,callback) => {
      if(value == ""){
        callback(new Error('请输入过期时间'));
      }else if(/[^\d]/g.test(value)){
        callback(new Error('过期时间的输入类型只能为数字类型'));
      }else {
        callback();
      }
    };
    validatePass4 = (rule, value,callback) => {
      if(value == ""){
        callback(new Error('请输入锁定次数'));
      }else if(/[^\d]/g.test(value)){
        callback(new Error('锁定次数的输入类型只能为数字类型'));
      }else {
        callback();
      }
    };
    validatePass5 = (rule, value,callback) => {
      if(value == ""){
        callback(new Error('请输入锁定时间'));
      }else if(/[^\d]/g.test(value)){
        callback(new Error('锁定时间的输入类型只能为数字类型'));
      }else {
        callback();
      }
    };
    return {
      //最小长度绑定value
      values:"",
      //最大长度绑定value
      values1:"",
      form:{},
      page: {
        pageSize: 10,
@@ -195,7 +121,18 @@
              labelWidth:"22%",
              rules: [{
                required: true,
                validator:this.validatePass,
                validator:(rule, value,callback)=>{
                  this.values=value*1
                  if(value == ""){
                    callback(new Error('请输入密码最小长度'));
                  }else if(/[^\d]/g.test(value)){
                    callback(new Error('密码最小长度的输入类型只能为数字类型'));
                  }else if(this.values >= this.values1 && this.values1 != 0){
                    callback(new Error('密码最小长度不能大于密码最大长度'))
                  }else {
                    callback();
                  }
                },
                trigger: 'blur'
              }]
            },
@@ -206,7 +143,18 @@
              labelWidth:"25%",
              rules: [{
                required: true,
                validator:this.validatePass1,
                validator:(rule, value,callback) =>{
                  this.values1=value*1
                  if(value == ""){
                    callback(new Error('请输入密码最大长度'));
                  }else if(this.values1 <= this.values){
                    callback(new Error('密码最大长度不能小于密码最大长度'));
                  }else if(/[^\d]/g.test(value)){
                    callback(new Error('密码最大长度的输入类型只能为数字类型'));
                  }else {
                    callback();
                  }
                },
                trigger: 'change'
              }]
            },
@@ -280,7 +228,15 @@
              labelWidth:"22%",
              rules: [{
                required: true,
                validator:this.validatePass2,
                validator: (rule, value,callback) => {
                  if(value == ""){
                    callback(new Error('请输入过期时间'));
                  }else if(/[^\d]/g.test(value)){
                    callback(new Error('过期时间的输入类型只能为数字类型'));
                  }else {
                    callback();
                  }
                },
                trigger: 'blur'
              }]
            },
@@ -291,7 +247,15 @@
              labelWidth:"25%",
              rules: [{
                required: true,
                validator:this.validatePass3,
                validator:(rule, value,callback) => {
                  if(value == ""){
                    callback(new Error('请输入过期时间'));
                  }else if(/[^\d]/g.test(value)){
                    callback(new Error('过期时间的输入类型只能为数字类型'));
                  }else {
                    callback();
                  }
                },
                trigger: 'blur'
              }]
            },
@@ -302,7 +266,15 @@
              labelWidth:"22%",
              rules: [{
                required: true,
                validator:this.validatePass4,
                validator:(rule, value,callback) => {
                  if(value == ""){
                    callback(new Error('请输入锁定次数'));
                  }else if(/[^\d]/g.test(value)){
                    callback(new Error('锁定次数的输入类型只能为数字类型'));
                  }else {
                    callback();
                  }
                },
                trigger: 'blur'
              }]
            },
@@ -313,7 +285,15 @@
              labelWidth:"25%",
              rules: [{
                required: true,
                validator:this.validatePass5,
                validator:(rule, value,callback) => {
                  if(value == ""){
                    callback(new Error('请输入锁定时间'));
                  }else if(/[^\d]/g.test(value)){
                    callback(new Error('锁定时间的输入类型只能为数字类型'));
                  }else {
                    callback();
                  }
                },
                trigger: 'blur'
              }]
            },
@@ -350,41 +330,72 @@
      this.selectlength=val
    },
    handleCheckboxChange(val) {
      // console.log("val",val);
      const arr = this.option.column[5];
      if(val){
        this.checkboxlength = val.value;
        return
      }
      // console.log("this.checkboxlength",this.checkboxlength);
      this.checkboxedit = this.checkboxlength.toString().split(",");
      if (val.value != undefined && val.value != null) {
        if (this.checkboxlist == val.value) {

      if (val.value !== undefined && val.value !== null) {
        if (this.checkboxlist === val.value) {
          return;
        } else {
          this.checkboxlist = val.value;
          if (
            this.selectlength.value >= val.value.length &&
            this.selectlength.value > val.value.length &&
            val.value.length > 0
          ) {
            this.showMessage("必填种类不能大于组合方法，请重新选择！");
            this.showWarningMessage();
          } else if (
            this.selectlength.value >= this.checkboxedit.length &&
            this.selectlength.value > this.checkboxedit.length &&
            this.checkboxedit.length > 0
          ) {
            this.showMessage("必填种类不能大于组合方法，请重新选择！");
            this.showWarningMessage();
          }
        }
      }
      const disabledCount = Math.min(this.checkboxedit.length, 4);
      for (let i = 0; i < arr.dicData.length; i++) {
        arr.dicData[i].disabled = i >= disabledCount;

      if (val.value !== undefined && val.value !== null) {
        if (val.value.length === 1) {
          this.setDisabled(arr, [0]);
        } else if (val.value.length === 2) {
          this.setDisabled(arr, [0, 1]);
        } else if (val.value.length === 3) {
          this.setDisabled(arr, [0, 1, 2]);
        } else if (val.value.length === 4) {
          this.setDisabled(arr, [0, 1, 2, 3]);
        } else if (val.value.length === 0) {
          this.setDisabled(arr, [-1]);
      }
      if (this.editFlag == true) {
        const disabledCount = Math.min(this.checkboxedit.length, 4);
        for (let i = 0; i < arr.dicData.length; i++) {
          arr.dicData[i].disabled = i >= disabledCount;
      } else if (this.checkboxNumber.length !== 0) {
        this.setDisabled(arr, [0, 1, 2, 3]);
      }

      if (this.editFlag) {
        if (this.checkboxedit.length === 1) {
          this.setDisabled(arr, [0]);
        } else if (this.checkboxedit.length === 2) {
          this.setDisabled(arr, [0, 1]);
        } else if (this.checkboxedit.length === 3) {
          this.setDisabled(arr, [0, 1, 2]);
        } else if (this.checkboxedit.length === 4) {
          this.setDisabled(arr, [0, 1, 2, 3]);
        } else if (this.checkboxedit.length === 0) {
          this.setDisabled(arr, [-1]);
        }
      }
    },

    setDisabled(arr, indices) {
      arr.dicData.forEach((item, index) => {
        item.disabled = !indices.includes(index);
      });
    },

    showWarningMessage() {
      this.$message({
        message: '必填种类不能大于组合方法，请重新选择！',
        type: 'warning',
        showClose: true,
      });
    },
    rowDel(row){
      this.$confirm("确定将选择数据删除?", {
@@ -432,7 +443,7 @@
      this.editFlag=true;
      this.checkboxNumber=row.combinationIds.split(",")
      this.selectNumber=row.requiredType
        if(this.checkboxNumber.length<=this.selectNumber){
        if(this.checkboxNumber.length < this.selectNumber){
          this.$message({
            type:"warning",
            message:"必填种类不能大于组合方法，请重新选择！"