<template>
|
<el-dialog
|
:title="!dataForm.id ? '公式' : '公式'"
|
:close-on-click-modal="false"
|
:visible.sync="visible"
|
>
|
<el-form
|
:model="dataForm"
|
ref="editOrderParamForm"
|
label-width="100px"
|
class="l-mes"
|
>
|
<el-form-item label="参数编号" prop="code">
|
<el-input v-model="dataForm.code" placeholder="" :disabled="true" />
|
</el-form-item>
|
<el-form-item label="参数项" prop="parameterItem">
|
<el-input
|
v-model="dataForm.parameterItem"
|
placeholder=""
|
:disabled="true"
|
/>
|
</el-form-item>
|
<el-form-item label="函数">
|
<div style="display:flex;">
|
<div
|
v-for="(item, i) in funcs"
|
:key="i"
|
style="margin-right:18px;color:red;font-size:12px;cursor: pointer;"
|
@click="addFun(item)"
|
>
|
<el-tooltip
|
class="item"
|
effect="dark"
|
:content="item.desc"
|
placement="top-start"
|
>
|
<div>{{ item.label }}</div>
|
</el-tooltip>
|
</div>
|
</div>
|
</el-form-item>
|
<el-form-item label="判定条件">
|
<div>
|
<ZttMonacoEditor
|
:items="params"
|
:idSubfix="monacoId"
|
@clickMonaco="clickMonacoCall"
|
ref="orderParamJudgmentCondition"
|
></ZttMonacoEditor>
|
</div>
|
<div style="color:red;">
|
点击输入框后，鼠标右键可选择参数项
|
</div>
|
</el-form-item>
|
<el-form-item label="计算公式">
|
<div>
|
<zttme
|
:items="params"
|
:idSubfix="zttmeId"
|
:monacoHeight="zttMonacoHeight"
|
@clickMonaco="clickMonacoCall"
|
ref="orderParamValueCompute"
|
></zttme>
|
</div>
|
<div style="color:red;">
|
点击输入框后，鼠标右键可选择参数项
|
</div>
|
</el-form-item>
|
</el-form>
|
<span slot="footer" class="dialog-footer">
|
<el-button @click="visible = false">取消</el-button>
|
<el-button type="primary" @click="dataFormSubmit()">确定</el-button>
|
</span>
|
</el-dialog>
|
</template>
|
|
<script>
|
import {
|
getOperationTestStandardParam,
|
putMoTestStandardParam
|
} from '@/api/plan/moteststandard'
|
import ZttMonacoEditor from '@/views/common/ztt-monaco-editor.vue'
|
import zttme from '@/views/common/ztt-monaco-editor.vue'
|
import { funcForParam } from '@/util/testFunctionRule'
|
export default {
|
data() {
|
return {
|
monacoId: 'order-param',
|
zttmeId: 'order-param-compute',
|
zttMonacoHeight: 50,
|
visible: false,
|
dataForm: {
|
id: null,
|
code: null,
|
parameterItem: null,
|
judgeFormula: null,
|
valueFormula: null,
|
testStandardId: null
|
},
|
params: [],
|
funcs: [],
|
currMonaco: 'order-param'
|
}
|
},
|
components: {
|
ZttMonacoEditor,
|
zttme
|
},
|
methods: {
|
init(row) {
|
this.visible = true
|
this.funcs = funcForParam()
|
this.$nextTick(() => {
|
if (row) {
|
this.dataForm = row
|
this.$refs.orderParamJudgmentCondition.setVal(
|
this.dataForm.judgeFormula == null ? '' : this.dataForm.judgeFormula
|
)
|
this.$refs.orderParamValueCompute.setVal(
|
this.dataForm.valueFormula == null ? '' : this.dataForm.valueFormula
|
)
|
this.params = []
|
getOperationTestStandardParam(
|
Object.assign({
|
moTestStandardId: this.dataForm.moTestStandardId
|
})
|
).then((response) => {
|
this.params = response.data.data
|
})
|
} else {
|
this.$refs.orderParamJudgmentCondition.setVal('')
|
this.$refs.orderParamValueCompute.setVal('')
|
}
|
})
|
},
|
addFun(item) {
|
let monacoRef = ''
|
if (this.currMonaco === 'order-param') {
|
monacoRef = 'orderParamJudgmentCondition'
|
} else {
|
monacoRef = 'orderParamValueCompute'
|
}
|
let index = this.$refs[monacoRef].getPosition().column
|
const lineNumber = this.$refs[monacoRef].getPosition().lineNumber
|
let preIndex = 0
|
if (lineNumber > 1) {
|
for (let i = 1; i <= lineNumber - 1; i++) {
|
preIndex += this.$refs[monacoRef].getLineLength(i) + 2
|
}
|
}
|
index = index + preIndex
|
const pre = this.$refs[monacoRef].getVal().substring(0, index - 1)
|
const fix = this.$refs[monacoRef].getVal().substring(index - 1)
|
this.$refs[monacoRef].setVal(pre + item.label + fix)
|
},
|
// 获取某段字符在字符串中出现的次数
|
getNumCharInStr(wholeSection, fragment, i) {
|
let num = i
|
const existIndex = wholeSection.indexOf(fragment)
|
if (existIndex >= 0) {
|
num = num + 1
|
wholeSection = wholeSection.substring(existIndex + fragment.length)
|
return this.getNumCharInStr(wholeSection, fragment, num)
|
} else {
|
return num
|
}
|
},
|
getRandom() {
|
let num = Math.random()
|
num = num * 100
|
num = Math.floor(num)
|
return num
|
},
|
// 表单提交
|
dataFormSubmit() {
|
// 校验判定公式
|
let judgeFormula = this.$refs.orderParamJudgmentCondition.getVal()
|
// 先判定公式中函数格式是否正确，再用默认值计算出函数值，替换进公式，最后将公式中剩余的参数进行默认值替换，利用js eval函数进行公式校验
|
let flag = true
|
let funcEl
|
for (let j = 0; j < this.funcs.length; j++) {
|
funcEl = this.funcs[j]
|
// 计算函数关键在公式中出现的次数
|
const num = this.getNumCharInStr(judgeFormula, funcEl.name, 0)
|
// for循环次数校验替换
|
for (let k = 0; k < num; k++) {
|
const existIndex = judgeFormula.indexOf(funcEl.name)
|
if (existIndex >= 0) {
|
// 函数关键字在公式中存在
|
const prefixStr = judgeFormula.substring(0, existIndex)
|
const startToEndStr = judgeFormula.substring(
|
existIndex + funcEl.name.length
|
)
|
if (startToEndStr.length > 0) {
|
const paramStartIndex = startToEndStr.indexOf('(')
|
const paramEndIndex = startToEndStr.indexOf(')')
|
if (paramStartIndex === 0 && paramEndIndex > 0) {
|
const suffixStr = startToEndStr.substring(paramEndIndex + 1)
|
const paramStr = startToEndStr.substring(
|
paramStartIndex + 1,
|
paramEndIndex
|
)
|
if (paramStr.trim() !== '') {
|
const paramArr = paramStr.split(',')
|
if (paramArr.length > 0) {
|
if (
|
(funcEl.singleParam && paramArr.length === 1) ||
|
!funcEl.singleParam
|
) {
|
let paramFlag = true
|
for (let i = 0; i < paramArr.length; i++) {
|
const param = this.params.find(
|
(item) =>
|
paramArr[i].trim() === 'V[' + item.code + ']'
|
)
|
if (param !== undefined) {
|
} else {
|
flag = false
|
paramFlag = false
|
this.$message.error('函数参数不存在')
|
}
|
}
|
if (paramFlag) {
|
if (funcEl.returnType === 'number') {
|
judgeFormula = prefixStr + '1' + suffixStr
|
} else {
|
judgeFormula = prefixStr + 'true' + suffixStr
|
}
|
} else {
|
break
|
}
|
} else {
|
flag = false
|
this.$message.error('函数参数个数不正确')
|
break
|
}
|
} else {
|
break
|
}
|
} else {
|
flag = false
|
this.$message.error('函数必须要有参数')
|
break
|
}
|
} else {
|
flag = false
|
this.$message.error(
|
'函数需包含左右小括号，且左侧小括号需紧邻函数'
|
)
|
break
|
}
|
} else {
|
flag = false
|
this.$message.error('函数需包含左右小括号')
|
break
|
}
|
}
|
}
|
}
|
if (flag) {
|
// 将公式中剩余的参数进行默认值替换
|
let param
|
for (let x = 0; x < this.params.length; x++) {
|
param = this.params[x]
|
// 计算参数在公式中出现的次数
|
const num = this.getNumCharInStr(
|
judgeFormula,
|
'V[' + param.code + ']',
|
0
|
)
|
// for循环次数校验替换
|
for (let y = 0; y < num; y++) {
|
const existIndex = judgeFormula.indexOf('V[' + param.code + ']')
|
if (existIndex >= 0) {
|
const prefixStr = judgeFormula.substring(0, existIndex)
|
const suffixStr = judgeFormula.substring(
|
existIndex + ('V[' + param.code + ']').length
|
)
|
judgeFormula = prefixStr + this.getRandom() + suffixStr
|
}
|
}
|
}
|
try {
|
eval(judgeFormula)
|
} catch (exception) {
|
flag = false
|
}
|
if (flag) {
|
if (this.dataForm.id) {
|
const objParam = {
|
id: this.dataForm.id,
|
judgeFormula: this.$refs.orderParamJudgmentCondition.getVal(),
|
valueFormula: this.$refs.orderParamValueCompute.getVal()
|
}
|
putMoTestStandardParam(objParam).then((data) => {
|
if (data.data.code === 0) {
|
this.$message.success('公式更新成功')
|
this.visible = false
|
this.$emit('refreshOrderParamList')
|
} else {
|
this.$message.error('公式更新失败')
|
}
|
})
|
}
|
} else {
|
this.$message.error('公式格式错误，请仔细检查')
|
}
|
}
|
},
|
// monaco点击回调,设定当前点击的monaco
|
clickMonacoCall(val) {
|
this.currMonaco = val
|
}
|
}
|
}
|
</script>
|
