@logwire/logwire-wms-pda-ui 1.1.17 → 1.2.0

package/src/utils/BarcodeResolve.js

@@ -1,281 +1,322 @@
-/*
-* 条码解析解析
-* @author: 张文
-* @date  2022-07-02
-* */
-
-import {common} from "../api/common/common";
-import {lwShowErrorMsg} 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.required && !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.warn(
-              '条码解析规则获取失败！接口返回数据不是数组类型或为空。将会导致条码解析无效或异常！！！返回值为：',
-              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-解析后的数据对象}
-   * */
-  resolve(param){
-
-    const {componentId, barcode, ownerId} = param
-
-    if (!componentId){
-      lwShowErrorMsg('获取条码解析规则失败，未指定输入框解析ID')
-      return
-    }
-
-    const data = this.getRule(componentId)
-
-
-    if (!data || !Object.keys(data).length){
-      lwShowErrorMsg('获取条码解析规则失败，未获取到解析规则。输入框解析ID：' + componentId)
-      return
-    }
-
-
-    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){
-            lwShowErrorMsg(
-                Language.get('','主字段配置有误，请联系管理员重新配置')
-            )
-            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}
-      }
-    }
-
-
-    // 走到这就是所有解析规则都没过了且没有使用默认规则
-    lwShowErrorMsg(Language.get('', '条码解析失败'))
-
-    return {
-      success: false,
-      barcode,
-      data: {}
-    }
-  }
-}
+/*
+* 条码解析解析
+* @author: 张文
+* @date  2022-07-02
+* */
+
+import {common} from "../api/common/common";
+import {lwShowErrorMsg} 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, ruleProductionData} = param
+
+    if (!componentId){
+      lwShowErrorMsg(
+        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 (
+        ruleProductionData &&
+        typeof ruleProductionData === 'object' &&
+        Object.keys(ruleProductionData).length
+      ){
+        try {
+          data = await common.commonWmsLoadAndInitComponentConfig({
+            ...ruleProductionData,
+            code: componentId
+          })
+
+          this.setRule(data, componentId)
+        }catch (e){
+          return {
+            success: false,
+            barcode,
+            data: {}
+          }
+        }
+
+      }else {
+        lwShowErrorMsg(
+          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){
+            lwShowErrorMsg(
+                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}
+      }
+    }
+
+
+    // 走到这就是所有解析规则都没过了且没有使用默认规则
+    lwShowErrorMsg(
+      Language.get('wms_project.pda.utils.BarcodeResolve.agyiotes','条码解析失败！输入框ID：') + componentId
+    )
+
+    return {
+      success: false,
+      barcode,
+      data: {}
+    }
+  }
+}

package/src/utils/DateTime.js

@@ -5,6 +5,7 @@
 * */
 
 import {Language} from "./Language";
+import {Timezone} from "./Timezone";
 
 // 内部使用函数，截取指定时间的值
 function timeTextSplit(str, type){
@@ -24,7 +25,16 @@ export const DateTime = {
    */
   format(date, format = 'yyyy-MM-dd') {
     if (!date) return '-'
-    const value = date instanceof Date ? date : new Date(date)
+
+    // 如果是标准时就调用标准时转换
+    if (/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?Z)/gm.test(date)){
+      return Timezone.UTCToTimezone({
+        date,
+        format
+      })
+    }
+
+    const value = date instanceof Date ? date : /^\d+$/.test(date) ? new Date(Number(date)) : new Date(date)
     let o = {
       'M+': value.getMonth() + 1,
       'd+': value.getDate(),
@@ -54,7 +64,7 @@ export const DateTime = {
    * @param {String} type 返回的时间类型默认秒钟，可选值：s-秒，m-分钟，h-小时, d-天
    * @return {Object} { time:返回相减后的值，不足1的忽略不计，ago: l < n 起始时间是否大于结束时间 }
    * */
-  judgeDate(l, n = new Date(), type = 's') {
+  judgeDate(l, n = new Date().toUTCString(), type = 's') {
     const a = new Date(this.format(l, 'yyyy-MM-dd hh:mm:ss')).getTime()
     const b = new Date(this.format(n, 'yyyy-MM-dd hh:mm:ss')).getTime()
     let time
@@ -88,13 +98,17 @@ export const DateTime = {
   /**
    * 两个时间差转换为中文，可自定义显示到最大时间单位
    * @author 张文
-   * @param {Object} {l-起始时间, n-结束时间,默认当前时间, s-当前秒数(存在值时忽略 l，n), type-最大显示单位（可选）, agoText-需要在文本后显示的文字（可选）,minType-文本翻译的最小单位}
-   * @param {String} type 参数解释： 最大显示单位 y-年（默认）；m-月，d-日，h-小时，min-分钟，s-秒
-   * @param {String} minType 参数解释： 文本的最小单位 y-年；m-月，d-日，h-小时，min-分钟，s-秒（默认）
-   * @param {String|Boolean} agoText 参数解释： 为空时值为 s > 0 || l-n > 0 ? '后' : '前'，若无需显示任何描述文字传入：false
+   * @param {Object} obj {
+   * l-起始时间,
+   * n-结束时间,默认当前时间,
+   * s-当前秒数(存在值时忽略 l，n),
+   * type-最大显示单位（可选）。y-年（默认）；m-月，d-日，h-小时，min-分钟，s-秒,
+   * agoText-需要在文本后显示的文字（可选）。为空时值为 s > 0 || l-n > 0 ? '后' : '前'，若无需显示任何描述文字传入：false(默认),
+   * minType-文本翻译的最小单位（可选）。 y-年；m-月，d-日，h-小时，min-分钟，s-秒（默认）
+   * }
    * @return {Object} {y-年, m-月, d-日, h-时, min-分, s-秒, text:当前时间的中文翻译，xx小时xx分xx秒, success-是否处理成功}
    * */
-  timeToStr({l, n = new Date(), s = 0, type='y', agoText=false, minType='s'}) {
+  timeToStr({l, n = new Date().toUTCString(), s = 0, type='y', agoText=false, minType='s'}) {
     const obj = {
       y: 0,
       m: 0,
@@ -215,5 +229,5 @@ export const DateTime = {
       text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])
     }
 
-  }
+  },
 }

package/src/utils/DeepCopy.js

@@ -9,7 +9,7 @@ import {cloneDeep} from "lodash/lang";
 /**
  * 深拷贝
  * @author 张文
- * @param {Object} data 需要拷贝的原始数据
+ * @param {*} data 需要拷贝的原始数据
  * @return {*} 返回拷贝后的数据
  *
  * */