@logwire/logwire-wms-pda-ui 3.3.4 → 3.5.0

package/src/utils/BarcodeResolve.js

@@ -8,6 +8,8 @@ import {common} from "../api/Common";
 import {lwErrMsg} from "../components/ErrorMsg";
 import {DateTime} from "luxon";
 import {Language} from "./Language";
+import lwAxios from "./Axios";
+import {LocalStorage} from "./LocalStorage";
 
 // 条码工具
 const barcodeUtils = {
@@ -49,7 +51,7 @@ const ruleValidation = (data, rules) => {
   const rs = rules.filter(i => i.field)
   for (let r of rs) {
     const value = data[r.field]
-    if (r.importd && !value) {
+    if (r.required && !value) {
       return false
     }
     if (value !== null && value !== undefined) {
@@ -64,6 +66,14 @@ const ruleValidation = (data, rules) => {
   return true
 }
 
+/**
+ * 内部方法：格式化数据
+ * @author dhc
+ * @param {*} value 需要格式化的数据
+ * @param {*} dataType 数据类型
+ * @param {*} format 格式化参数
+ * @returns {*} 格式化后的数据
+ */
 const dataTypeValid = (value, dataType, format) => {
   if (!value) {
     return true
@@ -120,9 +130,95 @@ const operatorValid = (value, validType, content) => {
 }
 
 
+/**
+ * 内部方法：校验数据是否包含在指定列表内
+ * @author 张文
+ * @param {string|Number} parentCode 父级code
+ * @param {string|Number} itemId 解析器的id
+ * @param {Array} list 列表
+ * @param {string} barcode 当前需要解析的条码
+ * @param {boolean} autoClear 是否清空输入框
+ * @returns {Object} success - 是否找到，data - 找到的数据
+ */
+const checkListSomeCode = (parentCode, itemId, list, barcode, autoClear = false) => {
+
+  if (!parentCode || !itemId) return {success: false, data: {}}
+
+  for (const item of list) {
+    if (item.code === parentCode) {
+
+      if (!item.resolvers) continue
+
+      for (const resolver of item.resolvers) {
+        if (resolver.id === itemId) {
+          // 判断是否终止解析
+          if (resolver.terminalFlag) {
+            return errorReturn(
+              barcode,
+              resolver.errorMsg,
+              autoClear
+            )
+          }
+
+          return {
+            success: true,
+            barcode,
+            data: resolver.data,
+            autoClear
+          }
+        }
+      }
+
+    }
+  }
+
+  return {
+    success: false,
+    data: {}
+  }
+
+}
+
+
+/**
+ * 内部方法：校验数据是否包含在指定列表内
+ * @author 张文
+ * @param {string} barcode 传入的条码
+ * @param {string} errorMsg 错误信息，当有时候显示错误信息，否则不显示
+ * @returns {Object} 返回错误数据集 success - 是否找到，data - 找到的数据
+ */
+const errorReturn = (barcode, errorMsg) => {
+
+  errorMsg && lwErrMsg.show(errorMsg)
+
+  return {
+    success: false,
+    barcode,
+    data: {},
+    stop: true
+  }
+
+}
+// 条码规则解析索引的前缀
+const prefix = 'barcodeResolveRule'
+
 export const BarcodeResolve = {
 
 
+  /**
+   * 清空本地储存的条码规则
+   * @author 张文
+   * @return -
+   * */
+  clearRule() {
+    for (const k in window.localStorage) {
+      if (k.startsWith(prefix)) {
+        LocalStorage.remove(k)
+      }
+    }
+  },
+
+
   /**
    * 设置条码规则到全局变量中
    * @author 张文
@@ -131,10 +227,18 @@ export const BarcodeResolve = {
    * @return -
    * */
   setRule(data, key = '') {
-    let index = 'barcodeResolveRule'
-    if (key) index += ('.' + key)
 
-    window.lwWindowGlobalData.set(index, data)
+    if (!key) {
+      if (Array.isArray(data)) {
+        data.forEach(item => {
+          LocalStorage.set(prefix + item.componentId, item)
+        })
+      } else {
+        LocalStorage.set(prefix + data.componentId, data)
+      }
+    } else {
+      LocalStorage.set(prefix + key, data)
+    }
   },
 
 
@@ -145,10 +249,7 @@ export const BarcodeResolve = {
    * @return {Object} 返回获取到的值
    * */
   getRule(key) {
-    let index = 'barcodeResolveRule'
-    if (key) index += ('.' + key)
-
-    return window.lwWindowGlobalData.get(index) || {}
+    return LocalStorage.get(prefix + key)
   },
 
 
@@ -164,20 +265,16 @@ export const BarcodeResolve = {
         appCodeList
       }).then(res => {
 
-        let obj = {}
-
         // 判断返回数据是否是数组且有值
         if (!Array.isArray(res) || !res.length) {
           console.error(
-              '条码解析规则获取失败！接口返回数据不是数组类型或为空。将会导致条码解析无效或异常！！！返回值为：',
-              res
+            '条码解析规则获取失败！接口返回数据不是数组类型或为空。将会导致条码解析无效或异常！！！返回值为：',
+            res
           )
         } else {
-          res.forEach(item => obj[item.componentId] = item)
+          this.setRule(res)
         }
 
-        this.setRule(obj)
-
         PR()
       }).catch((e) => PE(e))
     })
@@ -186,148 +283,197 @@ export const BarcodeResolve = {
   /**
    * 使用条码解析规则并解析条码
    * @author 张文
-   * @param {Object} param {componentId-输入框id, barcode-需要解析的内容, ownerId-货主id}
+   * @param {Object} param {componentId-输入框id, barcode-需要解析的内容, createRule-规则解析函数, ownerId-货主id, args-其他参数}
    * @return {Object} {success-解析是否成功，barcode-解析前的原始字符，bizType-成功解析的规则，data-解析后的数据对象}
    * */
   async resolve(param) {
 
-    const {componentId, barcode, ownerId, createRule} = param
+    const {componentId, barcode, createRule, ownerId, args} = param
 
     if (!componentId) {
-      lwErrMsg.show(
-          Language.get('wms_project.pda.utils.BarcodeResolve.qemvmsdn', '获取条码解析规则失败，未指定输入框解析ID')
-      )
-      return {
-        success: false,
+      return errorReturn(
         barcode,
-        data: {}
-      }
+        Language.get('wms_project.pda.utils.BarcodeResolve.qemvmsdn', '获取条码解析规则失败，未指定输入框解析ID')
+      )
     }
 
-    let data = this.getRule(componentId)
-
+    // 获取条码规则
+    let ruleData = this.getRule(componentId)
 
-    if (!data || !Object.keys(data).length) {
+    // 不存在在解码规则
+    if (!ruleData || !Object.keys(ruleData).length) {
 
+      // 判断是否存在创造规则的必要参数
       if (
-          createRule &&
-          typeof createRule === 'object' &&
-          Object.keys(createRule).length
+        createRule &&
+        typeof createRule === 'object' &&
+        Object.keys(createRule).length
       ) {
         try {
-          data = await common.commonWmsLoadAndInitComponentConfig({
+          // 创造解码规则
+          ruleData = await common.commonWmsLoadAndInitComponentConfig({
             ...createRule,
             code: componentId
           })
 
-          this.setRule(data, componentId)
+          // 存入解码规则
+          this.setRule(ruleData, componentId)
         } catch (e) {
-          return {
-            success: false,
+          console.warn('【条码解析】创建条码解析规则失败！输入框id：' + componentId + '错误信息：', e)
+          return errorReturn(
             barcode,
-            data: {}
-          }
+            Language.get('wms_project.pda.utils.BarcodeResolve.qemvmsdnc', '创建条码解析规则失败，请稍后重试，或联系系统管理员。输入框ID：' + componentId)
+          )
         }
 
       } else {
-        lwErrMsg.show(
-            Language.get('wms_project.pda.utils.BarcodeResolve.bmkxoyxk', '获取条码解析规则失败，未获取到解析规则。输入框解析ID：') + componentId
-        )
-        return {
-          success: false,
+        return errorReturn(
           barcode,
-          data: {}
-        }
+          Language.get('wms_project.pda.utils.BarcodeResolve.bmkxoyxk', '获取条码解析规则失败，未获取到解析规则。输入框解析ID：') + componentId
+        )
       }
-
-
     }
 
-
-    data.barcodeConfig.typeResolvers.forEach(item => {
-      item.resolvers = item.resolvers.filter(inItem => {
-        return !inItem.ownerId || (ownerId && inItem.ownerId === ownerId)
-      })
+    // 过滤货主，得到符合要求的解析规则
+    ruleData.barcodeConfig.typeResolvers.forEach(item => {
+      if (!item.resolvers) return
+      item.resolvers = item.resolvers.filter(inItem => (!inItem.ownerId || (ownerId && inItem.ownerId === ownerId)))
     })
 
-
-    for (let typeResolvers of data.barcodeConfig.typeResolvers) {
-
+    // 后台解析数据集
+    const ajaxData = {
+      // 是否已经后台解析
+      active: false,
+      // 解析后的数据
+      list: []
+    }
+    // 执行解析
+    for (let typeResolvers of ruleData.barcodeConfig.typeResolvers) {
       // 判断是否存在解析器
       if (
-          !typeResolvers.resolvers ||
-          !Array.isArray(typeResolvers.resolvers) ||
-          !typeResolvers.resolvers.length
+        !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
 
+        // 盘点当前解析器是否为本地解析
+        if (resolvers.clientHandle) {
+
+          if (!resolvers.clientScript || typeof resolvers.clientScript !== 'string') continue
 
-        // 执行解析脚本
-        const resolveData = (new Function('$param', '$utils', resolvers.clientScript))(param, barcodeUtils)
+          // 执行本地解析脚本
+          let resolveData = null
+          try {
+            resolveData = (new Function('$param', '$utils', resolvers.clientScript))(param, barcodeUtils)
+          } catch (e) {
+            console.warn('【条码解析】条码解析使用本地脚本解析，但脚本执行错误！错误信息：', e)
+            console.error('【条码解析】脚本信息：', resolvers.clientScript)
+          }
 
-        // 校验是否解析成功，且复核验证要求
-        if (
+          // 校验是否解析成功，且是否符合验证要求
+          if (
             resolveData &&
             ruleValidation(resolveData, typeResolvers.valids) &&
             (
-                !(resolvers.validScript && typeof resolvers.validScript === 'string') ||
-                (new Function('$param', '$utils', '$data', resolvers.validScript))(param, barcodeUtils, resolveData)
+              !(resolvers.validScript && typeof resolvers.validScript === 'string') ||
+              (new Function('$param', '$utils', '$data', resolvers.validScript))(param, barcodeUtils, resolveData)
             )
-        ) {
+          ) {
 
-          if (!typeResolvers.primaryValid || !typeResolvers.primaryValid.field) {
-            lwErrMsg.show(
+            if (!typeResolvers.primaryValid || !typeResolvers.primaryValid.field) {
+              return errorReturn(
+                barcode,
                 Language.get('wms_project.pda.utils.BarcodeResolve.stpryqma', '主字段配置有误，请联系管理员重新配置')
-            )
+              )
+            }
+
             return {
-              success: false,
+              success: true,
               barcode,
-              data: {}
+              bizType: typeResolvers.bizType,
+              data: {
+                ...resolveData,
+                key: resolveData[typeResolvers.primaryValid.field]
+              },
+              autoClear: ruleData.cleanAfterResolve
             }
           }
 
-          const successData = {
-            ...resolveData,
-            key: resolveData[typeResolvers.primaryValid.field]
+          continue
+        }
+
+        // 判断是否已经后台解析过了
+        if (ajaxData.active) {
+          const checkData = checkListSomeCode(
+            typeResolvers.code,
+            resolvers.id,
+            ajaxData.list,
+            barcode,
+            ruleData.cleanAfterResolve
+          )
+
+          if (checkData.stop) return checkData
+
+          if (checkData.success) return {
+            ...checkData,
+            bizType: typeResolvers.bizType,
           }
-          return {
-            success: true,
+          continue
+        }
+
+        // 调用后台解析接口获取解析数据
+        try {
+          const res = await lwAxios.action({
+            url: "commonWmsMobileBarcodeResolver",
+            data: {
+              barcode,
+              componentId,
+              ownerId,
+              args
+            }
+          })
+          ajaxData.active = true
+          ajaxData.list = res || []
+          const checkData = checkListSomeCode(
+            typeResolvers.code,
+            resolvers.id,
+            ajaxData.list,
             barcode,
+            ruleData.cleanAfterResolve
+          )
+
+          if (checkData.stop) return checkData
+
+          if (checkData.success) return {
+            ...checkData,
             bizType: typeResolvers.bizType,
-            data: successData
           }
+        } catch (e) {
+          console.warn('【条码解析】后台解析接口异常：', e)
         }
       }
     }
 
 
     // 判断是否使用了默认解析
-    if (data.barcodeConfig.defaultResolve) {
+    if (ruleData.barcodeConfig.defaultResolve) {
       return {
         success: true,
         barcode,
-        bizType: data.barcodeConfig.defaultBizType,
-        data: {key: barcode}
+        bizType: ruleData.barcodeConfig.defaultBizType,
+        data: {key: barcode},
+        autoClear: ruleData.cleanAfterResolve
       }
     }
 
 
     // 走到这就是所有解析规则都没过了且没有使用默认规则
-    lwErrMsg.show(
-        Language.get('wms_project.pda.utils.BarcodeResolve.agyiotes', '条码解析失败！输入框ID：') + componentId
-    )
-
-    return {
-      success: false,
+    return errorReturn(
       barcode,
-      data: {}
-    }
+      Language.get('wms_project.pda.utils.BarcodeResolve.agyiotes', '条码解析失败！请检查当前条码是否输入/扫描正确，或联系系统管理员。输入框ID：') + componentId
+    )
   }
 }

package/src/utils/DateTime.js

@@ -109,14 +109,14 @@ export const DateTime = {
    * @return {Object} {y-年, m-月, d-日, h-时, min-分, s-秒, text:当前时间的中文翻译，xx小时xx分xx秒, success-是否处理成功}
    * */
   timeToStr(
-      {
-        l,
-        n = Timezone.getTimezoneDate({format: 'yyyy-MM-dd hh:mm:ss'}),
-        s,
-        type = 'y',
-        agoText = false,
-        minType = 's'
-      }
+    {
+      l,
+      n = Timezone.getTimezoneDate({format: 'yyyy-MM-dd hh:mm:ss'}),
+      s,
+      type = 'y',
+      agoText = false,
+      minType = 's'
+    }
   ) {
 
     const obj = {
@@ -222,7 +222,8 @@ export const DateTime = {
 
     obj.d = maxD % 30
     text = `${obj.d}${language.d}${text}`
-    if (type === 'm' || !obj.y) {
+    const maxY = Math.floor(maxM / 12)
+    if (type === 'm' || !maxY) {
       obj.m = maxM
       return {
         ...obj,
@@ -232,7 +233,7 @@ export const DateTime = {
 
     obj.m = maxM % 12
     text = `${obj.m}${language.m}${text}`
-    obj.y = Math.floor(maxM / 12)
+    obj.y = maxY
     return {
       ...obj,
       text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])

package/src/utils/Dialog.js

@@ -1,8 +1,3 @@
-/*
-* 弹出框
-* @author: 张文
-* @date  2022-07-28
-* */
 
 
 import {Language} from "./Language";
@@ -16,8 +11,8 @@ function format(obj){
     const msg = obj.msgList.map(item => {
       return `
         <div style="text-align: left" class="lw-global-row">
-          <span class="lw-global-title">${item.key}</span>
-          <span class="lw-global-value-bold">${item.value}</span>
+          <span class="lw-global-title">${item.key || ''}</span>
+          <span class="lw-global-value-bold">${item.value || ''}</span>
         </div>
       `
     })
@@ -56,14 +51,14 @@ function format(obj){
 }
 
 
-export function lwDialog(){
+export function lwDialog() {
   const that = this
   return {
-    confirm(obj){
+    confirm(obj) {
       return that.$dialog.confirm(format(obj))
     },
     // 提示框
-    alert(obj){
+    alert(obj) {
       return that.$dialog.alert(format(obj))
     },
   }

package/src/utils/GetImgSrc.js

@@ -13,7 +13,7 @@ import {imgSrc} from "../api/GetImgSrc";
  * @author 张文
  * @date 2022-01-19
  * @param {String} strUrl 图片路径集合
- * @return {Promise} 返回异步函数，结果为获取到的图片路径
+ * @return {Promise} 返回异步函数，结果为获取到的图片路径集合
  * */
 export const GetImgSrc = {
 

package/src/utils/Language.js

@@ -15,19 +15,19 @@ function checkKey(key){
 export const Language = {
 
   /**
-  * 获取指定key的翻译
-  * @author 张文
-  * @date 2022-04-14
-  * @param {String} key 需要获取的语言的key
-  * @param {String} dft 当无法从当前语言获取时的默认值
-  * @param {Object|Array} params 语言中用到的参数
-  * @return {String}  获取到的语言或默认值
-  * */
-  get(key, dft = '未知', params = undefined) {
+   * 获取指定key的翻译
+   * @author 张文
+   * @date 2022-04-14
+   * @param {String} key 需要获取的语言的key
+   * @param {String} def 当无法从当前语言获取时的默认值
+   * @param {Object|Array} params 语言中用到的参数
+   * @return {String}  获取到的语言或默认值
+   * */
+  get(key, def = '未知', params = undefined) {
 
     // const language = window.lwWindowGlobalData.get('language.data') || {}
     const language = LocalStorage.get(checkKey(key))
-    const c = language || dft
+    const c = language || def
 
     if (params) {
       if (Array.isArray(params) && params.length) {

package/src/utils/LocalStaff.js

@@ -0,0 +1,52 @@
+/*
+* 获取或设置本地用户列表
+* @author: 张文
+* @date  2023-08-24
+* */
+
+import {LocalStorage} from "./LocalStorage";
+import {UserInfo} from "./UserInfo";
+
+export const LocalStaff = {
+  /**
+   * 获取指定key的用户列表
+   * 当当前用户 code 与储存用户 code 不一致时，调用此方法会删除原储存的数据
+   * @author 张文
+   * @date 2023-08-24
+   * @param {String} key 数据索引 key
+   * @return {Array} 返回用户列表数组
+   * */
+  get(key) {
+    if (!key) return []
+
+    const {user, list = []} = LocalStorage.get(key, {})
+    if (user === UserInfo.get().staff.code) return list
+
+    if (user) LocalStorage.remove(key)
+
+    return []
+  },
+  /**
+   * 储存指定 key 的用户列表
+   * @author 张文
+   * @date 2023-08-24
+   * @param {String} key 数据索引 key
+   * @param {Array} data 需要存入的用户数据列表，需要包含 code name disabled(可选，默认 false)
+   * @return
+   * */
+  set(key, data) {
+    if (!key || !Array.isArray(data)) return false
+    
+    LocalStorage.set(key, {
+      user: UserInfo.get().staff.code,
+      list: data.map(item => {
+        return {
+          code: item.code,
+          name: item.name,
+          disabled: !!item.disabled
+        }
+      })
+    })
+    return true
+  },
+}

package/src/utils/LocalStorage.js

@@ -12,16 +12,20 @@ export const LocalStorage = {
    * @author 张文
    * @date 2022-05-11
    * @param {String} key 数据key
+   * @param {*} def 当没有获取到值时候的默认值，默认为 undefined
    * @return {*} 返回存入的数据，如果存入数据是对象或数组类型的字符串将会自动转换为对象或数组类型
    * */
-  get(key) {
+  get(key, def = undefined) {
     if (!key) {
       console.error('本地储存，没有传入需要取值的key')
       return ''
     }
-    const data = window.localStorage.getItem(key) || undefined
-    const erg = /^\{.*\}$|^\[.*\]$/
-    return data && erg.test(data) ? JSON.parse(data) : data
+    const data = window.localStorage.getItem(key)
+    if (data) {
+      const erg = /^\{.*\}$|^\[.*\]$/
+      return erg.test(data) ? JSON.parse(data) : data
+    }
+    return def
   },