commonProcess.js

import commonDeclare from "./commonDeclare"
import commonApi from "./commonApi"
import commonGlobalSearch from "./commonGlobalSearch";
import Utils from "~/utils"
import _ from "~/utils/Lodash.js";

export default {
  mixins: [commonApi, commonDeclare,commonGlobalSearch],
  data: function () {
    return {
      // 弹框回填
      promptData: {
        title: '',
        columnStr: '',
        data: [],
        rulePath: ''
      }
    }
  },
  created() {
  },
  mounted() {
    if (!this.isInDisplay) {
      this.generateFormRules()
    }
  },
  methods: {
    /**
     * 表单校验 rules 的赋值
     * @returns void
     */
    generateFormRules() {
      if (this.root) {
        if (!this.root.rules) {
          return;
        } else {
          // 新添加的表单项，需要重新确定下 validator 的触发 trigger
          this.updateRulesTrigger();
          return
        }
      }
      if (!this.pattern)
        return
      // const keySet = new Set(Object.keys(this.pattern).concat(Object.keys(this.checkRules).concat(Object.keys(this.defaultRules))))
      const keySet = new Set(Object.keys(this.pattern).concat(Object.keys(this.defaultRules)))
      const res = {};
      const that = this;
      for (let key of keySet.keys()) {
        const rule = []
        if (that.pattern[key]) {
          rule.push(...that.pattern[key])
        }
        const triggerType = that.getTriggerType(key)
        // if(that.checkRules[key]){
        //   if (Array.isArray(that.checkRules[key])) {
        //     for (let j = 0; j < that.checkRules[key].length; j++) {
        //       const check = that.checkRules[key][j];
        //       rule.push({
        //         validator: check.bind(that),
        //         trigger: triggerType
        //       })
        //     }
        //   } else {
        //     rule.push({
        //       validator: that.checkRules[key].bind(that),
        //       trigger: triggerType
        //     })
        //   }
        // }
        if (that.defaultRules[key]) {
          rule.push({
            validator: that.defaultRules[key].bind(that),
            trigger: triggerType
          })
        }
        if (rule.length > 0) {
          res[key] = rule;
        }
      }
      that.rules = res;
    },
    /**
     * 触发方式
     * @param {String} prop item属性
     * @returns 
     */
    getTriggerType(prop) {
      const modelForm = this.root ? this.root.$refs.modelForm : this.$refs.modelForm
      const fields = modelForm.fields;
      for (let i = 0; i < fields.length; i++) {
        const field = fields[i];
        if (field.prop === prop) {
          // select、checkbox使用change触发
          const ele = field.$children[1] ? field.$children[1].$children[0] : field.$children[0].$children[0]
          if (ele.$el.className.startsWith("el-select") || ele.$el.className.startsWith("el-checkbox")) {
            return "change";
          }
          return "blur";
        }
      }
      return "blur";
    },
    /**
     * 表单有些 tab 是通过 v-if 控制的，这些表单项初始时的 trigger 均为 blur，需要手动更新
     */
    updateRulesTrigger() {
      const rules = this.root.rules
      for (const key in rules) {
        if (Object.hasOwnProperty.call(rules, key)) {
          const rule = rules[key];
          const triggerType = this.getTriggerType(key)
          for (let i = 0; i < rule.length; i++) {
            const r = rule[i];
            if (r.validator && r.trigger !== triggerType) {
              r.trigger = triggerType;
            }
          }
        }
      }
    },
    /**
     * Tabs切换事件
     * @param {VM} tab  
     */
    tabClick(tab) {
      if (this.isInDisplay) {
        return
      }
      const name = tab.name
      let rulePath;
      if (name === "setpan") {
        rulePath = "setmod.setpan";
      }
      if (name === "glepan") {
        rulePath = "setmod.glemod.glepan";
      }
      if (name === "docpan") {
        rulePath = "trnmod.trndoc.docpan"
      }
      if (name === "doctre") {
        rulePath = "trnmod.trndoc.doctre"
      }
      if (name === "engp") {
        rulePath = "liaall.engp"
      }
      if (name === "limitbody") {
        rulePath = "liaall.limmod.limitbody"
      }
      if (name === "ccvpan") {
        rulePath = "liaall.liaccv.ccvpan"
      }
      if( name === "detp1"){
        rulePath = "setmod.setpan"
      }
      if(name === "actinf"){
        rulePath = "recpan.actinf"
      }
      if(name === "libp"){
        rulePath = "cnybop.libp"
      }
      if(name === 'basp'){
        rulePath = "bopmod.dbcp.basp"
      }
      if(name === 'basp1'){
        rulePath = "bopmod.dbfp.basp"
      }
      if(name === 'basp2'){
        rulePath = "bopmod.dbdp.basp"
      }
      if(name === 'basp3'){
        rulePath = "bopmod.dbap.basp"
      }
      if(name === 'incp'){
        rulePath = "cnybop.incp"
      }
      if(name === 'outp'){
        rulePath = "cnybop.Outp"
      }
      if (!!rulePath) {
        // if(rulePath == "setmod.setpan"){
        //     this.executeCustomRule(rulePath).then(res => {
        //         if (res.respCode == SUCCESS) {
        //             this.updateModel(res.data)
        //         }
        //     })
        // }else{
            this.executeRule(rulePath).then(res => {
                if (res.respCode == SUCCESS) {
                    this.updateModel(res.data)
                }
            })
        // }
      }
    },
    /**
     * 以函数形式获取model（请求参数），保证取到的是最新赋值的
     * @param {any} params 参数
     * @param {any} selfCb 允许延时组数 参数
     * @returns 
     */
    wrapper(params,delayCb) {
      params = params || {}
      const fn = async () => {
        const that = this;
        const data = await new Promise(resolve => {
          // 保证前一次请求结果赋值VO完成
          setTimeout(() => {
            delayCb && delayCb()
            const d = Utils.flatObject(that.model)
            resolve(d)
          }, 0)
        })
        return { ...data, params }
      }
      return fn;
    },
    wrapperCustom(params,delayCb) {
        params = params || {}
        params['isCustom'] = true
        const fn = async () => {
          const that = this;
          const data = await new Promise(resolve => {
            // 保证前一次请求结果赋值VO完成
            setTimeout(() => {
              delayCb && delayCb()
              const d = Utils.flatObject(that.customModel)
              resolve(d)
            }, 0)
          })
          params['keys'] = Object.keys(data)
          return { ...data, params }
        }
        return fn;
      },
    /**
     * 用于手动的触发model里属性的 executeDefault 
     * @param {string} rule 执行的 rule path
     * @param {any} value   更改的值
     */
    defaultFunction(rule, value) {
      Utils.defaultFunction.call(this, rule, value)
    },
        /**
     * 用于手动的触发model里属性的 event
     * @param {string} rule 执行的 rule path
     * @param {any} value   更改的值
     */
    eventFunction(rulePath) {
      this.executeRule(rulePath).then((res) => {
        if (res.respCode == SUCCESS) {
            Utils.copyValueFromVO(this.model, res.data);
        }
      })
    },
    /**
     * 更新Model
     * @param {any} data model数据
     */
    updateModel(data) {
      Utils.copyValueFromVO(this.model, data);
    },
    /**
     * 弹出机构选择框
     * @param {String} rulePath 
     * @param {String} columns 自定义需要展示列
     * @param {String} shadow 自定义列后需要保留的影藏字段
     * @param {String} modelUrl 非机构双击后需要回填的字段路劲,k:对应列，value:应用model路劲,如{TXT:'ledgrp.blk.lcrgod'}
     * @param {String} isCover 非机构双击后需要回填的字段值是覆盖还是叠加，部分覆盖值为对象，false为叠加，如{TXT:false}，k值为modelUrl的k，如全部覆盖则isCover='T',如全部叠加则isCover='',默认全部覆盖
     */
    showGridPromptDialog(rulePath, columns, shadow, modelUrl, isCover = "T",Dialog='etyDialog') {
      this.executeRule(rulePath).then((res) => {
        if (res.respCode == SUCCESS) {
          if (res.data.params) {
            Utils.copyValueFromVO(this.model, res.data);
          } else {
            console.log("in if")
            console.log(this.root.$ref)
            console.log(this.root.$refs)
            console.log(this.root.$refs[Dialog]);
            this.root.$refs[Dialog].show = true
            this.root.promptData = {
              title: res.data.title,
              columnStr: columns ? columns : res.data.columns,
              shadow: shadow,
              data: res.data.vals.rows,
              rulePath: rulePath,
              modelUrl: modelUrl,
              isCover: isCover,
            }
          }
        }
        this.$el.querySelectorAll('input').forEach(input => input.blur()) 
      })
    },
    /**
     * 下拉框/多选框 改变时执行rule
     * @param {String} rulePath 路径
     */
     selectOrCheckboxRule(rulePath){
        this.executeRule(rulePath).then((res) => {
            if (res.respCode == SUCCESS) {
                Utils.copyValueFromVO(this.model, res.data);
            }
        })
    },
    /**
     * 机构回填
     * @param {String} val 选种行的值（一般是首列）
     * @param {String} rulePath 路径
     */
     selectEty(val, rulePath) {
      const props = rulePath.replaceAll(".", "_")
      const obj = {}
      obj[props] = val;
      Utils.copyValueFromVO(this.model, obj);
      this.executeRule(rulePath).then((res) => {

        if (res.respCode == SUCCESS) {
          Utils.copyValueFromVO(this.model, res.data);
        }
      });
    },

    /**
        * 货物条款等非机构栏位回填
        * @param {Object} val 选种行的值,按钮的值
        * @param {Object} url 字段路劲 需要回填的字段路劲
        *  @param {Object} url 对应字段值是否覆盖 ，需要为true,否则合并叠加
        * @param {String} rulePath 路径
        */
    selectMsg(val, modelUrl, isCover, rulePath) {
      for (let k in val) {
        let msg = val[k]
        if ((typeof isCover === 'string' && isCover === '') || !isCover[k]) {
          let ms = _.get(this.model, modelUrl[k], '')
          msg = (ms ? ms + '\r\n' : '') + msg
        }
        _.set(this.model, modelUrl[k], msg);
      }
    },
    /**
     * 改变表单项的是否必填属性
     * @param {String} property 属性
     * @param {Boolean} required 是否必填
     */
    changeFormItemRequired(property, required) {
        this.getRoot().pattern[property][0].required = required
    },
    /**
     * 在 A 交易中打开 B 交易视图（详情、开立...）。
     * 
     * 路由视图跳转，例：
     *    this.gotoView("Ditopn", {inr: "001021021"}, {name: "lisi"})   实际请求的 url 为 /business/ditopn/001021021?name=lisi
     *    params, query按需传入（得提前配置好 Router ），在对应的vue页面做好处理
     * @param {String} name 路由的name
     * @param {Object} params 路由的params
     * @param {Object} query 路由的query
     */
    gotoView(name, params, query) {
      params = params || {}
      query = query || {}
      this.$router.push({ name, params, query })
    },
    gotoUrl(url) {
      this.$router.push(url)
    },
    /**
     * 设置拖动组件的内容
     * @param {String} currentTool 
     * @param {String} toolTitle 
     */
    setDraggableContent(currentTool, toolTitle) {
      const layout = this.$root.$children[0].$children[0]
      layout.dragShow = true;
      layout.changeSize(1);
      layout.currentTool = currentTool;
      layout.toolTitle = toolTitle;
    }
  },
  computed: {
    isInDisplay() {
      return this.$store.state.Status.mode === 'display'
    }
  }
}