From 907a3504a77873a8e762adc2f684222c8946adec Mon Sep 17 00:00:00 2001
From: zhangzengfei <zhangzengfei@smartai.com>
Date: 星期三, 10 八月 2022 21:18:54 +0800
Subject: [PATCH] 添加实时监控，调整树的滚动条

---
 src/views/hashrate/CameraManage/CameraRules/components/SdkSettingBox.vue |  642 +++++++++++++++++++++++++--------------------------------
 1 files changed, 281 insertions(+), 361 deletions(-)

diff --git a/src/views/hashrate/CameraManage/CameraRules/components/SdkSettingBox.vue b/src/views/hashrate/CameraManage/CameraRules/components/SdkSettingBox.vue
index 30dab1d..0359727 100644
--- a/src/views/hashrate/CameraManage/CameraRules/components/SdkSettingBox.vue
+++ b/src/views/hashrate/CameraManage/CameraRules/components/SdkSettingBox.vue
@@ -27,26 +27,12 @@
       <div v-for="(arg, index) in sdkItem.defaultArg" :key="arg.sort">
         <div class="argums-item" v-show="arg.config.isShow">
           <div class="arg-name">
-            <el-select
-              class="h32"
-              v-model="arg.name"
-              size="mini"
-              :disabled="true"
-            >
-              <el-option
-                :label="arg.name"
-                :title="arg.name"
-                :value="arg"
-              ></el-option>
+            <el-select class="h32" v-model="arg.name" size="mini" :disabled="true">
+              <el-option :label="arg.name" :title="arg.name" :value="arg"></el-option>
             </el-select>
           </div>
           <div class="operator-name">
-            <el-select
-              :disabled="arg.operators.length == 1"
-              v-model="arg.operator"
-              size="mini"
-              class="h32"
-            >
+            <el-select :disabled="arg.operators.length == 1" v-model="arg.operator" size="mini" class="h32">
               <el-option
                 v-for="operator in arg.operators"
                 :key="operator.operator"
@@ -104,12 +90,7 @@
               <span class="font">{{ arg.unit }}</span>
             </div>
           </div>
-          <div
-            class="optional"
-            v-if="
-              sdkItem.initAddOptional && index == sdkItem.defaultArg.length - 1
-            "
-          >
+          <div class="optional" v-if="sdkItem.initAddOptional && index == sdkItem.defaultArg.length - 1">
             <span class="btn" @click="addOptionalArg()">
               <i class="iconfont addBtn">&#xe627;</i>
             </span>
@@ -117,11 +98,7 @@
         </div>
       </div>
 
-      <div
-        class="argums-item optional-line"
-        v-for="optArgItem in sdkItem.optArg"
-        :key="optArgItem.sort"
-      >
+      <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"
@@ -147,12 +124,7 @@
           </el-select>
         </div>
         <div class="operator-name">
-          <el-select
-            :disabled="optArgItem.operators.length == 1"
-            v-model="optArgItem.operator"
-            size="mini"
-            class="h32"
-          >
+          <el-select :disabled="optArgItem.operators.length == 1" v-model="optArgItem.operator" size="mini" class="h32">
             <el-option
               v-for="operatorItem in optArgItem.operators"
               :key="operatorItem.operator"
@@ -190,11 +162,7 @@
           <span class="font">{{ optArgItem.unit }}</span>
         </div>
         <div class="optional">
-          <span
-            class="btn"
-            @click="addOptionalArg()"
-            v-show="sdkItem.isAddable"
-          >
+          <span class="btn" @click="addOptionalArg()" v-show="sdkItem.isAddable">
             <i class="iconfont addBtn">&#xe627;</i>
           </span>
           <span class="btn" @click="delOptionalArg(optArgItem)">
@@ -219,25 +187,25 @@
     Cameras: {
       type: Array,
       default: () => {
-        return [];
-      },
+        return []
+      }
     },
     isTemplate: {
       type: Boolean,
-      default: false,
+      default: false
     },
 
     editSdk: {},
 
-    linkEditCamera: {},
+    linkEditCamera: {}
   },
   computed: {
     isLinkRule() {
-      return this.Cameras.length > 1;
-    },
+      return this.Cameras.length > 1
+    }
   },
   created() {
-    this.initOption();
+    this.initOption()
   },
   data() {
     return {
@@ -251,61 +219,55 @@
         optionalArg: [],
         optArg: [],
         optNames: [],
-        isAddable: true,
+        isAddable: true
       },
-      allPolygonData: [],
-    };
+      allPolygonData: []
+    }
   },
   methods: {
     rangeInput(arg) {
-      arg.sdk_arg_value = arg.min + "|" + arg.max;
-      this.$forceUpdate();
+      arg.sdk_arg_value = arg.min + "|" + arg.max
+      this.$forceUpdate()
     },
     selectPolygonOption(rule) {
-      rule.polygon_id = rule.polygonObj.polygonId
-        ? rule.polygonObj.polygonId
-        : rule.polygon_id;
-      rule.camera_id = rule.polygonObj.cameraId
-        ? rule.polygonObj.cameraId
-        : rule.camera_id;
+      rule.polygon_id = rule.polygonObj.polygonId ? rule.polygonObj.polygonId : rule.polygon_id
+      rule.camera_id = rule.polygonObj.cameraId ? rule.polygonObj.cameraId : rule.camera_id
     },
     close() {
-      this.$emit("close");
+      this.$emit("close")
     },
     initOption() {
-      this.initPolygon();
-      let sdkItem = null;
+      this.initPolygon()
+      let sdkItem = null
       if (this.editSdk) {
         this.TaskMange.list1.forEach((item) => {
           if (item.id === this.editSdk.sdk_id) {
-            sdkItem = item;
+            sdkItem = item
           }
-        });
+        })
 
         if (typeof sdkItem.argDef === "string") {
-          sdkItem.argDef = JSON.parse(sdkItem.argDef);
+          sdkItem.argDef = JSON.parse(sdkItem.argDef)
         }
 
-        this.sdkItem = sdkItem;
-        this.sdkItem.sdk_set = JSON.parse(JSON.stringify(this.editSdk.sdk_set));
-        this.sdkItem.polygon_id = this.editSdk.polygon_id;
+        this.sdkItem = sdkItem
+        this.sdkItem.sdk_set = JSON.parse(JSON.stringify(this.editSdk.sdk_set))
+        this.sdkItem.polygon_id = this.editSdk.polygon_id
 
-        this.editRule();
-        return;
+        this.editRule()
+        return
       } else {
-        sdkItem = this.$store.state.newSdk;
+        sdkItem = this.$store.state.newSdk
       }
       if (typeof sdkItem.argDef === "string") {
-        sdkItem.argDef = JSON.parse(sdkItem.argDef);
+        sdkItem.argDef = JSON.parse(sdkItem.argDef)
       }
       //鍙栧嚭榛樿鍙傛暟
-      sdkItem.defaultArg = sdkItem.argDef.filter(
-        (arg) => !arg.config.isOptional
-      );
+      sdkItem.defaultArg = sdkItem.argDef.filter((arg) => !arg.config.isOptional)
       //璧嬮粯璁perator/鍊�
       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") {
             //鍖洪棿鍊肩殑澶勭悊
@@ -313,156 +275,149 @@
         }
 
         if (arg.type == "option") {
-          this.setOptArgValueOptions(arg);
+          this.setOptArgValueOptions(arg)
         }
         if (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.optionalArg = sdkItem.argDef.filter((arg) => arg.config.isOptional)
       sdkItem.optNames = sdkItem.optionalArg.map((arg) => ({
         name: arg.name,
         sort: arg.sort,
-        isSelected: false,
-      }));
+        isSelected: false
+      }))
 
-      sdkItem.initAddOptional = sdkItem.optionalArg.length > 0 ? true : false;
-      sdkItem.optArg = [];
+      sdkItem.initAddOptional = sdkItem.optionalArg.length > 0 ? true : false
+      sdkItem.optArg = []
 
-      this.sdkItem = sdkItem;
+      this.sdkItem = sdkItem
     },
     initPolygon() {
-      let cameras = [];
+      let cameras = []
       if (this.linkEditCamera) {
-        this.allPolygonData = [];
-        cameras = this.linkEditCamera;
+        this.allPolygonData = []
+        cameras = this.linkEditCamera
         this.linkEditCamera.forEach((camera) => {
           camera.polygon.forEach((polygon) => {
             this.allPolygonData.push({
               defence_state: polygon.defenceState,
               polygonId: polygon.id,
-              name: camera.cameraName + ":" + polygon.name,
-              cameraId: camera.cameraId,
-            });
-          });
-        });
+              name: camera.camera_name + ":" + polygon.name,
+              cameraId: camera.camera_id
+            })
+          })
+        })
       } else {
-        cameras = [...this.Cameras];
+        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 || this.linkEditCamera
-                  ? cameras[i].cameraName + ":" + p.name
-                  : p.name,
+              name: this.isLinkRule || this.linkEditCamera ? cameras[i].cameraName + ":" + p.name : p.name,
 
-              cameraId: cameras[i].cameraId,
-            };
-          });
-          this.allPolygonData = this.allPolygonData.concat(polyOpt);
+              cameraId: cameras[i].cameraId
+            }
+          })
+          this.allPolygonData = this.allPolygonData.concat(polyOpt)
         }
       }
 
-      this.$forceUpdate();
+      this.$forceUpdate()
     },
 
     editRule() {
-      let tempObj = {};
+      let tempObj = {}
 
       // 濉厖鍖哄煙閫夐」鍒楄〃
       this.allPolygonData.forEach((p) => {
         if (p.polygonId === this.sdkItem.polygon_id) {
-          this.sdkItem.polygonObj = p;
+          this.sdkItem.polygonObj = p
         }
-      });
+      })
 
       if (!this.sdkItem.polygonObj) {
         this.sdkItem.polygonObj = {
           cameraId: this.sdkItem.camera_id,
           defence_state: 1,
           name: "鏈煡鍖哄煙",
-          polygonId: this.sdkItem.polygon_id,
-        };
+          polygonId: this.sdkItem.polygon_id
+        }
       }
 
       // 璁剧疆鍖哄煙
-      this.selectPolygonOption(this.sdkItem);
+      this.selectPolygonOption(this.sdkItem)
 
       //绠楁硶瀵硅薄,绠楁硶鍙傛暟閰嶇疆鏁扮粍,(鐢ㄤ簬鏁版嵁澶勭悊鐨�)榛樿鍙傛暟鏁扮粍, 鍙�夊弬鏁版暟缁�, 宸查厤缃殑鍙�夊弬鏁版暟缁�, (鐢ㄤ簬鍘婚噸鍒ゆ柇)瀛樻斁鍙�夊弬鏁板悕鐨勬暟缁�
       let argDef = [],
         defaultArg = [],
         optionalArg = [],
         optArg = [],
-        optNames = [];
+        optNames = []
 
-      argDef = this.sdkItem.argDef;
+      argDef = this.sdkItem.argDef
 
-      defaultArg = argDef.filter((arg) => !arg.config.isOptional);
-      optionalArg = argDef.filter((arg) => arg.config.isOptional);
+      defaultArg = argDef.filter((arg) => !arg.config.isOptional)
+      optionalArg = argDef.filter((arg) => arg.config.isOptional)
 
       this.sdkItem.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;
+          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);
+            this.setOptArgValueOptions(optItem)
           }
           if (optItem.alias == "bForceSend") {
           }
           //鍦╬ush涔嬪墠,闇�瑕佸垽鏂槸鍚﹂厤缃簡杩欎釜鍙�夐」  鍦╯dk_set閰嶇疆鏁扮粍閲�,
 
-          optArg.push(optItem);
+          optArg.push(optItem)
         } else {
           defaultArg.forEach((d) => {
             if (d.sort == arg.sort) {
               if (arg.sdk_arg_value.indexOf("|") > 0) {
                 //鍖洪棿鍊�
-                d.min = arg.sdk_arg_value.split("|")[0];
-                d.max = arg.sdk_arg_value.split("|")[1];
-                d.operator = "range";
+                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);
+                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;
+              d.operator = arg.operator
             }
-          });
+          })
         }
-      });
+      })
       optNames = optionalArg.map((arg) => ({
         name: arg.name,
         sort: arg.sort,
-        isSelected: false,
-      }));
+        isSelected: false
+      }))
 
       tempObj = {
         polygonObj: this.sdkItem.polygonObj,
@@ -481,138 +436,116 @@
         sdk_id: this.editSdk.sdk_id,
         rule_with_pre: this.editSdk.rule_with_pre,
         is_save_anyhow: this.editSdk.is_save_anyhow,
-        icon_blob: this.editSdk.icon_blob,
-      };
+        icon_blob: this.editSdk.icon_blob
+      }
       //鍥炴樉鏄惁鏄剧ず娣诲姞鍙�夊弬鏁�
-      tempObj.initAddOptional =
-        tempObj.optArg.length == 0 && tempObj.optionalArg.length > 0
-          ? true
-          : false;
+      tempObj.initAddOptional = tempObj.optArg.length == 0 && tempObj.optionalArg.length > 0 ? true : false
       //鍥炴樉鏄惁鏄剧ず鍙�夊弬鏁版坊鍔犳寜閽�
       if (tempObj.optArg.length < tempObj.optionalArg.length) {
-        tempObj.isAddable = true;
+        tempObj.isAddable = true
       } else {
-        tempObj.isAddable = false;
+        tempObj.isAddable = false
       }
 
-      this.sdkItem = tempObj;
-      this.$forceUpdate();
+      this.sdkItem = tempObj
+      this.$forceUpdate()
     },
 
     validateArgVal(sdkArgItem, e) {
-      console.log(sdkArgItem);
-      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;
+          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]);
+          max = Number(res[2])
 
         //鍒ゆ柇闈炲尯闂寸被
         if (sdkArgItem.sdk_arg_value && sdkArgItem.operator != "range") {
           if (leftHand == "(" && rightHand == ")") {
-            if (
-              Number(sdkArgItem.sdk_arg_value) <= min ||
-              Number(sdkArgItem.sdk_arg_value) >= max
-            ) {
-              sdkArgItem.valid = false;
+            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;
+                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;
+            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;
+                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;
+            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;
+                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);
+            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;
+                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;
+            if (Number(sdkArgItem.min) <= min || Number(sdkArgItem.min) >= max) {
+              sdkArgItem.valid = false
 
               this.$notify({
                 type: "warning",
-                message: `鍙傛暟鍖洪棿璁惧畾鍊奸』澶т簬${min},灏忎簬${max}`,
-              });
-              return false;
+                message: `鍙傛暟鍖洪棿璁惧畾鍊奸』澶т簬${min},灏忎簬${max}`
+              })
+              return false
             }
           } 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;
+                message: `鍙傛暟鍖洪棿璁惧畾鍊奸』澶т簬绛変簬${min},灏忎簬${max}`
+              })
+              return false
             }
           } 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;
+                message: `鍙傛暟鍖洪棿璁惧畾鍊奸』澶т簬${min},灏忎簬绛変簬${max}`
+              })
+              return false
             }
           } else if (leftHand == "[" && rightHand == "]") {
             if (
@@ -621,202 +554,193 @@
               Number(sdkArgItem.min) > max ||
               Number(sdkArgItem.max) < min
             ) {
-              sdkArgItem.valid = false;
+              sdkArgItem.valid = false
               //    this.showErrorColor(e);
               this.$notify({
                 type: "warning",
-                message: `鍙傛暟鍖洪棿璁惧畾鍊奸』澶т簬绛変簬${min},灏忎簬绛変簬${max}`,
-              });
-              return false;
+                message: `鍙傛暟鍖洪棿璁惧畾鍊奸』澶т簬绛変簬${min},灏忎簬绛変簬${max}`
+              })
+              return false
             }
           }
         }
       }
-      e.currentTarget.style.borderColor = "";
-      return true;
+      e.currentTarget.style.borderColor = ""
+      return true
     },
 
     addOptionalArg() {
-      this.sdkItem.initAddOptional = false;
+      this.sdkItem.initAddOptional = false
       this.sdkItem.optArg.forEach((arg) => {
         this.sdkItem.optNames.forEach((name) => {
           if (arg.sort == name.sort) {
-            name.isSelected = true;
+            name.isSelected = true
           }
-        });
-      }); //鎵惧埌鍙�塻dkItem.optNames鐨勭涓�涓搴旂殑sdkItem.optionalArg聽push鍒皊dkItem.optArg
-      let oneNotSelected = this.sdkItem.optNames.find(
-        (name) => !name.isSelected
-      );
+        })
+      }) //鎵惧埌鍙�塻dkItem.optNames鐨勭涓�涓搴旂殑sdkItem.optionalArg聽push鍒皊dkItem.optArg
+      let oneNotSelected = this.sdkItem.optNames.find((name) => !name.isSelected)
       if (oneNotSelected) {
-        oneNotSelected.isSelected = true;
+        oneNotSelected.isSelected = true
       }
 
       let argTemp = this.sdkItem.optionalArg.find((arg) => {
-        return arg.sort == oneNotSelected.sort;
-      });
+        return arg.sort == oneNotSelected.sort
+      })
 
-      let copyArgTemp = JSON.parse(JSON.stringify(argTemp));
+      let copyArgTemp = JSON.parse(JSON.stringify(argTemp))
       if (copyArgTemp.type == "option") {
-        this.setOptArgValueOptions(copyArgTemp);
+        this.setOptArgValueOptions(copyArgTemp)
       }
       //榛樿閫変腑绗竴涓猳perator
       //if (copyArgTemp.operators.length == 1) {
-      this.$set(copyArgTemp, "operator", copyArgTemp.operators[0].operator);
+      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)
       }
 
-      this.sdkItem.optArg.push(copyArgTemp);
-      this.$forceUpdate();
+      this.sdkItem.optArg.push(copyArgTemp)
+      this.$forceUpdate()
 
       if (this.sdkItem.optArg.length < this.sdkItem.optionalArg.length) {
-        this.sdkItem.isAddable = true;
+        this.sdkItem.isAddable = true
       } else {
-        this.sdkItem.isAddable = false;
+        this.sdkItem.isAddable = false
       }
     },
 
     selOptionalArg(optArgItem) {
-      let newSort = 0;
+      let newSort = 0
       this.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 = this.sdkItem.optionalArg.find((arg) => arg.sort == newSort);
+      let argObj = this.sdkItem.optionalArg.find((arg) => arg.sort == newSort)
       if (argObj.type == "option") {
-        this.setOptArgValueOptions(argObj);
+        this.setOptArgValueOptions(argObj)
       }
       //榛樿閫変腑绗竴涓猳perator
       //if (argObj.operators.length == 1) {
-      this.$set(argObj, "operator", argObj.operators[0].operator);
+      this.$set(argObj, "operator", argObj.operators[0].operator)
       //}
       //鏇挎崲鏂扮殑鍙傛暟閰嶇疆瀵硅薄
       this.sdkItem.optArg.forEach((arg, index) => {
         if (arg.sort == optArgItem.sort) {
-          this.$set(
-            this.sdkItem.optArg,
-            index,
-            JSON.parse(JSON.stringify(argObj))
-          );
+          this.$set(this.sdkItem.optArg, index, JSON.parse(JSON.stringify(argObj)))
         }
-      });
+      })
     },
 
     delOptionalArg(optArgItem) {
-      let index = this.sdkItem.optArg.findIndex(
-        (arg) => arg.sort == optArgItem.sort
-      );
-      this.sdkItem.optArg.splice(index, 1);
+      let index = this.sdkItem.optArg.findIndex((arg) => arg.sort == optArgItem.sort)
+      this.sdkItem.optArg.splice(index, 1)
       this.sdkItem.optNames.forEach((name) => {
         if (name.sort == optArgItem.sort) {
-          name.isSelected = false;
+          name.isSelected = false
         }
-      });
-      this.sdkItem.initAddOptional =
-        this.sdkItem.optArg.length == 0 ? true : false;
+      })
+      this.sdkItem.initAddOptional = this.sdkItem.optArg.length == 0 ? true : false
       if (this.sdkItem.optArg.length < this.sdkItem.optionalArg.length) {
-        this.sdkItem.isAddable = true;
+        this.sdkItem.isAddable = true
       } else {
-        this.sdkItem.isAddable = false;
+        this.sdkItem.isAddable = false
       }
-      this.$forceUpdate();
+      this.$forceUpdate()
     },
 
     setOptArgValueOptions(optArg) {
-      let alias = optArg.alias;
+      let alias = optArg.alias
+      console.log(121212)
+      console.log(alias)
       optArg.valueOptions = this.VideoManageData.Dictionary[alias].map((r) => {
         return {
           name: r.name,
-          value: r.value,
-        };
-      });
+          value: r.value
+        }
+      })
     },
 
     forceUpdate() {
-      console.log(1);
-      this.$forceUpdate();
+      console.log(1)
+      this.$forceUpdate()
     },
 
     save() {
-      let warn = false;
+      let warn = false
 
       //澶嶅埗绠楁硶鏃舵娴嬪尯鍩熶笉鑳戒负绌�
       if (!this.sdkItem.polygon_id) {
-        console.log(1);
-        warn = true;
+        console.log(1)
+        warn = true
       }
 
       //澶勭悊鏈睍绀虹殑鍙傛暟鐨勫��
       this.sdkItem.defaultArg.forEach((arg) => {
         if (!arg.config.isShow) {
-          arg.sdk_arg_value = arg.default_value;
+          arg.sdk_arg_value = arg.default_value
         }
-      });
+      })
       //琛ㄥ崟鎻愪氦鍓嶆牎楠�:鎵�鏈夌畻娉曠殑鍙傛暟鍊间笉鑳戒负绌�,(鏈塺ange鐨�,瑕佸湪range鑼冨洿鍐�)澶辩劍鏃舵牎楠�
       let defaultArgFlag = this.sdkItem.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;
+          return arg
         }
-      });
+      })
       if (defaultArgFlag) {
-        warn = true;
+        warn = true
       }
       //鏌ユ壘鍙�夊弬鏁板�兼槸鍚﹂兘璁剧疆(澶氶�夊�间负鏁扮粍绫诲瀷)
       let optionalArgFlag = this.sdkItem.optArg.find((arg) => {
         if (arg.sdk_arg_value instanceof Array) {
           if (arg.sdk_arg_value.length == 0) {
-            return arg;
+            return arg
           }
         } else {
           //鍖洪棿绫诲弬鏁板�兼渶灏�,鏈�澶у�兼槸鍚﹂兘璁剧疆
           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) {
-        warn = true;
+        warn = true
       }
 
       //鏍￠獙鍖洪棿宸︿晶鍊兼槸鍚﹀皬浜庡彸渚у��
-      let rangeArg = this.sdkItem.defaultArg.find(
-        (arg) => arg.operator == "range"
-      );
+      let rangeArg = this.sdkItem.defaultArg.find((arg) => arg.operator == "range")
       if (rangeArg) {
         if (Number(rangeArg.max) <= Number(rangeArg.min)) {
-          warn = true;
+          warn = true
         }
       }
 
       if (warn) {
         this.$notify({
           type: "error",
-          message: "绠楁硶鍙傛暟鏈夎,璇峰畬鍠勫悗鍐嶄繚瀛�",
-        });
-        return false;
+          message: "绠楁硶鍙傛暟鏈夎,璇峰畬鍠勫悗鍐嶄繚瀛�"
+        })
+        return false
       }
 
-      console.log(this.sdkItem);
+      console.log(this.sdkItem)
 
       let tempObj = {
         sdk_id: this.editSdk ? this.sdkItem.sdk_id : this.sdkItem.id,
@@ -824,55 +748,51 @@
         is_save_anyhow: this.sdkItem.is_save_anyhow,
         polygon_id: this.sdkItem.polygon_id,
         rule_with_pre: this.sdkItem.rule_with_pre,
-        sdk_set: [],
-      };
+        sdk_set: []
+      }
 
       let defaultArgs = this.sdkItem.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 = "( ";
+      let defaultArgDesc = "( "
       this.sdkItem.defaultArg.forEach((arg) => {
         //涓嶆樉绀洪殣钘忕殑鍙傛暟閰嶇疆
         if (!arg.config.isShow) {
-          return;
+          return
         }
-        let val = "";
+        let val = ""
         //澶勭悊涓嬫媺閫夊�肩被鍨�
         if (arg.type == "option") {
           if (arg.sdk_arg_value instanceof Array) {
             //澶氶�夊��
-            let multiNames = "";
+            let multiNames = ""
             arg.sdk_arg_value.forEach((val) => {
-              let opV = arg.valueOptions.find((opt) => opt.value == val);
-              multiNames += opV.name + " ";
-            });
-            val = multiNames;
+              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 res = arg.valueOptions.find((opt) => opt.value == arg.sdk_arg_value)
+            val = res.name
           }
         }
         if (arg.operator == "range") {
-          let valRange = "";
+          let valRange = ""
 
-          valRange = arg.sdk_arg_value.replace(",", "-");
-          defaultArgDesc += `${arg.name}${arg.operators[0].name}${valRange}${
-            arg.unit || ""
-          }, `;
+          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 || ""}, `;
+          }${arg.unit || ""}, `
         }
-      });
-      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);
@@ -884,89 +804,89 @@
         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) => {
         if (one.sdk_arg_value instanceof Array) {
-          one.sdk_arg_value = one.sdk_arg_value.join();
+          one.sdk_arg_value = one.sdk_arg_value.join()
         }
-      });
-      let optArgDesc = " ";
+      })
+      let optArgDesc = " "
+
+      //鏂板
+
+      //鏂板
+
       this.sdkItem.optArg.forEach((arg) => {
-        let val = "";
-        let valRange = "";
+        let val = ""
+        let valRange = ""
 
         //澶勭悊涓嬫媺閫夊�肩被鍨�
         if (arg.type == "option") {
           if (arg.sdk_arg_value instanceof Array) {
             //澶氶�夊��
-            let multiNames = "";
+            let multiNames = ""
             arg.sdk_arg_value.forEach((val) => {
-              let opV = arg.valueOptions.find((opt) => opt.value == val);
-              multiNames += opV.name + " ";
-            });
-            val = multiNames;
+              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
-            );
+            let res = arg.valueOptions.find((opt) => opt.value == arg.sdk_arg_value)
 
-            val = res.name;
+            val = res.name
           }
         }
 
-        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 || ""}, `;
-      });
+        }${arg.unit || ""}, `
+      })
       //灏嗗閫夐」鐨勫�兼嫾鎴愬瓧绗︿覆
       defaultArgs.forEach((one) => {
         if (one.sdk_arg_value instanceof Array) {
-          one.sdk_arg_value = one.sdk_arg_value.join();
+          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);
+        optArgDesc.substring(0, optArgDesc.length - 2) + optArgDesc.substring(optArgDesc.length - 1, optArgDesc.length)
+      optArgDesc += ")"
+      tempObj.sdk_set = defaultArgs.concat(optArgs)
+      tempObj.ruleDes = defaultArgDesc + optArgDesc
+      console.log(tempObj.ruleDes)
 
       if (this.editSdk) {
-        tempObj.icon_blob = this.editSdk.icon_blob;
-        this.$emit("getEditSdk", tempObj);
+        tempObj.icon_blob = this.editSdk.icon_blob
+        tempObj.group_id = this.editSdk.group_id
+        tempObj.sort = this.editSdk.sort
+        tempObj.id = this.editSdk.id
+        tempObj.icon_blob = this.editSdk.icon_blob
+        tempObj.icon_blob2 = this.editSdk.icon_blob2
+        this.$emit("getEditSdk", tempObj)
       } else {
-        tempObj.icon_blob = this.$store.state.newSdk.iconBlob;
-        this.$emit("getNewSdk", tempObj);
+        tempObj.icon_blob = this.$store.state.newSdk.iconBlob
+        this.$emit("getNewSdk", tempObj)
       }
-    },
+    }
   },
   watch: {
     sdkItem: {
       handler(newVal) {
-        let rangeOne = newVal.defaultArg.find(
-          (arg) => arg.operators[0].operator == "range"
-        );
+        let rangeOne = newVal.defaultArg.find((arg) => arg.operators[0].operator == "range")
         if (rangeOne) {
-          if (
-            rangeOne.min &&
-            rangeOne.max &&
-            rangeOne.min.trim() &&
-            rangeOne.max.trim()
-          ) {
-            rangeOne.sdk_arg_value = rangeOne.min + "|" + rangeOne.max;
+          if (rangeOne.min && rangeOne.max && rangeOne.min.trim() && rangeOne.max.trim()) {
+            rangeOne.sdk_arg_value = rangeOne.min + "|" + rangeOne.max
           } else {
-            rangeOne.sdk_arg_value = false;
+            rangeOne.sdk_arg_value = false
           }
         }
       },
-      deep: true,
-    },
-  },
-};
+      deep: true
+    }
+  }
+}
 </script>
 
 <style lang="scss" scoped>
@@ -1080,17 +1000,17 @@
       }
 
       .el-input ::v-deep {
-        width: 50px;
+        width: 100px;
         height: 32px;
 
         input {
-          width: 50px;
+          width: 100px;
           height: 32px;
         }
       }
 
       .el-select {
-        width: 68px;
+        width: 100px;
       }
 
       .font {
@@ -1117,7 +1037,7 @@
   .btns {
     position: absolute;
     display: flex;
-    justify-content: end;
+    justify-content: flex-end;
     align-items: center;
     left: 0;
     right: 0;
@@ -1146,4 +1066,4 @@
     }
   }
 }
-</style>
\ No newline at end of file
+</style>

--
Gitblit v1.8.0