Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

13.8 KB
Raw Blame
import { useState, useCallback, useRef, ReactNode } from 'react';
import { useQuery } from '@tanstack/react-query';
import { useNavigate } from 'react-router';
import { toast } from 'react-toastify';
import Icon from '../../common/Icon/Icon';
import FileIcon from '../../common/FileIcon/FileIcon';
import Select from '../../common/form/Select/Select';
import ActionModal from '../../common/ActionModal/ActionModal';
import { Backup, BackupMirror } from '../../../@types/backups';
import { useRestoreBackup } from '../../../services/restores';
import { useBrowseSnapshot } from '../../../services/backups';
import { FileItem } from '../../../@types/system';
import { isMobile, formatBytes, timeAgo } from '../../../utils/helpers';
import SnapshotBrowserToolbar from '../../common/SnapshotBrowser/SnapshotBrowserToolbar';
import SnapshotBrowserDirectories from '../../common/SnapshotBrowser/SnapshotBrowserDirectories';
import SnapshotBrowserFileList from '../../common/SnapshotBrowser/SnapshotBrowserFileList';
import SnapshotViewerFile from './SnapshotViewerFile';
import { useSnapshotDatabase } from '../../common/SnapshotBrowser/hooks/useSnapshotDatabase';
import { useSnapshotNavigation } from '../../common/SnapshotBrowser/hooks/useSnapshotNavigation';
import { useSnapshotSort } from '../../common/SnapshotBrowser/hooks/useSnapshotSort';
import classes from '../../common/SnapshotBrowser/SnapshotBrowser.module.scss';
import Upgrade from '../../Upgrade/Upgrade';

interface SnapshotViewerProps {
   files: FileItem[];
   backup: Backup;
   planId: string;
   isSync?: boolean;
   mirrors?: BackupMirror[];
   onClose: () => void;
   replicationId?: string;
   toolbarLeftContent?: ReactNode;
   toolbarRightContent?: ReactNode;
   isExternalLoading?: boolean;
   /** Render additional action buttons per file row (e.g. View, Download, Compare in Pro). */
   renderFileActions?: (file: FileItem, meta: { fileExtension: string; isDirectory: boolean }) => ReactNode;
   /** Hides the per-file Restore action. */
   hideRestore?: boolean;
   /** Extra elements rendered at the end (e.g. BackupFileLoader modal in Pro). */
   children?: ReactNode;
   primaryStorage?: { id: string; type: string; name: string };
   /** Called when the user selects a different storage mirror. Receives the replicationId (or undefined for primary). */
   onStorageChange?: (replicationId: string | undefined) => void;
}

const isMobileDevice = isMobile();
const GRID_COLUMNS = '1fr 120px minmax(100px, auto) 120px';
const GRID_COLUMNS_SYNC = '1fr 120px minmax(100px, auto)';

const SnapshotViewer = ({
   files,
   backup,
   planId,
   isSync = false,
   mirrors,
   onClose,
   replicationId,
   toolbarLeftContent,
   toolbarRightContent,
   isExternalLoading,
   renderFileActions,
   hideRestore = false,
   children,
   primaryStorage,
   onStorageChange,
}: SnapshotViewerProps) => {
   const [search, setSearch] = useState('');
   const [showRestoreModal, setShowRestoreModal] = useState<FileItem | false>(false);
   const [selectedReplicationId, setSelectedReplicationId] = useState<string | undefined>(replicationId);
   const [currentFiles, setCurrentFiles] = useState<FileItem[]>(files);
   const [showUpgrade, setShowUpgrade] = useState<boolean>(false);
   const fileListRef = useRef<HTMLDivElement | null>(null);
   const navigate = useNavigate();

   const backupId = backup.id;
   const restoreMutation = useRestoreBackup();
   const browseSnapshotMutation = useBrowseSnapshot();
   const useProgressiveLoading = currentFiles.length > 1000;

   const { db, initError, discoveredDirectories, expandedFolders, setExpandedFolders, addDirectoriesSorted } = useSnapshotDatabase(
      currentFiles,
      backupId,
      useProgressiveLoading,
   );

   const { selectedFolder, handleGoUp, handleDirectoryClick, toggleFolder, isVisible, hasSubdirectories } = useSnapshotNavigation(
      discoveredDirectories,
      expandedFolders,
      setExpandedFolders,
   );

   const { sortField, sortDirection, handleSort } = useSnapshotSort();

   // Handle storage change - re-browse from selected mirror
   const handleStorageChange = useCallback(
      (replicationIdValue?: string) => {
         setSelectedReplicationId(replicationIdValue);
         onStorageChange?.(replicationIdValue);
         if (replicationIdValue) {
            browseSnapshotMutation.mutate(
               { backupId: backup.id, replicationId: replicationIdValue },
               {
                  onSuccess: (data: any) => {
                     if (data?.result) {
                        setCurrentFiles(data.result);
                     }
                  },
               },
            );
         } else {
            setCurrentFiles(files);
         }
      },
      [backup.id, files, browseSnapshotMutation, onStorageChange],
   );

   // Build storage selector for toolbar
   const completedMirrors = mirrors?.filter((m) => m.status === 'completed') || [];
   const showStorageDropdown = primaryStorage && completedMirrors.length > 0;

   const storageSelector = showStorageDropdown ? (
      <Select
         customClasses={classes.storageSelect}
         options={[
            { label: primaryStorage!.name + ' (Primary)', value: 'primary', image: <img src={`/providers/${primaryStorage.type}.png`} /> },
            ...completedMirrors.map((m) => ({
               label: m.storageName + ' (Mirror)',
               value: m.replicationId,
               image: <img src={`/providers/${m.storageType}.png`} />,
            })),
         ]}
         fieldValue={selectedReplicationId || 'primary'}
         onUpdate={(value) => handleStorageChange(value === 'primary' ? undefined : value)}
         disabled={browseSnapshotMutation.isPending}
      />
   ) : undefined;

   // Directory contents query
   const directoryContentsQuery = useQuery({
      queryKey: ['directoryContents', selectedFolder, sortField, sortDirection, search, backupId],
      queryFn: async () => {
         if (!db || selectedFolder === null) return [];

         const contents = await db.getDirectoryContents(selectedFolder, sortField, sortDirection, search);

         if (useProgressiveLoading) {
            const subdirs = await db.getSubdirectories(selectedFolder);
            if (subdirs.length > 0) {
               addDirectoriesSorted(subdirs);
            }
         }

         if (selectedFolder) {
            return [{ isGoUp: true, path: '..', name: '..', isDirectory: true } as any, ...contents];
         }

         return contents;
      },
      enabled: !!db && selectedFolder !== null,
      staleTime: 30000,
      retry: 1,
   });

   const currentDirectoryFiles = directoryContentsQuery.data || [];
   const isInitializing = !db && !initError;
   const isDirectoryLoading = directoryContentsQuery.isPending;

   // Restore handler
   const restoreFile = (path: string) => {
      restoreMutation.mutate(
         {
            backupId,
            planId,
            target: '',
            includes: [path],
            overwrite: 'always',
            deleteOption: false,
            replicationId: selectedReplicationId,
         },
         {
            onSuccess: (_: any, variables) => {
               toast.success('Restoration Process Started..', { autoClose: 5000 });
               const targetPlanId = variables?.planId;
               if (targetPlanId) {
                  navigate(`/plan/${targetPlanId}?pendingrestore=1`);
               }
               onClose();
            },
            onError: (error) => {
               console.error('Restore error:', error);
               toast.error(`Restore failed. ${error.message || 'Unknown error'}`);
            },
            onSettled: () => {
               setShowRestoreModal(false);
            },
         },
      );
   };

   // File row renderer
   const gridColumns = isSync ? GRID_COLUMNS_SYNC : GRID_COLUMNS;

   const renderFileRow = useCallback(
      ({ index, style }: { index: number; style: React.CSSProperties }) => {
         const file = currentDirectoryFiles[index];
         if (!file) return null;

         return (
            <SnapshotViewerFile
               style={style}
               file={file}
               isSync={isSync}
               gridColumns={gridColumns}
               onGoUp={handleGoUp}
               onDirectoryClick={handleDirectoryClick}
               onRestore={(file) => setShowRestoreModal(file)}
               renderFileActions={renderFileActions}
               hideRestore={hideRestore}
               showUpgradeModal={() => setShowUpgrade(true)}
            />
         );
      },
      [currentDirectoryFiles, isSync, gridColumns, handleGoUp, handleDirectoryClick, renderFileActions, hideRestore],
   );

   // Error state
   if (initError) {
      return (
         <div className={classes.snapshotBrowser}>
            <div className={classes.errorState}>
               <Icon type="error" size={24} />
               <p>Failed to initialize database</p>
               <small>{initError}</small>
               <button onClick={() => window.location.reload()}>Reload Page</button>
            </div>
         </div>
      );
   }

   // Loading state
   if (isInitializing) {
      return (
         <div className={classes.snapshotBrowser}>
            <div className={classes.loadingState}>
               <Icon type="loading" size={24} />
               <p>Indexing snapshot data...</p>
               <small>Building efficient database for {files.length.toLocaleString()} files</small>
            </div>
         </div>
      );
   }

   const defaultToolbarLeft = (
      <div className={classes.stats}>
         <Icon type="box" />
         <strong>backup-{backup.id}</strong> • {formatBytes(backup.totalSize)} • {timeAgo(new Date(backup.ended))}
      </div>
   );

   return (
      <div className={classes.snapshotBrowser}>
         <SnapshotBrowserToolbar
            search={search}
            onSearchChange={setSearch}
            isLoading={isDirectoryLoading || isExternalLoading || browseSnapshotMutation.isPending}
            leftContent={toolbarLeftContent || defaultToolbarLeft}
            rightContent={
               <>
                  {storageSelector}
                  {toolbarRightContent}
               </>
            }
         />

         {isExternalLoading || browseSnapshotMutation.isPending ? (
            <div className={`${classes.browserContent} ${classes.loadingState}`}>
               <div>
                  <Icon type="loading" size={16} /> Loading...
               </div>
            </div>
         ) : (
            <div className={classes.browserContent}>
               <SnapshotBrowserDirectories
                  directories={discoveredDirectories}
                  selectedFolder={selectedFolder}
                  expandedFolders={expandedFolders}
                  useProgressiveLoading={useProgressiveLoading}
                  onDirectoryClick={handleDirectoryClick}
                  onToggleFolder={toggleFolder}
                  isVisible={isVisible}
                  hasSubdirectories={hasSubdirectories}
               />

               <div className={`${classes.content} styled__scrollbar`} ref={fileListRef}>
                  <SnapshotBrowserFileList
                     files={currentDirectoryFiles}
                     height={fileListRef.current?.clientHeight ? fileListRef.current.clientHeight - 45 : 520}
                     itemSize={isMobileDevice ? 65 : 46}
                     headerContent={
                        <>
                           <div onClick={() => handleSort('name')} className={sortField === 'name' ? classes.activeSort : ''}>
                              Name {sortField === 'name' && (sortDirection === 'asc' ? '↑' : '↓')}
                           </div>
                           <div onClick={() => handleSort('modifiedAt')} className={sortField === 'modifiedAt' ? classes.activeSort : ''}>
                              Last Modified {sortField === 'modifiedAt' && (sortDirection === 'asc' ? '↑' : '↓')}
                           </div>
                           <div onClick={() => handleSort('size')} className={sortField === 'size' ? classes.activeSort : ''}>
                              Size {sortField === 'size' && (sortDirection === 'asc' ? '↑' : '↓')}
                           </div>
                           {!isSync && <div className={classes.headerActions}>Actions</div>}
                        </>
                     }
                     renderRow={renderFileRow}
                     selectedFolder={selectedFolder}
                     isLoading={isDirectoryLoading}
                     gridTemplateColumns={gridColumns}
                  />
               </div>
            </div>
         )}

         {showRestoreModal && (
            <ActionModal
               title={`Restore ${showRestoreModal.isDirectory ? 'Directory' : 'File'}`}
               message={
                  <>
                     <p>Are you sure you want to restore this {showRestoreModal.isDirectory ? 'Directory' : 'File'}?</p>
                     <p className={classes.restoreModalFile}>
                        {showRestoreModal.isDirectory ? <Icon type={'fm-directory'} size={16} /> : <FileIcon filename={showRestoreModal.path} />}{' '}
                        {showRestoreModal.path}
                     </p>
                     <p>This action will overwrite the existing file/directory with the same name in the source.</p>
                  </>
               }
               closeModal={() => setShowRestoreModal(false)}
               width="600px"
               primaryAction={{
                  title: `Yes, Restore ${showRestoreModal.isDirectory ? 'Directory' : 'File'}`,
                  type: 'default',
                  isPending: restoreMutation.isPending,
                  action: () => restoreFile(showRestoreModal.path),
               }}
            />
         )}

         {children}
         {showUpgrade && <Upgrade focus="snapshot" onClose={() => setShowUpgrade(false)} />}
      </div>
   );
};

export default SnapshotViewer;