控制轮询

ZZJ

2022-07-15 a3f357e8a60443b74b64c7479113c68eb35ce1f5

 src/pages/cameraAccess/components/scene/Editor.vue

@@ -1,10 +1,10 @@
<template>

  <div class="edit-rules-box">

    <p style="padding: 0">

      <b style="font-size: 14px; line-height: 28px;">策略配置</b>

      <b style="font-size: 14px; line-height: 28px">策略配置</b>

    </p>

    <div class="sub-rules-box">

      <div style=" text-align: left;">

      <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

@@ -32,15 +32,26 @@
                  placeholder="选关系"

                  @change="selConnection(sdkItem)"

                >

                  <el-option value="&&" title="and/且" label="and/且"></el-option>

                  <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-option value="=>" title="—>/触发" label="—>/触发"></el-option>-->

                </el-select>

                <el-checkbox

                  v-show="sdkItem.rule_with_pre == '=>'"

                  v-show="

                    sdkItem.rule_with_pre == '=>' ||

                    sdkItem.rule_with_pre == '!=>'

                  "

                  v-model="sdkItem.is_save_anyhow"

                  style="margin-left:30px"

                >保存过程数据</el-checkbox>

                  style="margin-left: 30px"

                  >保存过程数据</el-checkbox

                >

              </div>

              <div class="top-line">

                <div class="left">

@@ -82,7 +93,11 @@
                  </div>

                </div>

                <div class="right">

                  <span class="del" v-show="!hideDel" @click="delConfigItem(index)">

                  <span

                    class="del"

                    v-show="!hideDel"

                    @click="delConfigItem(index)"

                  >

                    <i class="iconfont iconshanchu"></i>

                  </span>

                  <span class="collapse" @click="collapseLine(index)">

@@ -99,15 +114,23 @@


              <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-if="arg.config.isShow">

                  <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

                        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">

@@ -118,7 +141,7 @@
                        size="mini"

                      ></el-input>-->

                      <el-select

                        :disabled="arg.operators.length==1"

                        :disabled="arg.operators.length == 1"

                        v-model="arg.operator"

                        size="mini"

                        @change="selOperator(sdkItem)"

@@ -148,9 +171,22 @@
                        <span>{{ arg.unit }}</span>

                      </div>

                      <div v-else>

                        <el-select v-if="arg.type == 'option'" v-model="arg.sdk_arg_value">

                          <el-option>请选择</el-option>

                        <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"

@@ -168,11 +204,14 @@
                      class="optional"

                      v-if="

                        sdkItem.initAddOptional &&

                          index == sdkItem.defaultArg.length - 1

                        index == sdkItem.defaultArg.length - 1

                      "

                    >

                      <span class="btn" @click="addOptionalArg(sdkItem)">

                        <i class="iconfont iconhebingxingzhuang" style="font-size:16px"></i>

                        <i

                          class="iconfont iconhebingxingzhuang"

                          style="font-size: 16px"

                        ></i>

                      </span>

                    </div>

                  </div>

@@ -213,6 +252,7 @@
                    ></el-input>-->



                    <el-select

                      :disabled="optArgItem.operators.length == 1"

                      v-model="optArgItem.operator"

                      size="mini"

                      @change="selOperator(optArgItem)"

@@ -246,16 +286,29 @@
                      v-if="optArgItem.type == 'value'"

                      v-model="optArgItem.sdk_arg_value"

                      size="mini"

                      @blur="$event => validateArgVal(optArgItem, $event)"

                      @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

                      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

                      class="btn"

                      @click="delOptionalArg(sdkItem, optArgItem)"

                    >

                      <i

                        class="iconfont iconshanchu11"

                        style="font-size: 16px"

                      ></i>

                    </span>

                  </div>

                </div>

@@ -274,37 +327,37 @@
import {

  deleteCameraRules,

  updateRuleDefence,

  updateAlarmLevel

} from '@/api/camera'

  updateAlarmLevel,

} from "@/api/camera";



export default {

  name: 'SceneRuleEditor',

  name: "SceneRuleEditor",

  props: {

    Cameras: {

      type: Array,

      default: () => {

        return []

      }

        return [];

      },

    },

    isTemplate: {

      type: Boolean,

      default: false

      default: false,

    },

    isLinkRule: {

      type: Boolean,

      default: false

      default: false,

    },

    includeSdks: {

      type: Array

      type: Array,

    },

    ruleList: {

      type: String,

      default: ''

      default: "",

    },

    onSubmitRule: {

      type: Function,

      default: () => false

    }

      default: () => false,

    },

  },

  // computed: {

  //   allPolygonData() {

@@ -338,27 +391,25 @@
  watch: {

    Cameras: {

      handler(n, o) {

        debugger

        let polygon = []

        let cameras = [...n]

        let polygon = [];

        let cameras = [...n];



        for (let i = 0; i < cameras.length; i++) {

          let polyOpt = cameras[i].polygonData.map(p => {

          let polyOpt = cameras[i].polygonData.map((p) => {

            return {

              defence_state: p.defence_state,

              polygonId: p.id,

              name: this.isLinkRule

                ? cameras[i].cameraName + ':' + p.name

                ? cameras[i].cameraName + ":" + p.name

                : p.name,



              cameraId: cameras[i].cameraId

            }

          })

          polygon = polygon.concat(polyOpt)

              cameraId: cameras[i].cameraId,

            };

          });

          polygon = polygon.concat(polyOpt);



          this.allPolygonData = polygon

          this.allPolygonData = polygon;

          //添加场景初始化区域选项为'全部区域'

          debugger

          // if (polygon.length > 0 && this.ruleList == '') {

          //   this.polygonObj = polygon[0]

          //   this.sdkGroup[0].polygonObj = JSON.parse(

@@ -369,82 +420,57 @@
          // }

        }

      },

      deep: true

      deep: true,

    },

    sdkGroup: {

      handler(newV, oldV) {

        if (newV) {

          debugger

          newV.forEach(sdk => {

          newV.forEach((sdk) => {

            let rangeOne = sdk.defaultArg.find(

              arg => arg.operators[0].operator == 'range'

            )

              (arg) => arg.operators[0].operator == "range"

            );

            if (rangeOne) {

              debugger

              if (rangeOne.min.trim() && rangeOne.max.trim()) {

                // if (Number(rangeOne.min) >= Number(rangeOne.max)) {

                //   this.$notify({

                //     type: 'error',

                //     message: '区间左侧不能大于或等于区间右侧的值'

                //   })

                //   rangeOne.valid = false

                // }

                rangeOne.sdk_arg_value = rangeOne.min + ',' + rangeOne.max

                rangeOne.sdk_arg_value = rangeOne.min + "|" + rangeOne.max;

              } else {

                rangeOne.sdk_arg_value = false;

              }



            }

          })

          let res = newV.find(item => {

            return JSON.stringify(item.sdkObj) == '{}'

          })

          });

          let res = newV.find((item) => {

            return JSON.stringify(item.sdkObj) == "{}";

          });

          if (!res) {

            this.isAdd = true

            this.hideDel = false

            this.isAdd = true;

            this.hideDel = false;

          } else {

            this.isAdd = false

            this.isAdd = false;

            if (this.sdkGroup.length == 1) {

              this.hideDel = true

              this.hideDel = true;

            } else {

              this.hideDel = false

              this.hideDel = false;

            }

          }

        }

      },

      deep: true

    }

    // ruleList: {

    //   handler(newVal, oldVal) {

    //     debugger

    //     this.editHandle(newVal)

    //   }



    // }

      deep: true,

    },

  },

  mounted() {

    this.TaskMange.findAllSdk({installed:true})

    //this.TaskMange.list1 = sdkJson.data;

    this.TaskMange.findAllSdk({ installed: true });



    //this.editHandle(this.ruleList)

  },

  data() {

    return {

      // rule: {

      //   sdk_id:'',

      //   sdkObj: {},

      //   polygonObj: {},

      //   argDef: []

      // },

      hideDel: true,

      //isAddable: true,

      allPolygonData: [],

      group_id: '',

      group_id: "",

      baseSdkItem: {

        sdkObj: {},

        polygonObj: {},

        is_save_anyhow: true,

        rule_with_pre: '',

        rule_with_pre: "",

        isSpread: true,

        argDef: [],

        initAddOptional: false,

@@ -452,7 +478,7 @@
        optionalArg: [],

        optArg: [],

        optNames: [],

        isAddable: true

        isAddable: true,

      },

      sdkGroup: [

        {

@@ -466,33 +492,33 @@
          optionalArg: [],

          optArg: [],

          optNames: [],

          isAddable: true

        }

          isAddable: true,

        },

      ],

      polygonObj: {},

      isSpread: true,

      isAdd: false,

      tipColor: 'yellow',

      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: '',

        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: '',

        taskObj: "",



        sdkObj: {},

        argObj: {},

@@ -501,36 +527,42 @@


        sdksOptions: [],

        argsOptions: [],

        argType: '',

        argType: "",

        computeOptions: [],

        valueOptions: [],



        sdkDesc: '',

        argDesc: '',

        operatorDesc: '',

        typeDesc: '',

        valueDesc: '',

        sdkDesc: "",

        argDesc: "",

        operatorDesc: "",

        typeDesc: "",

        valueDesc: "",



        unit: '',

        value: '',

        valid: true

      }

    }

        unit: "",

        value: "",

        valid: true,

      },

    };

  },

  methods: {

    selConnection(sdkItem) {

      debugger



    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)

      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{

@@ -540,15 +572,20 @@


      //删除逻辑：当只有一个算法时，删除会回到初始状态；有多个算法时，删除既移除整个算法项

      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)

        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 = '';

        if (

          this.sdkGroup[index + 1] &&

          this.sdkGroup[index + 1].rule_with_pre

        ) {

          this.sdkGroup[index + 1].rule_with_pre = "";

        }

        


        this.sdkGroup.splice(index, 1);

      }

    },

@@ -557,29 +594,28 @@
      //   return sdk.sdk_id == sdkId;

      // });



      this.sdkGroup[index].isSpread = !this.sdkGroup[index].isSpread

      this.sdkGroup[index].isSpread = !this.sdkGroup[index].isSpread;

    },

    addOptionalArg(sdkItem) {

      debugger

      sdkItem.initAddOptional = false

      sdkItem.optArg.forEach(arg => {

        sdkItem.optNames.forEach(name => {

      sdkItem.initAddOptional = false;

      sdkItem.optArg.forEach((arg) => {

        sdkItem.optNames.forEach((name) => {

          if (arg.sort == name.sort) {

            name.isSelected = true

            name.isSelected = true;

          }

        })

      }) //找到可选sdkItem.optNames的第一个对应的sdkItem.optionalArg push到sdkItem.optArg

      let oneNotSelected = sdkItem.optNames.find(name => !name.isSelected)

        });

      }); //找到可选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 argTemp = sdkItem.optionalArg.find((arg) => {

        return arg.sort == oneNotSelected.sort;

      });



      let copyArgTemp = JSON.parse(JSON.stringify(argTemp))

      if (copyArgTemp.type == 'option') {

      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 => {

@@ -589,11 +625,15 @@
        //   }

        // })



        this.setOptArgValueOptions(copyArgTemp)

        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)

        this.$set(copyArgTemp, "sdk_arg_value", copyArgTemp.default_value);

      }

      sdkItem.optArg.push(copyArgTemp);

      if (sdkItem.optArg.length < sdkItem.optionalArg.length) {

@@ -603,13 +643,15 @@
      }

    },

    delOptionalArg(sdkItem, optArgItem) {

      let index = sdkItem.optArg.findIndex(arg => arg.sort == optArgItem.sort)

      sdkItem.optArg.splice(index, 1)

      sdkItem.optNames.forEach(name => {

      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

          name.isSelected = false;

        }

      })

      });

      sdkItem.initAddOptional = sdkItem.optArg.length == 0 ? true : false;

      if (sdkItem.optArg.length < sdkItem.optionalArg.length) {

        sdkItem.isAddable = true;

@@ -618,271 +660,274 @@
      }

    },

    selOptionalArg(sdkItem, optArgItem) {

      debugger

      let newSort = 0

      sdkItem.optNames.forEach(name => {

      let newSort = 0;

      sdkItem.optNames.forEach((name) => {

        if (name.name == optArgItem.name) {

          //新切换的参数名

          name.isSelected = true

          newSort = name.sort

          name.isSelected = true;

          newSort = name.sort;

        } else if (name.sort == optArgItem.sort) {

          //切换前的参数名

          name.isSelected = false

          name.isSelected = false;

        }

      })

      });

      //根据新的参数sort找到其对应配置对象

      let argObj = sdkItem.optionalArg.find(arg => arg.sort == newSort)

      if (argObj.type == 'option') {

      let argObj = sdkItem.optionalArg.find((arg) => arg.sort == newSort);

      if (argObj.type == "option") {

        this.setOptArgValueOptions(argObj);

      }

      debugger

      //默认选中第一个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) {

      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

          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) {

      debugger

      if (typeof (sdkArgItem.sdk_arg_value) == 'string' && sdkArgItem.sdk_arg_value == '') {

      if (

        typeof sdkArgItem.sdk_arg_value == "string" &&

        sdkArgItem.sdk_arg_value == ""

      ) {

        this.$notify({

          type: 'warning',

          message: '参数设定值不能为空!'

        })

        sdkArgItem.valid = false

          type: "warning",

          message: "参数设定值不能为空!",

        });

        sdkArgItem.valid = false;



        return 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 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

          max = Number(res[2]);



        //判断非区间类

        if (sdkArgItem.sdk_arg_value && sdkArgItem.operator != 'range') {

          if (leftHand == '(' && rightHand == ')') {

        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

              sdkArgItem.valid = false;



              this.$notify({

                type: 'warning',

                message: `参数设定值须大于${min},小于${max}`

              })

              return false

                type: "warning",

                message: `参数设定值须大于${min},小于${max}`,

              });

              return false;

            }

          } else if (leftHand == '[' && rightHand == ')') {

          } else if (leftHand == "[" && rightHand == ")") {

            if (

              Number(sdkArgItem.sdk_arg_value) < min ||

              Number(sdkArgItem.sdk_arg_value) >= max

            ) {

              sdkArgItem.valid = false

              sdkArgItem.valid = false;



              this.$notify({

                type: 'warning',

                message: `参数设定值须大于等于${min},小于${max}`

              })

              return false

                type: "warning",

                message: `参数设定值须大于等于${min},小于${max}`,

              });

              return false;

            }

          } else if (leftHand == '(' && rightHand == ']') {

          } else if (leftHand == "(" && rightHand == "]") {

            if (

              Number(sdkArgItem.sdk_arg_value) <= min ||

              Number(sdkArgItem.sdk_arg_value) > max

            ) {

              sdkArgItem.valid = false

              sdkArgItem.valid = false;



              this.$notify({

                type: 'warning',

                message: `参数设定值须大于${min},小于等于${max}`

              })

              return false

                type: "warning",

                message: `参数设定值须大于${min},小于等于${max}`,

              });

              return false;

            }

          } else if (leftHand == '[' && rightHand == ']') {

          } else if (leftHand == "[" && rightHand == "]") {

            if (

              Number(sdkArgItem.sdk_arg_value) < min ||

              Number(sdkArgItem.sdk_arg_value) > max

            ) {

              sdkArgItem.valid = false

              this.showErrorColor(e)

              sdkArgItem.valid = false;

              this.showErrorColor(e);

              this.$notify({

                type: 'warning',

                message: `参数设定值须大于等于${min},小于等于${max}`

              })

              return false

                type: "warning",

                message: `参数设定值须大于等于${min},小于等于${max}`,

              });

              return false;

            }

          }

        } else if (sdkArgItem.min || sdkArgItem.max) {

          //判断区间类

          if (leftHand == '(' && rightHand == ')') {

          if (leftHand == "(" && rightHand == ")") {

            if (

              Number(sdkArgItem.min) <= min ||

              Number(sdkArgItem.min) >= max

            ) {

              sdkArgItem.valid = false

              sdkArgItem.valid = false;



              this.$notify({

                type: 'warning',

                message: `参数区间设定值须大于${min},小于${max}`

                type: "warning",

                message: `参数区间设定值须大于${min},小于${max}`,

              });

              return false

              return false;

            }

          } else if (leftHand == '[' && rightHand == ')') {

          } else if (leftHand == "[" && rightHand == ")") {

            if (Number(sdkArgItem.min) < min || Number(sdkArgItem.max) >= max) {

              sdkArgItem.valid = false

              sdkArgItem.valid = false;



              this.$notify({

                type: 'warning',

                message: `参数区间设定值须大于等于${min},小于${max}`

              })

              return false

                type: "warning",

                message: `参数区间设定值须大于等于${min},小于${max}`,

              });

              return false;

            }

          } else if (leftHand == '(' && rightHand == ']') {

          } else if (leftHand == "(" && rightHand == "]") {

            if (Number(sdkArgItem.min) <= min || Number(sdkArgItem.max) > max) {

              sdkArgItem.valid = false

              sdkArgItem.valid = false;



              this.$notify({

                type: 'warning',

                message: `参数区间设定值须大于${min},小于等于${max}`

              })

              return false

                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)

          } 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

                type: "warning",

                message: `参数区间设定值须大于等于${min},小于等于${max}`,

              });

              return false;

            }

          }

        }

      }

      e.currentTarget.style.borderColor = ''

      return true

      e.currentTarget.style.borderColor = "";

      return true;

    },

    showErrorColor(e) {

      this.$nextTick(() => {

        e.currentTarget.style.borderColor = 'red'

      })

        e.currentTarget.style.borderColor = "red";

      });

    },

    setSdksOptions(rule) {

      rule.sdksOptions = this.includeSdks

      rule.sdksOptions = this.includeSdks;

    },

    setOperator(rule) {

      rule.operator = rule.operatorObj.value

      rule.operatorDesc = rule.operatorObj.name

      rule.operator = rule.operatorObj.value;

      rule.operatorDesc = rule.operatorObj.name;

    },

    setValue(rule) {

      rule.valid = true

      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 : ''

      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

        rule.typeDesc = "值";

        rule.valueDesc = rule.sdk_arg_value;

      }

      this.valideArgValue(rule)

      this.valideArgValue(rule);

    },

    selectPolygonOption(rule) {

      debugger

      rule.polygon_id = rule.polygonObj.polygonId

        ? rule.polygonObj.polygonId

        : rule.polygon_id

        : rule.polygon_id;

      rule.camera_id = rule.polygonObj.cameraId

        ? rule.polygonObj.cameraId

        : rule.camera_id

      rule.group_id = this.group_id

        : 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.argDef = JSON.parse(sdkItem.sdkObj.argDef);

        //取出默认参数

        sdkItem.defaultArg = sdkItem.argDef.filter(

          arg => !arg.config.isOptional

        )

          (arg) => !arg.config.isOptional

        );

        //赋默认operator/值

        sdkItem.defaultArg.forEach(arg => {

        sdkItem.defaultArg.forEach((arg) => {

          if (arg.operators.length == 1) {

            this.$set(arg, 'operator', arg.operators[0].operator)

            this.$set(arg, "operator", arg.operators[0].operator);



            if (arg.operators[0].operator == 'range') {

            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));

            }

          }



          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)

            this.$set(arg, "sdk_arg_value", arg.default_value);

          }

        })

        sdkItem.defaultArg

        });

        sdkItem.defaultArg;

        //取出可选参数

        sdkItem.optionalArg = sdkItem.argDef.filter(

          arg => arg.config.isOptional

        )

        sdkItem.optNames = sdkItem.optionalArg.map(arg => ({

          (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 = []

          isSelected: false,

        }));



        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)

        this.$emit("sdkNameChange", this.sdkGroup[0].sdkObj.sdk_name);

      }



      // 选项切换时需要刷新arg菜单项

      this.selectArgTypeOption(sdkItem, resetArgs)

      this.selectArgTypeOption(sdkItem, resetArgs);

    },



    selectArgTypeOption(rule, resetAlias) {

      if (rule.sdk_arg_type == '') {

        return

      if (rule.sdk_arg_type == "") {

        return;

      }



      if (resetAlias) {

        rule.sdk_arg_alias = ''

        rule.sdk_arg_alias = "";

      }



      rule.argsOptions = rule.sdkObj.args

      rule.argsOptions = rule.sdkObj.args;



      // 根据arg类型显示参数, 当前全部归为 target

      // if (rule.sdkObj.args) {

@@ -893,94 +938,92 @@
      //   rule.argsOptions = [];

      // }



      rule.argObj = {}

      rule.argObj = {};

    },

    //选择算法配置

    selOperator(rule) {

      debugger

    },

    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.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'

      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.VideoManageData.Dictionary.RULECOMPUTE.forEach((opt) => {

          if (opt.value == "==") {

            rule.operatorObj = opt;

          }

        })

        });



        this.setOperator(rule)

        this.setOperator(rule);



        this.selectValueOption(rule)

        this.selectValueOption(rule);

      } else {

        // 设置默认条件值

        rule.operator_type = 'value'

        rule.operator_type = "value";

        if (resetArgValue) {

          rule.sdk_arg_value = ''

          rule.sdk_arg_value = "";



          this.VideoManageData.Dictionary.RULECOMPUTE.forEach(opt => {

            if (opt.value == '>=') {

              rule.operatorObj = opt

          this.VideoManageData.Dictionary.RULECOMPUTE.forEach((opt) => {

            if (opt.value == ">=") {

              rule.operatorObj = opt;

            }

          })

          });

        } else {

          // 编辑规则匹配

          this.VideoManageData.Dictionary.RULECOMPUTE.forEach(opt => {

          this.VideoManageData.Dictionary.RULECOMPUTE.forEach((opt) => {

            if (opt.value == rule.operator) {

              rule.operatorObj = opt

              rule.operatorObj = opt;

            }

          })

          });

        }

        this.setOperator(rule)

        this.setOperator(rule);

      }

    },

    selectValueOption(rule) {

      if (rule.sdk_arg_alias === 'time_rule') {

        rule.valueOptions = this.VideoManageData.TimeRules.map(r => {

      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 => {

            value: r.id,

          };

        });

      } else if (rule.sdk_arg_alias === "compareBase") {

        rule.valueOptions = this.VideoManageData.TagList.map((r) => {

          return {

            name: r.tableName,

            value: r.id

          }

        })

            value: r.id,

          };

        });

      } else {

        let ops = this.VideoManageData.Dictionary[rule.sdk_arg_alias]

        let ops = this.VideoManageData.Dictionary[rule.sdk_arg_alias];

        if (ops && ops instanceof Array) {

          rule.valueOptions = ops.map(r => {

          rule.valueOptions = ops.map((r) => {

            return {

              name: r.name,

              value: r.value

            }

          })

              value: r.value,

            };

          });

        }

      }

    },



    valideArgValue(rule) {

      if (rule.sdk_arg_value == '') {

      if (rule.sdk_arg_value == "") {

        this.$notify({

          type: 'warning',

          message: '参数设定值不能为空!'

        })

        rule.valid = false

        return false

          type: "warning",

          message: "参数设定值不能为空!",

        });

        rule.valid = false;

        return false;

      }



      if (rule.argObj && rule.argObj.range) {

@@ -989,84 +1032,84 @@
          if (

            parseInt(rule.sdk_arg_value) < parseInt(rule.sdk_arg_defaultValue)

          ) {

            rule.valid = false

            rule.valid = false;

            this.$notify({

              type: 'warning',

              type: "warning",

              message:

                '参数设定值不能小于算法参数默认值 ' + rule.sdk_arg_defaultValue

            })

            rule.valueDesc = rule.sdk_arg_value = rule.argObj.default_value

            rule.valid = false

            return false

                "参数设定值不能小于算法参数默认值 " + 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]

        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

          rule.valid = false;

          this.$notify({

            type: 'warning',

            message: '参数设定值不能大于' + max

          })

          return false

            type: "warning",

            message: "参数设定值不能大于" + max,

          });

          return false;

        }

      }



      return true

      return true;

    },

    parataxis(rule_with_pre) {

      let relation = ''

      this.VideoManageData.Dictionary.RULECOMPUTEBETWEEN.forEach(pre => {

      let relation = "";

      this.VideoManageData.Dictionary.RULECOMPUTEBETWEEN.forEach((pre) => {

        if (pre.value === rule_with_pre) {

          relation = pre.name

          relation = pre.name;

        }

      })

      });



      return relation

      return relation;

    },



    generatDescription() {

      let desc = ''

      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

          desc += r.sdkDesc + r.argDesc + r.operatorDesc + r.valueDesc + r.unit;

        } else {

          desc +=

            '&nbsp;&nbsp;&nbsp;' +

            "&nbsp;&nbsp;&nbsp;" +

            this.parataxis(r.rule_with_pre) +

            '&nbsp;&nbsp;&nbsp;' +

            "&nbsp;&nbsp;&nbsp;" +

            r.sdkDesc +

            r.argDesc +

            r.operatorDesc +

            r.valueDesc +

            r.unit

            r.unit;

        }

      })

      });

      // console.log(desc,'拼接')

      return desc

      return desc;

    },

    createRule() {

      if (!this.isTemplate && this.Cameras.length > 0) {

        // 未选中摄像机或者未选中摄像机任务，不执行创建

        if (!this.Cameras[0].cameraId) return false

        if (!this.Cameras[0].cameraId) return false;

      }

      this.group_id = ''

      this.group_id = "";

      //this.addRule(0);

    },



    //清空配置并初始化

    cleanRule() {

      this.group_id = ''

      this.sdkGroup.splice(0, this.sdkGroup.length)

      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

      let newRule = JSON.parse(JSON.stringify(this.baseRule));

      newRule.sdksOptions = this.includeSdks;

      if (!this.isLinkRule) {

        // 设置默认全部区域

        // if (!this.isTemplate) {

@@ -1084,82 +1127,47 @@


      // this.groupRules.push(newRule);

      // 插入到指定位置

      this.groupRules.splice(index + 1, 0, newRule)

      this.groupRules.splice(index + 1, 0, newRule);

    },

    editHandle(ruleTxt) {

      debugger

      this.getSdkConnection();

      // if (ruleTxt.length < 1) {

      //   return

      // }

      let ruleInfo = JSON.parse(ruleTxt);

      debugger;



      //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)

      // }

      console.log(ruleInfo);

      this.editRule(ruleInfo);

    },

    editRule(ruleGroup) {

      debugger

      this.sdkGroup = []

      this.group_id = ''

      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 = {}

      ruleGroup.forEach((rule) => {

        let tempObj = {};



        if (rule.group_id && rule.group_id != '') {

          this.group_id = rule.group_id

        if (rule.group_id && rule.group_id != "") {

          this.group_id = rule.group_id;

        }



        // 填充区域选项列表

        this.allPolygonData.forEach(p => {

        this.allPolygonData.forEach((p) => {

          if (p.polygonId === rule.polygon_id) {

            rule.polygonObj = p

            rule.polygonObj = p;

          }

        })

        });



        if (!rule.polygonObj) {

          rule.polygonObj = {

            cameraId: rule.camera_id,

            defence_state: 1,

            name: '未知区域',

            polygonId: rule.polygon_id

          }

            name: "未知区域",

            polygonId: rule.polygon_id,

          };

        }

        console.log(rule)

        console.log(rule);



        // 设置区域

        this.selectPolygonOption(rule)

        this.selectPolygonOption(rule);



        //算法对象,算法参数配置数组,(用于数据处理的)默认参数数组, 可选参数数组, 已配置的可选参数数组, (用于去重判断)存放可选参数名的数组

        let sdkObj = {},

@@ -1167,60 +1175,72 @@
          defaultArg = [],

          optionalArg = [],

          optArg = [],

          optNames = []

          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)

        sdkObj = this.TaskMange.list1.find((sdk) => sdk.id == rule.sdk_id);



        rule.sdk_set.forEach(arg => {

          let optItem = optionalArg.find(oarg => {

        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

              return oarg;

            }

          })

          });

          if (optItem) {

            if (optItem.operators.length > 1) {

              optItem.operator = arg.operator

              //this.selOperator(optItem)

            }

            //if (optItem.operators.length > 1) {

            optItem.operator = arg.operator;

            //this.selOperator(optItem)

            //}



            //赋值

            optItem.sdk_arg_value = arg.sdk_arg_value

            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)

            let isMultiOne = optionalArg.find(

              (oarg) => oarg.sort == optItem.sort && optItem.config.isMulti

            );

            if (isMultiOne) {

              optItem.sdk_arg_value = arg.sdk_arg_value.split(',');

              optItem.sdk_arg_value = arg.sdk_arg_value.split(",");

            }



            if (optItem.type == 'option') {

              this.setOptArgValueOptions(optItem)

            if (optItem.type == "option") {

              this.setOptArgValueOptions(optItem);

            }

            optArg.push(optItem)

            if (optItem.alias == "bForceSend") {

            }

            //在push之前,需要判断是否配置了这个可选项  在sdk_set配置数组里,



            optArg.push(optItem);

          } else {

            defaultArg.forEach(d => {

            defaultArg.forEach((d) => {

              if (d.sort == arg.sort) {

                if (arg.sdk_arg_value.indexOf(',') > 0) {

                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'

                  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.sdk_arg_value = arg.sdk_arg_value;

                }

                d.operator = arg.operator;

              }

            })

            });

          }

        })

        optNames = optionalArg.map(arg => ({

        });

        optNames = optionalArg.map((arg) => ({

          name: arg.name,

          sort: arg.sort,

          isSelected: false

        }))

          isSelected: false,

        }));



        tempObj = {

          sdkObj,

@@ -1236,14 +1256,13 @@
          optNames,

          isAddable: true,

          camera_id: rule.camera_id,

          polygon_id: rule.polygon_id

        }

          polygon_id: rule.polygon_id,

        };

        //回显是否显示添加可选参数

        tempObj.initAddOptional =

          tempObj.optArg.length == 0 && tempObj.optionalArg.length > 0

            ? true

            : false;

        debugger

        //回显是否显示可选参数添加按钮

        if (tempObj.optArg.length < tempObj.optionalArg.length) {

          tempObj.isAddable = true;

@@ -1251,45 +1270,44 @@
          tempObj.isAddable = false;

        }

        //this.selectSDKOption(tempObj, false)

        debugger

        this.sdkGroup.push(tempObj)



        this.sdkGroup.push(tempObj);

        //设置算法

      })

      });

      //this.$nextTick(() => {})

    },

    delRule(rule) {

      this.$confirm('提示：删除后，该条规则将失效，是否删除？', {

      this.$confirm("提示：删除后，该条规则将失效，是否删除？", {

        center: true,

        cancelButtonClass: 'comfirm-class-cancle',

        confirmButtonClass: 'comfirm-class-sure'

        cancelButtonClass: "comfirm-class-cancle",

        confirmButtonClass: "comfirm-class-sure",

      })

        .then(() => {

          deleteCameraRules({ groupId: rule.group_id }).then(res => {

          deleteCameraRules({ groupId: rule.group_id }).then((res) => {

            if (res && res.success) {

              this.$notify({

                type: 'success',

                message: '删除成功'

              })

              this.$emit('delete-rule')

                type: "success",

                message: "删除成功",

              });

              this.$emit("delete-rule");

            } else {

              this.$notify({

                type: 'error',

                message: '删除失败！'

              })

                type: "error",

                message: "删除失败！",

              });

            }

          })

          });

        })

        .catch(() => { })

        .catch(() => {});

    },

    submitRule() {

      debugger

      let groupRule = { rules: [] }

      let groupRule = { rules: [] };



      let group_text = ''

      let validateFlag = false

      let group_text = "";

      let validateFlag = false;



      if (this.isTemplate) {

        groupRule.rules = this.groupRules.map(r => {

        groupRule.rules = this.groupRules.map((r) => {

          return {

            sdk_id: r.sdk_id,

            sdk_arg_alias: r.sdk_arg_alias,

@@ -1297,247 +1315,298 @@
            operator_type: r.operator_type,

            sdk_arg_value: r.sdk_arg_value,

            sort: 1,

            rule_with_pre: r.rule_with_pre

          }

        })

            rule_with_pre: r.rule_with_pre,

          };

        });

      } else {

        console.log(this.sdkGroup);

        //校验必填项

        let undefinished = this.sdkGroup.some((sdk, index) => {

          debugger

          //没有配置算法

          if (Object.keys(sdk.sdkObj).length == 0) {

            return sdk

            return sdk;

          }

          //复制算法时检测区域不能为空

          if (!sdk.polygon_id) {

            return sdk;

          }



          //多于两项算法时,算法关系不能为空

          if (sdk.rule_with_pre === '' && index != 0) {

            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 => !arg.sdk_arg_value)

          if (defaultArgFlag) {

            return sdk

          }

          //查找可选参数值是否都设置(多选值为数组类型)

          let optionalArgFlag = sdk.optArg.find(arg => {

          let defaultArgFlag = sdk.defaultArg.find((arg) => {

            if (arg.sdk_arg_value instanceof Array) {

              if (arg.sdk_arg_value.length == 0) {

                return arg

                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.operator == "range") {

                if (!arg.min.trim() && arg.max.trim()) {

                  return arg

                  return arg;

                }

              }

              if (!arg.sdk_arg_value) {

                return arg

                return arg;

              }

            }

          });



          if (optionalArgFlag) {

            return sdk

            return sdk;

          }

        });



        if (undefinished) {

          this.$notify({

            type: 'error',

            message: '算法参数未完善,请完善后再保存'

            type: "error",

            message: "算法参数未完善,请完善后再保存",

          });

          return false

          return false;

        }

        //校验区间左侧值是否小于右侧值

        let illegalRange = this.sdkGroup.some((sdk,index)=>{

          let rangeArg = sdk.defaultArg.find(arg=>arg.operator=='range');

          if(rangeArg){

        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

              return sdk;

            }

          }

        });

        if(illegalRange){

        if (illegalRange) {

          this.$notify({

            type: 'error',

            message: '区间左侧不能大于或等于区间右侧的值'

            type: "error",

            message: "区间左侧不能大于或等于区间右侧的值",

          });

          return false

          return false;

        }

        //校验若算法关系为触发,则算法名不能重

        let sameSdk = this.sdkGroup.some((sdk, index) => {

          debugger

          if (sdk.index != 0 && sdk.rule_with_pre == '=>') {

            debugger

          if (

            sdk.index != 0 &&

            (sdk.rule_with_pre == "=>" || sdk.rule_with_pre == "!=>")

          ) {

            if (sdk.sdkObj.id == this.sdkGroup[index - 1].sdkObj.id) {

              return sdk

              return sdk;

            }

          }

        });



        if (sameSdk) {

          this.$notify({

            type: 'error',

            message: '算法关系为触发时,算法名不能重复'

            type: "error",

            message: "算法关系为触发时,算法名不能重复",

          });

          return false

          return false;

        }



        if (!validateFlag && !sameSdk) {

          validateFlag = true

          validateFlag = true;

        }



        this.sdkGroup.forEach(sdk => {

        this.sdkGroup.forEach((sdk) => {

          let tempObj = {

            sdk_id: sdk.sdkObj.id,

            camera_id: sdk.camera_id,

            group_id: '',

            group_id: "",

            is_save_anyhow: sdk.is_save_anyhow,

            polygon_id: sdk.polygon_id,

            rule_with_pre: sdk.rule_with_pre,

            sdk_set: []

          }

            sdk_set: [],

          };



          let defaultArgs = sdk.defaultArg.map(arg => ({

          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

          }))

            sort: arg.sort,

          }));



          let defaultArgDesc = '( '

          sdk.defaultArg.forEach(arg => {

            if (arg.operator == 'range') {

              let valRange = '';

              debugger

              valRange = arg.sdk_arg_value.replace(',', '-');

              defaultArgDesc += `${arg.name}${arg.operators[0].name}${valRange}${arg.unit || ''}, `

          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.sdk_arg_value

                }${arg.unit || ''}, `

                arg.type == "option" ? val : arg.sdk_arg_value

              }${arg.unit || ""}, `;

            }



          });

          debugger;

          defaultArgDesc = defaultArgDesc.substring(0, defaultArgDesc.length - 2)

          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 => ({

          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

            sort: arg.sort,

          }));

          //将多选项的值拼成字符串

          optArgs.forEach(one => {

          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 = '';



          let optArgDesc = " ";

          sdk.optArg.forEach((arg) => {

            let val = "";

            let valRange = "";



            //处理下拉选值类型

            if (arg.type == 'option') {

            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 + ' ';

                })

                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

                  (opt) => opt.value == arg.sdk_arg_value

                );



                val = res.name;

              }

              //optArgDesc += `,${arg.name}${arg.operators[0].operator}${val}${arg.unit || ''}, `

            } else {

              //optArgDesc += `,${arg.name}${arg.operators[0].operator}${ arg.sdk_arg_value }${arg.unit || ''}, `

            }



            let operatorSelected = arg.operators.find(opr => opr.operator == arg.operator)

            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 || ''}, `

          })

          optArgDesc = optArgDesc.substring(0, optArgDesc.length - 2) + optArgDesc.substring(optArgDesc.length - 1, optArgDesc.length);

          optArgDesc += ')'

          tempObj.sdk_set = defaultArgs.concat(optArgs)

              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)

          groupRule.rules.push(tempObj);



          let rule_with_pre = ''

          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 = " and ";

                break;

              case "||":

                rule_with_pre = " or ";

                break;

              case "=>":

                rule_with_pre = " -> ";

                break;

              case "!=>":

                rule_with_pre = " !-> ";

                break;

              default:

                rule_with_pre = ''

                rule_with_pre = "";

            }

          }

          debugger;

          group_text += `${rule_with_pre ? "<br/>" + rule_with_pre + "<br/>" : ""} <span style="background-color:RGB(183,183,183);">${

          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}`;

          }</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.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)

              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

      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

            this.sdkGroup.map((r) => {

              return r.camera_id;

            })

          )

        )

        );

        if (cameraIds.length < 2) {

          this.$notify({

            type: 'error',

            type: "error",

            //message: '需要2个不同摄像机才能组成联动规则'

            message: '需要至少2个不同摄像机才能组成联动场景'

          })

          return

            message: "需要至少2个不同摄像机才能组成联动场景",

          });

          return;

        }



        // 联动规则编辑后，恢复之前选中的摄像机

@@ -1547,15 +1616,15 @@
        // }

      }

      //if(validateFlag){

      this.onSubmitRule(payload)

      this.onSubmitRule(payload);

      //}

    }

  }

}

    },

  },

};

</script>



<style lang="scss">

body{

body {

  font-size: 12px;

}

.edit-rules-box {