bonus
/
SafetyAlertSystem-ui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

班组管理bug修复

This commit is contained in:
jjLv 2024-09-30 15:10:56 +08:00
parent 637b5abd5d
commit b427da729c
3 changed files with 119 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/views/base/crew/config.js
View File

@ -6,7 +6,7 @@ export const formLabel = [
export const columnsList = [ export const columnsList = [
{ t_props: 'teamName', t_label: '班组名称', }, { t_props: 'teamName', t_label: '班组名称', },
{ t_props: 'proName', t_label: '所属工程', }, { t_props: 'proName', t_label: '所属工程', },
{ t_props: 'relName', t_label: '班组长', t_slot: 'relName' }, { t_props: 'relNamePhone', t_label: '班组长' },
{ t_props: 'peopleCount', t_label: '班组成员', t_slot: 'peopleCount' }, { t_props: 'peopleCount', t_label: '班组成员', t_slot: 'peopleCount' },
{ t_props: 'teamStatus', t_label: '班组状态', t_slot: 'teamStatus' }, { t_props: 'teamStatus', t_label: '班组状态', t_slot: 'teamStatus' },
{ t_props: 'createTime', t_label: '创建日期', }, { t_props: 'createTime', t_label: '创建日期', },

6
src/views/base/crew/index.vue
View File

@ -42,9 +42,9 @@
> >
<span v-if="data.teamStatus !== '正常'">-</span> <span v-if="data.teamStatus !== '正常'">-</span>
</template> </template>
<template slot="relName" slot-scope="{ data }"> <!-- <template slot="relNamePhone" slot-scope="{ data }">
{{ data.relName.split('/')[0] }}/{{ phoneCrypto(data.relName.split('/')[1]) }} {{ datarelNamePhone }}
</template> </template> -->
<template slot="peopleCount" slot-scope="{ data }"> <template slot="peopleCount" slot-scope="{ data }">
<span <span
:class="[{ peopleCount: data.teamStatus === '正常' }]" :class="[{ peopleCount: data.teamStatus === '正常' }]"

230
src/views/base/warning/components/form-warning.vue
View File

@ -330,7 +330,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入温度阈值(小数点后最多保留六位)')); return callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -338,8 +338,8 @@ export default {
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请正确输入温度阈值(小数点后最多保留六位)')); callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
} else { } else {
callback(); callback();
} }
@ -359,7 +359,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入温度阈值(小数点后最多保留六位)')); return callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -367,8 +367,8 @@ export default {
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请正确输入温度阈值(小数点后最多保留六位)')); callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
} else { } else {
callback(); callback();
} }
@ -388,7 +388,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -398,17 +398,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 100) { if (valueTemp < 0 || valueTemp > 100) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -426,7 +426,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -436,17 +436,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 100) { if (valueTemp < 0 || valueTemp > 100) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -464,7 +464,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -474,17 +474,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -502,7 +502,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -512,17 +512,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -540,7 +540,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -550,17 +550,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -578,7 +578,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -588,17 +588,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -616,7 +616,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -626,17 +626,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -654,7 +654,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -664,17 +664,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -701,7 +701,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -711,17 +711,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 90) { if (valueTemp < 0 || valueTemp > 90) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -739,7 +739,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -749,17 +749,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 90) { if (valueTemp < 0 || valueTemp > 90) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位')); callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -786,7 +786,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -796,17 +796,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -824,7 +824,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -834,17 +834,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -871,7 +871,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -881,17 +881,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 100) { if (valueTemp < 0 || valueTemp > 100) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -909,7 +909,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -919,17 +919,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 100) { if (valueTemp < 0 || valueTemp > 100) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -947,7 +947,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -957,17 +957,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -985,7 +985,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -995,17 +995,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -1023,7 +1023,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -1033,17 +1033,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 100) { if (valueTemp < 0 || valueTemp > 100) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -1061,7 +1061,7 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
@ -1071,17 +1071,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 || valueTemp > 100) { if (valueTemp < 0 || valueTemp > 100) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -1099,9 +1099,9 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^(0|[1-9]\d*)(\.\d{0,2})?$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
@ -1109,17 +1109,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -1137,9 +1137,9 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^(0|[1-9]\d*)(\.\d{0,2})?$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
@ -1147,17 +1147,17 @@ export default {
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0") // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") { if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位')); return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) { if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位')); callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
} else { } else {
callback(); callback();
} }
@ -1176,13 +1176,13 @@ export default {
}, },
methods: { methods: {
/** 校验数字 */ /** 校验数字 */
validateNum(rule, value, callback) { // validateNum(rule, value, callback) {
if(!this.numReg.test(value)) { // if(!this.numReg.test(value)) {
callback(new Error('请输入数字')) // callback(new Error('请输入数字'))
} else { // } else {
callback() // callback()
} // }
}, // },
/** 改变树结构 */ /** 改变树结构 */
changeTree(leaf) { changeTree(leaf) {
leaf.map(item => { leaf.map(item => {