kz-ui-base 1.0.70 → 1.0.71

package/common/src/api/common/common.js

@@ -1,5 +1,6 @@
 import Vue from "vue";
 import request from "../../utils/request";
+import localforage from 'localforage';
 let that = new Vue();
 
 //公共接口
@@ -257,17 +258,23 @@ export function getNameByDeptId(value) {
   return value;
 }
 
-export function getNameByPostId(value) {
-  var cache = that.$cache.local.getJSON("post");
-  if (!cache) return value;
-  for (var item of cache) {
-    if (item.postId == value) {
-      return item.postName;
-    } else if (item.postCode == value) {
-      return item.postName;
+export async function getNameByPostId(value) {
+  try {
+    const cache = await localforage.getItem("post");
+    if (!cache) return value;
+    
+    for (const item of cache) {
+      if (item.postId == value) {
+        return item.postName;
+      } else if (item.postCode == value) {
+        return item.postName;
+      }
     }
+    return value;
+  } catch (err) {
+    console.error("Error retrieving post data:", err);
+    return value;
   }
-  return value;
 }
 
 export function getLineNameByLineNo(value) {

package/common/src/store/bdData.js

@@ -1,7 +1,17 @@
 // store/modules/bdData.js
 import { getUrl } from '../api/common/common';
+import localforage from 'localforage';
 import Vue from 'vue'
 
+// Configure localforage instances for each data type
+const storage = {
+  itemClass: localforage.createInstance({ name: 'bdData', storeName: 'itemClass' }),
+  itemCategory: localforage.createInstance({ name: 'bdData', storeName: 'itemCategory' }),
+  productLine: localforage.createInstance({ name: 'bdData', storeName: 'productLine' }),
+  currency: localforage.createInstance({ name: 'bdData', storeName: 'currency' }),
+  scales: localforage.createInstance({ name: 'bdData', storeName: 'scales' })
+};
+
 const state = {
   itemClass: null,
   itemCategory: null,
@@ -29,7 +39,57 @@ const mutations = {
 };
 
 const actions = {
-  async initBdCache({ commit }) {
+  async initBdCache({ commit, dispatch }) {
+    try {
+      // First try to load from local storage
+      const loadedFromCache = await dispatch('loadFromLocalStorage');
+      
+      if (loadedFromCache) {
+        // If we successfully loaded from cache, still refresh from server in background
+        dispatch('refreshFromServer');
+        return loadedFromCache;
+      }
+      
+      // If no cache exists, load from server
+      return await dispatch('refreshFromServer');
+    } catch (error) {
+      console.error("Failed to initialize BD data cache:", error);
+      throw error;
+    }
+  },
+  
+  async loadFromLocalStorage({ commit }) {
+    try {
+      const [
+        itemClass, 
+        itemCategory, 
+        productLine, 
+        currency, 
+        scales
+      ] = await Promise.all([
+        storage.itemClass.getItem('data'),
+        storage.itemCategory.getItem('data'),
+        storage.productLine.getItem('data'),
+        storage.currency.getItem('data'),
+        storage.scales.getItem('data')
+      ]);
+      
+      if (itemClass && itemCategory && productLine && currency && scales) {
+        commit('SET_ITEM_CLASS', itemClass);
+        commit('SET_ITEM_CATEGORY', itemCategory);
+        commit('SET_PRODUCT_LINE', productLine);
+        commit('SET_CURRENCY', currency);
+        commit('SET_SCALES', scales);
+        return [itemClass, itemCategory, productLine, currency, scales];
+      }
+      return null;
+    } catch (error) {
+      console.error("Failed to load from local storage:", error);
+      return null;
+    }
+  },
+  
+  async refreshFromServer({ commit }) {
     try {
       const requests = [
         getUrl("/bd/ItemClass/getItemClassAll"),
@@ -40,17 +100,49 @@ const actions = {
       ];
       
       const responses = await Promise.all(requests);
+      const data = responses.map(r => r.data);
+      
+      // Commit to state
+      commit('SET_ITEM_CLASS', data[0]);
+      commit('SET_ITEM_CATEGORY', data[1]);
+      commit('SET_PRODUCT_LINE', data[2]);
+      commit('SET_CURRENCY', data[3]);
+      Vue.prototype.$cache.local.setJSON("currency", data[3]);
+      commit('SET_SCALES', data[4]);
       
-      commit('SET_ITEM_CLASS', responses[0].data);
-      commit('SET_ITEM_CATEGORY', responses[1].data);
-      commit('SET_PRODUCT_LINE', responses[2].data);
-      commit('SET_CURRENCY', responses[3].data);
-      Vue.prototype.$cache.local.setJSON("currency", responses[3].data);
-      commit('SET_SCALES', responses[4].data);
+      // Save to local storage
+      await Promise.all([
+        storage.itemClass.setItem('data', data[0]),
+        storage.itemCategory.setItem('data', data[1]),
+        storage.productLine.setItem('data', data[2]),
+        storage.currency.setItem('data', data[3]),
+        storage.scales.setItem('data', data[4])
+      ]);
       
-      return responses.map(r => r.data);
+      return data;
     } catch (error) {
-      console.error("Failed to initialize BD data cache:", error);
+      console.error("Failed to refresh from server:", error);
+      throw error;
+    }
+  },
+  
+  async clearLocalCache({ commit }) {
+    try {
+      await Promise.all([
+        storage.itemClass.removeItem('data'),
+        storage.itemCategory.removeItem('data'),
+        storage.productLine.removeItem('data'),
+        storage.currency.removeItem('data'),
+        storage.scales.removeItem('data')
+      ]);
+      
+      commit('SET_ITEM_CLASS', null);
+      commit('SET_ITEM_CATEGORY', null);
+      commit('SET_PRODUCT_LINE', null);
+      commit('SET_CURRENCY', null);
+      commit('SET_SCALES', null);
+    } catch (error) {
+      console.error("Failed to clear local cache:", error);
       throw error;
     }
   }

package/common/src/store/fdFactory.js

@@ -1,5 +1,5 @@
-// store/modules/fdFactory.js
-import { getUrl } from '@api/common/common';
+import { getUrl } from '../api/common/common';
+import localforage from 'localforage';
 import Vue from 'vue'
 
 // 常量定义
@@ -8,6 +8,15 @@ const WA_TYPE_CODE_WORKSHOP = "2";
 const WA_TYPE_CODE_PRODUCTION_LINE = "3";
 const WA_TYPE_CODE_WORKSHOP_SECTION = "4";
 
+const storage = {
+  sites: localforage.createInstance({ name: 'fdFactory', storeName: 'sites' }),
+  workAreas: localforage.createInstance({ name: 'fdFactory', storeName: 'workAreas' }),
+  workCenters: localforage.createInstance({ name: 'fdFactory', storeName: 'workCenters' }),
+  workUnits: localforage.createInstance({ name: 'fdFactory', storeName: 'workUnits' }),
+  storageZones: localforage.createInstance({ name: 'fdFactory', storeName: 'storageZones' }),
+  storageUnits: localforage.createInstance({ name: 'fdFactory', storeName: 'storageUnits' })
+};
+
 const state = {
   sites: null,
   workAreas: null,
@@ -39,7 +48,57 @@ const mutations = {
 };
 
 const actions = {
-  async initFdCache({ commit }) {
+  async initFdCache({ commit, dispatch }) {
+    try {
+      const loadedFromCache = await dispatch('loadFromLocalStorage');
+      
+      if (loadedFromCache) {
+        dispatch('refreshFromServer');
+        return loadedFromCache;
+      }
+      
+      return await dispatch('refreshFromServer');
+    } catch (error) {
+      console.error("Failed to initialize FD factory cache:", error);
+      throw error;
+    }
+  },
+  
+  async loadFromLocalStorage({ commit }) {
+    try {
+      const [
+        sites, 
+        workAreas, 
+        workCenters, 
+        workUnits, 
+        storageZones, 
+        storageUnits
+      ] = await Promise.all([
+        storage.sites.getItem('data'),
+        storage.workAreas.getItem('data'),
+        storage.workCenters.getItem('data'),
+        storage.workUnits.getItem('data'),
+        storage.storageZones.getItem('data'),
+        storage.storageUnits.getItem('data')
+      ]);
+      
+      if (sites && workAreas && workCenters && workUnits && storageZones && storageUnits) {
+        commit('SET_SITES', sites);
+        commit('SET_WORK_AREAS', workAreas);
+        commit('SET_WORK_CENTERS', workCenters);
+        commit('SET_WORK_UNITS', workUnits);
+        commit('SET_STORAGE_ZONES', storageZones);
+        commit('SET_STORAGE_UNITS', storageUnits);
+        return [sites, workAreas, workCenters, workUnits, storageZones, storageUnits];
+      }
+      return null;
+    } catch (error) {
+      console.error("Failed to load from local storage:", error);
+      return null;
+    }
+  },
+  
+  async refreshFromServer({ commit }) {
     try {
       const requests = [
         getUrl("/fd/fd/getAllSites"),
@@ -51,18 +110,51 @@ const actions = {
       ];
       
       const responses = await Promise.all(requests);
+      const data = responses.map(r => r.data);
+      
+      commit('SET_SITES', data[0]);
+      Vue.prototype.$cache.local.setJSON("sites", data[0]);
+      commit('SET_WORK_AREAS', data[1]);
+      commit('SET_WORK_CENTERS', data[2]);
+      commit('SET_WORK_UNITS', data[3]);
+      commit('SET_STORAGE_ZONES', data[4]);
+      commit('SET_STORAGE_UNITS', data[5]);
       
-      commit('SET_SITES', responses[0].data);
-      Vue.prototype.$cache.local.setJSON("sites", responses[0].data);
-      commit('SET_WORK_AREAS', responses[1].data);
-      commit('SET_WORK_CENTERS', responses[2].data);
-      commit('SET_WORK_UNITS', responses[3].data);
-      commit('SET_STORAGE_ZONES', responses[4].data);
-      commit('SET_STORAGE_UNITS', responses[5].data);
+      await Promise.all([
+        storage.sites.setItem('data', data[0]),
+        storage.workAreas.setItem('data', data[1]),
+        storage.workCenters.setItem('data', data[2]),
+        storage.workUnits.setItem('data', data[3]),
+        storage.storageZones.setItem('data', data[4]),
+        storage.storageUnits.setItem('data', data[5])
+      ]);
       
-      return responses.map(r => r.data);
+      return data;
     } catch (error) {
-      console.error("Failed to initialize FD factory cache:", error);
+      console.error("Failed to refresh from server:", error);
+      throw error;
+    }
+  },
+  
+  async clearLocalCache({ commit }) {
+    try {
+      await Promise.all([
+        storage.sites.removeItem('data'),
+        storage.workAreas.removeItem('data'),
+        storage.workCenters.removeItem('data'),
+        storage.workUnits.removeItem('data'),
+        storage.storageZones.removeItem('data'),
+        storage.storageUnits.removeItem('data')
+      ]);
+      
+      commit('SET_SITES', null);
+      commit('SET_WORK_AREAS', null);
+      commit('SET_WORK_CENTERS', null);
+      commit('SET_WORK_UNITS', null);
+      commit('SET_STORAGE_ZONES', null);
+      commit('SET_STORAGE_UNITS', null);
+    } catch (error) {
+      console.error("Failed to clear local cache:", error);
       throw error;
     }
   }

package/common/src/store/smSysSettings.js

@@ -1,5 +1,11 @@
-// store/modules/smSysSettings.js
 import { getUrl } from '../api/common/common';
+import localforage from 'localforage';
+
+// 配置LocalForage实例
+const settingsStorage = localforage.createInstance({
+  name: 'smSysSettings',  // 数据库名称
+  storeName: 'settings'   // 表名
+});
 
 const state = {
   settings: null
@@ -12,12 +18,82 @@ const mutations = {
 };
 
 const actions = {
-  async initSmCache({ commit }) {
+  async initSmCache({ commit, dispatch }) {
+    try {
+      // 先尝试从本地加载
+      const cachedSettings = await dispatch('loadFromLocalStorage');
+      
+      if (cachedSettings) {
+        // 如果有缓存，后台静默刷新
+        dispatch('refreshFromServer');
+        return cachedSettings;
+      }
+      
+      // 没有缓存则从服务器加载
+      return await dispatch('refreshFromServer');
+    } catch (error) {
+      console.error("初始化系统设置失败:", error);
+      throw error;
+    }
+  },
+  
+  // 从本地存储加载
+  async loadFromLocalStorage({ commit }) {
+    try {
+      const settings = await settingsStorage.getItem('data');
+      if (settings) {
+        commit('SET_SETTINGS', settings);
+        return settings;
+      }
+      return null;
+    } catch (error) {
+      console.error("从本地加载设置失败:", error);
+      return null;
+    }
+  },
+  
+  async refreshFromServer({ commit }) {
     try {
       const response = await getUrl("/sm/SmSysSetting/getSmSysSettingAll");
-      commit('SET_SETTINGS', response.data);
+      const settings = response.data;
+      
+      commit('SET_SETTINGS', settings);
+      
+      await settingsStorage.setItem('data', settings);
+      
+      return settings;
+    } catch (error) {
+      console.error("从服务器刷新设置失败:", error);
+      throw error;
+    }
+  },
+  
+  // 清除本地缓存
+  async clearLocalCache({ commit }) {
+    try {
+      await settingsStorage.removeItem('data');
+      commit('SET_SETTINGS', null);
+    } catch (error) {
+      console.error("清除本地缓存失败:", error);
+      throw error;
+    }
+  },
+  
+  // 更新单个设置项
+  async updateSetting({ commit, state }, { paramCode, paramValue }) {
+    try {
+      // 更新状态
+      const updatedSettings = state.settings.map(item => 
+        item.paramCode === paramCode ? { ...item, paramValue } : item
+      );
+      commit('SET_SETTINGS', updatedSettings);
+      
+      // 更新本地存储
+      await settingsStorage.setItem('data', updatedSettings);
+      
+      // 这里可以添加服务器更新逻辑
     } catch (error) {
-      console.error("Failed to initialize SM settings:", error);
+      console.error("更新设置失败:", error);
       throw error;
     }
   }
@@ -28,6 +104,10 @@ const getters = {
     if (!state.settings) return null;
     const item = state.settings.find(item => item.paramCode === paramCode);
     return item ? item.paramValue : null;
+  },
+  
+  allSettings: (state) => {
+    return state.settings || [];
   }
 };
 

package/common/src/store/tmTooling.js

@@ -1,42 +1,93 @@
-// store/modules/tmTooling.js
 import { getUrl } from '../api/common/common';
+import localforage from 'localforage';
+
+const toolingStorage = localforage.createInstance({
+  name: 'tooling-cache',
+  storeName: 'tooling_data'
+});
 
 const state = {
   toolingList: null,
   toolingIdMap: null,
-  toolingNoMap: null
+  toolingNoMap: null,
+  lastUpdated: null
 };
 
 const mutations = {
-  SET_TOOLING_LIST(state, list) {
-    state.toolingList = list;
-    // 预生成映射关系
+  SET_TOOLING_LIST(state, { list, lastUpdated }) {
+    state.toolingList = list || [];
     state.toolingIdMap = {};
     state.toolingNoMap = {};
-    list.forEach(item => {
+    state.lastUpdated = lastUpdated || new Date().toISOString();
+    
+    (list || []).forEach(item => {
       state.toolingIdMap[item.id] = item;
       state.toolingNoMap[item.toolingNo] = item;
     });
-  }
+  },
 };
 
 const actions = {
-  async initTmCache({ commit }) {
+  async initTmCache({ commit, state }) {
     try {
+      
+      const cachedData = await toolingStorage.getItem('toolingData');
+      const cacheTime = await toolingStorage.getItem('lastUpdated');
+      
+      const oneHourAgo = new Date(Date.now() - 3600000).toISOString();
+      if (cachedData && cacheTime && cacheTime > oneHourAgo) {
+        commit('SET_TOOLING_LIST', {
+          list: cachedData,
+          lastUpdated: cacheTime
+        });
+        return cachedData;
+      }
+      
       const response = await getUrl("/tm/tooling/list");
-      commit('SET_TOOLING_LIST', response.data);
+      if (!response.data) {
+        throw new Error("服务器返回空数据");
+      }
+      
+      await toolingStorage.setItem('toolingData', response.data);
+      const newLastUpdated = new Date().toISOString();
+      await toolingStorage.setItem('lastUpdated', newLastUpdated);
+      
+      commit('SET_TOOLING_LIST', {
+        list: response.data,
+        lastUpdated: newLastUpdated
+      });
       return response.data;
     } catch (error) {
-      console.error("Failed to initialize TM tooling cache:", error);
+      console.error("初始化刀具缓存失败:", error);
+      
+      const cachedData = await toolingStorage.getItem('toolingData');
+      if (cachedData) {
+        commit('SET_TOOLING_LIST', {
+          list: cachedData,
+          lastUpdated: await toolingStorage.getItem('lastUpdated')
+        });
+        return cachedData;
+      }
+      
       throw error;
     }
+  },
+  
+  async clearToolingCache() {
+    await toolingStorage.clear();
+  },
+  
+  async refreshToolingCache({ dispatch }) {
+    await toolingStorage.removeItem('lastUpdated');
+    return dispatch('initTmCache');
   }
 };
 
 const getters = {
-  toolingList: state => state.toolingList,
-  toolingIdMap: state => state.toolingIdMap,
-  toolingNoMap: state => state.toolingNoMap
+  toolingList: state => state.toolingList || [],
+  toolingIdMap: state => state.toolingIdMap || {},
+  toolingNoMap: state => state.toolingNoMap || {},
+  lastUpdated: state => state.lastUpdated,
 };
 
 export default {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kz-ui-base",
-  "version": "1.0.70",
+  "version": "1.0.71",
   "description": "",
   "main": "index.js",
   "scripts": {

package/views/bd/common/modal/EmployeeModal.vue

@@ -282,9 +282,10 @@ export default {
         params.deptId = this.listQueryParams.deptId
       }
       selectPageByEmployeeSearchVo(params).then(response => {
-        response.rows.forEach(item => {
+        response.rows.forEach(async item => {
           item.deptName = getNameByDeptId(item.deptId)
-          item.postName = getNameByPostId(item.postId)
+          // item.postName = await getNameByPostId(item.postId)
+          this.$set(item,'postName',await getNameByPostId(item.postId))
         })
         this.listQueryParams.total = Number(response.total);
         this.listData = response.rows;