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

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

import { computed } from "vue";
import type { AppName, FileServiceConfig } from "../types";
import { useFileInput } from "./useFileInput";
import { useFileUploader } from "./useFileUploader";
import { useFileStorage } from "./useFileStorage";
import { inject } from "vue";
import { FileServiceConfigManager } from "../config/FileServiceConfigManager";

export function useFileService(config?: Partial<FileServiceConfig>) {
  // Пытаемся получить глобальную конфигурацию из Vue provide
  const globalConfig = inject<FileServiceConfig | null>(
    "fileServiceConfig",
    null
  );
  const configManager = inject<FileServiceConfigManager | null>(
    "fileServiceConfigManager",
    null
  );

  // Объединяем конфигурации: глобальная + переданная
  const finalConfig: FileServiceConfig = {
    ...(globalConfig || FileServiceConfigManager.getInstance().getConfig()),
    ...config,
  };

  // Инициализируем composables с финальной конфигурацией
  const fileInput = useFileInput({
    maxFiles: finalConfig.maxFiles,
    maxFileSize: finalConfig.maxFileSize,
    allowedTypes: finalConfig.allowedTypes,
    multiple: finalConfig.multiple,
  });

  const fileUploader = useFileUploader({
    apiUrl: finalConfig.apiUrl,
    appName: finalConfig.appName,
    headers: finalConfig.headers,
    timeout: finalConfig.timeout,
    onProgress: finalConfig.onProgress,
    onError: finalConfig.onError,
  });

  const fileStorage = useFileStorage({
    appName: finalConfig.appName,
    maxStoredFiles: finalConfig.maxStoredFiles || 100,
  });

  // Computed свойства для общего состояния
  const isReady = computed(
    () =>
      fileInput.selectedFiles.value.length > 0 &&
      !fileUploader.isUploading.value
  );

  const hasSelectedFiles = computed(() => fileInput.isFileSelected.value);
  const hasUploads = computed(() => fileUploader.hasUploads.value);
  const hasErrors = computed(
    () => fileInput.errors.value.length > 0 || fileUploader.hasErrors.value
  );

  // Вспомогательный метод для вызова callback
  const callUploadSuccess = (results: any[]) => {
    if (finalConfig.onUploadSuccess) {
      finalConfig.onUploadSuccess(results);
    }
  };

  // Вспомогательный метод для сохранения файлов в localStorage
  const saveFilesToStorage = (results: any[], originalFiles: File[]) => {
    try {
      fileStorage.addStoredFiles(results, originalFiles);
      // Очищаем предыдущие выбранные файлы и добавляем новые загруженные файлы
      fileStorage.clearSelectedStoredFiles();
      results.forEach((result, index) => {
        const originalFile = originalFiles[index];
        if (originalFile) {
          const storedFile = {
            id: result.id.toString(),
            originalName: originalFile.name,
            url: result.url || "",
            size: originalFile.size,
            type: originalFile.type,
            uploadedAt: new Date().toISOString(),
            appName: finalConfig.appName,
          };
          fileStorage.addSelectedStoredFile(storedFile);
        }
      });
    } catch (error) {
      console.error("Ошибка при сохранении файлов в localStorage:", error);
    }
  };

  // Методы для работы с файлами
  const selectFiles = (files: FileList | File[]) => {
    fileInput.selectFiles(files);
  };

  const removeFile = (index: number) => {
    fileInput.removeFile(index);
  };

  const removeFileByName = (fileName: string) => {
    fileInput.removeFileByName(fileName);
  };

  const clearFiles = () => {
    fileInput.clearFiles();
  };

  const replaceFile = (oldFile: File, newFile: File) => {
    return fileInput.replaceFile(oldFile, newFile);
  };

  // Методы для загрузки
  const uploadSelectedFiles = async () => {
    if (fileInput.selectedFiles.value.length === 0) {
      throw new Error("Нет выбранных файлов для загрузки");
    }

    try {
      const results = await fileUploader.uploadFiles(
        fileInput.selectedFiles.value
      );
      callUploadSuccess(results);
      // Сохраняем файлы в localStorage
      saveFilesToStorage(results, fileInput.selectedFiles.value);
      // Очищаем выбранные файлы после успешной загрузки
      fileInput.clearFiles();
      return results;
    } catch (error) {
      throw error;
    }
  };

  const uploadFile = async (file: File) => {
    try {
      const results = await fileUploader.uploadFile(file);
      callUploadSuccess(results);
      // Сохраняем файл в localStorage
      saveFilesToStorage(results, [file]);
      return results;
    } catch (error) {
      throw error;
    }
  };

  const uploadFiles = async (files: File[]) => {
    try {
      const results = await fileUploader.uploadFiles(files);
      callUploadSuccess(results);
      // Сохраняем файлы в localStorage
      saveFilesToStorage(results, files);
      return results;
    } catch (error) {
      throw error;
    }
  };

  // Методы для управления загрузками
  const retryUpload = (uploadId: string) => {
    return fileUploader.retryUpload(uploadId);
  };

  const removeUpload = (uploadId: string) => {
    fileUploader.removeUpload(uploadId);
  };

  const clearUploads = () => {
    fileUploader.clearUploads();
  };

  const clearCompletedUploads = () => {
    fileUploader.clearCompletedUploads();
  };

  const clearFailedUploads = () => {
    fileUploader.clearFailedUploads();
  };

  // Методы для управления ошибками
  const clearErrors = () => {
    fileInput.clearErrors();
  };

  // Методы для получения состояния
  const getUploadState = (uploadId: string) => {
    return fileUploader.uploads.value.get(uploadId);
  };

  const getAllUploadStates = () => {
    return Array.from(fileUploader.uploads.value.values());
  };

  // Методы для получения статистики
  const getUploadStats = () => {
    const totalUploads = fileUploader.uploads.value.size;
    const stats = {
      total: totalUploads, // Используем общее количество загрузок
      pending: fileUploader.pendingUploads.value.length,
      uploading: fileUploader.uploadingFiles.value.length,
      completed: fileUploader.completedUploads.value.length,
      failed: fileUploader.failedUploads.value.length,
      totalProgress: fileUploader.totalProgress.value,
    };

    return stats;
  };

  return {
    // Конфигурация
    config: finalConfig,

    // Состояние input
    selectedFiles: fileInput.selectedFiles,
    errors: fileInput.errors,
    isFileSelected: fileInput.isFileSelected,
    totalSize: fileInput.totalSize,
    fileTypes: fileInput.fileTypes,
    canSelectMore: fileInput.canSelectMore,

    // Состояние загрузок
    uploads: fileUploader.uploads,
    isUploading: fileUploader.isUploading,
    totalProgress: fileUploader.totalProgress,

    // Computed свойства
    isReady,
    hasSelectedFiles,
    hasUploads,
    hasErrors,

    // Методы для работы с файлами
    selectFiles,
    removeFile,
    removeFileByName,
    clearFiles,
    replaceFile,

    // Методы для загрузки
    uploadSelectedFiles,
    uploadFile,
    uploadFiles,

    // Методы для управления загрузками
    retryUpload,
    removeUpload,
    clearUploads,
    clearCompletedUploads,
    clearFailedUploads,

    // Методы для управления ошибками
    clearErrors,

    // Методы для получения состояния
    getUploadState,
    getAllUploadStates,
    getUploadStats,

    // Методы для работы с хранилищем
    storedFiles: fileStorage.storedFiles,
    appStoredFiles: fileStorage.appStoredFiles,
    selectedStoredFiles: fileStorage.selectedStoredFiles,
    tempSelectedStoredFiles: fileStorage.tempSelectedStoredFiles,
    hasStoredFiles: fileStorage.hasStoredFiles,
    storedFilesCount: fileStorage.storedFilesCount,
    addStoredFile: fileStorage.addStoredFile,
    addStoredFiles: fileStorage.addStoredFiles,
    removeStoredFile: fileStorage.removeStoredFile,
    removeStoredFileByName: fileStorage.removeStoredFileByName,
    clearStoredFiles: fileStorage.clearStoredFiles,
    clearAppStoredFiles: fileStorage.clearAppStoredFiles,
    addSelectedStoredFile: fileStorage.addSelectedStoredFile,
    removeSelectedStoredFile: fileStorage.removeSelectedStoredFile,
    clearSelectedStoredFiles: fileStorage.clearSelectedStoredFiles,
    isStoredFileSelected: fileStorage.isStoredFileSelected,
    addTempSelectedStoredFile: fileStorage.addTempSelectedStoredFile,
    removeTempSelectedStoredFile: fileStorage.removeTempSelectedStoredFile,
    clearTempSelectedStoredFiles: fileStorage.clearTempSelectedStoredFiles,
    isTempStoredFileSelected: fileStorage.isTempStoredFileSelected,
    confirmTempSelection: fileStorage.confirmTempSelection,
    findStoredFile: fileStorage.findStoredFile,
    findStoredFileByName: fileStorage.findStoredFileByName,
    getStoredFilesByType: fileStorage.getStoredFilesByType,
    getStoredFilesByDateRange: fileStorage.getStoredFilesByDateRange,
    exportStoredFiles: fileStorage.exportStoredFiles,
    importStoredFiles: fileStorage.importStoredFiles,

    // Доступ к внутренним composables (для расширенного использования)
    fileInput,
    fileUploader,
    fileStorage,
  };
}