<template>
|
<div class="edit-rules-box">
|
<p style="padding: 0">
|
<b style="font-size: 14px; line-height: 28px">策略配置</b>
|
</p>
|
<div class="sub-rules-box">
|
<div style="text-align: left">
|
<div class="sdk-group">
|
<transition-group name="fade" mode="out-in" appear>
|
<div
|
class="config-item"
|
:class="{ init: index == 0 }"
|
v-cloak
|
v-for="(sdkItem, index) in sdkGroup"
|
:key="index"
|
>
|
<div class="connection" v-if="index !== 0">
|
<el-select
|
v-model="sdkItem.rule_with_pre"
|
size="mini"
|
placeholder="选关系"
|
@change="selConnection(sdkItem)"
|
>
|
<el-option
|
:value="item.value"
|
:title="item.name"
|
:label="item.name"
|
v-for="item in sdkConnects"
|
:key="item.id"
|
></el-option>
|
<!-- <el-option value="&&" title="and/且" label="and/且"></el-option>
|
<el-option value="||" title="or/或" label="or/或"></el-option>
|
<el-option value="=>" title="—>/触发" label="—>/触发"></el-option>-->
|
</el-select>
|
<el-checkbox
|
v-show="
|
sdkItem.rule_with_pre == '=>' ||
|
sdkItem.rule_with_pre == '!=>'
|
"
|
v-model="sdkItem.is_save_anyhow"
|
style="margin-left: 30px"
|
>保存过程数据</el-checkbox
|
>
|
</div>
|
|
<div class="top-line">
|
<div class="left">
|
<div class="init-sdk">
|
<el-select
|
v-model="sdkItem.sdkObj"
|
value-key="id"
|
placeholder="选择算法"
|
size="mini"
|
@change="selectSDKOption(sdkItem, true, index)"
|
>
|
<el-option
|
v-for="item in TaskMange.list1"
|
:key="item.id"
|
:label="item.sdk_name"
|
:value="item"
|
:title="item.sdk_name"
|
v-show="!item.del_flag"
|
></el-option>
|
</el-select>
|
</div>
|
<div class="init-polygon">
|
<el-select
|
v-model="sdkItem.polygonObj"
|
v-if="!isTemplate"
|
value-key="polygonId"
|
placeholder="选择区域"
|
size="mini"
|
@change="selectPolygonOption(sdkItem)"
|
>
|
<el-option
|
v-for="subitem in allPolygonData"
|
:key="subitem.id"
|
:label="subitem.name"
|
:value="subitem"
|
:title="subitem.name"
|
></el-option>
|
</el-select>
|
</div>
|
</div>
|
<div class="right">
|
<span
|
class="del"
|
v-show="!hideDel"
|
@click="delConfigItem(index)"
|
>
|
<i class="iconfont iconshanchu"></i>
|
</span>
|
<span class="collapse" @click="collapseLine(index)">
|
<i
|
:class="
|
sdkItem.isSpread
|
? 'el-icon-arrow-up'
|
: 'el-icon-arrow-down'
|
"
|
></i>
|
</span>
|
</div>
|
</div>
|
|
<div class="argums derive-line" v-show="sdkItem.isSpread">
|
<div v-for="(arg, index) in sdkItem.defaultArg" :key="arg.sort">
|
<div class="argums-item" v-show="arg.config.isShow">
|
<div class="arg-name">
|
<el-select
|
v-model="arg.name"
|
size="mini"
|
:disabled="true"
|
>
|
<el-option
|
:label="arg.name"
|
:title="arg.name"
|
:value="arg"
|
></el-option>
|
</el-select>
|
</div>
|
<div class="operator-name">
|
<el-select
|
:disabled="arg.operators.length == 1"
|
v-model="arg.operator"
|
size="mini"
|
@change="selOperator(sdkItem)"
|
>
|
<el-option
|
v-for="operator in arg.operators"
|
:key="operator.operator"
|
:value="operator.operator"
|
:label="operator.name"
|
:title="operator.name"
|
></el-option>
|
</el-select>
|
</div>
|
<div class="arg-val">
|
<div v-if="arg.operator == 'range'">
|
<el-input
|
class="range-min"
|
v-model="arg.min"
|
@blur="validateArgVal(arg, $event)"
|
></el-input>
|
<span class="devide"></span>
|
<el-input
|
class="range-max"
|
v-model="arg.max"
|
@blur="validateArgVal(arg, $event)"
|
></el-input>
|
<span>{{ arg.unit }}</span>
|
</div>
|
<div v-else>
|
<el-select
|
v-if="arg.type == 'option'"
|
v-model="arg.sdk_arg_value"
|
:multiple="arg.config.isMulti"
|
collapse-tags
|
size="mini"
|
>
|
<el-option
|
v-for="one in arg.valueOptions"
|
:key="one.value"
|
:value="one.value"
|
:label="one.name"
|
:title="one.name"
|
></el-option>
|
</el-select>
|
|
<el-input
|
v-if="arg.type == 'value'"
|
v-model="arg.sdk_arg_value"
|
:placeholder="
|
arg.default_value ? arg.default_value : ''
|
"
|
size="mini"
|
:style="{ borderColor: tipColor }"
|
@blur="validateArgVal(arg, $event)"
|
></el-input>
|
<span>{{ arg.unit }}</span>
|
</div>
|
</div>
|
<div
|
class="optional"
|
v-if="
|
sdkItem.initAddOptional &&
|
index == sdkItem.defaultArg.length - 1
|
"
|
>
|
<span class="btn" @click="addOptionalArg(sdkItem)">
|
<i
|
class="iconfont iconhebingxingzhuang"
|
style="font-size: 16px"
|
></i>
|
</span>
|
</div>
|
</div>
|
</div>
|
<div
|
class="argums-item optional-line"
|
v-for="optArgItem in sdkItem.optArg"
|
:key="optArgItem.sort"
|
>
|
<div class="arg-name">
|
<el-input
|
v-if="sdkItem.optNames.length == 1"
|
v-model="sdkItem.optNames[0].name"
|
size="mini"
|
:disabled="true"
|
></el-input>
|
<el-select
|
v-if="sdkItem.optNames.length > 1"
|
v-model="optArgItem.name"
|
size="mini"
|
@change="selOptionalArg(sdkItem, optArgItem)"
|
>
|
<el-option
|
v-for="optName in sdkItem.optNames"
|
:disabled="optName.isSelected"
|
:key="optName.sort"
|
:label="optName.name"
|
:title="optName.name"
|
:value="optName.name"
|
></el-option>
|
</el-select>
|
</div>
|
<div class="operator-name">
|
<el-select
|
:disabled="optArgItem.operators.length == 1"
|
v-model="optArgItem.operator"
|
size="mini"
|
@change="selOperator(optArgItem)"
|
>
|
<el-option
|
v-for="operatorItem in optArgItem.operators"
|
:key="operatorItem.operator"
|
:value="operatorItem.operator"
|
:label="operatorItem.name"
|
:title="operatorItem.name"
|
></el-option>
|
</el-select>
|
</div>
|
<div class="arg-val">
|
<el-select
|
v-if="optArgItem.type == 'option'"
|
v-model="optArgItem.sdk_arg_value"
|
:multiple="optArgItem.config.isMulti"
|
collapse-tags
|
size="mini"
|
>
|
<el-option
|
v-for="one in optArgItem.valueOptions"
|
:key="one.value"
|
:value="one.value"
|
:label="one.name"
|
:title="one.name"
|
></el-option>
|
</el-select>
|
<el-input
|
v-if="optArgItem.type == 'value'"
|
v-model="optArgItem.sdk_arg_value"
|
size="mini"
|
@blur="($event) => validateArgVal(optArgItem, $event)"
|
></el-input>
|
<span>{{ optArgItem.unit }}</span>
|
</div>
|
<div class="optional">
|
<span
|
class="btn"
|
@click="addOptionalArg(sdkItem)"
|
v-show="sdkItem.isAddable"
|
>
|
<i
|
class="iconfont iconhebingxingzhuang"
|
style="font-size: 16px"
|
></i>
|
</span>
|
<span
|
class="btn"
|
@click="delOptionalArg(sdkItem, optArgItem)"
|
>
|
<i
|
class="iconfont iconshanchu11"
|
style="font-size: 16px"
|
></i>
|
</span>
|
</div>
|
</div>
|
</div>
|
</div>
|
</transition-group>
|
</div>
|
<div class="btn-add" v-show="isAdd && this.sdkGroup.length < 4">
|
<el-button size="mini" @click="addSdkItem">+ 添加算法</el-button>
|
</div>
|
</div>
|
</div>
|
</div>
|
</template>
|
<script>
|
import {
|
deleteCameraRules,
|
updateRuleDefence,
|
updateAlarmLevel,
|
} from "@/api/camera";
|
|
export default {
|
name: "SceneRuleEditor",
|
props: {
|
Cameras: {
|
type: Array,
|
default: () => {
|
return [];
|
},
|
},
|
isTemplate: {
|
type: Boolean,
|
default: false,
|
},
|
isLinkRule: {
|
type: Boolean,
|
default: false,
|
},
|
includeSdks: {
|
type: Array,
|
},
|
ruleList: {
|
type: String,
|
default: "",
|
},
|
onSubmitRule: {
|
type: Function,
|
default: () => false,
|
},
|
},
|
|
watch: {
|
Cameras: {
|
handler(n, o) {
|
let polygon = [];
|
let cameras = [...n];
|
|
for (let i = 0; i < cameras.length; i++) {
|
let polyOpt = cameras[i].polygonData.map((p) => {
|
return {
|
defence_state: p.defence_state,
|
polygonId: p.id,
|
name: this.isLinkRule
|
? cameras[i].cameraName + ":" + p.name
|
: p.name,
|
|
cameraId: cameras[i].cameraId,
|
};
|
});
|
polygon = polygon.concat(polyOpt);
|
|
this.allPolygonData = polygon;
|
//添加场景初始化区域选项为'全部区域'
|
// if (polygon.length > 0 && this.ruleList == '') {
|
// this.polygonObj = polygon[0]
|
// this.sdkGroup[0].polygonObj = JSON.parse(
|
// JSON.stringify(this.polygonObj)
|
// )
|
|
// this.selectPolygonOption(this.sdkGroup[0])
|
// }
|
}
|
},
|
deep: true,
|
},
|
sdkGroup: {
|
handler(newV, oldV) {
|
if (newV) {
|
newV.forEach((sdk) => {
|
let rangeOne = sdk.defaultArg.find(
|
(arg) => arg.operators[0].operator == "range"
|
);
|
if (rangeOne) {
|
if (rangeOne.min.trim() && rangeOne.max.trim()) {
|
rangeOne.sdk_arg_value = rangeOne.min + "|" + rangeOne.max;
|
} else {
|
rangeOne.sdk_arg_value = false;
|
}
|
}
|
});
|
let res = newV.find((item) => {
|
return JSON.stringify(item.sdkObj) == "{}";
|
});
|
if (!res) {
|
this.isAdd = true;
|
this.hideDel = false;
|
} else {
|
this.isAdd = false;
|
if (this.sdkGroup.length == 1) {
|
this.hideDel = true;
|
} else {
|
this.hideDel = false;
|
}
|
}
|
}
|
},
|
deep: true,
|
},
|
},
|
mounted() {
|
this.TaskMange.findAllSdk({ installed: true });
|
|
//this.editHandle(this.ruleList)
|
},
|
data() {
|
return {
|
hideDel: true,
|
allPolygonData: [],
|
group_id: "",
|
baseSdkItem: {
|
sdkObj: {},
|
polygonObj: {},
|
is_save_anyhow: true,
|
rule_with_pre: "",
|
isSpread: true,
|
argDef: [],
|
initAddOptional: false,
|
defaultArg: [],
|
optionalArg: [],
|
optArg: [],
|
optNames: [],
|
isAddable: true,
|
},
|
sdkGroup: [
|
{
|
sdkObj: {},
|
polygonObj: {},
|
is_save_anyhow: true,
|
isSpread: true,
|
argDef: [],
|
initAddOptional: false,
|
defaultArg: [],
|
optionalArg: [],
|
optArg: [],
|
optNames: [],
|
isAddable: true,
|
},
|
],
|
polygonObj: {},
|
isSpread: true,
|
isAdd: false,
|
tipColor: "yellow",
|
tasksTable: {},
|
groupRules: [],
|
sdksOption: [],
|
baseRule: {
|
camera_id: "",
|
id: "",
|
operator: "",
|
operator_type: "",
|
polygon_id: "",
|
rule_with_pre: "",
|
sdk_id: "",
|
sdk_arg_alias: "",
|
sdk_arg_value: "",
|
sdk_arg_defaultValue: "",
|
select_time_rule: "",
|
sdk_arg_type: "",
|
// task_id: "",
|
|
polygonObj: {},
|
taskObj: "",
|
|
sdkObj: {},
|
argObj: {},
|
operatorObj: {},
|
valueObj: {},
|
|
sdksOptions: [],
|
argsOptions: [],
|
argType: "",
|
computeOptions: [],
|
valueOptions: [],
|
|
sdkDesc: "",
|
argDesc: "",
|
operatorDesc: "",
|
typeDesc: "",
|
valueDesc: "",
|
|
unit: "",
|
value: "",
|
valid: true,
|
},
|
};
|
},
|
methods: {
|
getSdkConnection() {
|
this.sdkConnects = this.VideoManageData.Dictionary[
|
"RULECOMPUTEBETWEEN"
|
].map((r) => {
|
return {
|
name: r.name,
|
value: r.value,
|
};
|
});
|
},
|
selConnection(sdkItem) {},
|
addSdkItem() {
|
let itemTemp = JSON.parse(JSON.stringify(this.baseSdkItem));
|
//初始化区域
|
itemTemp.polygonObj = JSON.parse(JSON.stringify(this.allPolygonData[0]));
|
this.selectPolygonOption(itemTemp);
|
this.sdkGroup.push(itemTemp);
|
},
|
delConfigItem(index) {
|
// if(index != 0){
|
// this.sdkGroup.splice(index,1);
|
// }else{
|
// //this.sdkGroup[0] = JSON.parse(JSON.stringify(this.baseSdkItem));
|
// this.sdkGroup.splice(0,1,JSON.parse(JSON.stringify(this.baseSdkItem)));
|
// }
|
|
//删除逻辑：当只有一个算法时，删除会回到初始状态；有多个算法时，删除既移除整个算法项
|
if (this.sdkGroup.length == 1) {
|
let itemTemp = JSON.parse(JSON.stringify(this.baseSdkItem));
|
itemTemp.polygonObj = JSON.parse(
|
JSON.stringify(this.allPolygonData[0])
|
);
|
this.selectPolygonOption(itemTemp);
|
this.sdkGroup.splice(index, 1, itemTemp);
|
} else {
|
if (
|
this.sdkGroup[index + 1] &&
|
this.sdkGroup[index + 1].rule_with_pre
|
) {
|
this.sdkGroup[index + 1].rule_with_pre = "";
|
}
|
|
this.sdkGroup.splice(index, 1);
|
}
|
},
|
collapseLine(index) {
|
// let one = this.sdkGroup.find(sdk=>{
|
// return sdk.sdk_id == sdkId;
|
// });
|
|
this.sdkGroup[index].isSpread = !this.sdkGroup[index].isSpread;
|
},
|
addOptionalArg(sdkItem) {
|
sdkItem.initAddOptional = false;
|
sdkItem.optArg.forEach((arg) => {
|
sdkItem.optNames.forEach((name) => {
|
if (arg.sort == name.sort) {
|
name.isSelected = true;
|
}
|
});
|
}); //找到可选sdkItem.optNames的第一个对应的sdkItem.optionalArg push到sdkItem.optArg
|
let oneNotSelected = sdkItem.optNames.find((name) => !name.isSelected);
|
if (oneNotSelected) {
|
oneNotSelected.isSelected = true;
|
}
|
|
let argTemp = sdkItem.optionalArg.find((arg) => {
|
return arg.sort == oneNotSelected.sort;
|
});
|
|
let copyArgTemp = JSON.parse(JSON.stringify(argTemp));
|
if (copyArgTemp.type == "option") {
|
// let alias = copyArgTemp.alias;
|
// console.log( this.VideoManageData.Dictionary[alias])
|
// copyArgTemp.valueOptions = this.VideoManageData.Dictionary[alias].map(r => {
|
// return {
|
// name: r.name,
|
// value: r.value
|
// }
|
// })
|
|
this.setOptArgValueOptions(copyArgTemp);
|
}
|
//默认选中第一个operator
|
//if (copyArgTemp.operators.length == 1) {
|
this.$set(copyArgTemp, "operator", copyArgTemp.operators[0].operator);
|
//}
|
|
if (copyArgTemp.default_value) {
|
this.$set(copyArgTemp, "sdk_arg_value", copyArgTemp.default_value);
|
}
|
sdkItem.optArg.push(copyArgTemp);
|
if (sdkItem.optArg.length < sdkItem.optionalArg.length) {
|
sdkItem.isAddable = true;
|
} else {
|
sdkItem.isAddable = false;
|
}
|
},
|
delOptionalArg(sdkItem, optArgItem) {
|
let index = sdkItem.optArg.findIndex(
|
(arg) => arg.sort == optArgItem.sort
|
);
|
sdkItem.optArg.splice(index, 1);
|
sdkItem.optNames.forEach((name) => {
|
if (name.sort == optArgItem.sort) {
|
name.isSelected = false;
|
}
|
});
|
sdkItem.initAddOptional = sdkItem.optArg.length == 0 ? true : false;
|
if (sdkItem.optArg.length < sdkItem.optionalArg.length) {
|
sdkItem.isAddable = true;
|
} else {
|
sdkItem.isAddable = false;
|
}
|
},
|
selOptionalArg(sdkItem, optArgItem) {
|
let newSort = 0;
|
sdkItem.optNames.forEach((name) => {
|
if (name.name == optArgItem.name) {
|
//新切换的参数名
|
name.isSelected = true;
|
newSort = name.sort;
|
} else if (name.sort == optArgItem.sort) {
|
//切换前的参数名
|
name.isSelected = false;
|
}
|
});
|
//根据新的参数sort找到其对应配置对象
|
let argObj = sdkItem.optionalArg.find((arg) => arg.sort == newSort);
|
if (argObj.type == "option") {
|
this.setOptArgValueOptions(argObj);
|
}
|
//默认选中第一个operator
|
//if (argObj.operators.length == 1) {
|
this.$set(argObj, "operator", argObj.operators[0].operator);
|
//}
|
//替换新的参数配置对象
|
sdkItem.optArg.forEach((arg, index) => {
|
if (arg.sort == optArgItem.sort) {
|
this.$set(sdkItem.optArg, index, JSON.parse(JSON.stringify(argObj)));
|
}
|
});
|
},
|
setOptArgValueOptions(optArg) {
|
let alias = optArg.alias;
|
optArg.valueOptions = this.VideoManageData.Dictionary[alias].map((r) => {
|
return {
|
name: r.name,
|
value: r.value,
|
};
|
});
|
},
|
validateArgVal(sdkArgItem, e) {
|
if (
|
typeof sdkArgItem.sdk_arg_value == "string" &&
|
sdkArgItem.sdk_arg_value == ""
|
) {
|
this.$notify({
|
type: "warning",
|
message: "参数设定值不能为空!",
|
});
|
sdkArgItem.valid = false;
|
|
return false;
|
}
|
//输入非数字
|
|
//范围是否合法
|
if (sdkArgItem.range) {
|
let leftHand = sdkArgItem.range.substr(0, 1);
|
let rightHand = sdkArgItem.range.substr(sdkArgItem.range.length - 1, 1);
|
let reg = /.*(\d+),(\d+).*/;
|
let res = sdkArgItem.range.match(reg);
|
let min = Number(res[1]),
|
max = Number(res[2]);
|
|
//判断非区间类
|
if (sdkArgItem.sdk_arg_value && sdkArgItem.operator != "range") {
|
if (leftHand == "(" && rightHand == ")") {
|
if (
|
Number(sdkArgItem.sdk_arg_value) <= min ||
|
Number(sdkArgItem.sdk_arg_value) >= max
|
) {
|
sdkArgItem.valid = false;
|
|
this.$notify({
|
type: "warning",
|
message: `参数设定值须大于${min},小于${max}`,
|
});
|
return false;
|
}
|
} else if (leftHand == "[" && rightHand == ")") {
|
if (
|
Number(sdkArgItem.sdk_arg_value) < min ||
|
Number(sdkArgItem.sdk_arg_value) >= max
|
) {
|
sdkArgItem.valid = false;
|
|
this.$notify({
|
type: "warning",
|
message: `参数设定值须大于等于${min},小于${max}`,
|
});
|
return false;
|
}
|
} else if (leftHand == "(" && rightHand == "]") {
|
if (
|
Number(sdkArgItem.sdk_arg_value) <= min ||
|
Number(sdkArgItem.sdk_arg_value) > max
|
) {
|
sdkArgItem.valid = false;
|
|
this.$notify({
|
type: "warning",
|
message: `参数设定值须大于${min},小于等于${max}`,
|
});
|
return false;
|
}
|
} else if (leftHand == "[" && rightHand == "]") {
|
if (
|
Number(sdkArgItem.sdk_arg_value) < min ||
|
Number(sdkArgItem.sdk_arg_value) > max
|
) {
|
sdkArgItem.valid = false;
|
this.showErrorColor(e);
|
this.$notify({
|
type: "warning",
|
message: `参数设定值须大于等于${min},小于等于${max}`,
|
});
|
return false;
|
}
|
}
|
} else if (sdkArgItem.min || sdkArgItem.max) {
|
//判断区间类
|
if (leftHand == "(" && rightHand == ")") {
|
if (
|
Number(sdkArgItem.min) <= min ||
|
Number(sdkArgItem.min) >= max
|
) {
|
sdkArgItem.valid = false;
|
|
this.$notify({
|
type: "warning",
|
message: `参数区间设定值须大于${min},小于${max}`,
|
});
|
return false;
|
}
|
} else if (leftHand == "[" && rightHand == ")") {
|
if (Number(sdkArgItem.min) < min || Number(sdkArgItem.max) >= max) {
|
sdkArgItem.valid = false;
|
|
this.$notify({
|
type: "warning",
|
message: `参数区间设定值须大于等于${min},小于${max}`,
|
});
|
return false;
|
}
|
} else if (leftHand == "(" && rightHand == "]") {
|
if (Number(sdkArgItem.min) <= min || Number(sdkArgItem.max) > max) {
|
sdkArgItem.valid = false;
|
|
this.$notify({
|
type: "warning",
|
message: `参数区间设定值须大于${min},小于等于${max}`,
|
});
|
return false;
|
}
|
} else if (leftHand == "[" && rightHand == "]") {
|
if (
|
Number(sdkArgItem.min) < min ||
|
Number(sdkArgItem.max) > max ||
|
Number(sdkArgItem.min) > max ||
|
Number(sdkArgItem.max) < min
|
) {
|
sdkArgItem.valid = false;
|
this.showErrorColor(e);
|
this.$notify({
|
type: "warning",
|
message: `参数区间设定值须大于等于${min},小于等于${max}`,
|
});
|
return false;
|
}
|
}
|
}
|
}
|
e.currentTarget.style.borderColor = "";
|
return true;
|
},
|
showErrorColor(e) {
|
this.$nextTick(() => {
|
e.currentTarget.style.borderColor = "red";
|
});
|
},
|
setSdksOptions(rule) {
|
rule.sdksOptions = this.includeSdks;
|
},
|
setOperator(rule) {
|
rule.operator = rule.operatorObj.value;
|
rule.operatorDesc = rule.operatorObj.name;
|
},
|
setValue(rule) {
|
rule.valid = true;
|
|
if (rule.operator_type === "option") {
|
rule.sdk_arg_value = rule.valueObj.value ? rule.valueObj.value : "";
|
rule.typeDesc = "被选项";
|
rule.valueDesc = rule.valueObj.name ? rule.valueObj.name : "";
|
} else {
|
rule.typeDesc = "值";
|
rule.valueDesc = rule.sdk_arg_value;
|
}
|
this.valideArgValue(rule);
|
},
|
selectPolygonOption(rule) {
|
rule.polygon_id = rule.polygonObj.polygonId
|
? rule.polygonObj.polygonId
|
: rule.polygon_id;
|
rule.camera_id = rule.polygonObj.cameraId
|
? rule.polygonObj.cameraId
|
: rule.camera_id;
|
rule.group_id = this.group_id;
|
console.log(9799898);
|
this.$forceUpdate();
|
},
|
//选择算法 resetArgs为true是添加为false是初始化编辑
|
selectSDKOption(sdkItem, resetArgs) {
|
//sdkItem.sdk_id = sdkItem.sdkObj.id;
|
if (resetArgs) {
|
sdkItem.argDef = JSON.parse(sdkItem.sdkObj.argDef);
|
//取出默认参数
|
sdkItem.defaultArg = sdkItem.argDef.filter(
|
(arg) => !arg.config.isOptional
|
);
|
//赋默认operator/值
|
sdkItem.defaultArg.forEach((arg) => {
|
if (arg.operators.length == 1) {
|
this.$set(arg, "operator", arg.operators[0].operator);
|
|
if (arg.operators[0].operator == "range") {
|
//区间值的处理
|
//this.$set(arg, 'sdk_arg_value', arg.min+','+arg.max)
|
//this.$set(arg, 'sdk_arg_value', arg.range.substring(1,arg.range.length-1));
|
}
|
}
|
|
if (arg.type == "option") {
|
this.setOptArgValueOptions(arg);
|
}
|
if (arg.default_value) {
|
//arg.sdk_arg_value = arg.default_value
|
this.$set(arg, "sdk_arg_value", arg.default_value);
|
}
|
});
|
sdkItem.defaultArg;
|
//取出可选参数
|
sdkItem.optionalArg = sdkItem.argDef.filter(
|
(arg) => arg.config.isOptional
|
);
|
sdkItem.optNames = sdkItem.optionalArg.map((arg) => ({
|
name: arg.name,
|
sort: arg.sort,
|
isSelected: false,
|
}));
|
|
sdkItem.initAddOptional = sdkItem.optionalArg.length > 0 ? true : false;
|
sdkItem.optArg = [];
|
}
|
|
//添加场景时,如果场景名称为空,就将选择的第一个算法名同步到场景名称
|
if (this.sdkGroup[0] && resetArgs) {
|
this.$emit("sdkNameChange", this.sdkGroup[0].sdkObj.sdk_name);
|
}
|
|
// 选项切换时需要刷新arg菜单项
|
this.selectArgTypeOption(sdkItem, resetArgs);
|
},
|
|
selectArgTypeOption(rule, resetAlias) {
|
if (rule.sdk_arg_type == "") {
|
return;
|
}
|
|
if (resetAlias) {
|
rule.sdk_arg_alias = "";
|
}
|
|
rule.argsOptions = rule.sdkObj.args;
|
|
rule.argObj = {};
|
},
|
//选择算法配置
|
selOperator(rule) {},
|
selectArgsOption(rule, resetArgValue) {
|
// rule.operator_type = "";
|
// console.log(rule, '选择算法参数')
|
rule.sdk_arg_alias = rule.argObj.alias;
|
rule.argDesc = rule.argObj.name;
|
rule.sdk_arg_defaultValue = rule.argObj.default_value;
|
rule.unit = rule.argObj.unit ? rule.argObj.unit : "";
|
//rule.default_value = rule.argObj.default_value ? Number(rule.argObj.default_value) : 0;
|
|
//console.log("置信度的默认值为",rule.sdk_arg_defaultValue)
|
// 保存值类型
|
rule.argType = rule.argObj.type;
|
if (rule.argType === "option") {
|
rule.operator_type = "option";
|
// 设置默认条件值
|
this.VideoManageData.Dictionary.RULECOMPUTE.forEach((opt) => {
|
if (opt.value == "==") {
|
rule.operatorObj = opt;
|
}
|
});
|
|
this.setOperator(rule);
|
|
this.selectValueOption(rule);
|
} else {
|
// 设置默认条件值
|
rule.operator_type = "value";
|
if (resetArgValue) {
|
rule.sdk_arg_value = "";
|
|
this.VideoManageData.Dictionary.RULECOMPUTE.forEach((opt) => {
|
if (opt.value == ">=") {
|
rule.operatorObj = opt;
|
}
|
});
|
} else {
|
// 编辑规则匹配
|
this.VideoManageData.Dictionary.RULECOMPUTE.forEach((opt) => {
|
if (opt.value == rule.operator) {
|
rule.operatorObj = opt;
|
}
|
});
|
}
|
this.setOperator(rule);
|
}
|
},
|
selectValueOption(rule) {
|
if (rule.sdk_arg_alias === "time_rule") {
|
rule.valueOptions = this.VideoManageData.TimeRules.map((r) => {
|
return {
|
name: r.name,
|
value: r.id,
|
};
|
});
|
} else if (rule.sdk_arg_alias === "compareBase") {
|
rule.valueOptions = this.VideoManageData.TagList.map((r) => {
|
return {
|
name: r.tableName,
|
value: r.id,
|
};
|
});
|
} else {
|
let ops = this.VideoManageData.Dictionary[rule.sdk_arg_alias];
|
if (ops && ops instanceof Array) {
|
rule.valueOptions = ops.map((r) => {
|
return {
|
name: r.name,
|
value: r.value,
|
};
|
});
|
}
|
}
|
},
|
|
valideArgValue(rule) {
|
if (rule.sdk_arg_value == "") {
|
this.$notify({
|
type: "warning",
|
message: "参数设定值不能为空!",
|
});
|
rule.valid = false;
|
return false;
|
}
|
|
if (rule.argObj && rule.argObj.range) {
|
// 如果设置了算法默认值，则判断不能小于该值
|
if (rule.argObj.default_value) {
|
if (
|
parseInt(rule.sdk_arg_value) < parseInt(rule.sdk_arg_defaultValue)
|
) {
|
rule.valid = false;
|
this.$notify({
|
type: "warning",
|
message:
|
"参数设定值不能小于算法参数默认值 " + rule.sdk_arg_defaultValue,
|
});
|
rule.valueDesc = rule.sdk_arg_value = rule.argObj.default_value;
|
rule.valid = false;
|
return false;
|
}
|
}
|
|
// let re = /(?<=,).*?(?=]|\))/
|
let re = /.*,(\d+)/;
|
let max = rule.argObj.range.match(re)[1];
|
// console.log(max,'获取范围最大值')
|
if (Number(rule.sdk_arg_value) > Number(max)) {
|
rule.valid = false;
|
this.$notify({
|
type: "warning",
|
message: "参数设定值不能大于" + max,
|
});
|
return false;
|
}
|
}
|
|
return true;
|
},
|
parataxis(rule_with_pre) {
|
let relation = "";
|
this.VideoManageData.Dictionary.RULECOMPUTEBETWEEN.forEach((pre) => {
|
if (pre.value === rule_with_pre) {
|
relation = pre.name;
|
}
|
});
|
|
return relation;
|
},
|
|
generatDescription() {
|
let desc = "";
|
this.groupRules.forEach((r, index) => {
|
// console.log(r,index,'拼接')
|
if (index === 0) {
|
desc += r.sdkDesc + r.argDesc + r.operatorDesc + r.valueDesc + r.unit;
|
} else {
|
desc +=
|
" " +
|
this.parataxis(r.rule_with_pre) +
|
" " +
|
r.sdkDesc +
|
r.argDesc +
|
r.operatorDesc +
|
r.valueDesc +
|
r.unit;
|
}
|
});
|
// console.log(desc,'拼接')
|
return desc;
|
},
|
createRule() {
|
if (!this.isTemplate && this.Cameras.length > 0) {
|
// 未选中摄像机或者未选中摄像机任务，不执行创建
|
if (!this.Cameras[0].cameraId) return false;
|
}
|
this.group_id = "";
|
//this.addRule(0);
|
},
|
|
//清空配置并初始化
|
cleanRule() {
|
this.group_id = "";
|
this.sdkGroup.splice(0, this.sdkGroup.length);
|
this.addSdkItem();
|
},
|
addRule(index) {
|
let newRule = JSON.parse(JSON.stringify(this.baseRule));
|
newRule.sdksOptions = this.includeSdks;
|
if (!this.isLinkRule) {
|
// 设置默认全部区域
|
// if (!this.isTemplate) {
|
// newRule.polygonObj = this.allPolygonData[0];
|
// this.selectPolygonOption(newRule)
|
// }
|
// 设置算法
|
// newRule.sdksOptions = this.includeSdks;
|
// 设置默认算法
|
// newRule.sdkObj = newRule.sdksOptions[0]
|
// this.selectSDKOption(newRule, false)
|
// newRule.sdk_arg_type = "target"
|
// this.selectArgTypeOption(newRule, true)
|
}
|
|
// this.groupRules.push(newRule);
|
// 插入到指定位置
|
this.groupRules.splice(index + 1, 0, newRule);
|
},
|
editHandle(ruleTxt) {
|
this.getSdkConnection();
|
// if (ruleTxt.length < 1) {
|
// return
|
// }
|
let ruleInfo = JSON.parse(ruleTxt);
|
|
this.editRule(ruleInfo);
|
// 如果是联动任务, 查询联动摄像机列表, 将树选中的列表更改为该条规则所需要的摄像机, 并备份当前的选中状态, 规则保存后恢复
|
// if (this.isLinkRule) {
|
// this.VideoRuleData.treeSelectedNodesBackupOnEditLinkRule = [...this.TreeDataPool.selectedNodes]
|
// this.VideoRuleData.editLinkRuleRow = { ...ruleInfo }
|
|
// this.TreeDataPool.selectedNodes = ruleInfo.group_rules.map(r => {
|
// return r.camera_id
|
// })
|
// this.$nextTick(() => {
|
// setTimeout(() => {
|
// this.editRule(ruleInfo)
|
// }, 1000)
|
// })
|
// } else {
|
// this.editRule(ruleInfo)
|
// }
|
},
|
editRule(ruleGroup) {
|
this.sdkGroup = [];
|
this.group_id = "";
|
|
ruleGroup.forEach((rule) => {
|
let tempObj = {};
|
|
if (rule.group_id && rule.group_id != "") {
|
this.group_id = rule.group_id;
|
}
|
|
// 填充区域选项列表
|
this.allPolygonData.forEach((p) => {
|
if (p.polygonId === rule.polygon_id) {
|
rule.polygonObj = p;
|
}
|
});
|
|
if (!rule.polygonObj) {
|
rule.polygonObj = {
|
cameraId: rule.camera_id,
|
defence_state: 1,
|
name: "未知区域",
|
polygonId: rule.polygon_id,
|
};
|
}
|
|
// 设置区域
|
this.selectPolygonOption(rule);
|
|
//算法对象,算法参数配置数组,(用于数据处理的)默认参数数组, 可选参数数组, 已配置的可选参数数组, (用于去重判断)存放可选参数名的数组
|
let sdkObj = {},
|
argDef = [],
|
defaultArg = [],
|
optionalArg = [],
|
optArg = [],
|
optNames = [];
|
|
sdkObj = this.TaskMange.list1.find((sdk) => sdk.id == rule.sdk_id);
|
|
argDef = JSON.parse(sdkObj.argDef);
|
|
defaultArg = argDef.filter((arg) => !arg.config.isOptional);
|
optionalArg = argDef.filter((arg) => arg.config.isOptional);
|
|
rule.sdk_set.forEach((arg) => {
|
let optItem = optionalArg.find((oarg) => {
|
if (oarg.sort == arg.sort) {
|
return oarg;
|
}
|
});
|
if (optItem) {
|
//if (optItem.operators.length > 1) {
|
optItem.operator = arg.operator;
|
//this.selOperator(optItem)
|
//}
|
|
//赋值
|
optItem.sdk_arg_value = arg.sdk_arg_value;
|
//if(arg.sdk_arg_value.indexOf(',')>0){
|
//判断是否是多选值类型的参数
|
let isMultiOne = optionalArg.find(
|
(oarg) => oarg.sort == optItem.sort && optItem.config.isMulti
|
);
|
if (isMultiOne) {
|
optItem.sdk_arg_value = arg.sdk_arg_value.split(",");
|
}
|
|
if (optItem.type == "option") {
|
this.setOptArgValueOptions(optItem);
|
}
|
if (optItem.alias == "bForceSend") {
|
}
|
//在push之前,需要判断是否配置了这个可选项 在sdk_set配置数组里,
|
|
optArg.push(optItem);
|
} else {
|
defaultArg.forEach((d) => {
|
if (d.sort == arg.sort) {
|
if (arg.sdk_arg_value.indexOf("|") > 0) {
|
//区间值
|
d.min = arg.sdk_arg_value.split("|")[0];
|
d.max = arg.sdk_arg_value.split("|")[1];
|
d.operator = "range";
|
//} else if(arg.sdk_arg_value.indexOf(',') > 0){
|
} else if (arg.operator_type == "option") {
|
//多选类型的值
|
d.sdk_arg_value = arg.sdk_arg_value.split(",");
|
this.setOptArgValueOptions(d);
|
} else {
|
d.sdk_arg_value = arg.sdk_arg_value;
|
}
|
d.operator = arg.operator;
|
}
|
});
|
}
|
});
|
optNames = optionalArg.map((arg) => ({
|
name: arg.name,
|
sort: arg.sort,
|
isSelected: false,
|
}));
|
|
tempObj = {
|
sdkObj,
|
polygonObj: rule.polygonObj,
|
rule_with_pre: rule.rule_with_pre,
|
is_save_anyhow: rule.is_save_anyhow,
|
isSpread: true,
|
argDef,
|
initAddOptional: false,
|
optionalArg,
|
optArg,
|
defaultArg,
|
optNames,
|
isAddable: true,
|
camera_id: rule.camera_id,
|
polygon_id: rule.polygon_id,
|
};
|
//回显是否显示添加可选参数
|
tempObj.initAddOptional =
|
tempObj.optArg.length == 0 && tempObj.optionalArg.length > 0
|
? true
|
: false;
|
//回显是否显示可选参数添加按钮
|
if (tempObj.optArg.length < tempObj.optionalArg.length) {
|
tempObj.isAddable = true;
|
} else {
|
tempObj.isAddable = false;
|
}
|
//this.selectSDKOption(tempObj, false)
|
|
this.sdkGroup.push(tempObj);
|
//设置算法
|
});
|
//this.$nextTick(() => {})
|
},
|
delRule(rule) {
|
this.$confirm("提示：删除后，该条规则将失效，是否删除？", {
|
center: true,
|
cancelButtonClass: "comfirm-class-cancle",
|
confirmButtonClass: "comfirm-class-sure",
|
})
|
.then(() => {
|
deleteCameraRules({ groupId: rule.group_id }).then((res) => {
|
if (res && res.success) {
|
this.$notify({
|
type: "success",
|
message: "删除成功",
|
});
|
this.$emit("delete-rule");
|
} else {
|
this.$notify({
|
type: "error",
|
message: "删除失败！",
|
});
|
}
|
});
|
})
|
.catch(() => {});
|
},
|
submitRule() {
|
let groupRule = { rules: [] };
|
|
let group_text = "";
|
let validateFlag = false;
|
|
if (this.isTemplate) {
|
groupRule.rules = this.groupRules.map((r) => {
|
return {
|
sdk_id: r.sdk_id,
|
sdk_arg_alias: r.sdk_arg_alias,
|
operator: r.operator,
|
operator_type: r.operator_type,
|
sdk_arg_value: r.sdk_arg_value,
|
sort: 1,
|
rule_with_pre: r.rule_with_pre,
|
};
|
});
|
} else {
|
//校验必填项
|
let undefinished = this.sdkGroup.some((sdk, index) => {
|
//没有配置算法
|
if (Object.keys(sdk.sdkObj).length == 0) {
|
return sdk;
|
}
|
//复制算法时检测区域不能为空
|
if (!sdk.polygon_id) {
|
return sdk;
|
}
|
|
//多于两项算法时,算法关系不能为空
|
if (sdk.rule_with_pre === "" && index != 0) {
|
return sdk;
|
}
|
|
//处理未展示的参数的值
|
sdk.defaultArg.forEach((arg) => {
|
if (!arg.config.isShow) {
|
arg.sdk_arg_value = arg.default_value;
|
}
|
});
|
//表单提交前校验:所有算法的参数值不能为空,(有range的,要在range范围内)失焦时校验
|
let defaultArgFlag = sdk.defaultArg.find((arg) => {
|
if (arg.sdk_arg_value instanceof Array) {
|
if (arg.sdk_arg_value.length == 0) {
|
return arg;
|
}
|
} else if (!arg.sdk_arg_value) {
|
return arg;
|
}
|
});
|
if (defaultArgFlag) {
|
return sdk;
|
}
|
//查找可选参数值是否都设置(多选值为数组类型)
|
let optionalArgFlag = sdk.optArg.find((arg) => {
|
if (arg.sdk_arg_value instanceof Array) {
|
if (arg.sdk_arg_value.length == 0) {
|
return arg;
|
}
|
} else {
|
//区间类参数值最小,最大值是否都设置
|
if (arg.operator == "range") {
|
if (!arg.min.trim() && arg.max.trim()) {
|
return arg;
|
}
|
}
|
if (!arg.sdk_arg_value) {
|
return arg;
|
}
|
}
|
});
|
|
if (optionalArgFlag) {
|
return sdk;
|
}
|
});
|
|
if (undefinished) {
|
this.$notify({
|
type: "error",
|
message: "算法参数未完善,请完善后再保存",
|
});
|
return false;
|
}
|
//校验区间左侧值是否小于右侧值
|
let illegalRange = this.sdkGroup.some((sdk, index) => {
|
let rangeArg = sdk.defaultArg.find((arg) => arg.operator == "range");
|
if (rangeArg) {
|
if (Number(rangeArg.max) <= Number(rangeArg.min)) {
|
return sdk;
|
}
|
}
|
});
|
if (illegalRange) {
|
this.$notify({
|
type: "error",
|
message: "区间左侧不能大于或等于区间右侧的值",
|
});
|
return false;
|
}
|
//校验若算法关系为触发,则算法名不能重
|
let sameSdk = this.sdkGroup.some((sdk, index) => {
|
if (
|
sdk.index != 0 &&
|
(sdk.rule_with_pre == "=>" || sdk.rule_with_pre == "!=>")
|
) {
|
if (sdk.sdkObj.id == this.sdkGroup[index - 1].sdkObj.id) {
|
return sdk;
|
}
|
}
|
});
|
|
if (sameSdk) {
|
this.$notify({
|
type: "error",
|
message: "算法关系为触发时,算法名不能重复",
|
});
|
return false;
|
}
|
|
if (!validateFlag && !sameSdk) {
|
validateFlag = true;
|
}
|
|
this.sdkGroup.forEach((sdk) => {
|
let tempObj = {
|
sdk_id: sdk.sdkObj.id,
|
camera_id: sdk.camera_id,
|
group_id: "",
|
is_save_anyhow: sdk.is_save_anyhow,
|
polygon_id: sdk.polygon_id,
|
rule_with_pre: sdk.rule_with_pre,
|
sdk_set: [],
|
};
|
|
let defaultArgs = sdk.defaultArg.map((arg) => ({
|
operator: arg.operator,
|
operator_type: arg.type,
|
sdk_arg_alias: arg.alias,
|
sdk_arg_value: arg.sdk_arg_value,
|
sort: arg.sort,
|
}));
|
|
let defaultArgDesc = "( ";
|
sdk.defaultArg.forEach((arg) => {
|
//不显示隐藏的参数配置
|
if (!arg.config.isShow) {
|
return;
|
}
|
let val = "";
|
//处理下拉选值类型
|
if (arg.type == "option") {
|
if (arg.sdk_arg_value instanceof Array) {
|
//多选值
|
let multiNames = "";
|
arg.sdk_arg_value.forEach((val) => {
|
let opV = arg.valueOptions.find((opt) => opt.value == val);
|
multiNames += opV.name + " ";
|
});
|
val = multiNames;
|
} else {
|
let res = arg.valueOptions.find(
|
(opt) => opt.value == arg.sdk_arg_value
|
);
|
val = res.name;
|
}
|
}
|
if (arg.operator == "range") {
|
let valRange = "";
|
|
valRange = arg.sdk_arg_value.replace(",", "-");
|
defaultArgDesc += `${arg.name}${
|
arg.operators[0].name
|
}${valRange}${arg.unit || ""}, `;
|
} else {
|
defaultArgDesc += `${arg.name}${arg.operators[0].name}${
|
arg.type == "option" ? val : arg.sdk_arg_value
|
}${arg.unit || ""}, `;
|
}
|
});
|
defaultArgDesc = defaultArgDesc.substring(
|
0,
|
defaultArgDesc.length - 2
|
);
|
|
//defaultArgDesc = defaultArgDesc.substring(0,defaultArgDesc.length-3)+defaultArgDesc.substring(defaultArgDesc.length-1,defaultArgDesc.length);
|
//defaultArgDesc = defaultArgDesc.substring(0,defaultArgDesc.length-1);
|
|
//处理可选项参数
|
|
let optArgs = sdk.optArg.map((arg) => ({
|
operator: arg.operator,
|
operator_type: arg.type,
|
sdk_arg_alias: arg.alias,
|
sdk_arg_value: arg.sdk_arg_value,
|
sort: arg.sort,
|
}));
|
//将多选项的值拼成字符串
|
optArgs.forEach((one) => {
|
if (one.sdk_arg_value instanceof Array) {
|
one.sdk_arg_value = one.sdk_arg_value.join();
|
}
|
});
|
let optArgDesc = " ";
|
sdk.optArg.forEach((arg) => {
|
let val = "";
|
let valRange = "";
|
|
//处理下拉选值类型
|
if (arg.type == "option") {
|
if (arg.sdk_arg_value instanceof Array) {
|
//多选值
|
let multiNames = "";
|
arg.sdk_arg_value.forEach((val) => {
|
let opV = arg.valueOptions.find((opt) => opt.value == val);
|
multiNames += opV.name + " ";
|
});
|
val = multiNames;
|
} else {
|
let res = arg.valueOptions.find(
|
(opt) => opt.value == arg.sdk_arg_value
|
);
|
|
val = res.name;
|
}
|
}
|
|
let operatorSelected = arg.operators.find(
|
(opr) => opr.operator == arg.operator
|
);
|
optArgDesc += `,${arg.name}${operatorSelected.name}${
|
arg.type == "option" ? val : arg.sdk_arg_value
|
}${arg.unit || ""}, `;
|
});
|
//将多选项的值拼成字符串
|
defaultArgs.forEach((one) => {
|
if (one.sdk_arg_value instanceof Array) {
|
one.sdk_arg_value = one.sdk_arg_value.join();
|
}
|
});
|
optArgDesc =
|
optArgDesc.substring(0, optArgDesc.length - 2) +
|
optArgDesc.substring(optArgDesc.length - 1, optArgDesc.length);
|
optArgDesc += ")";
|
tempObj.sdk_set = defaultArgs.concat(optArgs);
|
|
groupRule.rules.push(tempObj);
|
|
let rule_with_pre = "";
|
if (sdk.rule_with_pre) {
|
switch (sdk.rule_with_pre) {
|
case "&&":
|
rule_with_pre = " and ";
|
break;
|
case "||":
|
rule_with_pre = " or ";
|
break;
|
case "=>":
|
rule_with_pre = " -> ";
|
break;
|
case "!=>":
|
rule_with_pre = " !-> ";
|
break;
|
default:
|
rule_with_pre = "";
|
}
|
}
|
group_text += `${
|
rule_with_pre ? "<br/>" + rule_with_pre + "<br/>" : ""
|
} <span style="background-color:RGB(183,183,183);">${
|
sdk.sdkObj.sdk_name
|
}</span> ${sdk.polygonObj.name} ${defaultArgDesc}${optArgDesc}`;
|
|
if (
|
group_text.charAt(group_text.length - 3) == "," &&
|
group_text.charAt(group_text.length - 2) == " " &&
|
group_text.charAt(group_text.length - 1) == ")"
|
) {
|
group_text =
|
group_text.substring(0, group_text.length - 3) +
|
group_text.substring(group_text.length - 2, group_text.length);
|
}
|
});
|
}
|
|
groupRule.text = group_text;
|
groupRule.id = this.group_id;
|
return groupRule;
|
},
|
},
|
};
|
</script>
|
|
<style lang="scss">
|
body {
|
font-size: 12px;
|
}
|
.edit-rules-box {
|
width: 100%;
|
padding: 0px;
|
box-sizing: border-box;
|
.sub-rules-box {
|
width: 71%;
|
min-width: 1127.4px;
|
min-height: 50px;
|
border-top: 1px solid #eee;
|
padding-top: 7px;
|
|
box-sizing: border-box;
|
padding-bottom: 38px;
|
.task-rules-button {
|
text-align: right;
|
margin: 15px;
|
}
|
.config-item {
|
background: #f8f9f8;
|
padding: 15px 25px;
|
margin-bottom: 52px;
|
position: relative;
|
.el-select {
|
width: 225px !important;
|
}
|
.init-sdk {
|
margin-right: 30px;
|
}
|
.connection {
|
background: #fff;
|
position: absolute;
|
width: 100%;
|
top: -40px;
|
}
|
.top-line {
|
height: 30px;
|
.left {
|
float: left;
|
display: flex;
|
}
|
.right {
|
float: right;
|
cursor: pointer;
|
.del {
|
margin-right: 10px;
|
color: rgb(231, 76, 60);
|
}
|
.collapse {
|
font-size: 13px;
|
display: inline-block;
|
padding: 5px;
|
cursor: pointer;
|
}
|
}
|
}
|
.argums {
|
position: relative;
|
// width: calc(100% - 25px);
|
// top: 43px;
|
// left: 0;
|
// padding-left: 25px;
|
// background: #f8f9f8;
|
.argums-item {
|
display: flex;
|
align-items: center;
|
margin: 7px 0;
|
.arg-name,
|
.operator-name {
|
margin-right: 30px;
|
}
|
.arg-val {
|
width: 245px;
|
span {
|
margin-left: 6px;
|
}
|
.range-min,
|
.range-max {
|
width: 88px;
|
.el-input__inner {
|
height: 28px;
|
}
|
}
|
.devide {
|
display: inline-block;
|
width: 30px;
|
height: 1px;
|
background: #c5c5c5;
|
vertical-align: top;
|
margin: 14px 10px 0;
|
}
|
}
|
}
|
.el-input {
|
width: 225px;
|
}
|
}
|
}
|
.btn-add {
|
margin: 0 25px 15px;
|
margin-top: -38px;
|
.el-button {
|
width: 370px;
|
cursor: pointer;
|
}
|
}
|
}
|
|
.el-button--text {
|
text-decoration: unset;
|
}
|
.el-input.is-disabled .el-input__inner {
|
background: #fafafa;
|
color: #606266;
|
}
|
p {
|
text-align: left;
|
// padding: 10px;
|
box-sizing: border-box;
|
}
|
|
.task-blank {
|
float: left;
|
font-family: PingFangSC-Regular;
|
font-size: 12px;
|
color: #cccccc;
|
margin-top: 5px;
|
}
|
|
.btn {
|
cursor: pointer;
|
color: #3d68e1;
|
margin-left: 10px;
|
font-size: 14px;
|
}
|
}
|
</style>
|
