0602

store/modules/sync.js

@@ -0,0 +1,243 @@
+export default {
+  namespaced: true,
+  state: {
+    syncStatus: 'idle', // idle, syncing, success, error
+    lastSyncTime: null,
+    syncProgress: 0,
+    pendingSyncCount: 0,
+    syncLog: []
+  },
+  mutations: {
+    SET_SYNC_STATUS(state, status) {
+      state.syncStatus = status
+    },
+    SET_LAST_SYNC_TIME(state, time) {
+      state.lastSyncTime = time
+    },
+    SET_SYNC_PROGRESS(state, progress) {
+      state.syncProgress = progress
+    },
+    SET_PENDING_SYNC_COUNT(state, count) {
+      state.pendingSyncCount = count
+    },
+    ADD_SYNC_LOG(state, log) {
+      state.syncLog.unshift(log)
+      // 只保留最近50条日志
+      if (state.syncLog.length > 50) {
+        state.syncLog.splice(50)
+      }
+    },
+    CLEAR_SYNC_LOG(state) {
+      state.syncLog = []
+    }
+  },
+  actions: {
+    async syncData({ commit, dispatch, state }) {
+      if (state.syncStatus === 'syncing') {
+        console.log('同步已在进行中')
+        return
+      }
+      
+      try {
+        commit('SET_SYNC_STATUS', 'syncing')
+        commit('SET_SYNC_PROGRESS', 0)
+        
+        // 记录开始同步日志
+        commit('ADD_SYNC_LOG', {
+          type: 'start',
+          message: '开始数据同步',
+          timestamp: new Date().toISOString()
+        })
+        
+        // 获取待同步数据
+        const pendingData = await dispatch('getPendingSyncData')
+        
+        if (pendingData.length === 0) {
+          commit('SET_SYNC_STATUS', 'success')
+          commit('SET_SYNC_PROGRESS', 100)
+          commit('ADD_SYNC_LOG', {
+            type: 'info',
+            message: '没有待同步的数据',
+            timestamp: new Date().toISOString()
+          })
+          return
+        }
+        
+        // 开始同步
+        let successCount = 0
+        const totalCount = pendingData.length
+        
+        for (let i = 0; i < pendingData.length; i++) {
+          const item = pendingData[i]
+          
+          try {
+            // 模拟同步到服务器
+            await dispatch('syncItemToServer', item)
+            
+            // 标记为已同步
+            await dispatch('markItemSynced', item)
+            
+            successCount++
+            commit('SET_SYNC_PROGRESS', Math.round((i + 1) / totalCount * 100))
+            
+            commit('ADD_SYNC_LOG', {
+              type: 'success',
+              message: `成功同步: ${item.type} - ${item.data.id}`,
+              timestamp: new Date().toISOString()
+            })
+            
+          } catch (error) {
+            commit('ADD_SYNC_LOG', {
+              type: 'error',
+              message: `同步失败: ${item.type} - ${item.data.id} - ${error.message}`,
+              timestamp: new Date().toISOString()
+            })
+          }
+          
+          // 模拟网络延迟
+          await new Promise(resolve => setTimeout(resolve, 500))
+        }
+        
+        // 更新同步状态
+        if (successCount === totalCount) {
+          commit('SET_SYNC_STATUS', 'success')
+        } else {
+          commit('SET_SYNC_STATUS', 'error')
+        }
+        
+        // 更新最后同步时间
+        const now = new Date().toISOString()
+        commit('SET_LAST_SYNC_TIME', now)
+        uni.setStorageSync('lastSyncTime', now)
+        
+        // 更新待同步数量
+        await dispatch('updatePendingSyncCount')
+        
+        // 记录同步完成日志
+        commit('ADD_SYNC_LOG', {
+          type: 'complete',
+          message: `同步完成: ${successCount}/${totalCount} 成功`,
+          timestamp: new Date().toISOString()
+        })
+        
+      } catch (error) {
+        console.error('同步数据失败:', error)
+        commit('SET_SYNC_STATUS', 'error')
+        commit('ADD_SYNC_LOG', {
+          type: 'error',
+          message: `同步过程出错: ${error.message}`,
+          timestamp: new Date().toISOString()
+        })
+      }
+    },
+    
+    async getPendingSyncData({ }) {
+      try {
+        const pendingSync = uni.getStorageSync('pendingSync') || []
+        return pendingSync
+      } catch (error) {
+        console.error('获取待同步数据失败:', error)
+        return []
+      }
+    },
+    
+    async syncItemToServer({ }, item) {
+      // 模拟同步到服务器
+      // 实际应用中应该调用真实的API
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          // 模拟95%的成功率
+          if (Math.random() > 0.05) {
+            resolve({ success: true, message: '同步成功' })
+          } else {
+            reject(new Error('网络错误'))
+          }
+        }, 1000)
+      })
+    },
+    
+    async markItemSynced({ }, item) {
+      try {
+        const pendingSync = uni.getStorageSync('pendingSync') || []
+        const updatedSync = pendingSync.filter(syncItem => 
+          !(syncItem.type === item.type && syncItem.data.id === item.data.id)
+        )
+        
+        uni.setStorageSync('pendingSync', updatedSync)
+        
+        // 更新本地记录状态
+        const recordKey = item.type === 'inbound' ? 'inboundRecords' : 
+                          item.type === 'outbound' ? 'outboundRecords' : 
+                          item.type === 'inventory' ? 'inventoryRecords' : null
+        
+        if (recordKey) {
+          const records = uni.getStorageSync(recordKey) || []
+          const updatedRecords = records.map(record => {
+            if (record.id === item.data.id) {
+              return { ...record, syncStatus: 'synced' }
+            }
+            return record
+          })
+          uni.setStorageSync(recordKey, updatedRecords)
+        }
+        
+      } catch (error) {
+        console.error('标记同步成功失败:', error)
+        throw error
+      }
+    },
+    
+    async updatePendingSyncCount({ commit }) {
+      try {
+        const pendingSync = uni.getStorageSync('pendingSync') || []
+        commit('SET_PENDING_SYNC_COUNT', pendingSync.length)
+      } catch (error) {
+        console.error('更新待同步数量失败:', error)
+      }
+    },
+    
+    async uploadErrorLogs({ }, logs) {
+      // 模拟上传错误日志到服务器
+      console.log('上传错误日志:', logs.length, '条')
+    },
+    
+    async startAutoSync({ dispatch, state, rootState }) {
+      // 启动自动同步
+      const syncInterval = rootState.app.settings.syncInterval || 5
+      
+      setInterval(async () => {
+        if (state.syncStatus !== 'syncing') {
+          await dispatch('syncData')
+        }
+      }, syncInterval * 60 * 1000)
+    }
+  },
+  getters: {
+    syncStatusText: state => {
+      const statusMap = {
+        idle: '待同步',
+        syncing: '同步中',
+        success: '同步成功',
+        error: '同步失败'
+      }
+      return statusMap[state.syncStatus] || '未知状态'
+    },
+    lastSyncTimeText: state => {
+      if (!state.lastSyncTime) return '从未同步'
+      
+      const date = new Date(state.lastSyncTime)
+      const now = new Date()
+      const diff = now - date
+      
+      if (diff < 60000) {
+        return '刚刚'
+      } else if (diff < 3600000) {
+        return Math.floor(diff / 60000) + '分钟前'
+      } else if (diff < 86400000) {
+        return Math.floor(diff / 3600000) + '小时前'
+      } else {
+        return date.toLocaleDateString('zh-CN')
+      }
+    }
+  }
+}