platformFront/src/components/knowledgeExtra/AddNewRule.vue

<style lang="less" scoped>
// @import "../../less/admin.less";
#AddRuleContent {
  width: 100%;
  min-width: 1000px;
  padding: 20px;
  padding-top: 50px;
  padding-bottom: 0;
  box-sizing: border-box;
  .table_form {
    width: 100%;
    box-sizing: border-box;
    background: #fff;
    padding: 20px;
    padding-bottom: 0;
    display: flex;
    flex-wrap: wrap;
    .table_cell {
      flex: 1;
      min-width: 25%;
    }
  }
  /deep/ .el-input--mini .el-input__inner,
  .el-select {
    width: 100%;
    font-size: 14px;
  }
  .tip_text {
    // margin-top: -8px;
    font-size: 12px;
    color: red;
    line-height: 16px;
    // transform: scale(.8, .8);
  }
  .form_btn {
    width: 100%;
    background: #fff;
    padding-bottom: 20px;
    text-align: center;
  }
  /deep/ .el-form-item.is-success .el-input__inner,
  .el-form-item.is-success .el-textarea__inner {
    border-color: #c9c9c9 !important;
  }
  /deep/ .el-form-item.is-success .el-textarea__inner {
    border-color: #c9c9c9 !important;
  }
  /deep/ .el-form-item.is-success .el-textarea__inner {
    border-color: #c9c9c9 !important;
  }
  .my_error {
    position: absolute;
    top: 0;
    left: -16px;
    img {
      width: 12px;
      height: 12px;
      cursor: pointer;
    }
  }
}
</style>
<style lang="less">
.popper_class {
  // background: #fff !important;
  border: 1px solid #ffa0a0 !important;
  color: #999999 !important;
  padding: 3px 50px 3px 10px !important;
  margin-left: -10px;
}
.popper__arrow {
  border-top-color: #ffa0a0 !important;
}
</style>
<template>
  <div>
    <crumbs
      :title="title"
      :param="$route.params"
      linkTo="ZskRuleManager"
    ></crumbs>
    <div id="AddRuleContent">
      <el-form size="mini" :model="form" ref="ruleForm">
        <div class="table_form">
          <div class="table_cell">
            <!-- 规则名称 -->
            <el-form-item
              label-width="130px"
              label="规则名称："
              :rules="rules.parDescription"
              prop="parDescription"
            >
              <el-input
                style="width: 100%"
                v-model.trim="form.parDescription"
              />
            </el-form-item>
          </div>

          <div class="table_cell">
            <!-- 规则类型 -->
            <el-form-item
              label-width="130px"
              label="规则类型："
              :rules="rules.parRuleType"
              prop="parRuleType"
            >
              <el-select
                v-model="form.parRuleType"
                placeholder="请选择"
                @change="ruleTypeChange"
              >
                <el-option
                  v-for="item in ruleTypeList"
                  :key="item.id"
                  :label="item.name"
                  :value="item.id"
                ></el-option>
              </el-select>
              <template slot="error" slot-scope="scope">
                <div class="my_error">
                  <el-tooltip
                    class="item"
                    effect="light"
                    :content="scope.error"
                    placement="top-start"
                    popper-class="popper_class"
                  >
                    <img src="../../images/exclamationpoint.png" alt />
                  </el-tooltip>
                </div>
              </template>
              <div class="tip_text">
                注：更改规则类型，将会清空已填写的规则内容~
              </div>
            </el-form-item>
          </div>
          <div class="table_cell">
            <!-- 规则术语类型： -->
            <el-form-item
              label-width="130px"
              label="规则术语类型："
              :rules="rules.parLenCode"
              prop="parLenCode"
            >
              <template slot="error" slot-scope="scope">
                <div class="my_error">
                  <el-tooltip
                    class="item"
                    effect="light"
                    :content="scope.error"
                    placement="top-start"
                    popper-class="popper_class"
                  >
                    <img src="../../images/exclamationpoint.png" alt />
                  </el-tooltip>
                </div>
              </template>
              <el-select
                v-model="form.parLenCode"
                placeholder="请选择"
                @change="ruleTermChange"
              >
                <el-option
                  v-for="item in ruleTermTypeList"
                  :key="item.id"
                  :label="item.name"
                  :value="item.code"
                ></el-option>
              </el-select>
              <div class="tip_text">
                注：更改规则术语类型，将会清空已填写的规则内容~
              </div>
            </el-form-item>
          </div>
          <div class="table_cell">
            <el-form-item
              label-width="130px"
              label="医学标准术语："
              :style="{ height: '100%' }"
              :rules="rules.parConceptId"
              prop="parConceptId"
            >
              <el-select
                clearable
                filterable
                remote
                :remote-method="searchConcept"
                v-model.trim="form.parConceptId"
                @change="parConceptIdChange"
              >
                <el-option
                  v-for="item in conceptList"
                  :key="item.conceptId"
                  :label="item.conceptName"
                  :value="item.conceptId"
                  :title="item.conceptName"
                ></el-option>
              </el-select>
            </el-form-item>
          </div>
          <div
            class="table_cell"
            v-if="showHasSub && isShow"
            style="max-width: 25%"
          >
            <el-form-item
              label-width="130px"
              label="有无子条件："
              :rules="rules.parHasSub"
              prop="parHasSub"
            >
              <el-select
                v-model="form.parHasSub"
                placeholder="请选择"
                @change="hasSubChange"
              >
                <el-option label="有" :value="1"></el-option>
                <el-option label="无" :value="0"></el-option>
              </el-select>
            </el-form-item>
          </div>
          <!-- <div
            class="table_cell"
            style="flex: 3; max-width: 50%"
            v-if="showMsg"
          >
          
            <el-form-item
              label-width="130px"
              label="附加信息："
              :rules="rules.parMsg"
              prop="parMsg"
            >
              <el-input
                type="textarea"
                :rows="1"
                placeholder="请输入附加信息"
                v-model.trim="form.parMsg"
              ></el-input>
            </el-form-item>
          </div>-->
        </div>
        <!-- 表格 -->
        <AddNewRuleTable ref="tableView" v-if="form.parHasSub && tableShow"
        :klRuleByIdSub="form.klRuleByIdSub" :maxNum="subRuleMaxNum"
        :showMsg="showMsg" :showMsg2="showMsg2"
        :ruleTermCodeStr="ruleTermCodeStr" <<<<<<< HEAD
        :isStaticChild='isStatic' :isRedMsgs='isRedMsg' =======
        :isStaticChild="isStatic" :isRedMsgs="isRedMsg" >>>>>>> bug0818
        @subTypeChange="subTypeChange" @searchConcept="searchConcept"
        @addGroup="addGroup" @delGroup="delGroup" @delGroupChild="delGroupChild"
        @setFormData="setFormData" @editKlRuleByIdSub="editKlRuleByIdSub"
        @clearValidate="clearValidate" @childClearConcept="childClearConcept"
        @childClearNumText="childClearNumText"
        @ChildDataTypeChange="ChildDataTypeChange"
        @childSubCodeChange="childSubCodeChange" />
        <AddNewRuleContent
          ref="ruleContent"
          v-if="(!form.parHasSub && !tableShow) || contentRuls"
          @ruleContent="ruleContent"
          :isContent="isEdit"
          :formEidtCopy="formEidt"
          :isError="isErr"
        >
        </AddNewRuleContent>
        <el-form-item>
          <div class="form_btn">
            <el-button
              type="primary"
              size="medium "
              @click="submitForm('ruleForm')"
              >确定</el-button
            >
          </div>
        </el-form-item>
      </el-form>
    </div>
  </div>
</template>
<script type="text/javascript">
import api from "@api/knowledgeLib.js";
import { formRules } from "./rules";
import AddNewRuleTable from "./AddNewRuleTable";
import AddNewRuleContent from "./AddNewRuleContent";
export default {
  name: "AddRule",
  data() {
    return {
      isRedMsg: [],
      isErr: false, //控制护理开单项里面的错误提示
      staicData: {
        //护理开单项里面的数据
        gljtxx: [],
        fjxx: "",
      },
      formEidt: {},
      isEdit: false, //判断是否是编辑页面
      isStatic: false, //判断关联静态知识的tabel列是否显示
      contentRuls: false, //判断规则内容为列表还是表单
      title: "规则维护-添加规则",
      ruleTypeList: [], //规则类型列表  1
      ruleTermTypeList: [], //规则术语类型列表  2
      conceptList: [], //医学标准术语列表 3
      baseTypeList: [], //基础规则类型列表  4
      baseTermTypeList: [], //基础规则术语类型 5
      subRuleMaxNum: null, //规则内容中规则的限制个数
      isCopy: false,
      parId: null,
      msgDict: "", //显示附加信息的类型
      firstPlace: null,
      tableShow: true,
      form: {
        parDescription: "",
        parRuleType: "",
        parConceptId: "",
        parlibName: "",
        parLenName: "",
        parHasSub: undefined,
        parLenCode: "",
        klRuleByIdSub: [],
      },
      isShow: false,
      rules: formRules,
      dragVal: null,
      dragArr: null,
    };
  },
  created() {
    this.getTypeList();
    this.setDict();
    const param = this.$route.params;
    let info = param.data;
    if (info) {
      this.parId = info.parId;
      this.isCopy = param.copy;
      this.title = "规则维护-" + (this.isCopy ? "复制" : "修改") + "规则";
      this.getDragData(info);
      // 编辑初始化选择框

      this.initEdidData();
    }
  },
  mounted() {},
  watch: {},
  methods: {
    //护理开单项子组件里面的传过来的值
    ruleContent(data) {
      this.staicData = data;
    },
    clearValidate(data) {
      this.$refs.ruleForm.clearValidate(data);
    },
    // 编辑初始化
    async initEdidData() {
      // 规则术语类型初始化
      this.contentRuls = false;
      this.isEdit = false;
      this.isRedMsg = [];
      const newruleTermTypeList = await this.ruleTypeList.find(
        (it) => it.id == this.form.parRuleType
      );
      this.ruleTermTypeList = await newruleTermTypeList.subMenuList;
      // 基础规则类型初始化
      const obj = await this.ruleTermTypeList.find(
        (it1) => it1.code == this.form.parLenCode
      );
      this.baseTypeList = obj.subMenuList;
      this.subRuleMaxNum = obj.number;
      this.conceptList = [
        {
          conceptName: this.form.parlibName,
          conceptId: this.form.parConceptId,
        },
      ];
      // 加载护理开单项的推送内容
      if (!this.form.klRuleByIdSub) {
        this.isEdit = true;
        this.contentRuls = true;
        this.formEidt = JSON.parse(JSON.stringify(this.form));
        return;
      }
      //加载护理非开单项的关联静态知识
      if (this.form.parRuleType == 8) {
        this.isStatic = true;
        if (Array.isArray(this.form.klRuleByIdGroup)) {
          let itemCopy = {}; //用来存放对象
          let itemsCopy = {};
          let klRuleByIdSub = []; //中间数组
          this.form.klRuleByIdGroup.forEach((item, index) => {
            let obj = {
              groupType: item.groupType,
              klRuleStaticSub: item.klRuleStaticSub,
            };
            itemCopy = JSON.parse(JSON.stringify(obj));
            klRuleByIdSub.push(itemCopy);
          });
          if (Array.isArray(this.form.klRuleByIdSub)) {
            this.form.klRuleByIdSub.forEach((item) => {
              this.$set(item, "ruleStatic", []);
              this.$set(item, "ruleStaticList", []);
              this.$set(item, "ruleStaticLists", []);
            });
          }
          this.form.klRuleByIdSub.forEach((item, index) => {
            klRuleByIdSub.forEach((items) => {
              if (items.groupType == item.groupType) {
                this.form.klRuleByIdSub[index].ruleStaticLists =
                  items.klRuleStaticSub;
              }
            });
          });
          this.form.klRuleByIdSub.forEach((item, index) => {
            if (Array.isArray(item.ruleStaticLists)) {
              item.ruleStaticLists.forEach((items) => {
                let obj = {
                  id: items.conceptId,
                  name: items.name,
                };
                itemsCopy = JSON.parse(JSON.stringify(obj));
                this.form.klRuleByIdSub[index].ruleStaticList.push(itemsCopy);
                this.form.klRuleByIdSub[index].ruleStatic.push(itemsCopy.id);
              });
            }
          });
        }
      }
      //加载列表规则内容
      if (this.form.parConceptId && this.checkFirstPlace && this.conceptList) {
        this.firstPlace = this.conceptList.find(
          (it) => it.conceptId === this.form.parConceptId
        );
        if (this.firstPlace) {
          this.firstPlace["checkedType"] = this.ruleTermCodeStrs;
        }
      } else if (!this.form.parConceptId) {
        this.setInitGroupData();
        this.firstPlace = null;
      } else {
        this.firstPlace = null;
      }
      await this.form.klRuleByIdSub.forEach((item, i, arr) => {
        item.groupId = "groupId" + item.groupType;
        item.groupChildId = "child" + item.subId;
        //TODO => 赋值时一定要注意set更新页面
        this.$set(item, "baseTypes", [...this.baseTypeList]);
        // this.$set(key, "baseTypes", [...this.baseTypeList]);
        this.$set(
          item,
          "baseTermTypeList",
          item.baseTypes.find((it2) => it2.type === item.subType).subMenuList
        );
        this.$set(item, "conceptList", [
          {
            conceptName: item.subLibName || item.subConceptName,
            conceptId: item.subConceptId,
          },
        ]);
        if (item.subMaxOperator || item.subMinOperator) {
          item.dataType = "1";
        } else if (item.subEqValue) {
          item.dataType = "2";
        }
        // disable
        if (this.form.parHasSub && this.firstPlace) {
          const del =
            localStorage
              .getItem("zskDelDict")
              .match(
                new RegExp(this.firstPlace.checkedType + "-\\d+" + "-\\d+", "g")
              ) || [];
          if (arr[i - 1] && arr[i - 1].groupId == item.groupId) {
            this.$set(item, "disabled", false);
            if (del.length > 0 && item.subType == del[0].split("-")[2]) {
              const delType = del[0].split("-");
              const types = del[0].split("-");
              const subobj = this.baseTypeList.find(
                (it) => it.type == types[2]
              );
              const screenArr = subobj.subMenuList.filter((item) => {
                return !types[3].includes(item.code);
              });
              this.$set(item, "baseTermTypeList", screenArr);
            }
          } else {
            this.$set(item, "disabled", true);

            if (this.form.parLenCode == "108" && this.form.parRuleType == "8") {
              const subobj = this.baseTypeList.find((it) => it.type == "2");
              subobj.subMenuList.push({
                code: "108",
                creator: "0",
                firstPlace: null,
                gmtCreate: "1970-01-01 12:00:00",
                gmtModified: "1970-01-01 12:00:00",
                id: 27106,
                isDeleted: "N",
                modifier: "0",
                name: "实验室检查子项目",
                number: null,
                orderNo: 1,
                parentId: 27103,
                planCode: "rule",
                remark: "",
                ruleType: 8,
                subMenuList: [],
                type: null,
              });
              this.$set(item, "baseTermTypeList", subobj.subMenuList);
            }
          }
        }
        const dragDel =
          localStorage
            .getItem("zskDragDict")
            .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
        //药品开单合理判断
        if (dragDel.length > 0) {
          const obj = this.baseTypeList.find((it) => it.type === 1);
          if (arr[i - 1] && arr[i - 1].groupId == item.groupId) {
            let klRuleByIdSub = this.form.klRuleByIdSub;
            klRuleByIdSub.forEach((item, i, arr) => {
              if (arr[i].key != 0) {
                const arr = this.baseTypeList.filter((it) => {
                  return it.type == 1;
                });
                if (i > 0) {
                  this.$set(item, "baseTypes", arr);
                }
              }
            });
            if (item.key == 2) {
              //获取互斥项code
              const list = obj.subMenuList.filter((it) => {
                return (
                  it.code == arr[i - 1].subLenCode &&
                  it.remark.split("|")[0] == 3
                );
              });
              const dragArr = list[0].remark.split("|")[1].split(",");
              this.dragArr = dragArr;
              this.dragVal = item.subLenCode;
              item.dragArr = dragArr;
              //取出互斥项
              const screenArr = obj.subMenuList.filter((item) =>
                dragArr.some(
                  (ele) => ele === item.code && item.remark.split("|")[0] == 3
                )
              );
              this.$set(item, "baseTermTypeList", screenArr);
            } else {
              const screenArr = obj.subMenuList.filter((it) => {
                if (it.remark == "") {
                  return it;
                } else {
                  return it.remark.split("|")[0] == (item.key % 3) + 1;
                }
              });

              this.$set(item, "baseTermTypeList", screenArr);
            }
          }
        }
      });
    },
    //药品数据处理
    getDragData(info) {
      let dataArr = [];
      //处理修改接口请求的数据
      //先将数据深拷贝，避免数据污染
      let infoCopy = JSON.parse(JSON.stringify(info));
      infoCopy.klRuleByIdSubCopy = [];
      if (info.klRuleByIdGroup.length > 0) {
        let klRuleByIdSub = {};
        info.klRuleByIdGroup.forEach((item) => {
          if (item.klRuleByIdSub && Array.isArray(item.klRuleByIdSub)) {
            item.klRuleByIdSub.forEach((items) => {
              klRuleByIdSub = JSON.parse(JSON.stringify(items));
              infoCopy.klRuleByIdSubCopy.push(klRuleByIdSub);
            });
            infoCopy.klRuleByIdSub = [...item.klRuleByIdSub];
          }
        });
      }
      if (
        Array.isArray(info.klRuleByIdGroup) &&
        info.klRuleByIdGroup.length == 0
      ) {
        this.form = JSON.parse(JSON.stringify(info));
        return;
      }
      //判断是否存在klRuleByIdSub，没有就是护理开单项直接赋值
      if (!info.klRuleByIdGroup[0].klRuleByIdSub) {
        this.form = JSON.parse(JSON.stringify(info));
      } else {
        let arr = JSON.parse(JSON.stringify(infoCopy.klRuleByIdSubCopy));
        arr.map((mapItem) => {
          if (dataArr.length == 0) {
            dataArr.push({ groupType: mapItem.groupType, List: [mapItem] });
          } else {
            let res = dataArr.some((item) => {
              //判断相同日期，有就添加到当前项
              if (item.groupType == mapItem.groupType) {
                item.List.push(mapItem);
                return true;
              }
            });
            if (!res) {
              //如果没找相同日期添加一个新对象
              dataArr.push({ groupType: mapItem.groupType, List: [mapItem] });
            }
          }
        });
        this.getDragData2(info, dataArr);
      }
    },
    getDragData2(info, dataArr) {
      let arr = [];
      dataArr.map((item) => {
        item.List.map((it, i) => {
          it.key = i;
          it.del = i == 0 ? true : false;
          arr.push(it);
        });
      });
      info.klRuleByIdSub = arr;
      this.form = JSON.parse(JSON.stringify(info));
    },
    // 提交
    submitForm(formName) {
      this.$refs[formName].validate((valid) => {
        if (valid) {
          this.isErr = false;
          this.isRedMsg = [];
          let params = JSON.parse(JSON.stringify(this.form));
          if (params.klRuleByIdSub) {
            params.klRuleInfoSaveSub = params.klRuleByIdSub;
            delete params.klRuleByIdSub;
            params.klRuleInfoSaveSub.forEach((item, i, arr) => {
              if (i === 0) {
                item.groupType = 1;
              } else {
                if (item.groupId == arr[i - 1].groupId) {
                  item.groupType = arr[i - 1].groupType;
                  item.subMsg = arr[i - 1].subMsg;
                } else {
                  item.groupType = arr[i - 1].groupType + 1;
                }
              }
            });
            params.klRuleInfoSaveSub.forEach((ite) => {
              delete ite.groupId;
              delete ite.groupChildId;
              delete ite.rowIndex;
              delete ite.baseTypes;
              delete ite.baseTermTypeList;
              delete ite.conceptList;
            });
          }
          if (this.parId) {
            params.parId = this.isCopy ? undefined : this.parId;
            params.parStatus = this.isCopy ? 1 : this.form.parStatus;
          }
          //改造params,保存护理开单项类型的
          let paramsCopy = JSON.parse(JSON.stringify(params));
          //先遍历子集klRuleInfoSaveSub
          paramsCopy.klRuleInfoSaveGroup = [];
          let obj = {
            groupType: 0,
            klRuleInfoSaveSub: [],
          };
          this.$set(obj, "ruleStatic", []);
          if (
            params.klRuleInfoSaveSub &&
            Array.isArray(params.klRuleInfoSaveSub)
          ) {
            if (params.klRuleInfoSaveSub.length > 0) {
              params.klRuleInfoSaveSub.forEach((item) => {
                obj.groupType = item.groupType;
                obj.klRuleInfoSaveSub = [item];
                let objCopy = JSON.parse(JSON.stringify(obj));
                //可以处理objCopy，将groupType相同的放入klRuleInfoSaveSub里面
                paramsCopy.klRuleInfoSaveGroup.push(objCopy);
              });
            } else {
              paramsCopy.klRuleInfoSaveGroup.push(obj);
            }
          } else {
            paramsCopy.klRuleInfoSaveGroup.push(obj);
          }
          if (
            paramsCopy.klRuleInfoSaveSub &&
            Array.isArray(paramsCopy.klRuleInfoSaveSub)
          ) {
            //护理非开单项的关联静态知识的处理
            paramsCopy.klRuleInfoSaveSub.forEach((item, ind) => {
              let ruleObj = {};
              if (Array.isArray(item.ruleStatic)) {
                item.ruleStatic.forEach((items, index) => {
                  ruleObj.conceptId = items;
                  ruleObj.orderNo = index;
                  let ruleObjCopy = JSON.parse(JSON.stringify(ruleObj));
                  //将关联静态知识的对象放入数组内
                  paramsCopy.klRuleInfoSaveGroup[ind].ruleStatic.push(
                    ruleObjCopy
                  );
                });
              }
            });
            //删除第二层的klRuleInfoSaveSub
            delete paramsCopy.klRuleInfoSaveSub;
            //清除子集的关联静态知识
            paramsCopy.klRuleInfoSaveGroup.forEach((item, index) => {
              if (index + 1 >= paramsCopy.klRuleInfoSaveGroup.length) return;
              if (
                item.groupType ==
                paramsCopy.klRuleInfoSaveGroup[index + 1].groupType
              ) {
                paramsCopy.klRuleInfoSaveGroup[index + 1].ruleStatic = [];
              }
            });
          }
          //判断护理开单是否附加信息和关联静态信息是否都没存在值
          let flagRule = false;
          //附加信息
          if (this.staicData.fjxx) {
            paramsCopy.klRuleInfoSaveGroup[0].groupType = "1";
            paramsCopy.parMsg = this.staicData.fjxx;
            flagRule = true;
          } else {
            paramsCopy.parMsg = "";
          }
          //关联静态知识
          if (this.staicData.gljtxx.length > 0) {
            paramsCopy.klRuleInfoSaveGroup[0].groupType = "1";
            let rule = {};
            this.staicData.gljtxx.forEach((item, index) => {
              rule.conceptId = item;
              rule.orderNo = index;
              let ruleCopy = JSON.parse(JSON.stringify(rule));
              paramsCopy.klRuleInfoSaveGroup[0].ruleStatic.push(ruleCopy);
            });
            flagRule = true;
          }
          //如果是护理项并且静态知识和附加信息都没有值
          if (this.contentRuls && !flagRule) {
            this.isErr = true;
            return;
          }
          //如果护理非开单项关联静态知识和附加信息都没有值
          if (this.isStatic) {
            if (Array.isArray(paramsCopy.klRuleInfoSaveGroup)) {
              paramsCopy.klRuleInfoSaveGroup.forEach((item) => {
                if (Array.isArray(item.klRuleInfoSaveSub)) {
                  item.klRuleInfoSaveSub.forEach((items) => {
                    if (items.ruleStatic && Array.isArray(items.ruleStatic)) {
                      if (items.ruleStatic.length > 0 || items.subMsg) {
                        this.isRedMsg.push(false);
                      } else {
                        this.isRedMsg.push(true);
                      }
                    } else {
                      this.isRedMsg.push(false);
                    }
                  });
                }
              });
            }
          }
          //判断护理非开单项里面的附加信息和关联静态知识是否填写
          if (this.isStatic && this.isRedMsg.length > 0) {
            let flag = this.isRedMsg.some((item) => {
              return item;
            });
            //都填写了
            if (!flag) this.saveRule(paramsCopy);
          } else {
            this.saveRule(paramsCopy);
          }
        } else {
          return false;
        }
      });
    },
    // 子集修改父级的数组
    setFormData(index, data) {
      this.$set(this.form.klRuleByIdSub[index], "conceptList", data);
    },
    // table_form 规则类型选中
    ruleTypeChange(val) {
      //先初始化
      this.contentRuls = false;
      this.isStatic = false;
      this.isRedMsg = [];
      //是否护理非开单项
      if (val === 8) {
        this.isStatic = true;
      }
      this.form.parLenCode = "";
      const obj = this.ruleTypeList.find((it) => it.id === val);
      this.ruleTermTypeList = obj.subMenuList;
      this.subRuleMaxNum = undefined;
      this.setInitGroupData();
    },
    // table_form 规则术语类型选中
    ruleTermChange(val) {
      this.contentRuls = false;
      this.isRedMsg = [];
      const obj = this.ruleTermTypeList.find((it) => it.code === val);
      this.form.parLenName = obj.name;
      this.baseTypeList = obj.subMenuList;
      this.subRuleMaxNum = obj.number;
      this.form.parHasSub = obj.subMenuList.length ? 1 : 0;
      if (!this.form.parHasSub) {
        this.contentRuls = true;
      }
      //初始化护理开单项的输入框
      if (this.contentRuls) {
        this.$nextTick(() => {
          this.isEdit = false;
          this.$refs.ruleContent.clearFormData();
        });
      }

      this.isShow = obj.subMenuList.length ? 1 : 0;
      this.setInitGroupData();
    },
    // 医学标准术语
    parConceptIdChange(val) {
      this.$nextTick(() => {
        if (val && this.checkFirstPlace && this.conceptList) {
          this.firstPlace = this.conceptList.find((it) => it.conceptId === val);
          if (this.firstPlace) {
            this.firstPlace["checkedType"] = this.ruleTermCodeStrs;
          }
        } else if (!val) {
          this.setInitGroupData();
          this.firstPlace = null;
        } else {
          this.firstPlace = null;
        }
        if (this.form.parHasSub && this.firstPlace) {
          const dict =
            localStorage
              .getItem("zskDicts")
              .match(new RegExp(this.firstPlace.checkedType + "-\\d+", "g")) ||
            [];
          const del =
            localStorage
              .getItem("zskDelDict")
              .match(
                new RegExp(this.firstPlace.checkedType + "-\\d+" + "-\\d+", "g")
              ) || [];
          const types = dict[0].split("-");
          let obj = this.form.klRuleByIdSub;
          obj.forEach((item, i, arr) => {
            if (arr[i - 1] && arr[i - 1].groupId == item.groupId) {
              this.$set(item, "disabled", false);
              if (del.length > 0) {
                const delType = del[0].split("-");
                if (
                  item.subType == delType[2] ||
                  item.subLenCode == delType[3]
                ) {
                  this.$set(this.form.klRuleByIdSub, i, {
                    groupId: item.groupId,
                    groupChildId: "child" + new Date().valueOf(),
                    baseTypes: this.baseTypeList,
                    baseTermTypeList: [],
                    conceptList: [],
                    subDescription: "",
                    parRuleType: "",
                    subConceptId: "",
                    subType: "",
                    subMaxOperator: "",
                    subMaxUnit: "",
                    subMaxValue: "",
                    subMinOperator: "",
                    subMinUnit: "",
                    subMinValue: "",
                    subEqValue: "",
                    subLenCode: "",
                    dataType: "",
                    key: 0,
                  });
                }
              }
            } else {
              this.$set(item, "disabled", true);
              // //因为字典传的时候第三个值没有护理所以重新赋值为9，因为这里后端逻辑问题先注释后面可能有用
              // this.baseTypeList.forEach((item)=>{
              //  if(item.type==9){
              //   types[2]='9'
              //  }
              // })
              this.$set(item, "subType", parseInt(types[2]));
              const subobj = this.baseTypeList.find(
                (it) => it.type == types[2]
              );
              if (
                this.form.parLenCode == "108" &&
                this.form.parRuleType == "8"
              ) {
                subobj.subMenuList.push({
                  code: "108",
                  creator: "0",
                  firstPlace: null,
                  gmtCreate: "1970-01-01 12:00:00",
                  gmtModified: "1970-01-01 12:00:00",
                  id: 27106,
                  isDeleted: "N",
                  modifier: "0",
                  name: "实验室检查子项目",
                  number: null,
                  orderNo: 1,
                  parentId: 27103,
                  planCode: "rule",
                  remark: "",
                  ruleType: 8,
                  subMenuList: [],
                  type: null,
                });
              }
              this.$set(item, "baseTermTypeList", subobj.subMenuList);
              this.$set(item, "subLenCode", types[1]);
              this.$set(item, "subDescription", this.firstPlace.conceptName);
              this.$set(item, "subConceptId", this.firstPlace.conceptId);
              this.$set(item, "subConceptName", this.firstPlace.conceptName);
              this.$set(item, "conceptList", [this.firstPlace]);
            }
          });
          this.$set(this.form, "klRuleByIdSub", obj);
          if (this.form.parLenCode == "104" && this.form.parRuleType == "8") {
            this.form.klRuleByIdSub[0].dataType = "1";
          }
        }
      });
    },
    // 初始化表格
    setInitGroupData(init) {
      this.tableShow = false;
      const date = new Date().valueOf();
      this.$nextTick(() => {
        if (this.form.parHasSub && this.form.parHasSub != 0) {
          this.$set(this.form, "klRuleByIdSub", [
            {
              groupId: date,
              groupChildId: "child" + new Date().valueOf(),
              baseTypes: this.baseTypeList,
              baseTermTypeList: [],
              conceptList: [],
              subDescription: "",
              parRuleType: "",
              subConceptId: "",
              subType: "",
              subMaxOperator: "",
              subMaxUnit: "",
              subMaxValue: "",
              subMinOperator: "",
              subMinUnit: "",
              subMinValue: "",
              subEqValue: "",
              subLenCode: "",
              dataType: "",
              key: 0,
              del: true,
            },
          ]);
        } else {
          this.$set(this.form, "klRuleByIdSub", []);
        }
        if (!init) {
          this.form.parConceptId = ""; //医学标准术语清空
          this.conceptList = []; //下拉列表清空
          this.firstPlace = null;
        }
        this.tableShow = true;
      });
    },
    // 有无子条件切换
    hasSubChange(val) {
      if (val) {
        this.setInitGroupData(true);
      } else {
        this.form.klRuleByIdSub = [];
      }
    },
    // 基础规则类型切换
    subTypeChange(val, index, groupId, key) {
      // index
      const dragDel =
        localStorage
          .getItem("zskDragDict")
          .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
      const obj = this.baseTypeList.find((it) => it.type === val);
      let dragType = false;
      let isDel = false;
      let screenArr;
      let type;
      //药品开单合理判断
      if (dragDel.length > 0) {
        dragType = true;
        const types = dragDel[0].split("-");
        const arr = this.form.klRuleByIdSub.filter((item, i) => {
          return item.groupId == groupId;
        });
        if (key == 1 && arr[2]) {
          type = arr[2].subLenCode == "" ? false : true;
        } else if (key == 2) {
          type = arr[1].subLenCode == "" ? false : true;
        }
        if (arr.length == 3 && key != 0 && type) {
          //获取互斥项code
          const val = key == 1 ? arr[2].subLenCode : arr[1].subLenCode;
          const list = obj.subMenuList.filter((it) => {
            return it.code == val && it.remark.split("|")[0] == 3;
          });
          const dragArr = list[0].remark.split("|")[1].split(",");
          this.dragArr = dragArr;
          arr[1].dragArr = arr[2].dragArr = dragArr;
          //取出互斥项
          screenArr = obj.subMenuList.filter((item) =>
            dragArr.some(
              (ele) => ele === item.code && item.remark.split("|")[0] == 3
            )
          );
        } else {
          screenArr = obj.subMenuList.filter((item) => {
            if (item.remark == "") {
              return item;
            } else {
              return item.remark.split("|")[0] == (key % 3) + 1;
            }
          });
        }
      }
      //危急值实验室子项目已选医学标准术语判断
      if (this.form.parHasSub && this.firstPlace) {
        const del =
          localStorage
            .getItem("zskDelDict")
            .match(
              new RegExp(this.firstPlace.checkedType + "-\\d+" + "-\\d+", "g")
            ) || [];
        if (del.length > 0) {
          isDel = true;
          const types = del[0].split("-");
          const subobj = this.baseTypeList.find((it) => it.type == types[2]);
          screenArr = subobj.subMenuList.filter((item) => {
            return !types[3].includes(item.code);
          });
        }
        if (this.form.parLenCode == "108" && this.form.parRuleType == "8") {
          const subobj = this.baseTypeList.find((it) => it.type == "2");
          subobj.subMenuList.splice(1, 1);
          this.$set(obj, "baseTermTypeList", subobj.subMenuList);
        }
      }
      this.$set(
        this.form.klRuleByIdSub[index],
        "baseTermTypeList",
        (isDel && val == 2) || dragType ? screenArr : obj.subMenuList
      );
      this.$set(this.form.klRuleByIdSub[index], "subLenCode", "");
      this.$set(this.form.klRuleByIdSub[index], "dataType", "");

      this.clearConcept(index);
      this.clearNumText(index);
    },
    clearConcept(index) {
      this.$set(this.form.klRuleByIdSub[index], "subConceptId", "");
      this.conceptList = [];
    },
    clearNumText(index) {
      this.$set(this.form.klRuleByIdSub[index], "subMaxOperator", "");
      this.$set(this.form.klRuleByIdSub[index], "subMaxValue", "");
      this.$set(this.form.klRuleByIdSub[index], "subMaxUnit", "");
      this.$set(this.form.klRuleByIdSub[index], "subMinOperator", "");
      this.$set(this.form.klRuleByIdSub[index], "subMinValue", "");
      this.$set(this.form.klRuleByIdSub[index], "subMinUnit", "");
      this.$set(this.form.klRuleByIdSub[index], "subEqValue", "");
      this.$set(this.form.klRuleByIdSub[index], "subEqOperator", "");
    },
    editKlRuleByIdSub(data) {
      this.$set(this.form, "klRuleByIdSub", data);
      // this.form.klRuleByIdSub = data;
    },
    // 添加分组 || 规则
    addGroup(date, key, arg = { index: null, groupId: null }, index) {
      /**
       * @params
       *    date:存在则添加规则 不存在则添加分组
       *    arg:{index:添加规则用索引，groupId:添加分组用确切id}
       */
      !date && (date = new Date().valueOf());
      let dataType = "";
      if (this.form.parLenCode == "104" && this.form.parRuleType == "8") {
        dataType = "1";
      } else {
        dataType = "";
      }
      const obj = {
        groupId: date,
        groupChildId: "child" + new Date().valueOf(),
        baseTypes: this.baseTypeList,
        baseTermTypeList: [],
        conceptList: [],
        subDescription: "",
        parRuleType: "",
        subConceptId: "",
        subType: "",
        subMaxOperator: "",
        subMaxUnit: "",
        subMaxValue: "",
        subMinOperator: "",
        subMinUnit: "",
        subMinValue: "",
        subEqValue: "",
        subLenCode: "",
        dataType: dataType,
      };
      if (
        this.form.parLenCode == "108" &&
        this.form.parRuleType == "8" &&
        index == "1"
      ) {
        const subobj = this.baseTypeList.find((it) => it.type == "2");
        subobj.subMenuList.push({
          code: "108",
          creator: "0",
          firstPlace: null,
          gmtCreate: "1970-01-01 12:00:00",
          gmtModified: "1970-01-01 12:00:00",
          id: 27106,
          isDeleted: "N",
          modifier: "0",
          name: "实验室检查子项目",
          number: null,
          orderNo: 1,
          parentId: 27103,
          planCode: "rule",
          remark: "",
          ruleType: 8,
          subMenuList: [],
          type: null,
        });
        this.$set(obj, "baseTermTypeList", subobj.subMenuList);
      }
      if (typeof arg.index == "number") {
        // 添加规则 直接在当前位置之后添加
        this.form.klRuleByIdSub.splice(arg.index + 1, 0, obj);
        this.$set(obj, "del", false);
        const dragDel =
          localStorage
            .getItem("zskDragDict")
            .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
        if (dragDel.length > 0) {
          const len = this.form.klRuleByIdSub.filter((item, i) => {
            return item.groupId == date;
          });
          let obj = this.form.klRuleByIdSub;
          obj.forEach((item, i, arr) => {
            len.forEach((its, index) => {
              if (item.groupId == its.groupId) {
                this.$set(its, "key", index);
                if (its.key > 0 && index > 0) {
                  const arrList = this.baseTypeList.filter((it) => {
                    return it.type == 1;
                  });
                  this.$set(its, "baseTypes", arrList);
                }
              }
            });
          });
          if (
            len.length == 3 && (key == 1 || key == 0) && key == 0
              ? len[2].subLenCode
              : len[1].subLenCode
          ) {
            const dragVal = key == 0 ? len[2].subLenCode : len[1].subLenCode;
            this.dragVal = dragVal;
            const subobj = this.baseTypeList.find((it) => it.type == 1);
            const list = subobj.subMenuList.filter((it) => {
              return it.code == dragVal && it.remark.split("|")[0] == 3;
            });
            // //获取互斥项code
            const dragArr = list[0].remark.split("|")[1].split(",");
            len[1].dragArr = len[2].dragArr = dragArr;
          }
        }
      } else {
        // 添加分组 在列表中相同groupId之后添加
        // 添加分组时判断是否需要加disabled和添加默认值
        if (this.form.parHasSub && this.firstPlace) {
          obj.disabled = true;
          const dict =
            localStorage
              .getItem("zskDicts")
              .match(new RegExp(this.firstPlace.checkedType + "-\\d+", "g")) ||
            [];
          const types = dict[0].split("-");
          // //因为字典传的时候第三个值没有护理所以重新赋值为9,因为这里后端逻辑问题先注释后面可能有用
          // this.baseTypeList.forEach((item)=>{
          // 	if(item.type==9){
          // 		types[2]='9'
          // 	}
          // })
          this.$set(obj, "disabled", true);
          this.$set(obj, "subType", parseInt(types[2]));
          const subobj = this.baseTypeList.find((it) => it.type == types[2]);
          this.$set(obj, "baseTermTypeList", subobj.subMenuList);
          this.$set(obj, "subLenCode", types[1]);
          this.$set(obj, "subDescription", this.firstPlace.conceptName);
          this.$set(obj, "subConceptId", this.firstPlace.conceptId);
          this.$set(obj, "subConceptName", this.firstPlace.conceptName);
          this.$set(obj, "conceptList", [this.firstPlace]);
        }
        var i = -1;
        this.form.klRuleByIdSub.forEach((item, inx) => {
          if (item.groupId === arg.groupId) {
            i = inx;
          }
        });
        this.form.klRuleByIdSub.splice(i + 1, 0, obj);
        this.$set(obj, "del", true);
        this.$set(obj, "key", 0);
        this.dragArr = null;
      }
      this.$nextTick(() => {
        this.$refs.tableView.scrollFun();
      });
    },
    // 删除分组
    delGroup(groupId) {
      const list = this.form.klRuleByIdSub.filter(
        (item) => item.groupId != groupId
      );
      this.form.klRuleByIdSub = list;
    },
    // 删除规则
    delGroupChild(groupChildId, index, groupId, del, key, lens) {
      let newGroupList;
      const dragDel =
        localStorage
          .getItem("zskDragDict")
          .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
      let list;
      if (dragDel.length > 0) {
        const arr = this.form.klRuleByIdSub.filter((item, i) => {
          return item.groupId != groupId;
        });
        const len = this.form.klRuleByIdSub.filter((item, i) => {
          return item.groupId == groupId;
        });
        if (del) {
          const date = new Date().valueOf();
          if (key == 0 && arr.length > 0) {
            newGroupList = this.form.klRuleByIdSub.filter((item, i) => {
              return item.groupId != groupId;
            });
          } else {
            newGroupList = [
              {
                groupId: date,
                groupChildId: "child" + new Date().valueOf(),
                baseTypes: this.baseTypeList,
                baseTermTypeList: [],
                conceptList: [],
                subDescription: "",
                parRuleType: "",
                subConceptId: "",
                subType: "",
                subMaxOperator: "",
                subMaxUnit: "",
                subMaxValue: "",
                subMinOperator: "",
                subMinUnit: "",
                subMinValue: "",
                subEqValue: "",
                subLenCode: "",
                dataType: "",
                key: 0,
                del: true,
              },
            ];
            this.dragVal = null;
            this.dragArr = null;
          }
        } else if (key == 1) {
          let klRuleByIdSub = JSON.parse(
            JSON.stringify(this.form.klRuleByIdSub)
          );
          for (let i = klRuleByIdSub.length - 1; i >= 0; i--) {
            if (
              klRuleByIdSub[i].groupId == groupId &&
              klRuleByIdSub[i].key > 0
            ) {
              klRuleByIdSub.splice(i, 1);
            }
          }
          newGroupList = klRuleByIdSub;
          this.dragVal = null;
          this.dragArr = null;
        } else {
          newGroupList = this.form.klRuleByIdSub.filter(
            (item) => item.groupChildId != groupChildId
          );
          if (lens == 4) {
            const obj = this.baseTypeList.find((it) => it.type === 1);
            const screenArr = obj.subMenuList.filter((item) => {
              return item.remark.split("|")[0] == 2;
            });
            len[1].baseTermTypeList = screenArr;
          }

          this.dragVal = len[1].subLenCode;
        }
      } else {
        newGroupList = this.form.klRuleByIdSub.filter(
          (item) => item.groupChildId != groupChildId
        );
      }
      this.form.klRuleByIdSub = newGroupList;
    },
    setDict() {
      this.dict = localStorage.getItem("zskDicts");
      this.msgDict = localStorage.getItem("zskMsgDict");
      this.subDict = localStorage.getItem("zskSubDict");
    },
    showConfirmDialog(msg, resolve) {
      this.$alert(msg, "提示", {
        confirmButtonText: "确定",
        type: "warning",
      })
        .then(() => {
          resolve();
        })
        .catch(() => {});
    },
    searchConcept(val) {
      const param = {
        excludedConceptIds: [this.form.parRuleType],
        libType: this.form.parLenCode,
        name: val,
      };
      api
        .searchConcept(param)
        .then((res) => {
          if (res.data.code == "0") {
            const data = res.data.data;
            this.conceptList = data;
          }
        })
        .catch((error) => {
          console.log(error);
        });
    },
    getTypeList() {
      this.ruleTypeList = JSON.parse(localStorage.getItem("zskTypesList"));
    },
    saveRule(params) {
      api.saveRule(params).then((res) => {
        if (res.data.code == 0) {
          this.$message({
            message: "操作成功",
            type: "success",
          });
          this.$router.push({
            name: "ZskRuleManager",
            params: Object.assign({}, this.$route.params, { currentPage: 1 }),
          });
        } else {
          this.$message({
            message: res.data.msg,
            type: "warning",
          });
        }
      });
    },
    /**
     * 子组件调用方法
     */
    childClearConcept(index) {
      this.$set(this.form.klRuleByIdSub[index], "subConceptId", "");
      this.$set(this.form.klRuleByIdSub[index], "conceptList", []);
    },
    childClearNumText(index) {
      let obj = JSON.parse(JSON.stringify(this.form.klRuleByIdSub));
      obj[index].subMaxOperator = "";
      obj[index].subMaxValue = "";
      obj[index].subMaxUnit = "";
      obj[index].subMinOperator = "";
      obj[index].subMinValue = "";
      obj[index].subMinUnit = "";
      obj[index].subEqValue = "";
      // this.$set(obj[index], "subEqValue", "");
      obj[index].subEqOperator = "";
      // this.klRuleByIdSub = obj;
      // this.$emit("editKlRuleByIdSub", obj);
      this.editKlRuleByIdSub(obj);
    },
    ChildDataTypeChange(val, index) {
      this.form.klRuleByIdSub[index].subEqOperator = val === "2" ? "=" : "";
      this.$set(
        this.form.klRuleByIdSub[index],
        "subEqOperator",
        val === "2" ? "=" : ""
      );

      this.childClearNumText(index);
      // TODO 新增的内容追踪不到
      this.form.klRuleByIdSub.forEach((item, i) => {
        if (index === i) {
          this.$set(item, "dataType", val);
        }
      });
    },
    childSubCodeChange(val, index, numTypes, groupId, key, code, lens) {
      const dragDel =
        localStorage
          .getItem("zskDragDict")
          .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
      const subobj = this.baseTypeList.find((it) => it.type == 1);
      let obj = this.form.klRuleByIdSub;
      let type;
      const len = this.form.klRuleByIdSub.filter((item, i) => {
        return item.groupId == groupId;
      });
      const inx = key % 3 == 2 ? index - 1 : key % 3 == 1 ? index + 1 : index;
      if (key == 1 && len[2]) {
        type = len[2].subLenCode == "" ? false : true;
      } else if (key == 2) {
        type = len[1].subLenCode == "" ? false : true;
      }
      //判断药品合理性总条数是否大于1条,是否存在第二条或第三条类型为1,存在触发互斥
      if (
        //判断3条规则是否都已选中
        dragDel.length > 0 &&
        len.length == 3 &&
        index > 0 &&
        key > 0
      ) {
        if (type) {
          //判断是否存在符合互斥条件的两条出具,若存在,置空另一条出具
          if (
            code != "" &&
            (key == 1
              ? len[2].dragArr.indexOf(val)
              : len[1].dragArr.indexOf(val)) > -1 &&
            lens == 4
          ) {
            //剂型给药途径互斥判断
            const arr = this.baseTypeList.filter((it) => {
              return it.type == 1;
            });
            this.$set(this.form.klRuleByIdSub, inx, {
              groupId: this.form.klRuleByIdSub[inx].groupId,
              groupChildId: "child" + new Date().valueOf(),
              baseTypes: arr,
              baseTermTypeList: [],
              conceptList: [],
              subDescription: "",
              parRuleType: "",
              subConceptId: "",
              subType: "",
              subMaxOperator: "",
              subMaxUnit: "",
              subMaxValue: "",
              subMinOperator: "",
              subMinUnit: "",
              subMinValue: "",
              subEqValue: "",
              subLenCode: "",
              dataType: "",
              del: false,
              key: key == 2 ? 1 : 2,
            });
          }
        } else {
          const list = subobj.subMenuList.filter((it) => {
            return it.code == val && it.remark.split("|")[0] == 3;
          });
          //获取互斥项code
          const dragArr = list[0].remark.split("|")[1].split(",");
          this.dragArr = dragArr;
          len[1].dragArr = dragArr;
          len[2].dragArr = dragArr;
          // if (len[1]) {
          //   len[1].dragArr = dragArr;
          // } else if (len[2]) {
          //   len[2].dragArr = dragArr;
          // }
          //获取互斥项
          const screenArr = subobj.subMenuList.filter((item) =>
            dragArr.some(
              (ele) => ele === item.code && item.remark.split("|")[0] == 3
            )
          );
          if (
            this.form.klRuleByIdSub[inx] &&
            this.form.klRuleByIdSub[inx].subType != ""
          ) {
            this.$set(
              this.form.klRuleByIdSub[inx],
              "baseTermTypeList",
              screenArr
            );
          }
        }
        this.dragVal = val;
      }
      if ((numTypes + ",").indexOf(val + ",") > -1) {
        this.$set(this.form.klRuleByIdSub[index], "dataType", "1");
      } else {
        this.$set(this.form.klRuleByIdSub[index], "dataType", "");
      }
      this.childClearConcept(index);
      this.childClearNumText(index);
    },
    // 去重
    unique(arr, obj) {
      return arr.reduce((cur, next) => {
        obj[next] ? "" : (obj[next] = true && cur.push(next));
        return cur;
      }, []);
    },
  },
  watch: {
    form: {
      handler(val) {
        if (val.klRuleByIdSub) {
          this.form.klRuleByIdSub.forEach((item, i, arr) => {
            if (i == 0) {
              item.rowIndex = 1;
            } else if (item.groupId == arr[i - 1].groupId) {
              item.rowIndex = arr[i - 1].rowIndex;
            } else {
              item.rowIndex = arr[i - 1].rowIndex + 1;
            }
          });
        }
      },
      immediate: true,
      deep: true,
    },
  },
  computed: {
    disable: function () {
      return Object.keys(this.firstPlace || {}).length > 0;
    },
    ruleTermCodeStr: function () {
      const str = this.form.parRuleType + "-" + this.form.parLenCode + "-" + 1;
      if (str.length <= 1) {
        return "";
      }
      return str;
    },
    ruleTermCodeStr2: function () {
      const str = this.form.parRuleType + "-" + this.form.parLenCode + "-" + 0;
      if (str.length <= 1) {
        return "";
      }

      return str;
    },
    ruleTermCodeStrs: function () {
      const str = this.form.parRuleType + "-" + this.form.parLenCode;
      if (str.length <= 1) {
        return "";
      }
      return str;
    },
    showMsg: function () {
      return (
        this.ruleTermCodeStr.length > 2 &&
        this.msgDict.indexOf(this.ruleTermCodeStr) > -1
      );
    },
    showMsg2: function () {
      return (
        this.ruleTermCodeStr2.length > 2 &&
        this.msgDict.indexOf(this.ruleTermCodeStr2) > -1
      );
    },
    showHasSub() {
      if (this.ruleTermCodeStrs.length > 2) {
        console.log(this.subDict.indexOf(this.ruleTermCodeStrs) != -1);
        return this.subDict.indexOf(this.ruleTermCodeStrs) != -1;
      }
      return false;
    },
    checkFirstPlace: function () {
      return this.dict.indexOf(this.ruleTermCodeStrs) > -1;
    },
  },
  components: { AddNewRuleTable, AddNewRuleContent },
};
</script>