王明 / Food-Labeling-Management-Platform

  import { fetchLabelCategoryPage } from '../services/labelCategory'
  import { fetchProductCategoryPage } from '../services/productCategory'
  import { usAppFetchLocationDetail, usAppFetchMyLocations, usAppFetchMyProfile } from '../services/usAppAuth'
  import {
    fetchUsAppLabelingTree,
    fetchUsAppPrintLogList,
    prefetchUsAppLabelPreviewsForLocation,
  } from '../services/usAppLabeling'
  import { fetchGlobalSupportContact } from '../services/locationSupport'
  import {
    getAccessToken,
    getBoundLocations,
    isLoggedIn,
    setBoundLocations,
  } from './authSession'
  import { getCurrentStoreId } from './stores'
  import {
    clearFailedOfflineMutations,
    getOfflineMutationById,
    getOfflineSyncSummary,
    getPendingOfflineMutations,
    getPendingOfflineMutationsPreview,
    initOfflineSqlite,
    isNetworkOnline,
    markOfflineMutationDone,
    markOfflineMutationFailed,
    removeOfflineMutationById,
    refreshOfflineAuthAccountSession,
  } from './sqliteSync'
  import type { MutationRow } from './sqliteSync'
  import { usAppApiRequest } from './usAppApiRequest'
  
  export type OfflineSyncStats = {
    online: boolean
    lastSyncAt: number
    labels: { total: number; synced: number; pending: number }
    photos: { total: number; synced: number; pending: number }
    pendingMutations: number
  }
  
  export type OfflinePendingMutationPreview = {
    id: number
    method: 'POST' | 'PUT' | 'DELETE'
    endpoint: string
    createdAt: number
    lastError: string | null
  }
  
  export type OfflineSyncExecutionDetail = {
    total: number
    success: number
    failed: number
    at: number
  }
  
  const KEY_LAST_SYNC_AT = '__offline_last_sync_at__'
  const KEY_LAST_SYNC_EXECUTION = '__offline_last_sync_execution__'
  
  function getLastSyncAt(): number {
    return Number(uni.getStorageSync(KEY_LAST_SYNC_AT) || 0)
  }
  
  function setLastSyncAt(value: number): void {
    uni.setStorageSync(KEY_LAST_SYNC_AT, value)
  }
  
  function getLastSyncExecutionDetail(): OfflineSyncExecutionDetail {
    try {
      const raw = String(uni.getStorageSync(KEY_LAST_SYNC_EXECUTION) || '').trim()
      if (!raw) return { total: 0, success: 0, failed: 0, at: 0 }
      const p = JSON.parse(raw) as Partial<OfflineSyncExecutionDetail>
      return {
        total: Number(p.total || 0),
        success: Number(p.success || 0),
        failed: Number(p.failed || 0),
        at: Number(p.at || 0),
      }
    } catch {
      return { total: 0, success: 0, failed: 0, at: 0 }
    }
  }
  
  function setLastSyncExecutionDetail(detail: OfflineSyncExecutionDetail): void {
    uni.setStorageSync(KEY_LAST_SYNC_EXECUTION, JSON.stringify(detail))
  }
  
  export async function performInitialOfflineSync(): Promise<void> {
    await initOfflineSqlite()
    const online = await isNetworkOnline()
    if (!online) return
  
    const profile = await usAppFetchMyProfile()
    if (profile.fullName?.trim()) {
      uni.setStorageSync('userName', profile.fullName.trim())
    }
  
    const locations = await usAppFetchMyLocations()
    setBoundLocations(locations)
    const currentStoreId = getCurrentStoreId() || locations?.[0]?.id || ''
    const targetLocationIds = Array.from(
      new Set(
        [currentStoreId, ...locations.map((x) => x.id).filter(Boolean)].filter((x) => !!String(x).trim())
      )
    )
    for (const locId of targetLocationIds) {
      // 每个门店一组缓存，确保离线切店后仍有可读数据
      const [, treeResult] = await Promise.allSettled([
        usAppFetchLocationDetail(locId),
        fetchUsAppLabelingTree({ locationId: locId }),
        fetchUsAppPrintLogList({ locationId: locId, skipCount: 1, maxResultCount: 20 }),
      ])
      if (treeResult.status === 'fulfilled' && Array.isArray(treeResult.value)) {
        await prefetchUsAppLabelPreviewsForLocation(locId, treeResult.value)
      }
    }
    await Promise.allSettled([
      fetchLabelCategoryPage({ skipCount: 1, maxResultCount: 100, state: true }),
      fetchProductCategoryPage({ skipCount: 1, maxResultCount: 100, state: true }),
      fetchGlobalSupportContact(),
    ])
  
    if (isLoggedIn()) {
      const email = String(uni.getStorageSync('user_email') || '').trim()
      if (email) {
        await refreshOfflineAuthAccountSession({
          email,
          token: getAccessToken(),
          refreshToken: String(uni.getStorageSync('refresh_token') || ''),
          locations: getBoundLocations(),
          displayName: String(uni.getStorageSync('userName') || email),
        })
      }
    }
  
    setLastSyncAt(Date.now())
  }
  
  export async function flushPendingMutations(): Promise<number> {
    const online = await isNetworkOnline()
    if (!online) throw new Error('No network connection')
    await initOfflineSqlite()
    const list = await getPendingOfflineMutations()
    let ok = 0
    for (const row of list) {
      try {
        const payload = JSON.parse(row.payloadJson || 'null')
        await usAppApiRequest<unknown>({
          path: row.endpoint,
          method: row.method as 'POST' | 'PUT' | 'DELETE',
          auth: true,
          data: payload,
        })
        await markOfflineMutationDone(row.id)
        ok += 1
      } catch (e: unknown) {
        const msg = e instanceof Error ? e.message : String(e)
        await markOfflineMutationFailed(row.id, msg)
      }
    }
    return ok
  }
  
  async function flushPendingMutationsWithDetail(): Promise<OfflineSyncExecutionDetail> {
    const online = await isNetworkOnline()
    if (!online) throw new Error('No network connection')
    await initOfflineSqlite()
    const list = await getPendingOfflineMutations()
    let success = 0
    let failed = 0
    for (const row of list) {
      try {
        const payload = JSON.parse(row.payloadJson || 'null')
        await usAppApiRequest<unknown>({
          path: row.endpoint,
          method: row.method as 'POST' | 'PUT' | 'DELETE',
          auth: true,
          data: payload,
        })
        await markOfflineMutationDone(row.id)
        success += 1
      } catch (e: unknown) {
        const msg = e instanceof Error ? e.message : String(e)
        await markOfflineMutationFailed(row.id, msg)
        failed += 1
      }
    }
    const d: OfflineSyncExecutionDetail = {
      total: list.length,
      success,
      failed,
      at: Date.now(),
    }
    setLastSyncExecutionDetail(d)
    return d
  }
  
  export async function syncNowAndRefreshCaches(): Promise<OfflineSyncStats> {
    // 先回放本地待同步变更，再拉最新云端数据刷新本地缓存，避免“刚同步又被旧缓存覆盖”
    await flushPendingMutationsWithDetail()
    await performInitialOfflineSync()
    setLastSyncAt(Date.now())
    return getOfflineSyncStats()
  }
  
  export async function getOfflineSyncStats(): Promise<OfflineSyncStats> {
    const online = await isNetworkOnline()
    const summary = await getOfflineSyncSummary()
    const lastSyncAt = getLastSyncAt()
    return {
      online,
      lastSyncAt,
      labels: {
        total: summary.cacheCount,
        synced: summary.cacheCount,
        pending: summary.pendingMutationCount,
      },
      photos: {
        total: 0,
        synced: 0,
        pending: 0,
      },
      pendingMutations: summary.pendingMutationCount,
    }
  }
  
  function toPreviewRow(x: MutationRow): OfflinePendingMutationPreview {
    return {
      id: x.id,
      method: x.method,
      endpoint: x.endpoint,
      createdAt: x.createdAt,
      lastError: x.lastError ?? null,
    }
  }
  
  export async function getOfflinePendingMutationPreviewList(limit = 20): Promise<OfflinePendingMutationPreview[]> {
    const rows = await getPendingOfflineMutationsPreview(limit)
    return rows.map(toPreviewRow)
  }
  
  export function getOfflineLastSyncExecutionDetail(): OfflineSyncExecutionDetail {
    return getLastSyncExecutionDetail()
  }
  
  export async function retryOfflineMutationById(id: number): Promise<{ ok: boolean; message?: string }> {
    const online = await isNetworkOnline()
    if (!online) return { ok: false, message: 'No network connection' }
    await initOfflineSqlite()
    const row = await getOfflineMutationById(id)
    if (!row) return { ok: false, message: 'Queue item not found' }
    try {
      const payload = JSON.parse(row.payloadJson || 'null')
      await usAppApiRequest<unknown>({
        path: row.endpoint,
        method: row.method as 'POST' | 'PUT' | 'DELETE',
        auth: true,
        data: payload,
      })
      await markOfflineMutationDone(row.id)
      return { ok: true }
    } catch (e: unknown) {
      const msg = e instanceof Error ? e.message : String(e)
      await markOfflineMutationFailed(row.id, msg)
      return { ok: false, message: msg || 'Retry failed' }
    }
  }
  
  export async function removeOfflineMutation(id: number): Promise<void> {
    await removeOfflineMutationById(id)
  }
  
  export async function clearFailedOfflineMutationItems(): Promise<number> {
    return clearFailedOfflineMutations()
  }