Source/UBCS-WEB/src/views/code/code.vue

@@ -99,6 +99,13 @@
              @click="clearAllCodeSec">
              清空码值
          </el-button>
          <el-button
              size="small"
              icon="el-icon-guide"
              plain
              @click="escapeOwner">
              转移所有者
          </el-button>
        </template>
      </avue-crud>
    </basic-container>
@@ -219,6 +226,27 @@
        <el-button type="primary" @click="saveOtherCodeBasic">保 存</el-button>
        <el-button @click="cloneOtherCodeRuleSettingBox = false">取 消</el-button>
      </div>
    </el-dialog>
    
    <!-- 编码规则,转移所有者对话框 -->
    <el-dialog
      :visible.sync="escapeOwnerVisible"
      append-to-body
      title="转移所有者"
      width="30%">
      <el-select v-model="ruleOwner" placeholder="请选择" class="selects">
        <el-option
          v-for="item in ruleAdminUserList"
          :key="item.VALUE"
          :label="item.LABLE"
          :value="item.VALUE"
          class="seloption">
        </el-option>
      </el-select>
        <span slot="footer" class="dialog-footer">
          <el-button @click="escapeOwnerVisible = false">取 消</el-button>
          <el-button type="primary" @click="escapeOwnerConfirm">确 定</el-button>
        </span>
    </el-dialog>

    <!-- 基础码段展示区域 -->
@@ -418,6 +446,8 @@
      append-to-body
      style="height: 115vh; margin-top: -13vh; overflow: hidden"
      destroy-on-close
      lock-scroll
      :close-on-click-modal="false"
      @close="clearBasicAddForm">

      <!--  第一层对话框,添加码段信息对话框中的内容 -->
@@ -527,7 +557,7 @@
                  </el-option>
                </el-select>
              </el-form-item>
              <el-form-item label="补位时的字符:" :label-width="rightFormLabelWidth">
              <el-form-item v-if="form.codeFillType!='code_fill_none'" label="补位时的字符:" :label-width="rightFormLabelWidth">
                <el-select v-model="form.codeFillSeparator" @blur="inputSelectBlur" filterable placeholder="请选择" :disabled="basicSecOnlyRead">
                  <el-option
                    v-for="item in enumParam.codeFillSeparator"
@@ -575,7 +605,7 @@
                  </el-option>
                </el-select>
              </el-form-item>
              <el-form-item id="ShowOrHide" v-mode="showCutLength" v-if="showCutLength==true" label="值截取长度:" :label-width="rightFormLabelWidth">
              <el-form-item id="ShowOrHide" v-if="form.valueCutType!='code_cut_none'" label="值截取长度:" :label-width="rightFormLabelWidth">
                <el-input v-model.number="form.valueCutLength" ref="valueCutLength"  :readonly="basicSecOnlyRead"></el-input>
              </el-form-item>
              <el-form-item label="取值类型:" :label-width="rightFormLabelWidth">
@@ -667,7 +697,7 @@
                  </el-option>
                </el-select>
              </el-form-item>
              <el-form-item label="补位时的字符:" :label-width="rightFormLabelWidth">
              <el-form-item v-if="form.codeFillType!='code_fill_none'" label="补位时的字符:" :label-width="rightFormLabelWidth">
                <el-select v-model="form.codeFillSeparator" filterable @blur="inputSelectBlur" placeholder="请选择" :disabled="basicSecOnlyRead">
                  <el-option
                    v-for="item in enumParam.codeFillSeparator"
@@ -681,11 +711,11 @@
          </span>
        </el-form>
      </div>
      <!-- 第一层对话框的按钮和，线条 -->
      <!-- 第一层对话框的按钮和分隔线条 -->
      <el-divider class="horizontal-line" direction="horizontal"></el-divider>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="saveOrEditBasicCode" v-show="showbtn">保 存</el-button>
        <el-button @click="addBasicCodeSettingBox = false" v-show="showbtn">取 消</el-button>
        <el-button type="primary" @click="saveOrEditBasicCode" :disabled="!showbtn">保 存</el-button>
        <el-button @click="addBasicCodeSettingBox = false">取 消</el-button>
      </div>

      <!--  第二层对话框,属性码段，属性选择对话框 -->
@@ -737,8 +767,8 @@
      <formula-editor
        ref="formulaEditor"
        @updateFormulaContent="updateFormulaContent"
        :thisSceneTableData="formulaEditorParams.thisSceneTableData"
        :visible.sync="formulaEditorParams.formulaEditorSettingBox"
        :thisSceneTableData="formulaEditorParams.thisSceneTableData"
        :systemVariableTableData="formulaEditorParams.systemVariableTableData">
      </formula-editor>

@@ -777,18 +807,12 @@
        @echoReferBtmType="echoReferBtmType">
      </refer-btm-type-crud-dialog>

      <!-- 第二层对话框,自定义参照配置Form组件 -->
      <refer-config-form-dialog
        ref="referConfigFormDialog"
        @echoReferConfig="echoReferConfig">
      </refer-config-form-dialog>

      <!-- 第二层对话框,直接选择参照配置crud组件 -->
      <refer-config-crud-dialog
        ref="referConfigCrudDialog"
        @openReconfigInterFace="openReconfigInterFace"
        @echoReferConfig="echoReferConfig">
      </refer-config-crud-dialog>
      <!-- 第二层对话框,参照配置组件 -->
      <refer-config-dialog
        :display="referConfigVisble"
        @setReferConfigValue="setReferConfigValue"
        :referConfigOption="referConfigOption">
      </refer-config-dialog>

    </el-dialog>

@@ -822,8 +846,7 @@
  import parentClassifyParentOption from "@/const/code/parentClassifyParentOptionDialog";
  import fixedValueOption from "@/const/code/fixedValueMgrDialog";
  import {mapGetters} from "vuex";
  import func from "@/util/func";
  import {MasterTable} from "@/api/GetItem";
  import {getByRoleUserList} from "@/api/system/user";

  export default {
      data() {
@@ -838,7 +861,6 @@
            total: 0
          },
          selectionList: [],
          showCutLength: false,
          /*编码规则表格配置*/
          optionRule: optionRule,
          data: [],
@@ -858,6 +880,10 @@
          cloneBasicOption: cloneBasicOption,
          cloneCodeRuleOption: cloneCodeRuleOption,
          selectionOtherCloneCodeBasicList: [], // 当前选中的基础码段
          /** 转移所有者对话框 */
          escapeOwnerVisible: false,
          ruleAdminUserList: [], //规则管理员列表
          ruleOwner: '', // 当前要转移给哪个规则管理员的ID

          /*使用范围对话框显示控制*/
          codeRangeSettingBox: false,
@@ -907,7 +933,7 @@

          /** 码值管理相关数据 */
          isShowBasicSecCodeValueMgr: false, //码段码值管理对话框
          codefixedsecOrCodeclassifysecOid: '', //存放基础码段点击码值管理时的当前行id，用于保存码值时使用
          codefixedsecOrCodeclassifysec: '', //存放基础码段点击码值管理时的当前行id，用于保存码值时使用
          selectedFixedOrCodeclassifyValue: '', //当前选中的码值数据
          //固定码段码值表单
          codeFixdForm: {
@@ -930,7 +956,6 @@
          },
          classisyValueTreeOption: classisyValueTreeOption, //分类码段树相关配置项
          classifyValueTreeData: [],
          //currentSelectClsValueTreeData: '', //当前选中的分类码值树节点

          /* 为属性选取值窗口显示打开控制变量 */
          isShowSelectAttrOption: false,
@@ -1079,6 +1104,10 @@
            //conditionMapParams: {},
          },

          //引用码段中参照配置组件相关参数
          referConfigOption: {},
          referConfigVisble: false,

        };
      },
      computed: {
@@ -1095,7 +1124,48 @@
      watch:{

      },
      mounted(){
        this.loadTotalEnum();
      },
      // 解决表格错行问题
      activated () {
        this.$nextTick(() => {
          this.$refs.crud.doLayout();
          this.$refs.crudBasic.doLayout();
        })
      },
      methods: {

        /** 转移规则所有者对话框 */
        escapeOwner(){
          if (this.selectionList.length === 0) {
            this.$message.warning("请选择一条编码规则！");
            return;
          }
          this.escapeOwnerVisible = true;
          getByRoleUserList("规则管理员").then(res=>{
            this.ruleAdminUserList = res.data.data;
          });
        },
        /** 确认转移所有者 */
        escapeOwnerConfirm(){
          if(!this.ruleOwner){
            this.$message.warning("请选择您要转移的规则管理员！");
            return;
          }
          this.selectionList[0].owner = this.ruleOwner;
          let data = this.selectionList[0];
          update(data).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "规则转移成功!"
            });
            this.escapeOwnerVisible = false;
          }, error => {
            console.log(error);
          });
        },

        /** 高级查询对话框组件,组件返回的值是condtionMap[field]形式的查询条件，保留了和之前一样的方式 */
        echoSeniorContionMap(conditionMaps){
@@ -1115,14 +1185,13 @@
          this.form.getValueClass = content;
        },
        /* 引用码段参照配置,子组件填完参照配置之后内容回显时调用 */
        echoReferConfig(content){
        setReferConfigValue(content){
          // console.log(content.referTypeName);
          this.form.referBtmId = content.referType || '';
          this.form.referBtmName = content.referTypeName || content.referType;
          //转换成JSON字符串进行父组件回显
          let submitFormJson = JSON.stringify(content);
          this.form.referConfig = submitFormJson || '';
          this.form.referValueInfo = submitFormJson || '';
        },
        /** 引用码段为【参照引用的业务类型】选取值之后的内容回显时调用 */
        echoReferBtmType(content){
@@ -1132,7 +1201,7 @@
        },

        /** 父分类选择对话框，第二层嵌套对话框，及其相关方法 */
        // 保存当前父分类码段的选中行，并进行回显
        /** 保存当前父分类码段的选中行，并进行回显 */
        saveSelectedParentClassify(){
          //console.log(this.parentClsfyParams.parentClassifySelectionList.length);
          if(this.parentClsfyParams.parentClassifySelectionList.length != 1){
@@ -1201,12 +1270,12 @@


        /** 打开属性选取值，第二层嵌套对话框，及其相关方法 */
        // 获取当前被选中树节点的oid
        /** 获取当前被选中树节点的oid */
        nodeClick(data) {
          this.currentSelectTreeData = data;
          this.loadlistClassifyLinkAttr()
        },
        // 加载分类连接属性表格数据
        /** 加载分类连接属性表格数据 */
        loadlistClassifyLinkAttr() {
          let attrParam = this.selectAttrParams;
          //console.log(this.currentSelectTreeData);
@@ -1231,49 +1300,50 @@
            this.selectAttrParams.selectAttrQeury = {};
          })
        },
        // 点击搜索后触发该事件
        /** 点击搜索后触发该事件 */
        selectAttrSearchChange(params, done) {
          this.selectAttrParams.selectAttrQeury = params;
          //console.log(params);  //这儿需要改
          this.loadlistClassifyLinkAttr();
          done();
        },
        // 为属性选值界面，单击表格行时触发该事件
        /** 为属性选值界面，单击表格行时触发该事件 */
        selectionAttrRowClick(row){
          this.$refs[this.selectAttrParams.ref].toggleSelection();
          this.selectAttrParams.selectionChangeAttrList = row;
          this.$refs[this.selectAttrParams.ref].setCurrentRow(row);
          this.$refs[this.selectAttrParams.ref].toggleRowSelection(row); //选中当前行
        },
        // 属性取值当前选中行发生变化时触发
        /** 属性取值当前选中行发生变化时触发 */
        selectionChangeAttr(list){
          this.selectAttrParams.selectionChangeAttrList = list;
          this.$refs[this.selectAttrParams.ref].setCurrentRow(this.selectAttrParams.selectionChangeAttrList[list.length-1]);
        },
        // 重置位属性选取值表格的搜索框之后的回调
        /** 重置位属性选取值表格的搜索框之后的回调 */
        searchAttrReset() {
          this.selectAttrParams.selectAttrQeury = {};
          this.loadlistClassifyLinkAttr()
        },
        // 为属性选取值之后的回显
        /** 为属性选取值之后的回显 */
        selectedListClassifyLinkAttr(){
          if(this.selectAttrParams.selectionChangeAttrList.length != 1){
            this.$message.warning("请选择一条数据!");
            return false;
          }
          const attr = this.selectAttrParams.selectionChangeAttrList[0];
          //调用子组件并传递当前选中的参数值，实现回显
          this.form = Object.assign({}, this.form, {
            referAttributeId:this.selectAttrParams.selectionChangeAttrList[0].id,
            referAttributeName:this.selectAttrParams.selectionChangeAttrList[0].name,
            referCodeClassifyOid: this.currentSelectTreeData.key,
            referCodeClassifyOidName: this.currentSelectTreeData.title,
            referAttributeId: attr.id || '',
            referAttributeName: attr.name || attr.id,
            referCodeClassifyOid: this.currentSelectTreeData.key || '',
            referCodeClassifyOidName: this.currentSelectTreeData.title || '',
          })
          this.isShowSelectAttrOption = false;
        },


        /** 基础码段表中的码值管理的相关方法 */
        // 码值管理弹窗控制
        /** 码值管理弹窗控制*/
        openBasicSecCodeValueMgr(row){
          //当前为固定码段码值管理码值管理
          if(row.secType === "codefixedsec"){
@@ -1284,10 +1354,10 @@
            this.isShowFixedForm = false;
            this.loadClassifyValueData(row);
          }
          this.codefixedsecOrCodeclassifysecOid = row.oid;
          this.codefixedsecOrCodeclassifysec = row;
          this.isShowBasicSecCodeValueMgr = true;
        },
        //加载固定码段码值表数据
        /** 加载固定码段码值表数据*/
        loadFixedValueTableData(row){
          this.fixedValueOptionLoading = true;
          gridCodeFixedValue(1, -1, {"codeFixedSecOid":row.oid}).then(res=>{
@@ -1296,7 +1366,7 @@
            this.fixedValueOptionLoading = false;
          })
        },
        //单击固定码段的码值表中行时触发的事件
        /** 单击固定码段的码值表中行时触发的事件*/
        selectedCodeValueRow(row){
          //console.log(row);
          this.selectedFixedOrCodeclassifyValue = row;
@@ -1304,20 +1374,15 @@
          this.codeFixdForm.description = row.description;
          this.codeFixdForm.codeFixedSecOid = row.codefixedsecoid;
        },
        //新增码值
        /** 新增码值*/
        addCodeSecValue(condition){
          if(condition === "codefixedsec"){
            if(this.codeFixdForm.id.trim() == ''){
              this.$message.warning("码值不能为空！");
            if(!this.tipsCodeSecValueMessage(this.codeFixdForm.id)){
              return;
            }
            if(this.codeFixdForm.id.trim().length >= 12 ){
              this.$message.warning("码值长度不能大于12！");
              return;
            }
            this.codeFixdForm.codeFixedSecOid = this.codefixedsecOrCodeclassifysecOid;
            this.codeFixdForm.codeFixedSecOid = this.codefixedsecOrCodeclassifysec.oid;
            addSaveCodeFixedValue(this.codeFixdForm).then(() => {
              this.loadFixedValueTableData({"oid":this.codefixedsecOrCodeclassifysecOid});
              this.loadFixedValueTableData({"oid":this.codefixedsecOrCodeclassifysec.oid});
              this.clearFixedOrClassifyForm('codefixedsec');
              this.$message({
                type: "success",
@@ -1327,18 +1392,13 @@
              window.console.log(error);
            });
          }else {
            if(this.codeClassifyForm.id.trim() == ''){
              this.$message.warning("码值不能为空！");
            if(!this.tipsCodeSecValueMessage(this.codeClassifyForm.id)){
              return;
            }
            if(this.codeClassifyForm.id.trim().length > 4 ){
              this.$message.warning("码值长度不能大于4！");
              return;
            }
            this.codeClassifyForm.codeClassifySecOid = this.codefixedsecOrCodeclassifysecOid;
            this.codeClassifyForm.codeClassifySecOid = this.codefixedsecOrCodeclassifysec.oid;
            // console.log(this.codeClassifyForm);
            addSaveCodeClassifyValue(this.codeClassifyForm).then(() => {
              this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysecOid});
              this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysec.oid});
              this.clearFixedOrClassifyForm('codeclassifyvaluesec');
              this.$message({
                type: "success",
@@ -1352,7 +1412,7 @@
            });
          }
        },
        //清空码值表单
        /** 清空码值表单 */
        clearFixedOrClassifyForm(condition){
          //点击取消时清空表单与当前选中的码值，并禁用按钮
          this.selectedFixedOrCodeclassifyValue = '';
@@ -1368,19 +1428,34 @@
            this.codeClassifyForm = this.$options.data().codeClassifyForm;
          }
        },
        //修改码值
        /** 添加或修改码值之前对码值长度根据规则进行校验 */
        tipsCodeSecValueMessage(id){
          if(id.trim() == ''){
            this.$message.warning("码值不能为空！");
            return false;
          }
          if(id.trim().length > this.codefixedsecOrCodeclassifysec.codeSecLength ){
            this.$message.warning("码值长度不能大于" + this.codefixedsecOrCodeclassifysec.codeSecLength);
            return false;
          }
          return true;
        },
        /** 修改码值 */
        editCodeSecValue(condition){
          if(condition=='codefixedsec'){
            //以前是直接把当前选中行的所有数据都进行提交，但其实只需要传输一些比要参数即可，这儿做了修改，需要穿其他参数的请自行添加
            if(!this.tipsCodeSecValueMessage(this.codeFixdForm.id)){
              return;
            }
            //以前是直接把当前选中行的所有数据都进行提交，但其实只需要传输一些必要参数即可，这儿做了修改，需要传其他参数的请自行添加
            let editData = {
            "oid": this.selectedFixedOrCodeclassifyValue.oid,
            "ts": new Date().getTime(),
            "description": this.codeFixdForm.description,
            "id": this.codeFixdForm.id,
            "codeFixedSecOid":  this.selectedFixedOrCodeclassifyValue.codefixedsecoid
              "oid": this.selectedFixedOrCodeclassifyValue.oid,
              "ts": new Date().getTime(),
              "description": this.codeFixdForm.description,
              "id": this.codeFixdForm.id,
              "codeFixedSecOid":  this.selectedFixedOrCodeclassifyValue.codefixedsecoid
            }
            editCodeFixedValue(editData).then(() => {
                this.loadFixedValueTableData({"oid":this.codefixedsecOrCodeclassifysecOid})
                this.loadFixedValueTableData({"oid":this.codefixedsecOrCodeclassifysec.oid})
                this.$message({
                  type: "success",
                  message: "操作成功!"
@@ -1389,9 +1464,17 @@
                window.console.log(error);
            });
          }else {
            if(!this.tipsCodeSecValueMessage(this.codeClassifyForm.id)){
              return;
            }
            this.codeClassifyForm.oid = this.selectedFixedOrCodeclassifyValue.attributes.oid;
            // 分类码段，子分类和父分类之间不能相互更改
            if(this.checkClassUpdate(this.codefixedsecOrCodeclassifysec.oid,this.codeClassifyForm.codeClassifySecOid)){
              return;
            }
            this.$delete(this.codeClassifyForm,"parentClassifyValueOid");
            editCodeClassifyValue(this.codeClassifyForm).then(() => {
                this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysecOid})
                this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysec.oid})
                this.$message({
                  type: "success",
                  message: "操作成功!"
@@ -1402,7 +1485,7 @@
          }

        },
        //删除码值
        /** 删除码值 */
        delCodeSecValue(condition){
          //固定码段码值删除
          if(condition == 'codefixedsec'){
@@ -1418,7 +1501,7 @@
            })
            .then(() => {
              this.selectedFixedOrCodeclassifyValue = '';
              this.loadFixedValueTableData({"oid":this.codefixedsecOrCodeclassifysecOid})
              this.loadFixedValueTableData({"oid":this.codefixedsecOrCodeclassifysec.oid})
              this.clearFixedOrClassifyForm('codefixedsec');
              this.$message({
                type: "success",
@@ -1426,6 +1509,9 @@
              });
            });
          }else{
            if(this.checkClassUpdate(this.codefixedsecOrCodeclassifysec.oid,this.codeClassifyForm.codeClassifySecOid)){
              return;
            } 
            //分类码段码值删除
            this.$confirm("是否删除这条数据？如果被引用将不能被删除！", {
              confirmButtonText: "确定",
@@ -1438,7 +1524,7 @@
            })
            .then(() => {
              this.selectedFixedOrCodeclassifyValue = '';
              this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysecOid})
              this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysec.oid})
              this.clearFixedOrClassifyForm('codeclassifyvalue');
              this.$message({
                type: "success",
@@ -1446,9 +1532,8 @@
              });
            });
          }

        },
        //对固定码值表进行：上移、下移、移除操作
        /** 对固定码值表进行：上移、下移、移除操作*/
        codeFixedValueOpetion(condition,row){
          //console.log(this.fixedValueData[row.$index].orderNum);
          const index = row.$index;
@@ -1484,12 +1569,15 @@
          }
          //console.log(this.fixedValueData);
        },
        //对分类码值表进行：上移、下移、移除操作
        /** 对分类码值表进行：上移、下移、移除操作*/
        codeClassifyValueOpetion(condition){
          if(this.checkClassUpdate(this.codefixedsecOrCodeclassifysec.oid,this.codeClassifyForm.codeClassifySecOid)){
            return;
          } 
          //此处涉及到深浅拷贝问题，但是执行上下移保存操作之后会重新加载treedata，所以影响不大
          let currentTreeList = this.getCodeClassifyValueTreeData();
          let saveData = [];
          console.log(currentTreeList.treeList);
          // console.log(currentTreeList.treeList);
          if(condition == 'up'){
            if(currentTreeList.index-1>=0){
              // 调整顺序
@@ -1509,10 +1597,8 @@
              this.saveCodeFixedOrClassifyValueOption('classifyValue',saveData);
            }
          }
          console.log(saveData);
          console.log(this.classifyValueTreeData);
        },
        //选中被调整顺序的两个树的节点
        /** 选中被调整顺序的两个树的节点*/
        getCodeClassifyValueTreeData(){
          const currentNodeTreeData = this.selectedFixedOrCodeclassifyValue;
          /**考虑几种情况，第一种当前上移|下移操作已经是边界，
@@ -1548,12 +1634,12 @@
            }
          }
        },
        //上移下移等操作的保存
        saveCodeFixedOrClassifyValueOption(condition,editOrderNumdata){
        /** 上移下移等操作的保存*/
        async saveCodeFixedOrClassifyValueOption(condition,editOrderNumdata){
          //保存对固定码段码值的上移下移移出等操作
          if(condition == "fixedValue"){
            let data = {
            "codeFixedSecOid": this.codefixedsecOrCodeclassifysecOid,
            "codeFixedSecOid": this.codefixedsecOrCodeclassifysec.oid,
            "dtoList": JSON.stringify(this.fixedValueData),
            }
            saveOrder(data).then(() => {
@@ -1568,8 +1654,8 @@
            });
          }else {
            //保存对分类码值码段码值的上移下移移出等操作
            saveCodeClassifyValueOrder({
              "codeClassifySecOid": this.codefixedsecOrCodeclassifysecOid,
            await saveCodeClassifyValueOrder({
              "codeClassifySecOid": this.codefixedsecOrCodeclassifysec.oid,
              "dtoList": JSON.stringify(editOrderNumdata),
            }).then(() => {
              this.$message({
@@ -1579,11 +1665,11 @@
              }, error => {
                window.console.log(error);
            });
            this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysecOid});
            this.loadClassifyValueData({"oid":this.codefixedsecOrCodeclassifysec.oid});
          }

        },
        //分类码值树data加载
        /** 分类码值树data加载*/
        loadClassifyValueData(row){
          //console.log(row);
          let condtionData = {
@@ -1599,7 +1685,7 @@
            //console.log(res.data);
          });
        },
        //分类码值树单击时触发的事件
        /** 分类码值树单击时触发的事件*/
        classisyValueTreeOnodeClick(node){
          //console.log(node);
          this.selectedFixedOrCodeclassifyValue = node;
@@ -1607,17 +1693,431 @@
          this.codeClassifyForm.id = node.attributes.id;
          this.codeClassifyForm.name = node.attributes.name;
          this.codeClassifyForm.parentClassifyValueOid = node.attributes.oid;
          //console.log(this.codeClassifyForm);
          // console.log(this.codeClassifyForm);
        },
        /**
         * 分类码段码值，修改、删除、上下移之前，检查是否为子分类和父分类之间相互更改
         * @currentRowClassOid 当前选中行oid
         * @updateClassOid 要修改的分类码值oid
         */
        checkClassUpdate(currentRowClassOid,updateClassOid){
          if(currentRowClassOid!=updateClassOid){
            this.$message({
              type: "error",
              message: "操作失败【子分类与父分类之间不能相互修改码值】!"
            });
          }
          return currentRowClassOid!=updateClassOid;
        },

        /** 编码规则相关方法 */
        /** 打开高级查询窗口 */
        openAdvancedQuery(condition){
          if(condition=='codeRule'){
            this.advancedQueryParam.options = [
              {
                data: [],
                title: '编号',
                fieldType: 'text',
                queryField: 'id',
              },{
                data: [],
                title: '名称',
                fieldType: 'text',
                queryField: 'name',
              },{
                data: [],
                title: '描述',
                fieldType: 'text',
                queryField: 'description',
              },{
                data: [
                  // {
                  //   key: '编辑中',
                  //   value: 'Editing',
                  // },
                  // {
                  //   key: '已发布',
                  //   value: 'Released',
                  // },
                  // {
                  //   key: '停用',
                  //   value: 'Disabled',
                  // },
                ],
                title: '状态',
                fieldType: 'combox',
                queryField: 'lcStatus',
                comboxKey: 'codeSearchLCStatus',
              },
            ]
          }else {
            this.advancedQueryParam.options = [
              {
                data: [],
                title: '码段编号',
                fieldType: 'text',
                queryField: 'id',
              },{
                data: [],
                title: '码段名称',
                fieldType: 'text',
                queryField: 'name',
              },{
                data: [],
                title: '描述',
                fieldType: 'text',
                queryField: 'description',
              },{
                data: [],
                title: '码段类型',
                fieldType: 'combox',
                queryField: 'secType',
                comboxKey: 'codeSecType',
              }
            ]
          }
          this.advancedQueryParam.currentOpen = condition;
          this.advancedQueryParam.advancedQuerySettingBox = true;
        },
        /** 查询使用范围*/
        handleRange(){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          this.codeRangeSettingBox = true;
          this.getRangeCodeList()
        },
        /** 加载使用范围列表*/
        getRangeCodeList(){
          this.dialogLoading = true;
          if(this.selectionList[0].oid==null){
            this.$message.error("未获取到参数!");
          }

          listUseRange(this.selectionList[0].oid).then(res => {
            this.useRangeData = res.data.data;
            //console.log(this.useRangeData);
            this.dialogLoading = false;
          });
        },
        /** 刷新使用范围列表*/
        refreshUseRangeChange(){
          this.getRangeCodeList();
        },
        /** 启用与停用*/
        enableOrDeactivatse(oId,update){
          updateStatus({"oid":oId,"ts":new Date().getTime,"update":update}).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          }, error => {
            window.console.log(error);
          });
        },
        /** 打开编码规则克隆对话框*/
        openCodeRuleDialog() {
          if (!this.tipsMessage(this.selectionList)) {
            return;
          }
          this.cloneSettingBox = true;
          this.cloneCodeRuleForm.id = this.selectionList[0].id;
          this.cloneCodeRuleForm.name = this.selectionList[0].name;
          this.cloneCodeRuleForm.description = this.selectionList[0].description;
          this.loadBasic({"oid": this.selectionList[0].oid});
        },
        /** 克隆编码规则保存功能*/
        saveCloneCodeRule(){
          let form = this.cloneCodeRuleForm;
          if(form.id.trim()==''){
            this.$message.warning("编号不能为空!");
            return;
          }
          if(form.name.trim()==''){
            this.$message.warning("码值不能为空!");
            return;
          }
          this.selectionList[0].oid = '';
          this.selectionList[0].id = form.id;
          this.selectionList[0].name = form.name;
          this.selectionList[0].description = form.description;
          this.selectionList[0].createTime = new Date().getTime();
          this.selectionList[0].ts = new Date(this.selectionList[0].ts).getTime();
          this.selectionList[0].lcStatus = 'Editing';
          let data = Object.assign({}, this.selectionList[0],{elements:this.cloneData});
          clone(data).then(() => {
            this.cloneSettingBox = false;
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          }, error => {
            window.console.log(error);
          });
          //console.log(data);
        },
        /** 打开从其他编码规则中克隆码段对话框*/
        openOtherCodeRuleDialog(){
          if (!this.tipsMessage(this.selectionList)) {
            return;
          }
          if(this.selectionList[0].lcStatus != 'Editing'){
            this.$message.warning("编码规则已被引用，不允许编辑或删除!");
            return;
          }
          this.cloneOtherCodeRuleSettingBox = true;
        },
        //** 从其他编码规则中克隆码段对话框-单击编码规则实现行选择*/
        codeOtherCloneRuleRowClick(row) {
          this.$refs.crudCloneCodeRuleOther.toggleSelection();
          this.selectionOtherCloneCodeRuleList = row;
          this.$refs.crudCloneCodeRuleOther.setCurrentRow(row);
          this.$refs.crudCloneCodeRuleOther.toggleRowSelection(row); //选中当前行
          this.loadBasic(row);
        },
        /** 从其他编码规则中克隆码段对话框-单击基础码段实现行选择*/
        codeOtherCloneBasicRowClick(row){
          this.$refs.crudCloneCodeBasicOther.toggleSelection();
          this.selectionOtherCloneCodeBasicList = row;
          this.$refs.crudCloneCodeBasicOther.setCurrentRow(row);
          this.$refs.crudCloneCodeBasicOther.toggleRowSelection(row); //选中当前行
        },
        /** 从其他规则克隆码段界面中编码规则当前选中行变化的时候触发*/
        selectionOtherCloneCodeRuleChange(list) {
          //console.log(list);
          this.selectionOtherCloneCodeRuleList = list;
          this.$refs.crudBasic.setCurrentRow(this.selectionBasicList[list.length-1]);
          if(list == ''){
            this.basicData = [];
          }
          if(this.selectionOtherCloneCodeRuleList.length > 0){
            this.loadBasic(this.selectionOtherCloneCodeRuleList[list.length-1]);
          }
        },
        selectionOtherCloneCodeBasicChange(list){
          this.selectionOtherCloneCodeBasicList = list;
          this.$refs.crudCloneCodeBasicOther.setCurrentRow(this.selectionOtherCloneCodeBasicList[list.length-1]);
        },
        /** 从其他编码规则中克隆码段信息*/
        saveOtherCodeBasic(){
          let oid = this.selectionList[0].oid;
          let fromDialogPkCodebasic = this.selectionOtherCloneCodeBasicList;
          if(fromDialogPkCodebasic.length <= 0){
            this.$message.warning("请选择码段数据!");
            return;
          }
          let res = fromDialogPkCodebasic.filter((item) => {
            return item.pkCodeRule == oid;
          });
          if(res != ''){
            this.$message.warning("需要克隆的编码规则与被克隆的编码规则相同!");
            return;
          }
          //console.log(res);
          let oidArr = [];
          fromDialogPkCodebasic.forEach(ele => {
            oidArr.push(ele.oid);
          });
          let data = {
            "pkCodeRule": oid,
            "oidArr": oidArr.join(","),
          }
          //console.log(data);
          cloneCodeBasic(data).then(() => {
            this.cloneOtherCodeRuleSettingBox = false;
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          }, error => {
            window.console.log(error);
          });
        },
        /** 清空码值*/
        clearAllCodeSec(){
          if(this.selectionList.length == 0){
            this.$message.warning("没有选择数据!");
            return;
          }
          if(this.selectionList.length != 1){
            this.$message.warning("每次只能选择一条数据!");
            return;
          }
          let currentData = this.selectionList[0];
          this.$confirm("确定要清空码值？如果清空将不能被恢复，请谨慎！", {
              confirmButtonText: "确定",
              cancelButtonText: "取消",
              type: "warning"
            })
            .then(() => {
              let ts = new Date(currentData.ts).getTime();
              return clearAllCode({"oid": currentData.oid,"ts": ts});
            })
            .then(() => {
              this. this.onLoad(this.page);
              this.$message({
                type: "success",
                message: "操作成功!"
              });
            });
        },
        /** 添加*/
        rowSave(row, done, loading) {
          console.log(row);
          add(row).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
            done();
          }, error => {
            loading();
            window.console.log(error);
          });
        },
        openEdit(row){
          this.$refs.crud.rowEdit(row,row.$index);
        },
        /** 修改*/
        rowUpdate(row, index, done, loading) {
          row.ts = new Date().getTime;
          update(row).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
            done();
          }, error => {
            loading();
            console.log(error);
          });
        },
        /** 删除*/
        handleDelete() {
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          this.$confirm("确定将选择数据删除?", {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning"
          })
            .then(() => {
              // 只支持每次单条记录删除
              let oid = this.selectionList[0].oid;
              let ts = new Date(this.selectionList[0].ts).getTime();
              return remove({oid: oid,ts: ts});
            })
            .then(() => {
              this.onLoad(this.page);
              this.$message({
                type: "success",
                message: "操作成功!"
              });
              this.$refs.crud.toggleSelection();
            });
        },
        // 打开修改*/
        beforeOpen(done, type) {
          if (["edit", "view"].includes(type)) {
            getDetail(this.ruleForm.oid).then(res => {
              this.ruleForm = res.data.data;
            });
          }
          done();
        },
        searchReset() {
          this.query = {};
          this.onLoad(this.page);
        },
        searchChange(params, done) {
          this.page.currentPage = 1;
          // 多个conditionMap这样传参，快速查询默认采用模糊查询
          let requestData = {};
          if(params){
            Object.keys(params).forEach(key=>{
              requestData["conditionMap"+'['+key+'_like]'] = params[key].trim();
            });
          }
          this.query = requestData;
          this.onLoad(this.page);
          done();
        },
        /** 编码规则当前选中行变化的时候触发*/
        selectionChange(list) {
          this.selectionList = list;
          //当前选中行为空的时候就将码段管理表格数据置空,并禁用相关功能
          if(this.selectionList.length <= 0){
            this.hideBasicTable(false);
          }
          if (this.selectionList.length > 0) {
            this.$refs.crud.setCurrentRow(this.selectionList[list.length-1]);
            this.currentCodeRuleOid = this.selectionList[list.length-1].oid;
            this.currentRuleLcStatus = this.selectionList[list.length-1].lcStatus;
            this.loadBasic(this.selectionList[list.length-1]);
          }
        },
        /** 单击编码规则实现行选择*/
        codeRuleRowClick (row) {
          // console.log(this.currentRuleLcStatus);
          this.$refs.crud.toggleSelection();
          this.$refs.crud.toggleRowSelection(row); //选中当前行

        },
        selectionClear() {
          this.selectionList = [];
          this.$refs.crud.toggleSelection();
        },
        currentChange(currentPage){
          this.page.currentPage = currentPage;
        },
        sizeChange(pageSize){
          this.page.pageSize = pageSize;
        },
        refreshChange() {
          this.onLoad(this.page, this.query);
        },
        onLoad(page,params={}) {
          this.loading = true;
          gridCodeRule(
            page.currentPage,
            page.pageSize,
            this.query
          ).then(res => {
            //console.log(res.data);
            const data = res.data.data;
            this.page.total = data.total;
            this.data = data.records;
            this.loading = false;
            // 查询的值为空时，要将码段管理相关的内容禁用
            if(data.records.length <= 0) {
              this.hideBasicTable(false);
              return;
            }
            this.loadBasic(this.data[0])
            this.$nextTick(() => {
              this.$refs.crud.toggleRowSelection(this.data[0]);
              this.$refs.crud.setCurrentRow(this.data[0]);
            })
            this.selectionList = data.records[0];
            //this.selectionClear();
          });
        },


        /** 基础码段相关方法 */
        //防止打开过编辑窗口之后表单中存在值，所以需要清空,并初始化form表单属性
        /** 防止打开过编辑窗口之后表单中存在值，所以需要清空,并初始化form表单属性*/
        clearBasicAddForm(){
          this.form = this.$options.data().form;
          // this.changeSectypeFormItems(null);
        },
        // 打开新增窗口
        /** 打开新增窗口*/
        openAddBasicCodeSec(){
          if(!this.tipsMessage(this.selectionList)){
            return;
@@ -1629,7 +2129,7 @@
          this.openBasicDialog('add',null);
          this.loadCodeSecType();
        },
        // 打开新增或编辑基础码段对话框
        /** 打开新增或编辑基础码段对话框*/
        openBasicDialog(condition,row){
          //console.log(row);
          if(condition == 'add') {
@@ -1654,7 +2154,7 @@
          this.changeSectypeFormItems(condition == 'add' ? null:row);
          this.addBasicCodeSettingBox = true;
        },
        // 新增基础码段
        /** 新增基础码段*/
        async saveOrEditBasicCode(){
          if(this.selectionList[0].oid == null ||  this.selectionList[0].oid == ''){
            this.$message.warning('缺失必要参数，请重新选择编码规则后再试!');
@@ -1678,20 +2178,15 @@
            this.loadBasic(this.selectionList[0]);
          }else{
            // 可能参照引用的业务类型会发生改变所以这儿直接对referConfig的json进行改变
            if(this.form.referConfig != undefined){
            if(this.form.referConfig === "coderefersec" || this.form.referConfig != undefined){
              let referConfig = JSON.parse(this.form.referConfig);
              referConfig.referType = this.form.referBtmId;
              referConfig.referTypeName = this.form.referBtmName;
              this.form.referConfig = JSON.stringify(referConfig);
            }
            if(this.form.referValueInfo != undefined){
              let referValueInfo = JSON.parse(this.form.referValueInfo);
              referValueInfo.referType = this.form.referBtmId;
              this.form.referValueInfo = JSON.stringify(referValueInfo);
              // let referValueInfo = JSON.parse(this.form.referValueInfo);
              // referValueInfo.referType = this.form.referBtmId;
            }
            editSave(this.form).then(() => {
               // 关闭对话框
              this.addBasicCodeSettingBox = false
              this.$message({
                type: "success",
                message: "操作成功!"
@@ -1700,13 +2195,16 @@
                window.console.log(error);
            });
            this.loadBasic(this.selectionList[0]);
            // 关闭对话框
            this.addBasicCodeSettingBox = false
          }
        },
        // 因为elementui的表单校验设置不上所以采用判断的方式来做表单检验方式
        /** 因为elementui的表单校验设置不上所以采用判断的方式来做表单检验方式*/
        checkForm(){
          let form = this.form;
          //console.log(form);
          const regNumber = /^[0-9]+\.{0,1}[0-9]*$/; //数字或小数正则校验
          const regPos =  /^[0-9]*[1-9][0-9]*$/; //非负整数正则校验
          const tipsMsg = "必填项不能为空";
          if(form.id == ''){
            this.$message.warning("(码段编号)"+tipsMsg);
@@ -1727,7 +2225,7 @@
            //固定码段
            if(form.codeSecLengthType == ''){
              this.$message.warning("(码段长度类型)"+tipsMsg);
              this.$refs.codeSecLengthType.$el.querySelector('select').focus();
              // this.$refs.codeSecLengthType.$el.querySelector('select').focus();
              return false;
            }
            if(form.codeSecLength == ''){
@@ -1808,14 +2306,19 @@
              this.$message.warning('(层级类型)'+tipsMsg);
              return false;
            }
            if(!regNumber.test(form.codeLevelValue)){
              this.$message.warning('层级的值)只能填写数字');
            if(form.codeLevelType != 'code_level_min'&& !regNumber.test(form.codeLevelValue)){
              this.$message.warning('(层级的值)只能填写数字');
              this.$refs.codeLevelValue.$el.querySelector('input').focus();
              return false;
            }
            if(form.valueCutType == ''){
              this.$message.warning('(字符截取类型)'+tipsMsg);
              this.$refs.valueCutType.$el.querySelector('select').focus();
              // this.$refs.valueCutType.$el.querySelector('select').focus();
              return false;
            }
            if(form.valueCutType != 'code_cut_none' && !regPos.test(form.valueCutLength)){
              this.$message.warning('(值截取长度)只能填写正整数');
              this.$refs.valueCutLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='coderefersec'){
@@ -1877,7 +2380,7 @@
          }
          return true;
        },
        // 判断数据是否选择以及只能选择单条数据
        /** 判断数据是否选择以及只能选择单条数据*/
        tipsMessage(list){
          if(list.length != 1){
            this.$message.warning("请选择一条编码规则数据!");
@@ -1885,7 +2388,7 @@
          }
          return true;
        },
        // 基础码段删除
        /** 基础码段删除*/
        deleteBasicCode(){
          if(!this.tipsMessage(this.selectionBasicList)){
            return;
@@ -1909,7 +2412,7 @@
            this.$refs.crudBasic.toggleSelection();
          });
        },
        // 点击触发加载基础码段信息
        /** 点击触发加载基础码段信息*/
        loadBasic(row){
          if(this.cloneSettingBox){
            this.cloneTableLoading = true;
@@ -1924,7 +2427,7 @@
            this.sendGridCodeBasicSec({"pkCodeRule":row.oid},false);
          }
        },
        // 发送加载基础码段的请求
        /** 发送加载基础码段的请求*/
        sendGridCodeBasicSec(condition,isAdancedQuery/** 是否高级查询 */){
          // 如果当前基础码段表中的搜索按钮被隐藏，就需要在此开启
          if(this.selectionList.length>=0 && !this.$refs.crudBasic.option.column[0].search){
@@ -1953,13 +2456,13 @@
            }
          });
        },
        // 基础码段选中时触发
        /** 基础码段选中时触发*/
        selectionBasicChange(list) {
          this.selectionBasicList = list;
          this.$refs.crudBasic.setCurrentRow(this.selectionBasicList[list.length-1]);
          //console.log(this.selectionBasicList);
        },
        // 基础码段被单击表格行时触发
        /** 基础码段被单击表格行时触发*/
        codeBasicSecRowClick(row){
          this.$refs.crudBasic.toggleSelection();
          this.selectionBasicList = row;
@@ -1974,8 +2477,8 @@
        basicSearchReset(){
          this.sendGridCodeBasicSec({"pkCodeRule":this.selectionList[this.selectionList.length-1].oid},false);
        },
        // 上移下移基础码段
        upOrderNum(row){
        /** 上移下移基础码段*/
        async upOrderNum(row){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
@@ -1987,7 +2490,7 @@
            this.$message.warning("未获取到必填参数!");
            return;
          }
          upOrderNum(row.oid).then(() => {
          await upOrderNum(row.oid).then(() => {
            this.loadBasic(this.selectionList[0]);
            this.$message({
              type: "success",
@@ -2018,14 +2521,13 @@
            });
          })
        },
        // 基础码段刷新时查询
        /** 基础码段刷新时查询*/
        refreshChangeBasicSec(){
          this.loadBasic(this.selectionList.at(-1));
        },
        // 操作基础码段中搜索清空等按钮的显示/隐藏
        /** 操作基础码段中搜索清空等按钮的显示/隐藏*/
        hideBasicTable(hideBoolean){
          this.$refs.crudBasic.option.refreshBtn = hideBoolean;
          this.$refs.crudBasic.option.columnBtn = hideBoolean;
          this.$refs.crudBasic.option.column[0].search = hideBoolean;
          this.$refs.crudBasic.option.column[1].search = hideBoolean;
          if(!hideBoolean){
@@ -2033,423 +2535,22 @@
            this.basicData = [];
          }
        },


        /** 编码规则相关方法 */
        // 打开高级查询窗口
        openAdvancedQuery(condition){
          if(condition=='codeRule'){
            this.advancedQueryParam.options = [
              {
                data: [],
                title: '编号',
                fieldType: 'text',
                queryField: 'id',
              },{
                data: [],
                title: '名称',
                fieldType: 'text',
                queryField: 'name',
              },{
                data: [],
                title: '描述',
                fieldType: 'text',
                queryField: 'description',
              },{
                data: [
                  // {
                  //   key: '编辑中',
                  //   value: 'Editing',
                  // },
                  // {
                  //   key: '已发布',
                  //   value: 'Released',
                  // },
                  // {
                  //   key: '停用',
                  //   value: 'Disabled',
                  // },
                ],
                title: '状态',
                fieldType: 'combox',
                queryField: 'lcStatus',
                comboxKey: 'codeSearchLCStatus',
              },
            ]
          }else {
            this.advancedQueryParam.options = [
              {
                data: [],
                title: '码段编号',
                fieldType: 'text',
                queryField: 'id',
              },{
                data: [],
                title: '码段名称',
                fieldType: 'text',
                queryField: 'name',
              },{
                data: [],
                title: '描述',
                fieldType: 'text',
                queryField: 'description',
              },{
                data: [],
                title: '码段类型',
                fieldType: 'combox',
                queryField: 'secType',
                comboxKey: 'codeSecType',
              }
            ]
          }
          this.advancedQueryParam.currentOpen = condition;
          this.advancedQueryParam.advancedQuerySettingBox = true;
        },
        // 查询使用范围
        handleRange(){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          this.codeRangeSettingBox = true;
          this.getRangeCodeList()
        },
        // 加载使用范围列表
        getRangeCodeList(){
          this.dialogLoading = true;
          if(this.selectionList[0].oid==null){
            this.$message.error("未获取到参数!");
          }

          listUseRange(this.selectionList[0].oid).then(res => {
            this.useRangeData = res.data.data;
            //console.log(this.useRangeData);
            this.dialogLoading = false;
          });
        },
        // 刷新使用范围列表
        refreshUseRangeChange(){
          this.getRangeCodeList();
        },
        // 启用与停用
        enableOrDeactivatse(oId,update){
          updateStatus({"oid":oId,"ts":new Date().getTime,"update":update}).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          }, error => {
            window.console.log(error);
          });
        },
        // 打开编码规则克隆对话框
        openCodeRuleDialog() {
          if (!this.tipsMessage(this.selectionList)) {
            return;
          }
          this.cloneSettingBox = true;
          this.cloneCodeRuleForm.id = this.selectionList[0].id;
          this.cloneCodeRuleForm.name = this.selectionList[0].name;
          this.cloneCodeRuleForm.description = this.selectionList[0].description;
          this.loadBasic({"oid": this.selectionList[0].oid});
        },
        // 克隆编码规则保存功能
        saveCloneCodeRule(){
          let form = this.cloneCodeRuleForm;
          if(form.id.trim()==''){
            this.$message.warning("编号不能为空!");
            return;
          }
          if(form.name.trim()==''){
            this.$message.warning("码值不能为空!");
            return;
          }
          this.selectionList[0].oid = '';
          this.selectionList[0].id = form.id;
          this.selectionList[0].name = form.name;
          this.selectionList[0].description = form.description;
          this.selectionList[0].createTime = new Date().getTime();
          this.selectionList[0].ts = new Date(this.selectionList[0].ts).getTime();
          this.selectionList[0].lcStatus = 'Editing';
          let data = Object.assign({}, this.selectionList[0],{elements:this.cloneData});
          clone(data).then(() => {
            this.cloneSettingBox = false;
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          }, error => {
            window.console.log(error);
          });
          //console.log(data);
        },
        // 打开从其他编码规则中克隆码段对话框
        openOtherCodeRuleDialog(){
          if (!this.tipsMessage(this.selectionList)) {
            return;
          }
          if(this.selectionList[0].lcStatus != 'Editing'){
            this.$message.warning("编码规则已被引用，不允许编辑或删除!");
            return;
          }
          this.cloneOtherCodeRuleSettingBox = true;
        },
        // 从其他编码规则中克隆码段对话框-单击编码规则实现行选择
        codeOtherCloneRuleRowClick(row) {
          this.$refs.crudCloneCodeRuleOther.toggleSelection();
          this.selectionOtherCloneCodeRuleList = row;
          this.$refs.crudCloneCodeRuleOther.setCurrentRow(row);
          this.$refs.crudCloneCodeRuleOther.toggleRowSelection(row); //选中当前行
          this.loadBasic(row);
        },
        // 从其他编码规则中克隆码段对话框-单击基础码段实现行选择
        codeOtherCloneBasicRowClick(row){
          this.$refs.crudCloneCodeBasicOther.toggleSelection();
          this.selectionOtherCloneCodeBasicList = row;
          this.$refs.crudCloneCodeBasicOther.setCurrentRow(row);
          this.$refs.crudCloneCodeBasicOther.toggleRowSelection(row); //选中当前行
        },
        // 从其他规则克隆码段界面中编码规则当前选中行变化的时候触发
        selectionOtherCloneCodeRuleChange(list) {
          //console.log(list);
          this.selectionOtherCloneCodeRuleList = list;
          this.$refs.crudBasic.setCurrentRow(this.selectionBasicList[list.length-1]);
          if(list == ''){
            this.basicData = [];
          }
          if(this.selectionOtherCloneCodeRuleList.length > 0){
            this.loadBasic(this.selectionOtherCloneCodeRuleList[list.length-1]);
          }
        },
        selectionOtherCloneCodeBasicChange(list){
          this.selectionOtherCloneCodeBasicList = list;
          this.$refs.crudCloneCodeBasicOther.setCurrentRow(this.selectionOtherCloneCodeBasicList[list.length-1]);
        },
        // 从其他编码规则中克隆码段信息
        saveOtherCodeBasic(){
          let oid = this.selectionList[0].oid;
          let fromDialogPkCodebasic = this.selectionOtherCloneCodeBasicList;
          if(fromDialogPkCodebasic.length <= 0){
            this.$message.warning("请选择码段数据!");
            return;
          }
          let res = fromDialogPkCodebasic.filter((item) => {
            return item.pkCodeRule == oid;
          });
          if(res != ''){
            this.$message.warning("需要克隆的编码规则与被克隆的编码规则相同!");
            return;
          }
          //console.log(res);
          let oidArr = [];
          fromDialogPkCodebasic.forEach(ele => {
            oidArr.push(ele.oid);
          });
          let data = {
            "pkCodeRule": oid,
            "oidArr": oidArr.join(","),
          }
          //console.log(data);
          cloneCodeBasic(data).then(() => {
            this.cloneOtherCodeRuleSettingBox = false;
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          }, error => {
            window.console.log(error);
          });
        },
        // 清空码值
        clearAllCodeSec(){
          if(this.selectionList.length == 0){
            this.$message.warning("没有选择数据!");
            return;
          }
          if(this.selectionList.length != 1){
            this.$message.warning("每次只能选择一条数据!");
            return;
          }
          let currentData = this.selectionList[0];
          this.$confirm("确定要清空码值？如果清空将不能被恢复，请谨慎！", {
              confirmButtonText: "确定",
              cancelButtonText: "取消",
              type: "warning"
            })
            .then(() => {
              let ts = new Date(currentData.ts).getTime();
              return clearAllCode({"oid": currentData.oid,"ts": ts});
            })
            .then(() => {
              this. this.onLoad(this.page);
              this.$message({
                type: "success",
                message: "操作成功!"
              });
            });
        },
        // 添加
        rowSave(row, done, loading) {
          add(row).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
            done();
          }, error => {
            loading();
            window.console.log(error);
          });
        },
        openEdit(row){
          this.$refs.crud.rowEdit(row,row.$index);
        },
        // 修改
        rowUpdate(row, index, done, loading) {
          row.ts = new Date().getTime;
          update(row).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
            done();
          }, error => {
            loading();
            console.log(error);
          });
        },
        // 删除
        handleDelete() {
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          this.$confirm("确定将选择数据删除?", {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning"
          })
            .then(() => {
              // 只支持每次单条记录删除
              let oid = this.selectionList[0].oid;
              let ts = new Date(this.selectionList[0].ts).getTime();
              return remove({oid: oid,ts: ts});
            })
            .then(() => {
              this.onLoad(this.page);
              this.$message({
                type: "success",
                message: "操作成功!"
              });
              this.$refs.crud.toggleSelection();
            });
        },
        // 打开修改
        beforeOpen(done, type) {
          if (["edit", "view"].includes(type)) {
            getDetail(this.ruleForm.oid).then(res => {
              this.ruleForm = res.data.data;
            });
          }
          done();
        },
        searchReset() {
          this.query = {};
          this.onLoad(this.page);
        },
        searchChange(params, done) {
          this.page.currentPage = 1;
          // 多个conditionMap这样传参，快速查询默认采用模糊查询
          let requestData = {};
          if(params){
            Object.keys(params).forEach(key=>{
              requestData["conditionMap"+'['+key+'_like]'] = params[key].trim();
            });
          }
          this.query = requestData;
          this.onLoad(this.page);
          done();
        },
        // 编码规则当前选中行变化的时候触发
        selectionChange(list) {
          this.selectionList = list;
          //当前选中行为空的时候就将码段管理表格数据置空,并禁用相关功能
          if(this.selectionList.length <= 0){
            this.hideBasicTable(false);
          }
          if (this.selectionList.length > 0) {
            this.$refs.crud.setCurrentRow(this.selectionList[list.length-1]);
            this.currentCodeRuleOid = this.selectionList[list.length-1].oid;
            this.currentRuleLcStatus = this.selectionList[list.length-1].lcStatus;
            this.loadBasic(this.selectionList[list.length-1]);
          }
        },
        changeCutType(value){
          if (value != 'code_cut_none'){
            this.showCutLength = true;
            if(this.form.valueCutLength == ''){
              this.form.valueCutLength = 1;
            }
          }else{
            this.form.valueCutLength = '';
            this.showCutLength = false;
          }
        },
        // 单击编码规则实现行选择
        codeRuleRowClick (row) {
          // console.log(this.currentRuleLcStatus);
          this.$refs.crud.toggleSelection();
          this.$refs.crud.toggleRowSelection(row); //选中当前行

        },
        selectionClear() {
          this.selectionList = [];
          this.$refs.crud.toggleSelection();
        },
        currentChange(currentPage){
          this.page.currentPage = currentPage;
        },
        sizeChange(pageSize){
          this.page.pageSize = pageSize;
        },
        refreshChange() {
          this.onLoad(this.page, this.query);
        },
        onLoad(page,params={}) {
          this.loading = true;
          gridCodeRule(
            page.currentPage,
            page.pageSize,
            this.query
          ).then(res => {
            //console.log(res.data);
            const data = res.data.data;
            this.page.total = data.total;
            this.data = data.records;
            this.loading = false;
            // 查询的值为空时，要将码段管理相关的内容禁用
            if(data.records.length <= 0) {
              this.hideBasicTable(false);
              return;
            }
            this.loadBasic(this.data[0])
            this.$nextTick(() => {
              this.$refs.crud.toggleRowSelection(this.data[0]);
              this.$refs.crud.setCurrentRow(this.data[0]);
            })
            this.selectionList = data.records[0];
            //this.selectionClear();
          });
        },

        /** 第一层对话框相关方法 */
        // 打开二层对话框方法
        /** 打开二层对话框方法*/
        openAttrSelectOrGetValue(condition){
          if(condition === 'attr'){
            this.isShowSelectAttrOption = true;
            this.loadlistClassifyLinkAttr();
          }else if(condition === 'value'){
            //打开公式编辑框，第二层嵌套对话框
            //this.$refs.formulaEditor.isShowformulaEdit = true;
@@ -2461,52 +2562,17 @@
            // 调用子组件刷新表格数据
            this.$refs[this.referBtmDialogParams.ref].referBtmOnLoad();
          }else if(condition === 'referConfig'){
            if(func.notEmpty(this.form.referConfig) || func.notEmpty(this.form.referBtmName)){
              this.openReconfigInterFace(this.form);
            }else{
              this.openTipsChooseOrCust();
            this.referConfigVisble = true;
            this.referConfigOption = {
              referBtmName: this.form.referBtmName,
              referBtmId: this.form.referBtmId,
              referConfig: this.form.referConfig || '',
            }
            this.$refs.referConfig.$el.querySelector('input').blur();
          }
        },

        // 当前已存在编辑过的参照配置，所以直接打开参照配置界面
        openReconfigInterFace(preReferConfigForm){
          // console.log(preReferConfigForm);
          this.$refs.referConfigFormDialog.isShowReferConfigForm = true;
              let value = {
                referTypeName: preReferConfigForm.referBtmName,
                referType: preReferConfigForm.referBtmId,
                referConfig: preReferConfigForm.referConfig,
              }
              this.$refs.referConfigFormDialog.initPageData(value);
        },
        // 打开自定义参照配置或直接选择参照配置的提示框
        openTipsChooseOrCust(){
          this.$confirm('请选择参照配置的定义方式？','参照配置的方式', {
            distinguishCancelAndClose: true,
            closeOnClickModal: false,
            confirmButtonText: '自定义参照配置',
            cancelButtonText: '直接选择参照配置'
          })
          .then(() => {
            // 打开自定参照配置对话框
            this.$refs.referConfigFormDialog.isShowReferConfigForm = true;
            // 表格错行的问题
            this.$refs.referConfigFormDialog.onloadAttrData();
          })
          .catch(action => {
            if (action === "cancel") {
              // 打开直接选择参照配置对话框
              this.$refs.referConfigCrudDialog.isShowReferConfigCrud = true;
              this.$refs.referConfigCrudDialog.referConfigOnload();
            }
            //console.log(action);
          });
          // 让参照配置输入框失去焦点，否则该提示框无法被关闭
          this.$refs.referConfig.$el.querySelector('input').blur();
        },

        // 点击输入框的×号，清空输入框中的内容
        /** 点击输入框的×号，清空输入框中的内容*/
        clearAttrDataByIcon(condition){
          if(condition === 'attr'){
            this.form.referAttributeName = '';
@@ -2525,13 +2591,13 @@
            this.form.referConfig = '';
          }
        },
        // 补位时的字符，实现可输可选
        /** 补位时的字符，实现可输可选*/
        inputSelectBlur(e){
          if (e.target.value) {
            this.form.codeFillSeparator = e.target.value;
          }
        },
        // 码段类型改变时，增加对应的form表单中的属性
        /** 码段类型改变时，增加对应的form表单中的属性*/
        changeSectypeFormItems(row){
          //console.log(row);
          if(this.enumParam.secTypeList.length==0){
@@ -2607,12 +2673,6 @@
              valueCutLength: row!=null&&row.valueCutLength != '' ? row.valueCutLength:'',    //
              codeGetValueType: row!=null&&row.codeGetValueType != '' ? row.codeGetValueType:'code_get_value_all_up',  //取值类型 枚举查询
            });
            if(this.form.valueCutType === 'code_cut_none'){
              this.showCutLength = false;
            }else{
              this.showCutLength = true;
            }

            this.loadCodeLevelType();
            this.loadCodeCutType();
            this.loadCodeGetValueType();
@@ -2653,18 +2713,28 @@
          }
          // console.log(this.form);
        },
        // 第一次请求的枚举数据放缓存
        getLocalStorageEnum(key){
          let enumCach = JSON.parse(localStorage.getItem(key));
        /** 第一次请求的枚举数据放缓存*/
        getLocalStorageEnum(enumKey){
          let enumCach = JSON.parse(localStorage.getItem(enumKey));
          if(enumCach == null) {
            getDictionary({code: key}).then(res=>{
            getDictionary({code: enumKey}).then(res=>{
              enumCach = res.data.data;
              localStorage.setItem(key,JSON.stringify(res.data.data));
              localStorage.setItem(enumKey,JSON.stringify(res.data.data));
            })
          }
          return enumCach;
        },
        //枚举和可输可选内容查询
        /** 统一加载所有枚举查询，主要是为避免切换码段类型时还未加载完成的情况*/
        loadTotalEnum(){
          this.loadCodeSecType();
          this.loadCodeSecLength();
          this.loadCodeFillType();
          this.loadCodeFillSeparator();
          this.loadCodeLevelType();
          this.loadCodeCutType();
          this.loadCodeGetValueType();
        },
        /** 枚举和可输可选内容查询 */
        loadCodeSecType(){
          this.enumParam.secTypeList = this.getLocalStorageEnum("codeSecType");
          this.loadCodeSecLength();
@@ -2693,7 +2763,7 @@
        loadCodeGetValueType(){
          this.enumParam.codeGetValueType =  this.getLocalStorageEnum("codeGetValueType");
        },

        
      }
  };

@@ -2826,4 +2896,8 @@
    padding: 5px 10px 10px;
 }

 .seloption{
  margin-left: 10px;
}

</style>