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

package/src/utils/BarcodeResolve.js

@@ -49,7 +49,7 @@ const ruleValidation = (data, rules) => {
   const rs = rules.filter(i => i.field)
   for (let r of rs) {
     const value = data[r.field]
-    if (r.required && !value) {
+    if (r.importd && !value) {
       return false
     }
     if (value !== null && value !== undefined) {
@@ -107,7 +107,7 @@ const operatorValid = (value, validType, content) => {
 }
 
 
-export const barcodeResolve = {
+export const BarcodeResolve = {
 
 
   /**
@@ -155,7 +155,7 @@ export const barcodeResolve = {
 
         // 判断返回数据是否是数组且有值
         if (!Array.isArray(res) || !res.length){
-          console.warn(
+          console.error(
               '条码解析规则获取失败！接口返回数据不是数组类型或为空。将会导致条码解析无效或异常！！！返回值为：',
               res
           )
@@ -176,21 +176,60 @@ export const barcodeResolve = {
    * @param {Object} param {componentId-输入框id, barcode-需要解析的内容, ownerId-货主id}
    * @return {Object} {success-解析是否成功，barcode-解析前的原始字符，bizType-成功解析的规则，data-解析后的数据对象}
    * */
-  resolve(param){
+  async resolve(param){
 
-    const {componentId, barcode, ownerId} = param
+    const {componentId, barcode, ownerId, ruleProductionData} = param
 
     if (!componentId){
-      lwShowErrorMsg('获取条码解析规则失败，未指定输入框解析ID')
-      return
+      lwShowErrorMsg(
+        Language.get('wms_project.pda.utils.BarcodeResolve.qemvmsdn','获取条码解析规则失败，未指定输入框解析ID')
+      )
+      return {
+        success: false,
+        barcode,
+        data: {}
+      }
     }
 
-    const data = this.getRule(componentId)
+    let data = this.getRule(componentId)
 
 
     if (!data || !Object.keys(data).length){
-      lwShowErrorMsg('获取条码解析规则失败，未获取到解析规则。输入框解析ID：' + componentId)
-      return
+
+      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: {}
+        }
+      }
+
+
+
+
     }
 
 
@@ -234,7 +273,7 @@ export const barcodeResolve = {
 
           if (!typeResolvers.primaryValid || !typeResolvers.primaryValid.field){
             lwShowErrorMsg(
-                Language.get('','主字段配置有误，请联系管理员重新配置')
+                Language.get('wms_project.pda.utils.BarcodeResolve.stpryqma','主字段配置有误，请联系管理员重新配置')
             )
             return {
               success: false,
@@ -270,7 +309,9 @@ export const barcodeResolve = {
 
 
     // 走到这就是所有解析规则都没过了且没有使用默认规则
-    lwShowErrorMsg(Language.get('', '条码解析失败'))
+    lwShowErrorMsg(
+      Language.get('wms_project.pda.utils.BarcodeResolve.agyiotes','条码解析失败！输入框ID：') + componentId
+    )
 
     return {
       success: false,

package/src/utils/DateTime.js

@@ -1,219 +1,233 @@
-/*
-* 时间处理
-* @author 张文
-* @date  2022-01-26
-* */
-
-import {Language} from "./Language";
-
-// 内部使用函数，截取指定时间的值
-function timeTextSplit(str, type){
-  // 如果没有传入类型或者当前值不包含传入类型则返回传入值
-  if (!type || !str.includes(type)) return str
-
-  return str.split(type)[0] + type
-}
-
-export const DateTime = {
-
-  /**
-   * 时间格式化
-   * @author 张文
-   * @param date 需要格式化的时间（字符串、时间戳或时间对象）
-   * @param format 格式化表达式
-   */
-  format(date, format = 'yyyy-MM-dd') {
-    if (!date) return '-'
-    const value = date instanceof Date ? date : new Date(date)
-    let o = {
-      'M+': value.getMonth() + 1,
-      'd+': value.getDate(),
-      'h+': value.getHours(),
-      'm+': value.getMinutes(),
-      's+': value.getSeconds(),
-      'q+': Math.floor((value.getMonth() + 3) / 3),
-      'S': value.getMilliseconds()
-    }
-    if (/(y+)/.test(format)) {
-      format = format.replace(RegExp.$1, (value.getFullYear() + '').substr(4 - RegExp.$1.length))
-    }
-    for (let k in o) {
-      if (Object.prototype.hasOwnProperty.call(o, k) && new RegExp('(' + k + ')').test(format)) {
-        format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k].toString() : (('00' + o[k]).substr((o[k].toString()).length)))
-      }
-    }
-    return format
-  },
-
-
-  /**
-   * 计算两个时间的差值
-   * @author 张文
-   * @param  l 起始时间（字符串、时间戳或时间对象）
-   * @param  n 结束时间（字符串、时间戳或时间对象）
-   * @param {String} type 返回的时间类型默认秒钟，可选值：s-秒，m-分钟，h-小时, d-天
-   * @return {Object} { time:返回相减后的值，不足1的忽略不计，ago: l < n 起始时间是否大于结束时间 }
-   * */
-  judgeDate(l, n = new Date(), 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
-    switch (type) {
-      case 's':
-        time = 1000
-        break;
-      case 'm':
-        time = 1000 * 60
-        break;
-      case 'h':
-        time = 1000 * 60 * 60
-        break;
-      case 'd':
-        time = 1000 * 60 * 60 * 24
-        break;
-      default:
-        time = 1000
-        break;
-    }
-
-    const abs = a - b
-
-    return {
-      time: Math.floor(Math.abs(abs) / time),
-      ago: abs < 0
-    }
-  },
-
-
-  /**
-   * 两个时间差转换为中文，可自定义显示到最大时间单位
-   * @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
-   * @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'}) {
-    const obj = {
-      y: 0,
-      m: 0,
-      d: 0,
-      h: 0,
-      min: 0,
-      s: 0,
-      success:true
-    }
-
-    let time, ago
-
-
-    try {
-
-      // 判断是否传入了需要计算的秒数
-      if (!s) throw Error
-
-      let nTime = Number(s)
-      if (isNaN(nTime) || nTime === 0) {
-        throw Error
-      }
-
-      ago = nTime > 0
-      time = Math.abs(nTime)
-    }catch {
-
-      if (!l || !n){
-        obj.success = false
-        return {
-          ...obj,
-          text:''
-        }
-      }
-
-      let oTime = this.judgeDate(l, n)
-      time = oTime.time
-      ago = oTime.ago
-    }
-
-    const language = {
-      s : Language.get('wms_project.pda.common.sec','秒'),
-      min : Language.get('wms_project.pda.common.min','分钟'),
-      h : Language.get('wms_project.pda.common.hour','小时'),
-      d : Language.get('wms_project.pda.common.day','天'),
-      m : Language.get('wms_project.pda.common.month','月'),
-      y : Language.get('wms_project.pda.common.year','年'),
-    }
-
-    let text
-    if (agoText === false) {
-      text = ''
-    } else if (agoText) {
-      text = agoText
-    } else {
-      text = ago ? Language.get('wms_project.pda.common.ago','前') : Language.get('wms_project.pda.common.old','后')
-    }
-
-
-    const maxMin = Math.floor(time / 60)
-    if (type === 's' || !maxMin) {
-      obj.s = time
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.s}${language.s}${text}`, language[minType])
-      }
-    }
-
-
-    obj.s = time % 60
-    text = `${obj.s}${language.s}${text}`
-    const maxH = Math.floor(maxMin / 60)
-    if (type === 'min' || !maxH) {
-      obj.min = maxMin
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.min}${language.min}${text}`, language[minType])
-      }
-    }
-
-    obj.min = maxMin % 60
-    text = `${obj.min}${language.min}${text}`
-    const maxD = Math.floor(maxH / 24)
-    if (type === 'h' || !maxD) {
-      obj.h = maxH
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.h}${language.h}${text}`, language[minType])
-      }
-    }
-
-    obj.h = maxH % 24
-    text = `${obj.h}${language.h}${text}`
-    const maxM = Math.floor(maxD / 30)
-    if (type === 'd' || !maxM) {
-      obj.d = maxD
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.d}${language.d}${text}`, language[minType])
-      }
-    }
-
-    obj.d = maxD % 30
-    text = `${obj.d}${language.d}${text}`
-    if (type === 'm' || !obj.y) {
-      obj.m = maxM
-      return {
-        ...obj,
-        text: timeTextSplit(`${obj.m}${language.m}${text}`, language[minType])
-      }
-    }
-
-    obj.m = maxM % 12
-    text = `${obj.m}${language.m}${text}`
-    obj.y = Math.floor(maxM / 12)
-    return {
-      ...obj,
-      text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])
-    }
-
-  }
-}
+/*
+* 时间处理
+* @author 张文
+* @date  2022-01-26
+* */
+
+import {Language} from "./Language";
+import {Timezone} from "./Timezone";
+
+// 内部使用函数，截取指定时间的值
+function timeTextSplit(str, type){
+  // 如果没有传入类型或者当前值不包含传入类型则返回传入值
+  if (!type || !str.includes(type)) return str
+
+  return str.split(type)[0] + type
+}
+
+export const DateTime = {
+
+  /**
+   * 时间格式化
+   * @author 张文
+   * @param date 需要格式化的时间（字符串、时间戳或时间对象）
+   * @param format 格式化表达式
+   */
+  format(date, format = 'yyyy-MM-dd') {
+    if (!date) return '-'
+
+    // 如果是标准时就调用标准时转换
+    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(),
+      'h+': value.getHours(),
+      'm+': value.getMinutes(),
+      's+': value.getSeconds(),
+      'q+': Math.floor((value.getMonth() + 3) / 3),
+      'S': value.getMilliseconds()
+    }
+    if (/(y+)/.test(format)) {
+      format = format.replace(RegExp.$1, (value.getFullYear() + '').substr(4 - RegExp.$1.length))
+    }
+    for (let k in o) {
+      if (Object.prototype.hasOwnProperty.call(o, k) && new RegExp('(' + k + ')').test(format)) {
+        format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k].toString() : (('00' + o[k]).substr((o[k].toString()).length)))
+      }
+    }
+    return format
+  },
+
+
+  /**
+   * 计算两个时间的差值
+   * @author 张文
+   * @param  l 起始时间（字符串、时间戳或时间对象）
+   * @param  n 结束时间（字符串、时间戳或时间对象）
+   * @param {String} type 返回的时间类型默认秒钟，可选值：s-秒，m-分钟，h-小时, d-天
+   * @return {Object} { time:返回相减后的值，不足1的忽略不计，ago: l < n 起始时间是否大于结束时间 }
+   * */
+  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
+    switch (type) {
+      case 's':
+        time = 1000
+        break;
+      case 'm':
+        time = 1000 * 60
+        break;
+      case 'h':
+        time = 1000 * 60 * 60
+        break;
+      case 'd':
+        time = 1000 * 60 * 60 * 24
+        break;
+      default:
+        time = 1000
+        break;
+    }
+
+    const abs = a - b
+
+    return {
+      time: Math.floor(Math.abs(abs) / time),
+      ago: abs < 0
+    }
+  },
+
+
+  /**
+   * 两个时间差转换为中文，可自定义显示到最大时间单位
+   * @author 张文
+   * @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().toUTCString(), s = 0, type='y', agoText=false, minType='s'}) {
+    const obj = {
+      y: 0,
+      m: 0,
+      d: 0,
+      h: 0,
+      min: 0,
+      s: 0,
+      success:true
+    }
+
+    let time, ago
+
+
+    try {
+
+      // 判断是否传入了需要计算的秒数
+      if (!s) throw Error
+
+      let nTime = Number(s)
+      if (isNaN(nTime) || nTime === 0) {
+        throw Error
+      }
+
+      ago = nTime > 0
+      time = Math.abs(nTime)
+    }catch {
+
+      if (!l || !n){
+        obj.success = false
+        return {
+          ...obj,
+          text:''
+        }
+      }
+
+      let oTime = this.judgeDate(l, n)
+      time = oTime.time
+      ago = oTime.ago
+    }
+
+    const language = {
+      s : Language.get('wms_project.pda.common.sec','秒'),
+      min : Language.get('wms_project.pda.common.min','分钟'),
+      h : Language.get('wms_project.pda.common.hour','小时'),
+      d : Language.get('wms_project.pda.common.day','天'),
+      m : Language.get('wms_project.pda.common.month','月'),
+      y : Language.get('wms_project.pda.common.year','年'),
+    }
+
+    let text
+    if (agoText === false) {
+      text = ''
+    } else if (agoText) {
+      text = agoText
+    } else {
+      text = ago ? Language.get('wms_project.pda.common.ago','前') : Language.get('wms_project.pda.common.old','后')
+    }
+
+
+    const maxMin = Math.floor(time / 60)
+    if (type === 's' || !maxMin) {
+      obj.s = time
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.s}${language.s}${text}`, language[minType])
+      }
+    }
+
+
+    obj.s = time % 60
+    text = `${obj.s}${language.s}${text}`
+    const maxH = Math.floor(maxMin / 60)
+    if (type === 'min' || !maxH) {
+      obj.min = maxMin
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.min}${language.min}${text}`, language[minType])
+      }
+    }
+
+    obj.min = maxMin % 60
+    text = `${obj.min}${language.min}${text}`
+    const maxD = Math.floor(maxH / 24)
+    if (type === 'h' || !maxD) {
+      obj.h = maxH
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.h}${language.h}${text}`, language[minType])
+      }
+    }
+
+    obj.h = maxH % 24
+    text = `${obj.h}${language.h}${text}`
+    const maxM = Math.floor(maxD / 30)
+    if (type === 'd' || !maxM) {
+      obj.d = maxD
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.d}${language.d}${text}`, language[minType])
+      }
+    }
+
+    obj.d = maxD % 30
+    text = `${obj.d}${language.d}${text}`
+    if (type === 'm' || !obj.y) {
+      obj.m = maxM
+      return {
+        ...obj,
+        text: timeTextSplit(`${obj.m}${language.m}${text}`, language[minType])
+      }
+    }
+
+    obj.m = maxM % 12
+    text = `${obj.m}${language.m}${text}`
+    obj.y = Math.floor(maxM / 12)
+    return {
+      ...obj,
+      text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])
+    }
+
+  },
+}