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

package/src/utils/Axios.js

@@ -5,18 +5,20 @@
 * @date 2022-02-10
 * */
 
-import Axios from 'axios'
+import Axios from 'axios';
 import {ApiUtils} from "./ApiUtils";
 import {Warehouse} from "./Warehouse";
 import {lwShowErrorMsg} from "../components/ui/ErrorMsg";
 import {lwShowLoading, lwCloseLoading} from "../components/ui/Loading";
 import {Language} from "./Language";
+import {LocalStorage} from "./LocalStorage";
+import {Timezone} from "./Timezone";
 
 // 用于自定义处理http报错的问题，为false时候不显示报错信息，直接返回错误信息，通过catch接收
 let errGetMe = false
 
 const lwAxios = Axios.create({
-  baseURL: process.env.VUE_APP_BASE_URL,
+  baseURL: import.meta.env.VITE_APP_BASE_URL,
   timeout: 1000 * 60 * 30,
 })
 
@@ -28,6 +30,38 @@ const lwAxios = Axios.create({
  * */
 lwAxios.setBaseUrl = url => lwAxios.defaults.baseURL = url
 
+/**
+ * 设置语言
+ * @author 董和春
+ * @param lang 需要设置的语言
+ * */
+lwAxios.setLanguage = lang => lwAxios.defaults.headers['Accept-Language'] = (lang || LocalStorage.get('lwLanguage') || 'zh-CN,zh')
+
+lwAxios.setLanguage()
+
+
+/**
+ * 设置时区
+ * @author 张文
+ * @param timezone 需要设置的时区值
+ * */
+lwAxios.setTimezone = timezone => {
+
+  if (timezone) {
+    lwAxios.defaults.headers['W-TIME-ZONE'] = timezone
+    return
+  }
+
+  const local = LocalStorage.get('lwTimezone')
+  if (typeof local === 'object'){
+    lwAxios.defaults.headers['W-TIME-ZONE'] = local.offset
+    return
+  }
+
+  lwAxios.defaults.headers["W-TIME-ZONE"] = Timezone.getTimezone().offset;
+}
+
+lwAxios.setTimezone()
 
 /**
  * 更新请求的 Token，正常情况下无需手动更新token，因为当token发生变化时应当主动触发 lwApiUtils.setToken 方法。从而会自动更新当前token
@@ -88,7 +122,7 @@ lwAxios.interceptors.request.use(
   },
   error => {
     lwCloseLoading()
-    console.warn('请求异常: ', error)
+    console.error('请求异常: ', error)
     return Promise.reject(error)
   }
 )
@@ -118,7 +152,7 @@ lwAxios.interceptors.response.use(
   error => {
 
     lwCloseLoading()
-    console.warn('接口返回异常: ', error)
+    console.error('接口返回异常: ', error)
 
     let resp = error.response
 

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, createRule} = 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 (
+        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 {
+        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

@@ -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 = Timezone.getTimezoneDate({format:'yyyy-MM-dd hh:mm:ss'}), 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,18 @@ 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 = Timezone.getTimezoneDate({format:'yyyy-MM-dd hh:mm:ss'}), s = 0, type='y', agoText=false, minType='s'}) {
+
     const obj = {
       y: 0,
       m: 0,
@@ -215,5 +230,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 {*} 返回拷贝后的数据
  *
  * */

package/src/utils/Dialog.js

@@ -0,0 +1,74 @@
+/*
+* 弹出框
+* @author: 张文
+* @date  2022-07-28
+* */
+
+
+import {Language} from "./Language";
+
+// 处理传入的数据
+function format(obj){
+
+  if (obj.msgList && obj.msgList.length) {
+    obj.allowHtml = true
+
+    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>
+        </div>
+      `
+    })
+
+    obj.message = `
+      <div class="lw-global-value">${obj.message}</div>
+      ${msg.join('')}
+    `
+  }
+
+  if (!obj.confirmButtonText){
+    obj.confirmButtonText = Language.get('utils.dialog.confirm','确认')
+  }
+
+  if (!obj.cancelButtonText){
+    obj.cancelButtonText = Language.get('utils.dialog.cancel','取消')
+  }
+
+  let className = ''
+  switch (obj.type){
+    case 'success':
+      className = 'lw-global-dialog-success'
+      break;
+    case 'error':
+      className = 'lw-global-dialog-error'
+      break;
+    case 'warning':
+      className = 'lw-global-dialog-warning'
+      break;
+    default:
+      break
+  }
+  obj.className = 'lw-global-dialog ' + className + ' ' + obj.className
+
+  return obj
+}
+
+
+export function lwDialog(){
+  const that = this
+  return {
+    confirm(obj){
+      return that.$dialog.confirm(format(obj))
+    },
+    // 提示框
+    alert(obj){
+      return that.$dialog.alert(format(obj))
+    },
+  }
+}

package/src/utils/Dict.js

@@ -5,20 +5,30 @@
 * */
 
 import {dict} from "../api/common/Dict";
+import {LocalStorage} from "./LocalStorage";
+
+function checkKey(key){
+  return key.indexOf('dict_') === 0 ? key : 'dict_' + key
+}
 
 export const Dict = {
 
   /**
-   * 设置字典数据
-   * @author 张文
-   * @param {Object|Array} data 需要设置的数据
-   * @param {String} key 需要设置字典的某一项，为空时将修改全部数据
-   * */
+  * 设置字典数据
+  * @author 张文
+  * @param {Object|Array} data 需要设置的数据
+  * @param {String} key 需要设置字典的某一项，为空时将修改全部数据
+  * */
   set(data, key = null) {
     if (key) {
-      window.lwWindowGlobalData.set('dict.'+key, data)
-    } else {
-      window.lwWindowGlobalData.set('dict', data)
+      // window.lwWindowGlobalData.set('dict.'+key, data)
+      LocalStorage.set(checkKey(key), data)
+
+    }else {
+      for (let dataKey in data) {
+        LocalStorage.set(checkKey(dataKey), data[dataKey])
+      }
+      // window.lwWindowGlobalData.set('dict', data)
     }
   },
 
@@ -26,11 +36,16 @@ export const Dict = {
   /**
    * 根据字典key获取数据
    * @author 张文
-   * @param {String} key 字典类型名称，为空时返回全部数据
+   * @param {String} key 字典类型名称
    * @return {*} 字典项的数据
    */
   get(key = null) {
-    return key ? window.lwWindowGlobalData.get('dict.'+key) : window.lwWindowGlobalData.get('dict')
+    if (!key){
+      console.error("获取字典数据失败，传入字典key不能为空")
+      return ""
+    }
+    // return key ? window.lwWindowGlobalData.get('dict.'+key) : window.lwWindowGlobalData.get('dict')
+    return LocalStorage.get(checkKey(key))
   },
 
 
@@ -39,8 +54,8 @@ export const Dict = {
    * @author 张文
    * @param key 字典类型名称
    * @param value 字典项的值
-   * @param def 默认值
-   * @returns {*} 字典项的名称，如果未找到且默认值为空，则返回字典项的值
+   * @param def 无法获取值的缺省显示值
+   * @returns {String} 字典项的名称，如果未找到且默认值为空，则返回字典项的值
    */
   getDictLabel(key, value, def) {
     const list = this.get(key)
@@ -59,13 +74,14 @@ export const Dict = {
    * 异步获取字典数据
    * @author 张文
    * @param {String} key 字典类型名称，为空时返回全部数据
+   * @param {Boolean} loading 是否显示加载
    * @returns {Promise} 字典项的数据
    */
-  asyncGet(key = null) {
+  asyncGet(key = null, loading) {
     return new Promise((PR, PE) => {
-      dict.get().then(res=>{
+      dict.get(loading).then(res=>{
         this.set(res)
-        PR(this.get(key))
+        PR(key ? this.get(key) : '')
       }).catch(err => PE(err))
     })
   },

package/src/utils/GetImgSrc.js

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

package/src/utils/Language.js

@@ -8,52 +8,80 @@ import {language} from "../api/common/Language";
 import {LocalStorage} from "./LocalStorage";
 
 
+function checkKey(key){
+  return key.indexOf('i18n_') === 0 ? key : 'i18n_' + 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 = '未知'){
-    if (!key) return dft
+  get(key, dft = '未知', params = undefined) {
+
+    // const language = window.lwWindowGlobalData.get('language.data') || {}
+    const language = LocalStorage.get(checkKey(key))
+    const c = language || dft
 
-    const language = window.lwWindowGlobalData.get('language.data')
-    return language[key] || dft
+    if (params) {
+      if (Array.isArray(params) && params.length) {
+        return c.replace(/\{(\d+)}/g, (m, i) => params[i])
+      }
+      if (typeof params === 'object') {
+        return c.replace(/\{(\w+)}/g, (m, i) => params[i])
+      }
+    }
+    return c
   },
 
 
-  // 获取当前设置语言的key
-  getKey(){
+  /**
+  * 获取当前设置语言的key
+  * @author 张文
+  * @date 2022-04-14
+  * @return {String} 当前语言类型
+  * */
+  getKey() {
     return window.lwWindowGlobalData.get('language.key')
   },
 
 
-  // 设置当前设置语言的key
-  setKey(data){
-    return window.lwWindowGlobalData.set('language.key', data)
+  /**
+  * 设置当前设置语言的key
+  * @author 张文
+  * @date 2022-04-14
+  * @param {String} key 设置的语言类型
+  * */
+  setKey(key) {
+    return window.lwWindowGlobalData.set('language.key', key)
   },
 
 
-  // 异步设置当前语言的key
-  asyncSetKey(key, loading = true){
-    return new Promise((pres,perr)=>{
-
-      // 判断当前设置值是否和原始值一致，如果一直就不请求接口
-      if (window.lwWindowGlobalData.get('language.key') === key){
-        pres()
-        return
-      }
+  /**
+  * 异步设置当前语言的key，设置成功后会调取接口获取当前设置的语言资源
+  * @author 张文
+  * @date 2022-04-14
+  * @param {String} key 设置的语言类型
+  * @param {Boolean} loading 是否显示加载框，默认显示
+  * */
+  asyncSetKey(key, loading = true) {
+    return new Promise((pres, perr) => {
 
       window.lwWindowGlobalData.set('language.key', key)
       LocalStorage.set('lwLanguage', key)
-      language.get(key, loading).then(res=>{
-        window.lwWindowGlobalData.set('language.data', res)
+      language.get(key, loading).then(res => {
+        // window.lwWindowGlobalData.set('language.data', res)
+        for (const resKey in res) {
+          LocalStorage.set(checkKey(resKey), res[resKey])
+        }
         pres()
-      }).catch(()=>perr())
+      }).catch(() => perr())
     })
   },
 }

package/src/utils/LocalStorage.js

@@ -7,23 +7,59 @@
 
 export const LocalStorage = {
 
-  get(key){
+  /**
+   * 获取存入数据
+   * @author 张文
+   * @date 2022-05-11
+   * @param {String} key 数据key
+   * @return {*} 返回存入的数据，如果存入数据是对象或数组类型的字符串将会自动转换为对象或数组类型
+   * */
+  get(key) {
+    if (!key) {
+      console.error('本地储存，没有传入需要取值的key')
+      return ''
+    }
     const data = window.localStorage.getItem(key) || undefined
-    const erg = /^\{|\[/
+    const erg = /^\{.*\}$|^\[.*\]$/
     return data && erg.test(data) ? JSON.parse(data) : data
   },
 
-  set(key, data){
+
+  /**
+   * 存入数据
+   * @author 张文
+   * @date 2022-05-11
+   * @param {String} key 数据key
+   * @param {*} data 数据，当存入数据为非字符串类型时，将会被转换为字符串
+   * */
+  set(key, data) {
+    if (!key) {
+      console.error('本地储存，没有传入需要设置的key')
+      return
+    }
     let str = typeof data === "string" ? data : JSON.stringify(data)
 
     window.localStorage.setItem(key, str)
   },
 
-  remove(key){
+
+  /**
+   * 删除存入数据
+   * @author 张文
+   * @date 2022-05-11
+   * @param {String} key 数据key
+   * */
+  remove(key) {
     window.localStorage.removeItem(key)
   },
 
-  removeAll(){
+
+  /**
+   * 清空全部存入数据
+   * @author 张文
+   * @date 2022-05-11
+   * */
+  removeAll() {
     window.localStorage.clear()
   },
 

package/src/utils/Permissions.js

@@ -11,14 +11,18 @@ export const Permissions = {
   /**
    * 设置权限数据
    * @author 张文
-   * @param {Array} data 需要设置的仓库数据
+   * @param {Array} data 需要设置的权限数据
    * */
   set(data) {
     window.lwWindowGlobalData.set('permissions.data', data)
   },
 
 
-  // 获取权限数据
+  /**
+   * 获取权限数据
+   * @author 张文
+   * @return {Array} 权限列表
+   * */
   get() {
     return window.lwWindowGlobalData.get('permissions.data')
   },
@@ -29,22 +33,32 @@ export const Permissions = {
    * @author 张文
    * @return {Promise} 权限数据
    */
-  asyncGet() {
+  asyncGet(loading) {
     return new Promise((PR, PE) => {
-      permissions.get(this.getQuery()).then(res => {
+      permissions.get(this.getQuery(), loading).then(res => {
         this.set(res)
         PR(this.get())
       }).catch(err => PE(err))
     })
   },
 
-  // 设置权限获取的参数
-  setQuery(arr){
-    window.lwWindowGlobalData.set('permissions.query', arr)
+
+  /**
+   * 设置权限获取的参数
+   * @author 张文
+   * @param {*} data 参数
+   */
+  setQuery(data) {
+    window.lwWindowGlobalData.set('permissions.query', data)
   },
 
-  // 获取权限获取的参数
-  getQuery(){
+
+  /**
+   * 获取权限获取的参数
+   * @author 张文
+   * @return {*} 设置的值
+   */
+  getQuery() {
     return window.lwWindowGlobalData.get('permissions.query')
   }