logwire-wms-ui-test/src/utils/BarcodeResolve.js

运匠科技wms-PDA基础组件库

/*
* 条码解析解析
* @author: 张文
* @date  2022-07-02
* */

import {common} from "../api/common/common";
import {lwErrMsg} from "../components/ui/ErrorMsg";
import {DateTime} from "luxon";
import {Language} from "./Language";

// 条码工具
const barcodeUtils = {
  /**
   *
   * @param {string} barcode 条码
   * @param {string} seperator 分隔符
   * @param {string} fields 属性列表
   * @returns 根据分隔符和属性解析的对象，解析失败返回null
   */
  split (barcode, seperator, fields) {
    if (!barcode || !fields) {
      return null
    }
    const values = typeof seperator === 'string' ? barcode.split(seperator) : [ barcode ]
    const fs = Array.isArray(fields) ? fields : (typeof seperator === 'string' ? fields.split(seperator) : [ fields ])
    if (fs.length === 0 || values.length !== fs.length) {
      return null
    }
    const data = {}
    for (let i in fs) {
      data[fs[i]] = values[i]
    }
    return data
  }
}

/**
 * 内部方法：根据验证规则对对象属性进行验证
 * @author dhc
 * @param {*} data 验证对象
 * @param {*} rules 验证规则列表
 * @returns {Boolean}
 */
const ruleValidation = (data, rules) => {
  if (!rules || !Array.isArray(rules) || rules.length === 0) {
    return true;
  }
  const rs = rules.filter(i => i.field)
  for (let r of rs) {
    const value = data[r.field]
    if (r.importd && !value) {
      return false
    }
    if (value !== null && value !== undefined) {
      if (r.dataType && !dataTypeValid(value, r.dataType, r.format)) {
        return false
      }
      if (r.validType && !operatorValid(value, r.validType, r.content)) {
        return false
      }
    }
  }
  return true
}

const dataTypeValid = (value, dataType, format) => {
  if (!value) {
    return true
  }
  switch(dataType) {
    case 'int': return Number.isInteger(Number(value))
    case 'decimal': return !Number.isNaN(Number(value))
    case 'string': return typeof value === 'string'
    case 'date':
    case 'datetime':
    case 'time':
      return (format ? DateTime.fromFormat(value, format) : DateTime.fromISO(value)).toISO() !== null
  }
  return false
}

/**
 * 内部方法：属性操作符验证
 * @param {*} value 验证值
 * @param {*} validType 验证类型
 * @param {*} content 验证参数内容
 * @returns 验证是否通过
 */
const operatorValid = (value, validType, content) => {
  if (!value) {
    return true
  }
  switch (validType) {
    case 'EQ': return value == content
    case 'NEQ': return value != content
    case 'GT': return parseFloat(value) > parseFloat(content)
    case 'GE': return parseFloat(value) >= parseFloat(content)
    case 'LT': return parseFloat(value) < parseFloat(content)
    case 'LE': return parseFloat(value) <= parseFloat(content)
    case 'IN': return content && content.split(',').includes(value)
    case 'NOTIN': return !content || !content.split(',').includes(value)
    case 'LENGTH': return (value.length || (!value ? 0 : 1)) === parseInt(content)
    case 'MATCH': return !!content && !!value && new RegExp(content).test(value)
  }
  return false
}


export const BarcodeResolve = {


  /**
   * 设置条码规则到全局变量中
   * @author 张文
   * @param {Object|Array} data 设置的值
   * @param {String} key 需要设置值的key，默认设置顶级，传入值后设置顶级的下级
   * @return -
   * */
  setRule(data, key=''){
    let index = 'barcodeResolveRule'
    if (key) index+=('.'+key)

    window.lwWindowGlobalData.set(index, data)
  },


  /**
   * 获取全局变量中的条码规则
   * @author 张文
   * @param {String} key 需要获取值的key，默认获取全部，传入值后获取指定key的数据
   * @return {Object} 返回获取到的值
   * */
  getRule(key){
    let index = 'barcodeResolveRule'
    if (key) index+=('.'+key)

    return window.lwWindowGlobalData.get(index) || {}
  },


  /**
   * 初始化规则
   * @author 张文
   * @param {Array} appCodeList 获取指定app的解析规则
   * @return -
   * */
  asyncInitRule(appCodeList=[]){
    return new Promise((PR,PE)=>{
      common.commonWmsLoadAllComponentConfig({
        appCodeList
      }).then(res=>{

        let obj = {}

        // 判断返回数据是否是数组且有值
        if (!Array.isArray(res) || !res.length){
          console.error(
              '条码解析规则获取失败！接口返回数据不是数组类型或为空。将会导致条码解析无效或异常！！！返回值为：',
              res
          )
        }else {
          res.forEach(item => obj[item.componentId] = item)
        }

        this.setRule(obj)

        PR()
      }).catch((e)=>PE(e))
    })
  },

  /**
   * 使用条码解析规则并解析条码
   * @author 张文
   * @param {Object} param {componentId-输入框id, barcode-需要解析的内容, ownerId-货主id}
   * @return {Object} {success-解析是否成功，barcode-解析前的原始字符，bizType-成功解析的规则，data-解析后的数据对象}
   * */
  async resolve(param){

    const {componentId, barcode, ownerId, createRule} = param

    if (!componentId){
      lwErrMsg.show(
        Language.get('wms_project.pda.utils.BarcodeResolve.qemvmsdn','获取条码解析规则失败，未指定输入框解析ID')
      )
      return {
        success: false,
        barcode,
        data: {}
      }
    }

    let data = this.getRule(componentId)


    if (!data || !Object.keys(data).length){

      if (
        createRule &&
        typeof createRule === 'object' &&
        Object.keys(createRule).length
      ){
        try {
          data = await common.commonWmsLoadAndInitComponentConfig({
            ...createRule,
            code: componentId
          })

          this.setRule(data, componentId)
        }catch (e){
          return {
            success: false,
            barcode,
            data: {}
          }
        }

      }else {
        lwErrMsg.show(
          Language.get('wms_project.pda.utils.BarcodeResolve.bmkxoyxk','获取条码解析规则失败，未获取到解析规则。输入框解析ID：')+ componentId
        )
        return {
          success: false,
          barcode,
          data: {}
        }
      }




    }


    data.barcodeConfig.typeResolvers.forEach(item=>{
      item.resolvers = item.resolvers.filter(inItem=>{
        return !inItem.ownerId || (ownerId && inItem.ownerId === ownerId)
      })
    })


    for (let typeResolvers of data.barcodeConfig.typeResolvers) {

      // 判断是否存在解析器
      if (
        !typeResolvers.resolvers ||
        !Array.isArray(typeResolvers.resolvers) ||
        !typeResolvers.resolvers.length
      ) continue

      for (let resolvers of typeResolvers.resolvers) {
        // 判断解析脚本是否合法
        if (
          !resolvers.clientHandle ||
          !resolvers.clientScript ||
          typeof resolvers.clientScript !== 'string'
        ) continue


        // 执行解析脚本
        const resolveData = (new Function('$param', '$utils', resolvers.clientScript))(param, barcodeUtils)

        // 校验是否解析成功，且复核验证要求
        if (
          resolveData &&
          ruleValidation(resolveData, typeResolvers.valids) &&
          (
            !(resolvers.validScript && typeof resolvers.validScript === 'string') ||
            (new Function('$param', '$utils', '$data', resolvers.validScript))(param, barcodeUtils, resolveData)
          )
        ) {

          if (!typeResolvers.primaryValid || !typeResolvers.primaryValid.field){
            lwErrMsg.show(
                Language.get('wms_project.pda.utils.BarcodeResolve.stpryqma','主字段配置有误，请联系管理员重新配置')
            )
            return {
              success: false,
              barcode,
              data: {}
            }
          }

          const successData = {
            ...resolveData,
            key: resolveData[typeResolvers.primaryValid.field]
          }
          return {
            success: true,
            barcode,
            bizType: typeResolvers.bizType,
            data: successData
          }
        }
      }
    }


    // 判断是否使用了默认解析
    if (data.barcodeConfig.defaultResolve){
      return {
        success: true,
        barcode,
        bizType: data.barcodeConfig.defaultBizType,
        data: {key: barcode}
      }
    }


    // 走到这就是所有解析规则都没过了且没有使用默认规则
    lwErrMsg.show(
      Language.get('wms_project.pda.utils.BarcodeResolve.agyiotes','条码解析失败！输入框ID：') + componentId
    )

    return {
      success: false,
      barcode,
      data: {}
    }
  }
}