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 = [
{ t_props: 'teamName', 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: 'teamStatus', t_label: '班组状态', t_slot: 'teamStatus' },
{ t_props: 'createTime', t_label: '创建日期', },

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

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