<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 style="margin-left:10px;margin-top: 4px;" v-show="index > 0">
|
<el-select v-model="rule.rule_with_pre" placeholder="并列关系" size="mini">
|
<el-option
|
v-for="subitem in VideoManageData.Dictionary.RULECOMPUTEBETWEEN"
|
:key="subitem.id"
|
:label="subitem.name"
|
:value="subitem.value"
|
:title="subitem.name"
|
></el-option>
|
</el-select>
|
</div>-->
|
<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="&&" 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 == '=>'"
|
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-input
|
v-model="arg.name"
|
size="mini"
|
:disabled="true"
|
></el-input>-->
|
<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-input
|
v-if="arg.operators.length == 1"
|
v-model="arg.operators[0].operator"
|
:disabled="true"
|
size="mini"
|
></el-input>-->
|
<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-input
|
v-model="optArgItem.operators[0].operator"
|
:disabled="true"
|
size="mini"
|
></el-input>-->
|
|
<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
|
}
|
},
|
// computed: {
|
// allPolygonData() {
|
// let polygon = []
|
// let cameras = [...this.Cameras]
|
|
// 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)
|
// }
|
// //添加场景初始化区域选项为'全部区域'
|
// if (polygon.length > 0 && this.ruleList.length == 0) {
|
// this.polygonObj = polygon[0];
|
// this.sdkGroup[0].polygonObj = JSON.parse(JSON.stringify(this.polygonObj));
|
// this.selectPolygonOption(this.sdkGroup[0])
|
// }
|
// return polygon
|
// }
|
// },
|
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) {
|
debugger
|
newV.forEach(sdk => {
|
let rangeOne = sdk.defaultArg.find(
|
arg => arg.operators[0].operator == 'range'
|
)
|
if (rangeOne) {
|
debugger
|
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
|
}
|
// ruleList: {
|
// handler(newVal, oldVal) {
|
// debugger
|
// this.editHandle(newVal)
|
// }
|
|
// }
|
},
|
mounted() {
|
this.TaskMange.findAllSdk({ installed: true })
|
//this.TaskMange.list1 = sdkJson.data;
|
|
//this.editHandle(this.ruleList)
|
},
|
data() {
|
return {
|
// rule: {
|
// sdk_id:'',
|
// sdkObj: {},
|
// polygonObj: {},
|
// argDef: []
|
// },
|
hideDel: true,
|
//isAddable: 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: {
|
selConnection(sdkItem) {
|
debugger
|
|
},
|
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) {
|
debugger
|
// 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) {
|
debugger
|
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)))
|
}
|
})
|
|
console.log(argObj.valueOptions)
|
},
|
setOptArgValueOptions(optArg) {
|
debugger
|
let alias = optArg.alias;
|
console.log(this.VideoManageData.Dictionary[alias])
|
optArg.valueOptions = this.VideoManageData.Dictionary[alias].map(r => {
|
return {
|
name: r.name,
|
value: r.value
|
}
|
});
|
},
|
validateArgVal(sdkArgItem, e) {
|
debugger
|
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])
|
debugger
|
|
//判断非区间类
|
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) {
|
debugger
|
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
|
},
|
//选择算法 resetArgs为true是添加为false是初始化编辑
|
selectSDKOption(sdkItem, resetArgs) {
|
debugger
|
//sdkItem.sdk_id = sdkItem.sdkObj.id;
|
if (resetArgs) {
|
sdkItem.argDef = JSON.parse(sdkItem.sdkObj.argDef)
|
console.log(sdkItem.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') {
|
//区间值的处理
|
debugger
|
//this.$set(arg, 'sdk_arg_value', arg.min+','+arg.max)
|
//this.$set(arg, 'sdk_arg_value', arg.range.substring(1,arg.range.length-1));
|
}
|
}
|
debugger
|
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
|
}))
|
debugger
|
sdkItem.initAddOptional = sdkItem.optionalArg.length > 0 ? true : false
|
sdkItem.optArg = []
|
}
|
|
//添加场景时,如果场景名称为空,就将选择的第一个算法名同步到场景名称
|
if (this.sdkGroup[0] && resetArgs) {
|
debugger
|
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
|
|
// 根据arg类型显示参数, 当前全部归为 target
|
// if (rule.sdkObj.args) {
|
// rule.argsOptions = rule.sdkObj.args.filter(ele => {
|
// return ele.arg_type === rule.sdk_arg_type
|
// });
|
// } else {
|
// rule.argsOptions = [];
|
// }
|
|
rule.argObj = {}
|
},
|
//选择算法配置
|
selOperator(rule) {
|
debugger
|
},
|
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) {
|
debugger
|
// 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) {
|
debugger
|
this.sdkGroup = []
|
this.group_id = ''
|
|
// this.sdkGroup = ruleGroup;
|
// sdkGroup: [
|
// {
|
// sdkObj: {},
|
// polygonObj: {},
|
// is_save_anyhow: true,
|
// isSpread: true,
|
// argDef: [],
|
// initAddOptional: false,
|
// defaultArg: [],
|
// optionalArg: [],
|
// optArg: [],
|
// optNames: []
|
// }
|
// ],
|
ruleGroup.forEach(rule => {
|
debugger
|
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
|
}
|
}
|
console.log(rule)
|
|
// 设置区域
|
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)
|
debugger
|
defaultArg = argDef.filter(arg => !arg.config.isOptional)
|
optionalArg = argDef.filter(arg => arg.config.isOptional)
|
//过滤掉rule.sdk_set里没有出现的可选配置项
|
let isConfiged = false;
|
let configedAlias = [];
|
optionalArg.forEach(optArg=>{
|
rule.sdk_set.forEach(sdkSet => {
|
if(sdkSet.sdk_arg_alias == optArg.alias){
|
isConfiged = true;
|
configedAlias.push(optArg)
|
}
|
})
|
});
|
if(!isConfiged){
|
optionalArg = [];
|
}
|
if(isConfiged){
|
optionalArg = configedAlias
|
}
|
rule.sdk_set.forEach(sdkSet => {
|
rule.sdk_set
|
})
|
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配置数组里,
|
debugger
|
optArg.push(optItem)
|
|
} else {
|
defaultArg.forEach(d => {
|
if (d.sort == arg.sort) {
|
|
if (arg.sdk_arg_value.indexOf('|') > 0) {
|
debugger
|
//区间值
|
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'){
|
debugger
|
//多选类型的值
|
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)
|
debugger
|
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() {
|
debugger
|
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) => {
|
debugger
|
//没有配置算法
|
if (Object.keys(sdk.sdkObj).length == 0) {
|
return sdk
|
}
|
//多于两项算法时,算法关系不能为空
|
if (sdk.rule_with_pre === '' && index != 0) {
|
return sdk
|
}
|
debugger
|
//处理未展示的参数的值
|
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') {
|
debugger
|
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) => {
|
debugger
|
if (sdk.index != 0 && sdk.rule_with_pre == '=>') {
|
debugger
|
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 = '';
|
debugger
|
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 || ''}, `
|
}
|
|
});
|
debugger;
|
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
|
default:
|
rule_with_pre = ''
|
}
|
}
|
debugger;
|
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)
|
}
|
debugger
|
})
|
console.log(group_text)
|
}
|
|
groupRule.text = group_text
|
groupRule.id = this.group_id
|
return groupRule
|
|
if (this.isLinkRule) {
|
// 判断规则中至少包含两摄像机
|
let cameraIds = Array.from(
|
new Set(
|
this.sdkGroup.map(r => {
|
return r.camera_id
|
})
|
)
|
)
|
if (cameraIds.length < 2) {
|
this.$notify({
|
type: 'error',
|
//message: '需要2个不同摄像机才能组成联动规则'
|
message: '需要至少2个不同摄像机才能组成联动场景'
|
})
|
return
|
}
|
|
// 联动规则编辑后，恢复之前选中的摄像机
|
// if (this.VideoRuleData.treeSelectedNodesBackupOnEditLinkRule.length) {
|
// this.TreeDataPool.selectedNodes = this.VideoRuleData.treeSelectedNodesBackupOnEditLinkRule
|
// this.VideoRuleData.treeSelectedNodesBackupOnEditLinkRule = []
|
// }
|
}
|
//if(validateFlag){
|
this.onSubmitRule(payload)
|
//}
|
}
|
}
|
}
|
</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>
|
