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

package/src/test/file/index.vue

@@ -1,11 +1,15 @@
 <!--
 
   @author: 张文
-  @date: 2022-02-25
+  @date: 2023-12-01
 -->
 <template>
   <div>
+    <lw-nav-bar :title="$lwLanguage.get('', '')"/>
 
+    <lw-page-body-module>
+
+    </lw-page-body-module>
   </div>
 </template>
 

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/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/Print.js

@@ -11,6 +11,7 @@ import {lwLoading} from "../components/Loading";
 import {lwErrMsg} from "../components/ErrorMsg";
 import {lwNoticeBar} from "../components/NoticeBar";
 import {Language} from "./Language";
+import {WarehouseConfig} from "./WarehouseConfig";
 
 export const Print = {
   /**
@@ -74,11 +75,10 @@ export const Print = {
    * @author 张文
    * @param {String} templateCode 需要判断的模板数据Code
    * @param {String} msg 描述文字，默认“当前”
-   * @param {Boolean} needWarn 是否显示强警告，默认强提醒
-   * @param {Boolean} showMsg 是否显示警告信息，默认显示
+   * @param {Boolean} needCheck 是否强制校验，为true时忽略后台配置。默认false
    * @return {Object} 返回判断后的结果{success:'成功-true，失败-false',printData:{'包含打印模板和打印机类型的数据'}}
    * */
-  test(templateCode, msg = '当前', needWarn = true, showMsg = true) {
+  test(templateCode, msg = '当前', needCheck = false) {
 
     for (let i of this.get()) {
       // 判断当前模板是否配置，没配置就弹出对话框提示去配置
@@ -86,9 +86,19 @@ export const Print = {
     }
 
     const message = msg + Language.get('wms_project.pda.utils.print.template', '打印模板未配置！请前往【打印设置栏】配置模板。模板编码：') + templateCode
-    
-    if (showMsg) {
-      needWarn ? lwErrMsg.show(message) : lwNoticeBar.show({message, showTime: 8, type: 'warning'})
+
+    if (needCheck) {
+      lwErrMsg.show(message)
+    } else {
+      switch (WarehouseConfig.get('systemConfig.WMS_PDA_PRINT_CONFIG_CHECK')) {
+        case 'HARD':
+          lwErrMsg.show(message)
+          break
+        case 'SOFT':
+          lwNoticeBar.show({message, showTime: 8, type: 'warning'})
+          break
+        default:
+      }
     }
 
     return {success: false, printData: {}}