@spacecorexdev/core 0.0.2 → 0.0.5

package/src/utils/CacheDepartmentInfo.ts

@@ -0,0 +1,372 @@
+'use strict';
+
+/**
+ * Copyright (c) 2025 SPACECORE Co.,Ltd. All Rights Reserved.
+ * Author: brian.li
+ * Date: 2025-04-02 11:43
+ * Desc: 部门信息工具类 - 支持Dexie缓存
+ *
+ * @example 使用方法
+ *
+ * // 1. 获取所有部门信息
+ * import { CacheDepartmentInfo } from './CacheDepartmentInfo';
+ * const depts = await CacheDepartmentInfo.getDepartmentInfo({});
+ * console.log(depts);
+ *
+ * // 2. 强制刷新缓存（不使用缓存）
+ * const depts = await CacheDepartmentInfo.getDepartmentInfo({ forceRefresh: true });
+ * console.log(depts);
+ *
+ * // 3. 清除部门缓存
+ * CacheDepartmentInfo.clearDepartmentCache();
+ *
+ * // 4. 获取缓存统计信息
+ * const stats = await CacheDepartmentInfo.getCacheStats();
+ * console.log(`缓存数量: ${stats.count}`);
+ */
+
+import Dexie, { Table } from 'dexie';
+import { API } from "../api";
+import { ResponseCode } from "../api/_base";
+
+/** 部门信息缓存时间（毫秒）24小时 */
+const CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
+
+/** 公司信息数据类型 */
+export interface CompanyInfo {
+  id: string;
+  name: string;
+  descs: string;
+  parent_id: string;
+  admin_id: string;
+  is_spv_company?: boolean;
+  created_at?: Date;
+}
+
+/** 部门信息数据类型 */
+export interface DepartmentInfo {
+  id: string;
+  name: string;
+  descs: string;
+  parent_id: string;
+  admin_id: string;
+  company_id?: string;
+  company?: CompanyInfo;
+  created_at?: Date;
+  children?: DepartmentInfo[];
+}
+
+/** 部门信息缓存数据结构 */
+interface DepartmentCache {
+  id: string;
+  data: DepartmentInfo[];
+  timestamp: number;
+}
+
+/** Dexie 数据库类 */
+class DepartmentInfoDatabase extends Dexie {
+  departmentCache!: Table<DepartmentCache, string>;
+
+  constructor() {
+    super('DepartmentInfoDB');
+    this.version(1).stores({
+      departmentCache: 'id, timestamp'
+    });
+  }
+}
+
+/** 单例数据库实例 */
+const db = new DepartmentInfoDatabase();
+let departmentListPromise: Promise<DepartmentInfo[] | null> | null = null;
+
+/**
+ * 从缓存获取部门信息
+ * @returns 缓存的部门信息或null
+ */
+const getFromCache = async (): Promise<DepartmentInfo[] | null> => {
+  try {
+    const cached = await db.departmentCache.get('DEPARTMENT_ALL');
+    if (cached) {
+      const now = Date.now();
+      if (now - cached.timestamp < CACHE_EXPIRATION_MS) {
+        return cached.data;
+      }
+      // 缓存过期，删除
+      await db.departmentCache.delete('DEPARTMENT_ALL');
+    }
+    return null;
+  } catch (error) {
+    console.error('读取部门缓存失败:', error);
+    return null;
+  }
+};
+
+/**
+ * 设置部门信息到缓存
+ * @param data 部门信息数组
+ */
+const setToCache = async (data: DepartmentInfo[]): Promise<void> => {
+  try {
+    await db.departmentCache.put({
+      id: 'DEPARTMENT_ALL',
+      data,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    console.error('写入部门缓存失败:', error);
+  }
+};
+
+/**
+ * 清除所有部门缓存
+ */
+const clearCache = async (): Promise<void> => {
+  try {
+    await db.departmentCache.clear();
+  } catch (error) {
+    console.error('清除部门缓存失败:', error);
+  }
+};
+
+const attachCompanyInfo = (
+  departments: DepartmentInfo[],
+  company: CompanyInfo
+): DepartmentInfo[] => {
+  return departments.map(department => ({
+    ...department,
+    company_id: department.company_id || company.id,
+    company,
+    children: department.children
+      ? attachCompanyInfo(department.children, company)
+      : undefined
+  }));
+};
+
+/**
+ * 从API获取公司下的部门信息
+ * 公司信息不做缓存，刷新部门缓存时实时获取公司后再获取部门
+ */
+const fetchDepartmentsFromApi = async (): Promise<DepartmentInfo[] | null> => {
+  const companyRes = await API.user.role.listCompanies();
+
+  if (companyRes.code !== ResponseCode.SUCCESS) {
+    return null;
+  }
+
+  const companies: CompanyInfo[] = (companyRes.data || []).map(company => ({
+    id: company.id,
+    name: company.name,
+    descs: company.descs,
+    parent_id: company.parent_id,
+    admin_id: company.admin_id,
+    is_spv_company: company.is_spv_company,
+    created_at: company.created_at
+  }));
+
+  if (companies.length === 0) {
+    return [];
+  }
+
+  const departmentResults = await Promise.all(
+    companies.map(async (company) => {
+      const departmentRes = await API.user.role.listCompanyDepartments({ company_id: company.id });
+
+      if (departmentRes.code !== ResponseCode.SUCCESS) {
+        return null;
+      }
+
+      return attachCompanyInfo((departmentRes.data || []) as DepartmentInfo[], company);
+    })
+  );
+
+  if (departmentResults.some(result => result === null)) {
+    return null;
+  }
+
+  return departmentResults.flatMap(result => result || []);
+};
+
+/**
+ * 获取所有部门信息
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 部门信息数组
+ */
+const getDepartmentList = async (
+  {
+    forceRefresh = false
+  }: {
+    forceRefresh?: boolean
+  }
+): Promise<DepartmentInfo[] | null> => {
+
+  // 尝试从缓存获取（除非强制刷新）
+  if (!forceRefresh) {
+    const cachedDeptInfo = await getFromCache();
+    if (cachedDeptInfo) {
+      return cachedDeptInfo;
+    }
+  }
+
+  if (!departmentListPromise) {
+    departmentListPromise = fetchDepartmentsFromApi()
+      .then(async (departments) => {
+        if (departments) {
+          await setToCache(departments);
+        }
+        return departments;
+      })
+      .finally(() => {
+        departmentListPromise = null;
+      });
+  }
+
+  const departments = await departmentListPromise;
+  if (!departments) {
+    return null;
+  }
+
+  return departments;
+};
+
+/**
+ * 获取扁平化的部门列表（包含所有子部门）
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 扁平化的部门信息数组
+ */
+const getFlatDepartmentList = async (
+  {
+    forceRefresh = false
+  }: {
+    forceRefresh?: boolean
+  }
+): Promise<DepartmentInfo[] | null> => {
+  const departments = await getDepartmentList({ forceRefresh });
+
+  if (!departments) {
+    return null;
+  }
+
+  const flatten = (depts: DepartmentInfo[]): DepartmentInfo[] => {
+    let result: DepartmentInfo[] = [];
+    for (const dept of depts) {
+      const { children, ...deptWithoutChildren } = dept;
+      result.push(deptWithoutChildren as DepartmentInfo);
+      if (dept.children && dept.children.length > 0) {
+        result = result.concat(flatten(dept.children));
+      }
+    }
+    return result;
+  };
+
+  return flatten(departments);
+};
+
+/**
+ * 根据部门ID获取部门信息
+ * @param deptId 部门ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 部门信息或null
+ */
+const getDepartmentById = async (
+  {
+    deptId,
+    forceRefresh = false
+  }: {
+    deptId: string,
+    forceRefresh?: boolean
+  }
+): Promise<DepartmentInfo | null> => {
+  const departments = await getFlatDepartmentList({ forceRefresh });
+
+  if (!departments) {
+    return null;
+  }
+
+  return departments.find(dept => dept.id === deptId) || null;
+};
+
+/**
+ * 根据部门ID获取部门名称
+ * @param deptId 部门ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 部门名称或空字符串
+ */
+const getDepartmentNameById = async (
+  {
+    deptId,
+    forceRefresh = false
+  }: {
+    deptId: string,
+    forceRefresh?: boolean
+  }
+): Promise<string> => {
+  const dept = await getDepartmentById({ deptId, forceRefresh });
+  return dept?.name || '';
+};
+
+/**
+ * 清除部门缓存
+ */
+const clearDepartmentCache = async (): Promise<void> => {
+  await clearCache();
+};
+
+/**
+ * 获取缓存统计信息
+ * @returns 缓存统计信息
+ */
+const getCacheStats = async (): Promise<{ count: number; oldest: number | null; newest: number | null }> => {
+  try {
+    const all = await db.departmentCache.toArray();
+    if (all.length === 0) {
+      return { count: 0, oldest: null, newest: null };
+    }
+    const timestamps = all.map(item => item.timestamp);
+    return {
+      count: all.length,
+      oldest: Math.min(...timestamps),
+      newest: Math.max(...timestamps)
+    };
+  } catch (error) {
+    console.error('获取缓存统计失败:', error);
+    return { count: 0, oldest: null, newest: null };
+  }
+};
+
+export const CacheDepartmentInfo = {
+  /**
+ * 获取所有部门信息
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 部门信息数组
+ */
+  getDepartmentList,
+  /**
+ * 获取扁平化的部门列表（包含所有子部门）
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 扁平化的部门信息数组
+ */
+  getFlatDepartmentList,
+  /**
+ * 根据部门ID获取部门信息
+ * @param deptId 部门ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 部门信息或null
+ */
+  getDepartmentById,
+  /**
+ * 根据部门ID获取部门名称
+ * @param deptId 部门ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 部门名称或空字符串
+ */
+  getDepartmentNameById,
+  /**
+ * 清除部门缓存
+ */
+  clearDepartmentCache,
+  /**
+ * 获取缓存统计信息
+ * @returns 缓存统计信息
+ */
+  getCacheStats
+};

package/src/utils/CacheFileContent.ts

@@ -0,0 +1,315 @@
+'use strict';
+
+import Dexie, { Table } from 'dexie';
+import * as febs from 'febs-browser';
+
+interface FileCacheRecord {
+  id: string;
+  fileId: string;
+  /** 文件内容使用 ArrayBuffer 存储 —— Safari 对 IndexedDB 中 Blob 的序列化/反序列化存在兼容性问题
+   *  （Blob 可能变成 size=0 空对象或在 GC 后变成 detached 状态），而 ArrayBuffer 是纯二进制数据，
+   *  在所有浏览器（包括 Safari）的 IndexedDB 中都能可靠存取。
+   *  读取时通过 `new Blob([arrayBuffer], { type: contentType })` 重新构造 Blob。 */
+  content: ArrayBuffer;
+  crc32: number;
+  fileSize: number;
+  /** 单独存储的 MIME 类型（字符串持久化不受 Safari IndexedDB Blob.type 丢失 Bug 影响） */
+  contentType: string;
+  updateTime: number;
+}
+
+/** 服务器文件元数据缓存记录（用于离线时重建文件列表） */
+interface FileMetaRecord {
+  id: string;
+  fileId: string;
+  projectId: string;
+  /** 完整 ProjectFile 对象（序列化后） */
+  meta: any;
+  updateTime: number;
+}
+
+class FileContentDatabase extends Dexie {
+  fileCache!: Table<FileCacheRecord, string>;
+  fileMeta!: Table<FileMetaRecord, string>;
+
+  constructor() {
+    super('FileContentDB');
+    this.version(1).stores({
+      fileCache: 'id, fileId, crc32, fileSize, updateTime'
+    });
+    // v2: 新增 fileMeta store，用于离线显示缓存文件元数据
+    this.version(2).stores({
+      fileCache: 'id, fileId, crc32, fileSize, updateTime',
+      fileMeta: 'id, fileId, projectId, updateTime',
+    });
+  }
+}
+
+const db = new FileContentDatabase();
+
+const calculateCrc32 = async (blob: Blob): Promise<number> => {
+  return new Promise((resolve, reject) => {
+    const file = new File([blob], 'temp');
+    febs.crypt.crc32_file(file as unknown as File, (crc: number) => {
+      if (crc === 0) {
+        reject(new Error('CRC32 计算失败'));
+      } else {
+        resolve(crc);
+      }
+    });
+  });
+};
+
+const getCacheRecord = async (fileId: string): Promise<FileCacheRecord | undefined> => {
+  try {
+    const records = await db.fileCache.where('fileId').equals(fileId).toArray();
+    return records.length > 0 ? records[0] : undefined;
+  } catch (error) {
+    console.error('读取文件缓存失败:', error);
+    return undefined;
+  }
+};
+
+const saveToCache = async (fileId: string, content: Blob, crc32?: number, fileSize?: number, contentType?: string): Promise<void> => {
+  try {
+    const actualCrc32 = crc32 ?? await calculateCrc32(content);
+    const actualSize = fileSize ?? content.size;
+    // 显式传入的 contentType 优先；否则用 Blob.type（注意：Safari IndexedDB 回读后 Blob.type 可能丢失，所以必须独立保存）
+    const actualContentType = contentType ?? content.type ?? '';
+    
+    // 关键修复：将 Blob 转为 ArrayBuffer 存储，避免 Safari IndexedDB Blob 损坏问题
+    // ArrayBuffer 是纯二进制数据，在 Safari IndexedDB 中可靠存取
+    const arrayBuffer = await content.arrayBuffer();
+    
+    // 先删除旧记录，确保同一个fileId只有一条记录
+    await db.fileCache.where('fileId').equals(fileId).delete();
+    
+    const record: FileCacheRecord = {
+      id: fileId,
+      fileId,
+      content: arrayBuffer,
+      crc32: actualCrc32,
+      fileSize: actualSize,
+      contentType: actualContentType,
+      updateTime: Date.now(),
+    };
+    
+    await db.fileCache.put(record);
+  } catch (error) {
+    console.error('写入文件缓存失败:', error);
+  }
+};
+
+const removeFromCache = async (fileId: string): Promise<void> => {
+  try {
+    await db.fileCache.where('fileId').equals(fileId).delete();
+  } catch (error) {
+    console.error('删除文件缓存失败:', error);
+  }
+};
+
+const hasCache = async (fileId: string): Promise<boolean> => {
+  const record = await getCacheRecord(fileId);
+  return record !== undefined;
+};
+
+const getCachedContent = async (fileId: string): Promise<{ content: Blob; crc32: number; contentType: string } | null> => {
+  const record = await getCacheRecord(fileId);
+  if (!record) {
+    console.log('[CacheFileContent] getCachedContent: 无缓存记录 fileId=', fileId);
+    return null;
+  }
+
+  // 读取兼容处理：
+  //   新版本：record.content 是 ArrayBuffer（Safari 兼容存储方式）
+  //   旧版本：record.content 可能是 Blob（之前的存储方式，Safari 可能已损坏）
+  // 为了兼容旧数据，检测类型后统一转为 ArrayBuffer，再构造 Blob
+  const safeContentType = record.contentType ?? '';
+  let blob: Blob;
+
+  if (record.content instanceof ArrayBuffer) {
+    // 新版本：直接从 ArrayBuffer 构造 Blob
+    blob = new Blob([record.content], { type: safeContentType });
+    console.log('[CacheFileContent] getCachedContent: fileId=', fileId,
+      '[ArrayBuffer] byteLength=', record.content.byteLength,
+      'reconstructedBlob.size=', blob.size,
+      'contentType=', safeContentType);
+  } else if ((record.content as any) instanceof Blob) {
+    // 旧版本：兼容处理。检测旧 Blob 是否在 Safari 中已损坏
+    const oldBlob = record.content as unknown as Blob;
+    if (oldBlob.size === 0) {
+      console.warn('[CacheFileContent] getCachedContent: 旧 Blob 已损坏 (size=0)，将删除缓存并重新下载');
+      await removeFromCache(fileId);
+      return null;
+    }
+    // 将旧 Blob 转换为 ArrayBuffer 再重建 Blob，确保数据完整性
+    try {
+      const ab = await oldBlob.arrayBuffer();
+      blob = new Blob([ab], { type: safeContentType || oldBlob.type });
+      console.log('[CacheFileContent] getCachedContent: fileId=', fileId,
+        '[Blob→ArrayBuffer] size=', blob.size,
+        'contentType=', safeContentType);
+      // 迁移：将旧 Blob 记录转换为 ArrayBuffer 存储
+      await saveToCache(fileId, blob, record.crc32, record.fileSize, safeContentType || oldBlob.type);
+    } catch (e) {
+      console.warn('[CacheFileContent] getCachedContent: 旧 Blob 读取失败，删除缓存:', e);
+      await removeFromCache(fileId);
+      return null;
+    }
+  } else {
+    // 未知类型，删除缓存
+    console.warn('[CacheFileContent] getCachedContent: 未知 content 类型，删除缓存');
+    await removeFromCache(fileId);
+    return null;
+  }
+
+  return { content: blob, crc32: record.crc32, contentType: safeContentType };
+};
+
+const validateCache = async (fileId: string, expectedCrc32: number): Promise<boolean> => {
+  const record = await getCacheRecord(fileId);
+  if (!record) {
+    console.log('[CacheFileContent] validateCache: 无缓存记录 fileId=', fileId);
+    return false;
+  }
+  // Safari 调试：输出 crc32 的类型和值，排查类型不一致问题
+  const storedCrc32 = record.crc32;
+  const expected = expectedCrc32;
+  const isMatch = storedCrc32 === expected;
+  if (!isMatch) {
+    console.warn('[CacheFileContent] validateCache: crc32 不匹配',
+      'stored=', storedCrc32, typeof storedCrc32,
+      'expected=', expected, typeof expected);
+  }
+  return isMatch;
+};
+
+const clearAllCache = async (): Promise<void> => {
+  try {
+    await db.fileCache.clear();
+  } catch (error) {
+    console.error('清除所有文件缓存失败:', error);
+  }
+};
+
+const getCacheStats = async (): Promise<{ fileCount: number; totalSize: number; oldestTime: number | null; newestTime: number | null }> => {
+  try {
+    const all = await db.fileCache.toArray();
+    if (all.length === 0) {
+      return { fileCount: 0, totalSize: 0, oldestTime: null, newestTime: null };
+    }
+    const totalSize = all.reduce((sum, record) => sum + record.fileSize, 0);
+    const updateTimes = all.map(record => record.updateTime);
+    return {
+      fileCount: all.length,
+      totalSize,
+      oldestTime: Math.min(...updateTimes),
+      newestTime: Math.max(...updateTimes),
+    };
+  } catch (error) {
+    console.error('获取文件缓存统计失败:', error);
+    return { fileCount: 0, totalSize: 0, oldestTime: null, newestTime: null };
+  }
+};
+
+const getCacheList = async (): Promise<{ fileId: string; crc32: number; fileSize: number; updateTime: number }[]> => {
+  try {
+    const all = await db.fileCache.toArray();
+    return all.map(record => ({
+      fileId: record.fileId,
+      crc32: record.crc32,
+      fileSize: record.fileSize,
+      updateTime: record.updateTime,
+    }));
+  } catch (error) {
+    console.error('获取文件缓存列表失败:', error);
+    return [];
+  }
+};
+
+export const CacheFileContent = {
+  saveToCache,
+  removeFromCache,
+  hasCache,
+  getCachedContent,
+  validateCache,
+  clearAllCache,
+  getCacheStats,
+  getCacheList,
+};
+
+// ============================================================
+// 服务器文件元数据缓存（FileMeta store）— 用于离线时重建文件列表
+// ============================================================
+
+/** 批量保存/更新服务器文件元数据（online 时每次 listFiles 后调用） */
+const saveFileMetaBatch = async (projectId: string, files: any[]): Promise<void> => {
+  try {
+    if (!files || files.length === 0) return;
+    const now = Date.now();
+    const records: FileMetaRecord[] = files.map(f => ({
+      id: f.id,
+      fileId: f.id,
+      projectId,
+      meta: f,
+      updateTime: now,
+    }));
+    await db.fileMeta.bulkPut(records);
+  } catch (error) {
+    console.error('批量保存文件元数据缓存失败:', error);
+  }
+};
+
+/** 保存单个文件元数据（预览/编辑单个文件时调用） */
+const saveFileMeta = async (projectId: string, file: any): Promise<void> => {
+  try {
+    await db.fileMeta.put({
+      id: file.id,
+      fileId: file.id,
+      projectId,
+      meta: file,
+      updateTime: Date.now(),
+    });
+  } catch (error) {
+    console.error('保存文件元数据缓存失败:', error);
+  }
+};
+
+/** 按项目列出所有缓存过的文件元数据（offline 时用于重建列表） */
+const listFileMetaByProject = async (projectId: string): Promise<any[]> => {
+  try {
+    const records = await db.fileMeta.where('projectId').equals(projectId).toArray();
+    return records.map(r => r.meta);
+  } catch (error) {
+    console.error('列出项目文件元数据缓存失败:', error);
+    return [];
+  }
+};
+
+/** 按 fileId 获取单个元数据 */
+const getFileMeta = async (fileId: string): Promise<any | undefined> => {
+  try {
+    const records = await db.fileMeta.where('fileId').equals(fileId).toArray();
+    return records.length > 0 ? records[0].meta : undefined;
+  } catch (error) {
+    console.error('获取文件元数据缓存失败:', error);
+    return undefined;
+  }
+};
+
+/** 删除单个文件的元数据 */
+const removeFileMeta = async (fileId: string): Promise<void> => {
+  try {
+    await db.fileMeta.where('fileId').equals(fileId).delete();
+  } catch (error) {
+    console.error('删除文件元数据缓存失败:', error);
+  }
+};
+
+export const CacheFileMeta = {
+  saveFileMetaBatch,
+  saveFileMeta,
+  listFileMetaByProject,
+  getFileMeta,
+  removeFileMeta,
+};