barneo-file-service/src/composables/useFileStorage.ts

Комплексная библиотека Vue 3 для работы с файлами в приложениях Barneo. Предоставляет мощную функциональность для загрузки, управления и обработки файлов с валидацией, отслеживанием прогресса и поддержкой localStorage.

import { ref, computed, watch } from "vue";
import type { FileUploadResponse } from "../types";

export interface StoredFile {
  id: string;
  originalName: string;
  url: string;
  size: number;
  type: string;
  uploadedAt: string;
  appName: string;
}

export interface FileStorageOptions {
  storageKey?: string;
  maxStoredFiles?: number;
  appName?: string;
}

export function useFileStorage(options: FileStorageOptions = {}) {
  const {
    storageKey = "barneo-file-service-stored-files",
    maxStoredFiles = 100,
    appName = "default",
  } = options;

  // Состояние
  const storedFiles = ref<StoredFile[]>([]);
  const selectedStoredFiles = ref<StoredFile[]>([]);
  const tempSelectedStoredFiles = ref<StoredFile[]>([]);
  const isLoading = ref(false);

  // Computed свойства
  const hasStoredFiles = computed(() => storedFiles.value.length > 0);
  const storedFilesCount = computed(() => storedFiles.value.length);

  // Фильтр по appName
  const appStoredFiles = computed(() =>
    storedFiles.value.filter((file) => file.appName === appName)
  );

  // Методы
  const loadStoredFiles = () => {
    try {
      isLoading.value = true;
      const stored = localStorage.getItem(storageKey);
      if (stored) {
        const parsed = JSON.parse(stored);
        storedFiles.value = Array.isArray(parsed) ? parsed : [];
      }
    } catch (error) {
      console.error("Ошибка при загрузке файлов из localStorage:", error);
      storedFiles.value = [];
    } finally {
      isLoading.value = false;
    }
  };

  const saveStoredFiles = () => {
    try {
      localStorage.setItem(storageKey, JSON.stringify(storedFiles.value));
    } catch (error) {
      console.error("Ошибка при сохранении файлов в localStorage:", error);
    }
  };

  const addStoredFile = (
    fileResponse: FileUploadResponse,
    originalFile: File
  ) => {
    const storedFile: StoredFile = {
      id: fileResponse.id.toString(),
      originalName: originalFile.name,
      url: fileResponse.url || "",
      size: originalFile.size,
      type: originalFile.type,
      uploadedAt: new Date().toISOString(),
      appName,
    };

    // Добавляем файл в начало списка
    storedFiles.value.unshift(storedFile);

    // Ограничиваем количество хранимых файлов
    if (storedFiles.value.length > maxStoredFiles) {
      storedFiles.value = storedFiles.value.slice(0, maxStoredFiles);
    }

    saveStoredFiles();
  };

  const addStoredFiles = (
    fileResponses: FileUploadResponse[],
    originalFiles: File[]
  ) => {
    fileResponses.forEach((response, index) => {
      const originalFile = originalFiles[index];
      if (originalFile) {
        addStoredFile(response, originalFile);
      }
    });
  };

  const removeStoredFile = (fileId: string) => {
    const index = storedFiles.value.findIndex((file) => file.id === fileId);
    if (index !== -1) {
      storedFiles.value.splice(index, 1);
      saveStoredFiles();
    }
  };

  const removeStoredFileByName = (fileName: string) => {
    const index = storedFiles.value.findIndex(
      (file) => file.originalName === fileName
    );
    if (index !== -1) {
      storedFiles.value.splice(index, 1);
      saveStoredFiles();
    }
  };

  const clearStoredFiles = () => {
    storedFiles.value = [];
    saveStoredFiles();
  };

  const clearAppStoredFiles = () => {
    storedFiles.value = storedFiles.value.filter(
      (file) => file.appName !== appName
    );
    saveStoredFiles();
  };

  // Методы для работы с выбранными файлами
  const addSelectedStoredFile = (storedFile: StoredFile) => {
    const exists = selectedStoredFiles.value.find(
      (file) => file.id === storedFile.id
    );
    if (!exists) {
      selectedStoredFiles.value.push(storedFile);
    }
  };

  const removeSelectedStoredFile = (fileId: string) => {
    selectedStoredFiles.value = selectedStoredFiles.value.filter(
      (file) => file.id !== fileId
    );
  };

  const clearSelectedStoredFiles = () => {
    selectedStoredFiles.value = [];
  };

  const isStoredFileSelected = (fileId: string) => {
    return selectedStoredFiles.value.some((file) => file.id === fileId);
  };

  // Методы для работы с временными выбранными файлами
  const addTempSelectedStoredFile = (storedFile: StoredFile) => {
    const exists = tempSelectedStoredFiles.value.find(
      (file) => file.id === storedFile.id
    );
    if (!exists) {
      tempSelectedStoredFiles.value.push(storedFile);
    }
  };

  const removeTempSelectedStoredFile = (fileId: string) => {
    tempSelectedStoredFiles.value = tempSelectedStoredFiles.value.filter(
      (file) => file.id !== fileId
    );
  };

  const clearTempSelectedStoredFiles = () => {
    tempSelectedStoredFiles.value = [];
  };

  const isTempStoredFileSelected = (fileId: string) => {
    return tempSelectedStoredFiles.value.some((file) => file.id === fileId);
  };

  const confirmTempSelection = () => {
    selectedStoredFiles.value = [...tempSelectedStoredFiles.value];
    clearTempSelectedStoredFiles();
  };

  const findStoredFile = (fileId: string): StoredFile | undefined => {
    return storedFiles.value.find((file) => file.id === fileId);
  };

  const findStoredFileByName = (fileName: string): StoredFile | undefined => {
    return storedFiles.value.find((file) => file.originalName === fileName);
  };

  const getStoredFilesByType = (fileType: string): StoredFile[] => {
    return storedFiles.value.filter((file) => file.type.startsWith(fileType));
  };

  const getStoredFilesByDateRange = (
    startDate: Date,
    endDate: Date
  ): StoredFile[] => {
    return storedFiles.value.filter((file) => {
      const uploadedAt = new Date(file.uploadedAt);
      return uploadedAt >= startDate && uploadedAt <= endDate;
    });
  };

  const exportStoredFiles = (): string => {
    return JSON.stringify(storedFiles.value, null, 2);
  };

  const importStoredFiles = (jsonData: string) => {
    try {
      const parsed = JSON.parse(jsonData);
      if (Array.isArray(parsed)) {
        storedFiles.value = parsed;
        saveStoredFiles();
        return true;
      }
      return false;
    } catch (error) {
      console.error("Ошибка при импорте файлов:", error);
      return false;
    }
  };

  // Автоматически сохраняем файлы при изменении
  watch(storedFiles, saveStoredFiles, { deep: true });

  // Загружаем файлы при инициализации
  loadStoredFiles();

  return {
    // Состояние
    storedFiles,
    selectedStoredFiles,
    tempSelectedStoredFiles,
    isLoading,

    // Computed
    hasStoredFiles,
    storedFilesCount,
    appStoredFiles,

    // Методы
    loadStoredFiles,
    saveStoredFiles,
    addStoredFile,
    addStoredFiles,
    removeStoredFile,
    removeStoredFileByName,
    clearStoredFiles,
    clearAppStoredFiles,
    addSelectedStoredFile,
    removeSelectedStoredFile,
    clearSelectedStoredFiles,
    isStoredFileSelected,
    addTempSelectedStoredFile,
    removeTempSelectedStoredFile,
    clearTempSelectedStoredFiles,
    isTempStoredFileSelected,
    confirmTempSelection,
    findStoredFile,
    findStoredFileByName,
    getStoredFilesByType,
    getStoredFilesByDateRange,
    exportStoredFiles,
    importStoredFiles,
  };
}