diff --git a/src/app/api/audit/preview-consent/route.ts b/src/app/api/audit/preview-consent/route.ts
new file mode 100644
index 0000000..96373d3
--- /dev/null
+++ b/src/app/api/audit/preview-consent/route.ts
@@ -0,0 +1,68 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { AuditService } from '@/domains/audit/audit-service';
+import { MongoAuditRepository } from '@/infrastructure/database/mongo-audit-repository';
+import { getDb } from '@/infrastructure/database/mongodb';
+import { logger } from '@/lib/logger';
+
+export async function POST(request: NextRequest) {
+ try {
+ const body = await request.json();
+ const { fileId, shareId, mimeType, fileName } = body;
+
+ if (!fileId || !shareId) {
+ return NextResponse.json(
+ { error: 'Missing required fields: fileId and shareId' },
+ { status: 400 }
+ );
+ }
+
+ // Get client IP address
+ const forwarded = request.headers.get('x-forwarded-for');
+ const ipAddress = forwarded ? forwarded.split(',')[0].trim() :
+ request.headers.get('x-real-ip') ||
+ 'unknown';
+
+ // Get user agent
+ const userAgent = request.headers.get('user-agent') || 'unknown';
+
+ // Create audit service with repository
+ const db = await getDb();
+ const auditRepository = new MongoAuditRepository(db);
+ const auditService = new AuditService(auditRepository);
+
+ // Log the preview consent action
+ await auditService.log({
+ action: 'file.preview',
+ targetId: fileId,
+ severity: 'info',
+ metadata: {
+ shareId,
+ mimeType,
+ fileName,
+ userAgent: userAgent.substring(0, 500), // Limit length for storage
+ timestamp: new Date().toISOString(),
+ source: 'share_page',
+ consentType: 'preview_explicit'
+ }
+ }, {
+ ip: ipAddress,
+ userAgent
+ });
+
+ logger.info('Preview consent logged', {
+ fileId,
+ shareId,
+ ipAddress,
+ mimeType
+ });
+
+ return NextResponse.json({ success: true });
+
+ } catch (error) {
+ logger.error('Failed to log preview consent', { error });
+
+ // Return success even if logging fails to not block user experience
+ // but log the error for monitoring
+ return NextResponse.json({ success: true });
+ }
+}
diff --git a/src/app/api/auth/[...all]/route.ts b/src/app/api/auth/[...all]/route.ts
new file mode 100644
index 0000000..e11351a
--- /dev/null
+++ b/src/app/api/auth/[...all]/route.ts
@@ -0,0 +1,4 @@
+import { auth } from "@/lib/auth";
+import { toNextJsHandler } from "better-auth/next-js";
+
+export const { GET, POST } = toNextJsHandler(auth.handler);
diff --git a/src/app/api/health/route.ts b/src/app/api/health/route.ts
index ddb3de3..086f6f7 100644
--- a/src/app/api/health/route.ts
+++ b/src/app/api/health/route.ts
@@ -106,7 +106,7 @@ export async function GET(request: NextRequest) {
/**
* HEAD /api/health - Health check simple (pour les load balancers)
*/
-export async function HEAD(request: NextRequest) {
+export async function HEAD(_request: NextRequest) {
try {
const manager = getHealthCheckManager();
const result = await manager.runAll();
@@ -143,17 +143,18 @@ function generateTextResponse(result: any): string {
if ('checks' in result) {
// Rapport complet
const lines = [
- `Status: ${result.status.toUpperCase()}`,
+ `Status: ${String(result.status).toUpperCase()}`,
`Timestamp: ${result.timestamp}`,
`Response Time: ${result.totalResponseTime}ms`,
- `Uptime: ${Math.floor(result.uptime / 1000)}s`,
+ `Uptime: ${Math.floor(Number(result.uptime) / 1000)}s`,
`Version: ${result.version}`,
'',
'Components:'
];
- for (const check of result.checks) {
- const status = check.status.toUpperCase().padEnd(9);
+ const checks = result.checks as Array>;
+ for (const check of checks) {
+ const status = String(check.status).toUpperCase().padEnd(9);
const responseTime = check.responseTime ? `${check.responseTime}ms`.padStart(6) : ' -';
lines.push(` ${status} ${responseTime} ${check.component} - ${check.message || 'OK'}`);
}
@@ -161,6 +162,6 @@ function generateTextResponse(result: any): string {
return lines.join('\n');
} else {
// Check individuel
- return `${result.status.toUpperCase()} - ${result.component}: ${result.message || 'OK'} (${result.responseTime}ms)`;
+ return `${String(result.status).toUpperCase()} - ${result.component}: ${result.message || 'OK'} (${result.responseTime}ms)`;
}
}
diff --git a/src/app/api/share/[id]/route.ts b/src/app/api/share/[id]/route.ts
index c2d29e8..37ca976 100644
--- a/src/app/api/share/[id]/route.ts
+++ b/src/app/api/share/[id]/route.ts
@@ -1,11 +1,6 @@
import { NextRequest, NextResponse } from 'next/server';
import { MongoFileRepository } from '@/infrastructure/database/mongo-file-repository';
import { MongoShareRepository } from '@/infrastructure/database/mongo-share-repository';
-import { DiskStorageService } from '@/infrastructure/storage/disk-storage-service';
-import { WebCryptoService } from '@/domains/security/web-crypto-service';
-import { FileApplicationService } from '@/application/file-application-service';
-import { QueryFactory } from '@/application/commands';
-import { ConfigurationService, DEFAULT_CONFIGURATION } from '@/domains/shared/configuration';
import { getCacheKey, rateLimiter, withCache } from '@/lib/cache';
import { ShareNotFoundError, FileNotFoundError } from '@/domains/shared';
@@ -45,19 +40,6 @@ export async function GET(
// Initialize services
const fileRepository = new MongoFileRepository();
const shareRepository = new MongoShareRepository();
- const storageService = new DiskStorageService();
- const cryptoService = new WebCryptoService();
- const configService = new ConfigurationService(DEFAULT_CONFIGURATION);
- const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || 'http://localhost:3000';
-
- const fileAppService = new FileApplicationService(
- fileRepository,
- shareRepository,
- storageService,
- cryptoService,
- configService,
- baseUrl
- );
// Find share
const share = await shareRepository.findById(shareId);
diff --git a/src/app/api/upload/route.ts b/src/app/api/upload/route.ts
index 5344669..3020a4f 100644
--- a/src/app/api/upload/route.ts
+++ b/src/app/api/upload/route.ts
@@ -9,20 +9,34 @@ import { FileApplicationService } from '@/application/file-application-service';
import { CommandFactory } from '@/application/commands';
import { ConfigurationService, DEFAULT_CONFIGURATION } from '@/domains/shared/configuration';
import { rateLimiter } from '@/lib/cache';
+import { auth } from '@/lib/auth';
import mime from 'mime-types';
export async function POST(request: NextRequest) {
return serverPerformanceMonitor.measureApiOperation('upload', async () => {
try {
+ // Check authentication (optional - anonymous uploads are allowed)
+ let userId: string | undefined;
+ try {
+ const session = await auth.api.getSession({
+ headers: request.headers,
+ });
+ userId = session?.user?.id;
+ } catch {
+ // Silent fail - anonymous uploads are allowed
+ userId = undefined;
+ }
+
// Get client metadata
const clientIP = request.headers.get('x-forwarded-for') ||
request.headers.get('x-real-ip') ||
'unknown';
const userAgent = request.headers.get('user-agent') || 'unknown';
- // Rate limiting by IP
- const rateLimitKey = `upload:${clientIP}`;
- const { allowed, remaining, resetTime } = rateLimiter.check(rateLimitKey, 10, 60000); // 10 uploads per minute
+ // Rate limiting by IP (more lenient for authenticated users)
+ const rateLimitKey = userId ? `upload:user:${userId}` : `upload:ip:${clientIP}`;
+ const uploadLimit = userId ? 20 : 10; // Authenticated users get higher limit
+ const { allowed, remaining, resetTime } = rateLimiter.check(rateLimitKey, uploadLimit, 60000);
if (!allowed) {
return NextResponse.json(
@@ -43,11 +57,10 @@ export async function POST(request: NextRequest) {
const file = formData.get('file') as File;
const originalName = formData.get('originalName') as string;
let mimeType = formData.get('mimeType') as string;
- const size = Number(formData.get('size'));
const expirationHours = formData.get('expirationHours') ? Number(formData.get('expirationHours')) : undefined;
const maxDownloads = formData.get('maxDownloads') ? Number(formData.get('maxDownloads')) : undefined;
const passwordProtected = formData.get('passwordProtected') === 'true';
- let password: string | undefined = formData.get('password') as string | null || undefined;
+ const password: string | undefined = formData.get('password') as string | null || undefined;
// Use mime-types library for proper MIME type detection
if (!mimeType || mimeType === 'application/octet-stream') {
@@ -93,7 +106,8 @@ export async function POST(request: NextRequest) {
password,
metadata: {
userAgent,
- ipAddress: clientIP
+ ipAddress: clientIP,
+ userId // Include userId if authenticated
}
});
diff --git a/src/app/api/user/files/[fileId]/route.ts b/src/app/api/user/files/[fileId]/route.ts
new file mode 100644
index 0000000..6d92db6
--- /dev/null
+++ b/src/app/api/user/files/[fileId]/route.ts
@@ -0,0 +1,153 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { MongoFileRepository } from '@/infrastructure/database/mongo-file-repository';
+import { MongoShareRepository } from '@/infrastructure/database/mongo-share-repository';
+import { MongoAuditRepository } from '@/infrastructure/database/mongo-audit-repository';
+import { AuditService } from '@/domains/audit/audit-service';
+import { getDb } from '@/infrastructure/database/mongodb';
+import { logger } from '@/lib/logger';
+import { unlink } from 'fs/promises';
+import { join } from 'path';
+
+interface RouteParams {
+ params: {
+ fileId: string;
+ };
+}
+
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+ try {
+ // Check authentication
+ const session = await auth.api.getSession({
+ headers: request.headers,
+ });
+
+ if (!session?.user) {
+ return NextResponse.json(
+ { error: 'Authentication required' },
+ { status: 401 }
+ );
+ }
+
+ const userId = session.user.id;
+ const { fileId } = params;
+
+ if (!fileId) {
+ return NextResponse.json(
+ { error: 'File ID is required' },
+ { status: 400 }
+ );
+ }
+
+ const db = await getDb();
+ const fileRepository = new MongoFileRepository();
+ const shareRepository = new MongoShareRepository();
+ const auditRepository = new MongoAuditRepository(db);
+ const auditService = new AuditService(auditRepository);
+
+ // Check that the file exists and belongs to the user
+ const file = await fileRepository.findById(fileId);
+ if (!file) {
+ return NextResponse.json(
+ { error: 'File not found' },
+ { status: 404 }
+ );
+ }
+
+ if (!file.belongsToUser(userId)) {
+ return NextResponse.json(
+ { error: 'Unauthorized: File does not belong to user' },
+ { status: 403 }
+ );
+ }
+
+ // Supprimer les partages associés
+ try {
+ // Find the share for this file (there's usually only one)
+ const share = await shareRepository.findByFileId(fileId);
+
+ // Supprimer le partage s'il existe
+ if (share) {
+ await shareRepository.delete(share.id);
+
+ // Log share deletion
+ await auditService.logShareEvent(
+ 'share.delete',
+ share.id,
+ {
+ ip: request.headers.get('x-forwarded-for') ||
+ request.headers.get('x-real-ip') ||
+ 'unknown',
+ userAgent: request.headers.get('user-agent') || undefined,
+ userId,
+ },
+ { reason: 'file_deletion', fileName: file.originalName }
+ );
+ }
+ } catch (error) {
+ logger.warn('Failed to delete share during file deletion', {
+ fileId,
+ userId,
+ error
+ });
+ // Continue even if share deletion fails
+ }
+
+ // Delete physical file from filesystem
+ try {
+ const filePath = join(process.cwd(), 'uploads', file.encryptedPath);
+ await unlink(filePath);
+ logger.debug('Physical file deleted', { fileId, path: file.encryptedPath });
+ } catch (error) {
+ logger.warn('Failed to delete physical file', {
+ fileId,
+ path: file.encryptedPath,
+ error
+ });
+ // Continue even if physical deletion fails
+ }
+
+ // Delete file record from database
+ await fileRepository.deleteByUserAndId(userId, fileId);
+
+ // Audit log for file deletion
+ await auditService.logFileEvent(
+ 'file.delete',
+ fileId,
+ {
+ ip: request.headers.get('x-forwarded-for') ||
+ request.headers.get('x-real-ip') ||
+ 'unknown',
+ userAgent: request.headers.get('user-agent') || undefined,
+ userId,
+ },
+ {
+ fileName: file.originalName,
+ fileSize: file.size,
+ reason: 'user_request'
+ }
+ );
+
+ logger.info('File deleted by user', {
+ userId,
+ fileId,
+ fileName: file.originalName,
+ fileSize: file.size,
+ });
+
+ return NextResponse.json({
+ success: true,
+ message: 'File deleted successfully',
+ });
+ } catch (error) {
+ logger.error('Failed to delete file', {
+ fileId: params.fileId,
+ error
+ });
+
+ return NextResponse.json(
+ { error: 'Internal server error' },
+ { status: 500 }
+ );
+ }
+}
diff --git a/src/app/api/user/files/route.ts b/src/app/api/user/files/route.ts
new file mode 100644
index 0000000..0efd761
--- /dev/null
+++ b/src/app/api/user/files/route.ts
@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { MongoFileRepository } from '@/infrastructure/database/mongo-file-repository';
+import { PaginationParams, FileSearchFilters } from '@/domains/user/user-file-types';
+import { logger } from '@/lib/logger';
+
+export async function GET(request: NextRequest) {
+ try {
+ // Check authentication
+ const session = await auth.api.getSession({
+ headers: request.headers,
+ });
+
+ if (!session?.user) {
+ return NextResponse.json(
+ { error: 'Authentication required' },
+ { status: 401 }
+ );
+ }
+
+ const userId = session.user.id;
+ const { searchParams } = new URL(request.url);
+
+ // Extraction des paramĂštres de pagination
+ const page = parseInt(searchParams.get('page') || '1');
+ const limit = parseInt(searchParams.get('limit') || '10');
+ const sortBy = searchParams.get('sortBy') as 'createdAt' | 'name' | 'size' || 'createdAt';
+ const sortOrder = searchParams.get('sortOrder') as 'asc' | 'desc' || 'desc';
+
+ const pagination: PaginationParams = {
+ page: Math.max(1, page),
+ limit: Math.min(50, Math.max(1, limit)), // Limite max de 50
+ sortBy,
+ sortOrder,
+ };
+
+ // Extraction des filtres de recherche
+ const filters: FileSearchFilters = {};
+
+ const name = searchParams.get('name');
+ if (name) filters.name = name;
+
+ const status = searchParams.get('status');
+ if (status && ['active', 'expired', 'expiring_soon'].includes(status)) {
+ filters.status = status as 'active' | 'expired' | 'expiring_soon';
+ }
+
+ const mimeType = searchParams.get('mimeType');
+ if (mimeType) filters.mimeType = mimeType;
+
+ const startDate = searchParams.get('startDate');
+ if (startDate) filters.startDate = new Date(startDate);
+
+ const endDate = searchParams.get('endDate');
+ if (endDate) filters.endDate = new Date(endDate);
+
+ const minSize = searchParams.get('minSize');
+ if (minSize) filters.minSize = parseInt(minSize);
+
+ const maxSize = searchParams.get('maxSize');
+ if (maxSize) filters.maxSize = parseInt(maxSize);
+
+ // Retrieve files
+ const fileRepository = new MongoFileRepository();
+ const result = await fileRepository.findByUserId(userId, pagination, filters);
+
+ // Log de l'activité
+ logger.info('User files retrieved', {
+ userId,
+ page: pagination.page,
+ limit: pagination.limit,
+ totalFiles: result.total,
+ hasFilters: Object.keys(filters).length > 0,
+ });
+
+ return NextResponse.json(result);
+ } catch (error) {
+ logger.error('Failed to retrieve user files', { error });
+ return NextResponse.json(
+ { error: 'Internal server error' },
+ { status: 500 }
+ );
+ }
+}
diff --git a/src/app/api/user/stats/route.ts b/src/app/api/user/stats/route.ts
new file mode 100644
index 0000000..f767dc6
--- /dev/null
+++ b/src/app/api/user/stats/route.ts
@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { MongoFileRepository } from '@/infrastructure/database/mongo-file-repository';
+import { logger } from '@/lib/logger';
+
+export async function GET(request: NextRequest) {
+ try {
+ // Check authentication
+ const session = await auth.api.getSession({
+ headers: request.headers,
+ });
+
+ if (!session?.user) {
+ return NextResponse.json(
+ { error: 'Authentication required' },
+ { status: 401 }
+ );
+ }
+
+ const userId = session.user.id;
+
+ // Retrieve user statistics
+ const fileRepository = new MongoFileRepository();
+ const stats = await fileRepository.getUserFileStats(userId);
+
+ // Helper to format file sizes
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return '0 B';
+ const k = 1024;
+ const sizes = ['B', 'KB', 'MB', 'GB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+ };
+
+ // Enrichir les stats avec des informations formatées
+ const enrichedStats = {
+ ...stats,
+ totalSizeFormatted: formatFileSize(stats.totalSize),
+ averageFileSize: stats.totalFiles > 0 ? Math.round(stats.totalSize / stats.totalFiles) : 0,
+ averageFileSizeFormatted: stats.totalFiles > 0 ? formatFileSize(Math.round(stats.totalSize / stats.totalFiles)) : '0 B',
+ averageDownloadsPerFile: stats.totalFiles > 0 ? Math.round(stats.totalDownloads / stats.totalFiles * 100) / 100 : 0,
+ };
+
+ // Log de l'activité
+ logger.info('User stats retrieved', {
+ userId,
+ totalFiles: stats.totalFiles,
+ totalSize: stats.totalSize,
+ });
+
+ return NextResponse.json(enrichedStats);
+ } catch (error) {
+ logger.error('Failed to retrieve user stats', { error });
+ return NextResponse.json(
+ { error: 'Internal server error' },
+ { status: 500 }
+ );
+ }
+}
diff --git a/src/app/auth/login/page.tsx b/src/app/auth/login/page.tsx
new file mode 100644
index 0000000..8259067
--- /dev/null
+++ b/src/app/auth/login/page.tsx
@@ -0,0 +1,108 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { signIn } from "@/lib/auth-client";
+import Link from "next/link";
+
+export default function LoginPage() {
+ const [email, setEmail] = useState("");
+ const [password, setPassword] = useState("");
+ const [isLoading, setIsLoading] = useState(false);
+ const [error, setError] = useState("");
+ const router = useRouter();
+
+ const handleSubmit = async (e: React.FormEvent) => {
+ e.preventDefault();
+ setIsLoading(true);
+ setError("");
+
+ try {
+ const result = await signIn.email({
+ email,
+ password,
+ });
+
+ if (result.error) {
+ setError(result.error.message || "Login failed");
+ } else {
+ router.push("/dashboard");
+ }
+ } catch {
+ setError("An unexpected error occurred");
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ return (
+
+
+ );
+}
diff --git a/src/app/auth/register/page.tsx b/src/app/auth/register/page.tsx
new file mode 100644
index 0000000..48a2a29
--- /dev/null
+++ b/src/app/auth/register/page.tsx
@@ -0,0 +1,155 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { signUp } from "@/lib/auth-client";
+import Link from "next/link";
+
+export default function RegisterPage() {
+ const [email, setEmail] = useState("");
+ const [password, setPassword] = useState("");
+ const [confirmPassword, setConfirmPassword] = useState("");
+ const [name, setName] = useState("");
+ const [isLoading, setIsLoading] = useState(false);
+ const [error, setError] = useState("");
+ const router = useRouter();
+
+ const handleSubmit = async (e: React.FormEvent) => {
+ e.preventDefault();
+ setIsLoading(true);
+ setError("");
+
+ if (password !== confirmPassword) {
+ setError("Passwords do not match");
+ setIsLoading(false);
+ return;
+ }
+
+ if (password.length < 8) {
+ setError("Password must be at least 8 characters long");
+ setIsLoading(false);
+ return;
+ }
+
+ try {
+ const result = await signUp.email({
+ email,
+ password,
+ name,
+ });
+
+ if (result.error) {
+ setError(result.error.message || "Registration failed");
+ } else {
+ router.push("/dashboard");
+ }
+ } catch {
+ setError("An unexpected error occurred");
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ return (
+
+
+
+
+
+ + Sign in to your account +
++ Or{" "} + + create a new account + +
+
+
+ );
+}
diff --git a/src/app/dashboard/page.tsx b/src/app/dashboard/page.tsx
new file mode 100644
index 0000000..d3f0979
--- /dev/null
+++ b/src/app/dashboard/page.tsx
@@ -0,0 +1,34 @@
+"use client";
+
+import { useSession } from "@/lib/auth-client";
+import { useRouter } from "next/navigation";
+import { useEffect } from "react";
+import { UserDashboard } from "@/components/dashboard/user-dashboard";
+
+export default function DashboardPage() {
+ const { data: session, isPending } = useSession();
+ const router = useRouter();
+
+ useEffect(() => {
+ if (!isPending && !session) {
+ router.push("/auth/login");
+ }
+ }, [session, isPending, router]);
+
+ if (isPending) {
+ return (
+
+
+
+
+
+ + Create your account +
++ Or{" "} + + sign in to your existing account + +
+
+
+ );
+ }
+
+ if (!session) {
+ return null; // Will redirect to login
+ }
+
+ return
+
+
+ Loading your dashboard...
+- The file you're looking for has either vanished or never existed. + The file you're looking for has either vanished or never existed.
@@ -67,15 +67,15 @@ export default function NotFound() {
diff --git a/src/app/page.tsx b/src/app/page.tsx
index 2ac504a..f749447 100644
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
@@ -58,7 +58,7 @@ export default function Home() {
{/* No Registration Card */}
- {">"}
+ >
Scanning for target...
- {">"}
+ >
ERROR: Target not found
- {">"}
+ >
Initiating redirect protocol...
-
+
@@ -82,7 +82,7 @@ export default function Home() {
{/* Auto-Expiring Card */}
-
+ (null);
+ // Authentication
+ const { data: session, isPending } = useSession();
+
// React Query hook for upload
const uploadMutation = useUploadFile();
@@ -332,6 +337,60 @@ export function FileUpload() {
+ {/* Auth Status */}
+ {!isPending && (
+
diff --git a/src/application/__tests__/file-application-service.test.ts b/src/application/__tests__/file-application-service.test.ts
index 4b4b112..6989368 100644
--- a/src/application/__tests__/file-application-service.test.ts
+++ b/src/application/__tests__/file-application-service.test.ts
@@ -7,8 +7,8 @@ import { CryptoService } from '../../domains/security/crypto-service';
import { ConfigurationService } from '../../domains/shared/configuration';
import { FileEntity } from '../../domains/file/file-entity';
import { ShareEntity } from '../../domains/share/share-entity';
-import { UploadFileCommand, DownloadFileCommand, DeleteFileCommand, CommandFactory } from '../commands';
-import { ErrorFactory, ErrorCode } from '../../domains/shared/errors';
+import { CommandFactory } from '../commands';
+import { ErrorCode } from '../../domains/shared/errors';
// Mock des dépendances
const mockFileRepository = {
diff --git a/src/application/file-application-service.ts b/src/application/file-application-service.ts
index 51fa0cf..68791b1 100644
--- a/src/application/file-application-service.ts
+++ b/src/application/file-application-service.ts
@@ -16,7 +16,6 @@ import {
UploadFileCommand,
DownloadFileCommand,
DeleteFileCommand,
- CreateShareCommand,
OperationResult
} from './commands';
import {
@@ -24,8 +23,6 @@ import {
FileDownloadResult
} from '../domains/file/file-value-objects';
import {
- AppError,
- ErrorCode,
ErrorFactory,
ErrorUtils
} from '../domains/shared/errors';
@@ -77,10 +74,10 @@ export class FileApplicationService {
throw ErrorFactory.validationError(passwordValidation.errors);
}
- // Conversion du fichier en ArrayBuffer
+ // Convert file to ArrayBuffer
const fileBuffer = await payload.file.arrayBuffer();
- // Chiffrement du fichier
+ // Encrypt the file
const encryptionResult = await this.cryptoService.encryptFile(fileBuffer, payload.password);
// Génération de valeurs par défaut à partir de la configuration
@@ -96,10 +93,11 @@ export class FileApplicationService {
encryptedPath: '', // Sera défini aprÚs le stockage
expirationHours,
maxDownloads,
- passwordHash: payload.password ? await this.hashPassword(payload.password) : undefined
+ passwordHash: payload.password ? await this.hashPassword(payload.password) : undefined,
+ userId: payload.metadata?.userId // Associate file with logged-in user
});
- // Génération du chemin de stockage et sauvegarde
+ // Generate storage path and save
const storagePath = this.storageService.generatePath(fileEntity.id);
const combinedData = this.combineEncryptedData(
encryptionResult.encryptedData,
@@ -112,7 +110,7 @@ export class FileApplicationService {
// Mise à jour de l'entité avec le chemin de stockage
const updatedFileEntity = fileEntity.updateEncryptedPath(storagePath);
- // Sauvegarde en base de données
+ // Save to database
await this.fileRepository.save(updatedFileEntity);
// Création du partage si la fonctionnalité est activée
@@ -125,7 +123,8 @@ export class FileApplicationService {
expirationHours,
maxAccess: shareConfig.defaultMaxAccess,
passwordProtected: !!payload.password,
- passwordHash: updatedFileEntity.passwordHash
+ passwordHash: updatedFileEntity.passwordHash,
+ userId: payload.metadata?.userId // Associate share with logged-in user
});
await this.shareRepository.save(shareEntity);
@@ -187,7 +186,7 @@ export class FileApplicationService {
try {
const { payload } = command;
- // Recherche du fichier
+ // Find the file
const file = await this.fileRepository.findById(payload.fileId);
if (!file) {
throw ErrorFactory.fileNotFound(payload.fileId);
@@ -202,11 +201,11 @@ export class FileApplicationService {
}
}
- // Lecture du fichier chiffré
+ // Read encrypted file
const combinedData = await this.storageService.read(file.encryptedPath);
const { encryptedData, iv, salt } = this.separateEncryptedData(combinedData);
- // DĂ©chiffrement
+ // Decryption
const decryptedData = await this.cryptoService.decryptFile(
encryptedData,
iv,
@@ -268,20 +267,20 @@ export class FileApplicationService {
return this.createErrorResult('FILE_NOT_FOUND', 'File not found');
}
- // Suppression du fichier physique
+ // Delete physical file
try {
await this.storageService.delete(file.encryptedPath);
} catch (error) {
logger.warn('Failed to delete physical file', { fileId: file.id, error });
}
- // Suppression du partage associé
+ // Delete associated share
const share = await this.shareRepository.findByFileId(file.id);
if (share) {
await this.shareRepository.delete(share.id);
}
- // Suppression de l'enregistrement du fichier
+ // Delete file record
await this.fileRepository.delete(file.id);
// Génération de l'événement
@@ -315,7 +314,7 @@ export class FileApplicationService {
const deletedFilesCount = await this.fileRepository.cleanup();
const deletedSharesCount = await this.shareRepository.cleanup();
- // Nettoyage du stockage (fichiers orphelins)
+ // Clean up storage (orphaned files)
await this.storageService.cleanup();
logger.info('Cleanup completed', {
diff --git a/src/components/dashboard/advanced-search.tsx b/src/components/dashboard/advanced-search.tsx
new file mode 100644
index 0000000..88f9b78
--- /dev/null
+++ b/src/components/dashboard/advanced-search.tsx
@@ -0,0 +1,236 @@
+"use client";
+
+import { useState } from "react";
+import { FileSearchFilters } from "@/domains/user/user-file-types";
+import { Search, X, Calendar, HardDrive, FileType } from "lucide-react";
+
+interface AdvancedSearchProps {
+ initialFilters: FileSearchFilters;
+ onSearch: (filters: FileSearchFilters) => void;
+ onCancel: () => void;
+}
+
+export function AdvancedSearch({ initialFilters, onSearch, onCancel }: AdvancedSearchProps) {
+ const [filters, setFilters] = useState(initialFilters);
+
+ const handleSubmit = (e: React.FormEvent) => {
+ e.preventDefault();
+ onSearch(filters);
+ };
+
+ const clearFilters = () => {
+ setFilters({});
+ };
+
+ const formatDateForInput = (date?: Date) => {
+ if (!date) return '';
+ return date.toISOString().split('T')[0];
+ };
+
+ const parseInputDate = (dateString: string) => {
+ if (!dateString) return undefined;
+ return new Date(dateString + 'T00:00:00.000Z');
+ };
+
+ const formatSizeForInput = (bytes?: number) => {
+ if (!bytes) return '';
+ return Math.round(bytes / (1024 * 1024)).toString(); // Convert to MB
+ };
+
+ const parseSizeInput = (sizeString: string) => {
+ if (!sizeString) return undefined;
+ return parseInt(sizeString) * 1024 * 1024; // Convert from MB to bytes
+ };
+
+ return (
+
+ );
+}
diff --git a/src/components/dashboard/bulk-actions.tsx b/src/components/dashboard/bulk-actions.tsx
new file mode 100644
index 0000000..0b8079b
--- /dev/null
+++ b/src/components/dashboard/bulk-actions.tsx
@@ -0,0 +1,183 @@
+"use client";
+
+import { useState } from "react";
+import { Trash2, Download, Copy, X, Check, Square } from "lucide-react";
+import { SerializedFile } from "@/domains/user/user-file-types";
+import { useFileActions } from "@/hooks/use-user-files";
+
+interface BulkActionsProps {
+ selectedFiles: SerializedFile[];
+ onClearSelection: () => void;
+ onDeleteSelected: (fileIds: string[]) => void;
+}
+
+export function BulkActions({ selectedFiles, onClearSelection, onDeleteSelected }: BulkActionsProps) {
+ const [isDeleting, setIsDeleting] = useState(false);
+ const { copyShareLink } = useFileActions();
+
+ if (selectedFiles.length === 0) {
+ return null;
+ }
+
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return "0 B";
+ const k = 1024;
+ const sizes = ["B", "KB", "MB", "GB"];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+ };
+
+ const totalSize = selectedFiles.reduce((sum, file) => sum + file.size, 0);
+ const totalDownloads = selectedFiles.reduce((sum, file) => sum + file.downloadCount, 0);
+
+ const handleBulkDelete = async () => {
+ if (isDeleting) return;
+
+ const confirmed = window.confirm(
+ `Are you sure you want to delete ${selectedFiles.length} file(s)? This action cannot be undone.`
+ );
+
+ if (confirmed) {
+ setIsDeleting(true);
+ try {
+ const fileIds = selectedFiles.map(file => file.id);
+ await onDeleteSelected(fileIds);
+ onClearSelection();
+ } finally {
+ setIsDeleting(false);
+ }
+ }
+ };
+
+ const handleBulkCopyLinks = async () => {
+ const links = selectedFiles.map(file => `${window.location.origin}/share/${file.id}`);
+ const linksList = links.join('\n');
+
+ try {
+ await navigator.clipboard.writeText(linksList);
+ copyShareLink(''); // Just trigger the success toast
+ } catch {
+ // Fallback: show links in a modal or alert
+ const linkText = `Share links for ${selectedFiles.length} files:\n\n${linksList}`;
+ window.alert(linkText);
+ }
+ };
+
+ const handleBulkDownload = () => {
+ // Open each file in a new tab for download
+ selectedFiles.forEach((file, index) => {
+ setTimeout(() => {
+ window.open(`/share/${file.id}`, '_blank');
+ }, index * 500); // Stagger downloads to avoid browser blocking
+ });
+ };
+
+ return (
+ (null);
+ const [enablePasswordProtection, setEnablePasswordProtection] = useState(false);
+ const [expirationHours, setExpirationHours] = useState(24);
+ const [maxDownloads, setMaxDownloads] = useState(undefined);
+ const [uploadStage, setUploadStage] = useState<"encrypting" | "uploading" | "processing">("encrypting");
+
+ const queryClient = useQueryClient();
+ const uploadMutation = useUploadFile();
+ const { encryptFile: encryptFileWorker, isAvailable: isWorkerAvailable } = useCryptoWorker();
+ const { addToast } = useToast();
+
+ const generateRandomPassword = useCallback(() => {
+ const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+ let password = "";
+ for (let i = 0; i < 12; i++) {
+ password += charset.charAt(Math.floor(Math.random() * charset.length));
+ }
+ return password;
+ }, []);
+
+ const handleDrag = useCallback((e: React.DragEvent) => {
+ e.preventDefault();
+ e.stopPropagation();
+ if (e.type === "dragenter" || e.type === "dragover") {
+ setDragActive(true);
+ } else if (e.type === "dragleave") {
+ setDragActive(false);
+ }
+ }, []);
+
+ const handleDrop = useCallback((e: React.DragEvent) => {
+ e.preventDefault();
+ e.stopPropagation();
+ setDragActive(false);
+
+ if (e.dataTransfer.files && e.dataTransfer.files[0]) {
+ const file = e.dataTransfer.files[0];
+ if (file.size > 50 * 1024 * 1024) {
+ addToast({
+ type: "error",
+ title: "File Too Large",
+ message: "File size must be less than 50MB"
+ });
+ return;
+ }
+ setSelectedFile(file);
+ }
+ }, [addToast]);
+
+ const handleFileSelect = useCallback((e: React.ChangeEvent) => {
+ const file = e.target.files?.[0];
+ if (!file) return;
+
+ if (file.size > 50 * 1024 * 1024) {
+ addToast({
+ type: "error",
+ title: "File Too Large",
+ message: "File size must be less than 50MB"
+ });
+ return;
+ }
+
+ setSelectedFile(file);
+ }, [addToast]);
+
+ const handleUpload = async () => {
+ if (!selectedFile) return;
+
+ try {
+ setUploadStage("encrypting");
+
+ let password = "";
+ if (enablePasswordProtection) {
+ password = generateRandomPassword();
+ }
+
+ const fileBuffer = await selectedFile.arrayBuffer();
+ let encryptionResult;
+
+ if (isWorkerAvailable) {
+ encryptionResult = await performanceMonitor.measureCryptoOperation(
+ 'worker-encrypt',
+ () => encryptFileWorker(fileBuffer, password)
+ );
+ } else {
+ encryptionResult = await performanceMonitor.measureCryptoOperation(
+ 'main-thread-encrypt',
+ async () => {
+ const cryptoService = new ClientCryptoService();
+ const mainThreadResult = await cryptoService.encryptFile(fileBuffer, password);
+
+ return {
+ encryptedData: cryptoService.combineEncryptedData(
+ mainThreadResult.encryptedData,
+ mainThreadResult.iv,
+ mainThreadResult.salt
+ ),
+ key: mainThreadResult.key,
+ };
+ }
+ );
+ }
+
+ setUploadStage("uploading");
+
+ const formData = new FormData();
+ const encryptedBlob = new Blob([encryptionResult.encryptedData], { type: 'application/octet-stream' });
+
+ formData.append("file", encryptedBlob, selectedFile.name);
+ formData.append("originalName", selectedFile.name);
+ formData.append("mimeType", selectedFile.type || 'application/octet-stream');
+ formData.append("size", selectedFile.size.toString());
+ formData.append("expirationHours", expirationHours.toString());
+ formData.append("passwordProtected", enablePasswordProtection ? "true" : "false");
+ if (enablePasswordProtection && password) {
+ formData.append("password", password);
+ }
+ if (maxDownloads) {
+ formData.append("maxDownloads", maxDownloads.toString());
+ }
+
+ setUploadStage("processing");
+ await uploadMutation.mutateAsync(formData);
+
+ // Invalidate caches to refresh data
+ queryClient.invalidateQueries({ queryKey: ['user-files'] });
+ queryClient.invalidateQueries({ queryKey: ['user-stats'] });
+
+ // Show success with details
+ addToast({
+ type: "success",
+ title: "Upload Successful",
+ message: `${selectedFile.name} has been uploaded and is ready to share.`
+ });
+
+ // If a password was generated, display it
+ if (password) {
+ addToast({
+ type: "info",
+ title: "Generated Password",
+ message: `Password: ${password} - Save this securely!`
+ });
+ }
+
+ // Reset et fermer
+ setSelectedFile(null);
+ setEnablePasswordProtection(false);
+ setMaxDownloads(undefined);
+ onUploadComplete();
+
+ } catch (error) {
+ console.error("Upload error:", error);
+ // Error is handled automatically by React Query
+ }
+ };
+
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return "0 Bytes";
+ const k = 1024;
+ const sizes = ["Bytes", "KB", "MB", "GB"];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+ };
+
+ return (
+ setShowPreview(false)}
+ onDownload={() => downloadFile()}
+ />
+ )}
);
}
diff --git a/src/components/file-upload.tsx b/src/components/file-upload.tsx
index 7427c14..286d385 100644
--- a/src/components/file-upload.tsx
+++ b/src/components/file-upload.tsx
@@ -1,7 +1,7 @@
"use client";
import { useState, useCallback } from "react";
-import { Upload, Lock, Clock, Download, Copy, Check, Eye, EyeOff, FileIcon, AlertCircle } from "lucide-react";
+import { Upload, Lock, Clock, Download, Copy, Check, Eye, EyeOff, FileIcon, AlertCircle, User, UserPlus, LogIn } from "lucide-react";
import { ClientCryptoService } from "@/lib/client-crypto";
import { useUploadFile } from "@/hooks/use-api";
import { useCryptoWorker } from "@/hooks/use-crypto-worker";
@@ -9,6 +9,8 @@ import { performanceMonitor } from "@/lib/performance";
import { useToast } from "@/components/ui/toast";
import { ProgressBar, CryptoLoading } from "@/components/ui/loading";
import { HelpTooltip, InfoTooltip } from "@/components/ui/tooltip";
+import { useSession } from "@/lib/auth-client";
+import Link from "next/link";
interface UploadResult {
shareUrl: string;
@@ -28,6 +30,9 @@ export function FileUpload() {
const [uploadStage, setUploadStage] = useState<"encrypting" | "uploading" | "processing">("encrypting");
const [selectedFile, setSelectedFile] = useState
+
+ );
+}
diff --git a/src/components/dashboard/dashboard-stats.tsx b/src/components/dashboard/dashboard-stats.tsx
new file mode 100644
index 0000000..91128d1
--- /dev/null
+++ b/src/components/dashboard/dashboard-stats.tsx
@@ -0,0 +1,118 @@
+"use client";
+
+import { Files, HardDrive, Download, TrendingUp, Clock, AlertTriangle } from "lucide-react";
+import { FormattedUserFileStats } from "@/domains/user/user-file-types";
+
+interface DashboardStatsProps {
+ stats?: FormattedUserFileStats;
+ isLoading: boolean;
+}
+
+export function DashboardStats({ stats, isLoading }: DashboardStatsProps) {
+ if (isLoading) {
+ return (
+
+
+
+ {/* Preview des fichiers sélectionnés */}
+ {selectedFiles.length <= 5 && (
+
+
+
+
+
+
+
+
+
+ {selectedFiles.length} file{selectedFiles.length !== 1 ? 's' : ''} selected
+
+
+ Total size: {formatFileSize(totalSize)} âą Total downloads: {totalDownloads}
+
+
+ {/* Actions */}
+
+
+
+
+
+
+
+
+
+
+
+
+ )}
+
+ {selectedFiles.length > 5 && (
+
+ Selected:
+ {selectedFiles.map((file) => (
+
+
+
+ {file.originalName}
+
+
+ ({formatFileSize(file.size)})
+
+
+ ))}
+
+
+ )}
+
+ Selected files:
+
+
+ {selectedFiles.slice(0, 3).map((file) => (
+
+
+ {file.originalName}
+
+ ))}
+ {selectedFiles.length > 3 && (
+
+ +{selectedFiles.length - 3} more
+
+ )}
+
+ {[...Array(4)].map((_, i) => (
+
+ );
+ }
+
+ if (!stats) {
+ return (
+
+
+ ))}
+
+
+
+
+
+
+
+
+
+ );
+ }
+
+ const statCards = [
+ {
+ icon: Files,
+ label: "Total Files",
+ value: stats.totalFiles.toString(),
+ subValue: `${stats.activeFiles} active`,
+ color: "text-primary",
+ bgColor: "bg-primary/10",
+ borderColor: "border-primary/20",
+ },
+ {
+ icon: HardDrive,
+ label: "Storage Used",
+ value: stats.totalSizeFormatted,
+ subValue: `Avg: ${stats.averageFileSizeFormatted}`,
+ color: "text-blue-500",
+ bgColor: "bg-blue-500/10",
+ borderColor: "border-blue-500/20",
+ },
+ {
+ icon: Download,
+ label: "Total Downloads",
+ value: stats.totalDownloads.toString(),
+ subValue: `Avg: ${stats.averageDownloadsPerFile} per file`,
+ color: "text-green-500",
+ bgColor: "bg-green-500/10",
+ borderColor: "border-green-500/20",
+ },
+ {
+ icon: stats.expiringFiles > 0 ? AlertTriangle : Clock,
+ label: "Expiring Soon",
+ value: stats.expiringFiles.toString(),
+ subValue: `${stats.expiredFiles} expired`,
+ color: stats.expiringFiles > 0 ? "text-warning" : "text-muted-foreground",
+ bgColor: stats.expiringFiles > 0 ? "bg-warning/10" : "bg-secondary/10",
+ borderColor: stats.expiringFiles > 0 ? "border-warning/20" : "border-border",
+ },
+ ];
+
+ return (
+ Unable to load statistics
+
+ {statCards.map((stat, index) => (
+
+ );
+}
diff --git a/src/components/dashboard/dashboard-upload.tsx b/src/components/dashboard/dashboard-upload.tsx
new file mode 100644
index 0000000..03a18c5
--- /dev/null
+++ b/src/components/dashboard/dashboard-upload.tsx
@@ -0,0 +1,348 @@
+"use client";
+
+import { useState, useCallback } from "react";
+import { Upload, X, FileIcon, AlertCircle, Lock, Clock, Download } from "lucide-react";
+import { useUploadFile } from "@/hooks/use-api";
+import { useCryptoWorker } from "@/hooks/use-crypto-worker";
+import { useToast } from "@/components/ui/toast";
+import { useQueryClient } from "@tanstack/react-query";
+import { ClientCryptoService } from "@/lib/client-crypto";
+import { performanceMonitor } from "@/lib/performance";
+import { ProgressBar, CryptoLoading } from "@/components/ui/loading";
+
+interface DashboardUploadProps {
+ onUploadComplete: () => void;
+}
+
+export function DashboardUpload({ onUploadComplete }: DashboardUploadProps) {
+ const [dragActive, setDragActive] = useState(false);
+ const [selectedFile, setSelectedFile] = useState
+
+ ))}
+
+ {/* Most downloaded file */}
+ {stats.mostDownloadedFile && (
+
+
+
+
+
+
+ {stat.label}
+{stat.value}
+{stat.subValue}
+
+
+ )}
+
+
+
+
+
+
+
+
+ Most Downloaded File
+{stats.mostDownloadedFile.name}
++ {stats.mostDownloadedFile.downloads} downloads +
+
+
+ );
+}
diff --git a/src/components/dashboard/delete-confirmation.tsx b/src/components/dashboard/delete-confirmation.tsx
new file mode 100644
index 0000000..4699f32
--- /dev/null
+++ b/src/components/dashboard/delete-confirmation.tsx
@@ -0,0 +1,120 @@
+"use client";
+
+import { AlertTriangle, Trash2, X, Loader2 } from "lucide-react";
+import { SerializedFile } from "@/domains/user/user-file-types";
+
+interface DeleteConfirmationProps {
+ file: SerializedFile;
+ onConfirm: () => void;
+ onCancel: () => void;
+ isDeleting: boolean;
+}
+
+export function DeleteConfirmation({ file, onConfirm, onCancel, isDeleting }: DeleteConfirmationProps) {
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return "0 B";
+ const k = 1024;
+ const sizes = ["B", "KB", "MB", "GB"];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+ };
+
+ return (
+
+
+
+ {!selectedFile ? (
+ Quick Upload
+ +
+
+ ) : (
+ + Drop your file here, or{" "} + +
+Maximum file size: 50MB
+
+ {/* Selected file */}
+
+ )}
+
+
+
+ {/* Options */}
+
+
+
+
+
+ {selectedFile.name}
+{formatFileSize(selectedFile.size)}
+
+
+
+ {/* Bouton d'upload */}
+
+
+
+
+
+
+
+
+
+
+
+ setMaxDownloads(e.target.value ? Number(e.target.value) : undefined)}
+ placeholder="Unlimited"
+ min="1"
+ max="100"
+ className="w-full px-2 py-1 text-sm bg-input border border-border text-foreground placeholder-muted-foreground"
+ />
+
+
+
+
+
+
+ {/* Progress */}
+ {uploadMutation.isPending && (
+
+
+ )}
+
+ {/* Error */}
+ {uploadMutation.error && (
+ + {uploadStage === "encrypting" && "Encrypting file..."} + {uploadStage === "uploading" && "Uploading to server..."} + {uploadStage === "processing" && "Processing and generating link..."} +
+
+
+ )}
+
+
+ + {uploadMutation.error.message} +
+
+
+ );
+}
diff --git a/src/components/dashboard/file-card.tsx b/src/components/dashboard/file-card.tsx
new file mode 100644
index 0000000..a72d4b3
--- /dev/null
+++ b/src/components/dashboard/file-card.tsx
@@ -0,0 +1,238 @@
+"use client";
+
+import { useState } from "react";
+import {
+ Copy,
+ Trash2,
+ Clock,
+ AlertTriangle,
+ Lock,
+ Eye,
+ MoreHorizontal
+} from "lucide-react";
+import { SerializedFile } from "@/domains/user/user-file-types";
+
+interface FileCardProps {
+ file: SerializedFile;
+ onDelete: () => void;
+ onCopyLink: (url: string) => void;
+}
+
+export function FileCard({ file, onDelete, onCopyLink }: FileCardProps) {
+ const [showActions, setShowActions] = useState(false);
+
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return "0 B";
+ const k = 1024;
+ const sizes = ["B", "KB", "MB", "GB"];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+ };
+
+ const formatDate = (date: string): string => {
+ return new Date(date).toLocaleDateString('en-US', {
+ year: 'numeric',
+ month: 'short',
+ day: 'numeric',
+ hour: '2-digit',
+ minute: '2-digit'
+ });
+ };
+
+ const getFileIcon = (mimeType: string) => {
+ if (mimeType.startsWith('image/')) return 'đŒïž';
+ if (mimeType.startsWith('video/')) return 'đ„';
+ if (mimeType.startsWith('audio/')) return 'đ”';
+ if (mimeType.includes('pdf')) return 'đ';
+ if (mimeType.startsWith('text/')) return 'đ';
+ return 'đ';
+ };
+
+ const getStatusInfo = () => {
+ const now = new Date();
+ const expiresAt = new Date(file.expiresAt);
+ const isExpired = expiresAt <= now;
+ const isExpiringSoon = !isExpired && (expiresAt.getTime() - now.getTime()) < 24 * 60 * 60 * 1000;
+
+ if (isExpired) {
+ return {
+ status: 'expired',
+ color: 'text-destructive',
+ bgColor: 'bg-destructive/10',
+ borderColor: 'border-destructive/20',
+ icon: AlertTriangle,
+ text: 'Expired'
+ };
+ }
+
+ if (isExpiringSoon) {
+ return {
+ status: 'expiring',
+ color: 'text-warning',
+ bgColor: 'bg-warning/10',
+ borderColor: 'border-warning/20',
+ icon: Clock,
+ text: 'Expiring Soon'
+ };
+ }
+
+ return {
+ status: 'active',
+ color: 'text-success',
+ bgColor: 'bg-success/10',
+ borderColor: 'border-success/20',
+ icon: Eye,
+ text: 'Active'
+ };
+ };
+
+ const statusInfo = getStatusInfo();
+ const downloadProgress = file.maxDownloads
+ ? Math.round((file.downloadCount / file.maxDownloads) * 100)
+ : 0;
+
+ // Construire l'URL de partage (simplifié pour l'exemple)
+ const shareUrl = `/share/${file.id}`;
+
+ return (
+
+ {/* Header */}
+
+
+
+
+ {/* File Info */}
+
+
+
+
+
+ Delete File
+This action cannot be undone
+
+
+
+ {/* Warning Message */}
+
+
+ đ
+
+
+ + {file.originalName} +
+
+ {formatFileSize(file.size)}
+ {file.downloadCount} downloads
+ {file.maxDownloads && (
+ Max: {file.maxDownloads}
+ )}
+
+
+
+
+ {/* Actions */}
+ + Are you sure you want to delete this file? This will: +
+-
+
- âą Permanently remove the file from storage +
- âą Invalidate all existing share links +
- âą Delete all associated download records +
- âą Cannot be recovered once deleted +
+
+
+
+
+
+ {/* Additional Info */}
+
+
+
+
+
+
+ Important Note
++ If this file has been shared, all recipients will lose access immediately. + Consider notifying them before deletion if necessary. +
+
+ {/* Header avec icĂŽne et actions */}
+
)}
+
+ {/* Preview Modal */}
+ {showPreview && fileInfo && encryptedContent && fileMimeType && (
+
+
+
+ {/* Statut */}
+
+
+
+ {getFileIcon(file.mimeType)}
+
+
+ + {file.originalName} +
++ {formatFileSize(file.size)} +
+
+
+
+ {showActions && (
+
+
+
+
+
+ +
+ )}
+ + +
+
+
+ {/* Informations */}
+
+
+ )}
+
+
+
+ {/* Barre de progression des téléchargements */}
+ {file.maxDownloads && (
+
+ Uploaded:
+ {formatDate(file.uploadedAt)}
+
+
+ Expires:
+ {formatDate(file.expiresAt)}
+
+
+ Downloads:
+
+ {file.downloadCount}
+ {file.maxDownloads && ` / ${file.maxDownloads}`}
+
+
+
+ ({
+ page: 1,
+ limit: 10,
+ sortBy: 'createdAt',
+ sortOrder: 'desc',
+ });
+
+ const [filters, setFilters] = useState({});
+ const [searchTerm, setSearchTerm] = useState('');
+
+ // Data retrieval
+ const { data: files, isLoading: filesLoading, error: filesError } = useUserFiles({
+ pagination,
+ filters: { ...filters, name: searchTerm || undefined },
+ });
+
+ const { data: stats, isLoading: statsLoading } = useUserStats();
+
+ const handleSearchSubmit = (e: React.FormEvent) => {
+ e.preventDefault();
+ setPagination(prev => ({ ...prev, page: 1 })); // Reset Ă la page 1
+ };
+
+ const handleAdvancedSearch = (newFilters: FileSearchFilters) => {
+ setFilters(newFilters);
+ setPagination(prev => ({ ...prev, page: 1 }));
+ setShowAdvancedSearch(false);
+ };
+
+ const handlePageChange = (newPage: number) => {
+ setPagination(prev => ({ ...prev, page: newPage }));
+ };
+
+ const handleSortChange = (sortBy: 'createdAt' | 'name' | 'size') => {
+ setPagination(prev => ({
+ ...prev,
+ sortBy,
+ sortOrder: prev.sortBy === sortBy && prev.sortOrder === 'desc' ? 'asc' : 'desc',
+ page: 1,
+ }));
+ };
+
+ const clearFilters = () => {
+ setFilters({});
+ setSearchTerm('');
+ setPagination(prev => ({ ...prev, page: 1 }));
+ };
+
+ const hasActiveFilters = Object.keys(filters).length > 0 || searchTerm.length > 0;
+
+ return (
+ ;
+ isLoading: boolean;
+ error: Error | null;
+ pagination: PaginationParams;
+ onPageChange: (page: number) => void;
+ onSortChange: (sortBy: 'createdAt' | 'name' | 'size') => void;
+}
+
+export function UserFilesList({
+ files,
+ isLoading,
+ error,
+ pagination,
+ onPageChange,
+ onSortChange
+}: UserFilesListProps) {
+ const [fileToDelete, setFileToDelete] = useState(null);
+
+ const deleteFileMutation = useDeleteFile();
+ const { copyShareLink } = useFileActions();
+
+ const handleDeleteConfirm = async () => {
+ if (fileToDelete) {
+ await deleteFileMutation.mutateAsync(fileToDelete.id);
+ setFileToDelete(null);
+ }
+ };
+
+ const getSortIcon = (sortBy: 'createdAt' | 'name' | 'size') => {
+ if (pagination.sortBy !== sortBy) {
+ return (null);
const [showPassword, setShowPassword] = useState(false);
const [downloadStage, setDownloadStage] = useState<"decrypting" | "downloading" | "processing">("downloading");
+ const [showPreview, setShowPreview] = useState(false);
+ const [encryptedContent, setEncryptedContent] = useState(null);
+ const [fileMimeType, setFileMimeType] = useState(null);
// React Query hooks
const { data: fileInfo, isLoading: loading, error: queryError } = useFileInfo(shareId);
@@ -36,6 +40,34 @@ export function FileDownload({ shareId }: FileDownloadProps) {
const requiresPassword = fileInfo?.passwordProtected || false;
+ // Shared function to get encrypted content
+ const getEncryptedContent = async () => {
+ if (!fileInfo) return null;
+
+ try {
+ // Use React Query mutation to get encrypted content
+ const result = await downloadMutation.mutateAsync({
+ fileId: fileInfo.id,
+ password: requiresPassword ? password : undefined,
+ shareId: shareId // Pass shareId to enable access counting
+ });
+
+ // Store the mimeType for preview
+ setFileMimeType(result.mimeType);
+
+ return result.content;
+ } catch (error: unknown) {
+ const errorMessage = error instanceof Error ? error.message : "Failed to get file content.";
+ setError(errorMessage);
+ addToast({
+ type: "error",
+ title: "Access Failed",
+ message: errorMessage
+ });
+ return null;
+ }
+ };
+
const downloadFile = async () => {
if (!fileInfo) return;
@@ -53,17 +85,14 @@ export function FileDownload({ shareId }: FileDownloadProps) {
return;
}
- // Use React Query mutation for download
- const result = await downloadMutation.mutateAsync({
- fileId: fileInfo.id,
- password: requiresPassword ? password : undefined,
- shareId: shareId // Pass shareId to enable access counting
- });
+ // Get encrypted content (either cached or fresh)
+ const content = encryptedContent || await getEncryptedContent();
+ if (!content) return;
setDownloadStage("decrypting");
// Convert base64 back to ArrayBuffer
- const binaryString = atob(result.content);
+ const binaryString = atob(content);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
@@ -81,12 +110,12 @@ export function FileDownload({ shareId }: FileDownloadProps) {
setDownloadStage("processing");
- const blob = new Blob([decryptedData], { type: result.mimeType });
+ const blob = new Blob([decryptedData], { type: 'application/octet-stream' });
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url;
- a.download = result.fileName;
+ a.download = fileInfo.originalName;
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
@@ -96,7 +125,7 @@ export function FileDownload({ shareId }: FileDownloadProps) {
addToast({
type: "success",
title: "Download Complete",
- message: `${result.fileName} has been downloaded successfully`
+ message: `${fileInfo.originalName} has been downloaded successfully`
});
// React Query will automatically update the file info (download count)
@@ -111,6 +140,19 @@ export function FileDownload({ shareId }: FileDownloadProps) {
}
};
+ const handlePreview = async () => {
+ if (!fileInfo) return;
+
+ // Get encrypted content if not already cached
+ if (!encryptedContent) {
+ const content = await getEncryptedContent();
+ if (!content) return;
+ setEncryptedContent(content);
+ }
+
+ setShowPreview(true);
+ };
+
const formatFileSize = (bytes: number): string => {
if (bytes === 0) return "0 Bytes";
const k = 1024;
@@ -282,29 +324,60 @@ export function FileDownload({ shareId }: FileDownloadProps) {
)}
-
+
+ Download Progress
+ {downloadProgress}%
+
+
+
+ )}
+
+ {/* Actions rapides */}
+ = 90 ? 'bg-destructive' :
+ downloadProgress >= 70 ? 'bg-warning' : 'bg-success'
+ }`}
+ style={{ width: `${downloadProgress}%` }}
+ />
+
+
+
+
+
+
+ {/* Clic en dehors pour fermer le menu */}
+ {showActions && (
+ setShowActions(false)}
+ />
+ )}
+
+
+ );
+}
diff --git a/src/components/dashboard/user-dashboard.tsx b/src/components/dashboard/user-dashboard.tsx
new file mode 100644
index 0000000..7606be6
--- /dev/null
+++ b/src/components/dashboard/user-dashboard.tsx
@@ -0,0 +1,170 @@
+"use client";
+
+import { useState } from "react";
+import { useSession } from "@/lib/auth-client";
+import { PaginationParams, FileSearchFilters } from "@/domains/user/user-file-types";
+import { useUserFiles, useUserStats } from "@/hooks/use-user-files";
+import { DashboardStats } from "./dashboard-stats";
+import { DashboardUpload } from "./dashboard-upload";
+import { UserFilesList } from "./user-files-list";
+import { AdvancedSearch } from "./advanced-search";
+import { Plus, Search, Filter } from "lucide-react";
+
+export function UserDashboard() {
+ const { data: session } = useSession();
+ const [showUpload, setShowUpload] = useState(false);
+ const [showAdvancedSearch, setShowAdvancedSearch] = useState(false);
+
+ // Ătat de la pagination et des filtres
+ const [pagination, setPagination] = useState
+
+ );
+}
diff --git a/src/components/dashboard/user-files-list.tsx b/src/components/dashboard/user-files-list.tsx
new file mode 100644
index 0000000..97abc18
--- /dev/null
+++ b/src/components/dashboard/user-files-list.tsx
@@ -0,0 +1,227 @@
+"use client";
+
+import { useState } from "react";
+import { PaginationParams, PaginatedResult, SerializedFile } from "@/domains/user/user-file-types";
+import { useDeleteFile, useFileActions } from "@/hooks/use-user-files";
+import { FileCard } from "./file-card";
+import { DeleteConfirmation } from "./delete-confirmation";
+import {
+ FileIcon,
+ AlertCircle,
+ ChevronLeft,
+ ChevronRight,
+ ArrowUpDown,
+ ArrowUp,
+ ArrowDown,
+ Loader2
+} from "lucide-react";
+
+interface UserFilesListProps {
+ files?: PaginatedResult
+ {/* Header */}
+
+
+
+
+ {/* Zone d'upload dépliable */}
+ {showUpload && (
+
+
+
+ {/* Statistiques */}
+
+
+
+ + Welcome back, {session?.user.name || session?.user.email} +
++ Manage your files, view statistics, and upload new content. +
+
+ {
+ setShowUpload(false);
+ // React Query hooks will automatically revalidate
+ }}
+ />
+
+ )}
+
+ {/* Barre de recherche et filtres */}
+
+
+
+ {/* File list */}
+
+ {/* Recherche simple */}
+
+
+ {/* Boutons d'actions */}
+
+
+ {/* Recherche avancée dépliable */}
+ {showAdvancedSearch && (
+
+
+
+ {hasActiveFilters && (
+
+ )}
+
+
+ setShowAdvancedSearch(false)}
+ />
+
+ )}
+
+
+ );
+ }
+
+ if (error) {
+ return (
+
+
+
+
+ );
+ }
+
+ if (!files || files.data.length === 0) {
+ return (
+
+
+
+
+ Failed to load files
+{error.message}
+
+
+ );
+ }
+
+ return (
+ No files found
++ {Object.keys(pagination).length > 0 + ? "Try adjusting your search filters or upload your first file." + : "Upload your first file to get started." + } +
+
+ {/* Header avec tri */}
+ setFileToDelete(null)}
+ isDeleting={deleteFileMutation.isPending}
+ />
+ )}
+
+ );
+}
diff --git a/src/components/file-download.tsx b/src/components/file-download.tsx
index ff88f81..f8f7109 100644
--- a/src/components/file-download.tsx
+++ b/src/components/file-download.tsx
@@ -7,6 +7,7 @@ import { useFileInfo, useDownloadFile, usePrefetchFileInfo } from "@/hooks/use-a
import { CryptoLoading, ProgressBar, LaserScanLoading } from "@/components/ui/loading";
import { HelpTooltip, InfoTooltip } from "@/components/ui/tooltip";
import { useToast } from "@/components/ui/toast";
+import { SecureFilePreview } from "@/components/shared/secure-file-preview";
interface FileDownloadProps {
shareId: string;
@@ -17,6 +18,9 @@ export function FileDownload({ shareId }: FileDownloadProps) {
const [error, setError] = useState
+
+
+ {/* Grille des fichiers */}
+
+
+
+ {/* Informations de pagination */}
+ + Your Files ({files.total}) +
+ + {/* Options de tri */} +
+ Sort by:
+
+
+
+
+
+ Showing {((pagination.page - 1) * pagination.limit) + 1} to{' '}
+ {Math.min(pagination.page * pagination.limit, files.total)} of {files.total} files
+
+
+ {files.data.map((file) => (
+ setFileToDelete(file)}
+ onCopyLink={copyShareLink}
+ />
+ ))}
+
+
+ {/* Pagination */}
+ {files.totalPages > 1 && (
+
+
+ )}
+
+ {/* Modal de confirmation de suppression */}
+ {fileToDelete && (
+
+
+
+ Page {pagination.page} of {files.totalPages}
+
+
+
+
+
+ {/* Pages */}
+
+
+ {Array.from({ length: Math.min(5, files.totalPages) }, (_, i) => {
+ let pageNum;
+ if (files.totalPages <= 5) {
+ pageNum = i + 1;
+ } else if (pagination.page <= 3) {
+ pageNum = i + 1;
+ } else if (pagination.page >= files.totalPages - 2) {
+ pageNum = files.totalPages - 4 + i;
+ } else {
+ pageNum = pagination.page - 2 + i;
+ }
+
+ return (
+
+ );
+ })}
+
+
+
+
+
+
+
+
File will be decrypted in your browser before download
+ {session ? (
+
+ )}
+
{/* Upload Area */}
+
+ ) : (
+
+
+
+
+
+
+ + Connected as {session.user.name || session.user.email} +
++ Your files will be saved to your account for easy management +
+
+
+ )}
+
+
+
+
+ + âą View upload history âą Manage your shares âą Delete files anytime +
+
+
+
+ + You can still upload files anonymously below +
+ {
+ await signOut();
+ setIsMenuOpen(false);
+ };
+
return (
('');
+ const [isLoading, setIsLoading] = useState(true);
+ const [lineCount, setLineCount] = useState(0);
+
+ useEffect(() => {
+ const loadContent = async () => {
+ try {
+ setIsLoading(true);
+
+ // Limit preview size to 1MB
+ if (blob.size > 1024 * 1024) {
+ onError('File too large for preview (max 1MB)');
+ return;
+ }
+
+ const text = await blob.text();
+ setContent(text);
+ setLineCount(text.split('\n').length);
+ } catch (error) {
+ onError('Failed to read file content');
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ loadContent();
+ }, [blob, onError]);
+
+ const copyToClipboard = async () => {
+ try {
+ await navigator.clipboard.writeText(content);
+ // Could add a toast notification here
+ } catch (error) {
+ // Fallback for older browsers or when clipboard API fails
+ const textArea = document.createElement('textarea');
+ textArea.value = content;
+ document.body.appendChild(textArea);
+ textArea.select();
+ document.execCommand('copy');
+ document.body.removeChild(textArea);
+ }
+ };
+
+ const getLanguageFromFilename = (filename: string): string => {
+ const extension = filename.toLowerCase().split('.').pop() || '';
+ const languageMap: Record = {
+ 'js': 'javascript',
+ 'jsx': 'javascript',
+ 'ts': 'typescript',
+ 'tsx': 'typescript',
+ 'py': 'python',
+ 'java': 'java',
+ 'c': 'c',
+ 'cpp': 'cpp',
+ 'cc': 'cpp',
+ 'cxx': 'cpp',
+ 'h': 'c',
+ 'hpp': 'cpp',
+ 'cs': 'csharp',
+ 'php': 'php',
+ 'rb': 'ruby',
+ 'go': 'go',
+ 'rs': 'rust',
+ 'html': 'html',
+ 'htm': 'html',
+ 'css': 'css',
+ 'scss': 'scss',
+ 'sass': 'sass',
+ 'less': 'less',
+ 'json': 'json',
+ 'xml': 'xml',
+ 'yaml': 'yaml',
+ 'yml': 'yaml',
+ 'sql': 'sql',
+ 'sh': 'bash',
+ 'bash': 'bash',
+ 'md': 'markdown',
+ 'markdown': 'markdown'
+ };
+
+ return languageMap[extension] || 'text';
+ };
+
+ if (isLoading) {
+ return (
+ (null);
+ const [previewUrl, setPreviewUrl] = useState(null);
+ const [error, setError] = useState(null);
+ const [hasConsentLogged, setHasConsentLogged] = useState(false);
+
+ // Enhanced preview detection with file extension fallback
+ const getFileExtension = (filename: string): string => {
+ return filename.toLowerCase().split('.').pop() || '';
+ };
+
+ const isTextFileByExtension = (filename: string): boolean => {
+ const extension = getFileExtension(filename);
+ const textExtensions = [
+ // Data formats
+ 'json', 'xml', 'yaml', 'yml', 'toml', 'ini', 'conf', 'config',
+
+ // Programming languages
+ 'js', 'ts', 'jsx', 'tsx', 'py', 'java', 'c', 'cpp', 'cc', 'cxx', 'h', 'hpp',
+ 'cs', 'php', 'rb', 'go', 'rs', 'scala', 'kt', 'swift', 'dart', 'lua',
+
+ // Web technologies
+ 'html', 'htm', 'css', 'scss', 'sass', 'less', 'vue', 'svelte',
+
+ // Shell scripts
+ 'sh', 'bash', 'zsh', 'fish', 'ps1', 'cmd', 'bat',
+
+ // SQL and query languages
+ 'sql', 'graphql', 'gql',
+
+ // Config and infrastructure
+ 'dockerfile', 'docker-compose', 'nginx', 'apache', 'htaccess',
+ 'gitignore', 'gitattributes', 'editorconfig',
+
+ // Documentation
+ 'md', 'markdown', 'txt', 'readme', 'license', 'changelog',
+ 'rst', 'adoc', 'asciidoc',
+
+ // Data files
+ 'csv', 'tsv', 'log', 'env', 'properties',
+
+ // Markup and template languages
+ 'mustache', 'handlebars', 'hbs', 'twig', 'jinja', 'j2',
+
+ // Package managers
+ 'lock', 'sum', 'mod', 'gradle', 'sbt',
+
+ // Others
+ 'makefile', 'cmake', 'dockerfile', 'vagrantfile',
+ 'r', 'rmd', 'ipynb', 'jl', 'elm', 'ex', 'exs', 'erl', 'hrl'
+ ];
+
+ return textExtensions.includes(extension);
+ };
+
+ const enhancedCanPreview = (): boolean => {
+ // First check explicit MIME types
+ if (PREVIEW_ALLOWED_TYPES.includes(fileInfo.mimeType)) {
+ return true;
+ }
+
+ // For generic MIME types, check file extension
+ if (fileInfo.mimeType === 'application/octet-stream' ||
+ fileInfo.mimeType === 'text/plain' ||
+ fileInfo.mimeType === 'application/unknown') {
+ return isTextFileByExtension(fileInfo.originalName);
+ }
+
+ // Check if any text MIME type prefix matches
+ const textPrefixes = ['text/', 'application/json', 'application/xml', 'application/javascript'];
+ return textPrefixes.some(prefix => fileInfo.mimeType.startsWith(prefix));
+ };
+
+ const canPreview = enhancedCanPreview();
+ const isSensitive = SENSITIVE_TYPES.includes(fileInfo.mimeType);
+
+ const getContentTypeLabel = () => {
+ if (fileInfo.mimeType.startsWith('image/')) return 'Image Content';
+ if (fileInfo.mimeType.startsWith('video/')) return 'Media Content';
+ if (fileInfo.mimeType.startsWith('audio/')) return 'Audio Content';
+ if (fileInfo.mimeType === 'application/pdf') return 'Document Content';
+ if (fileInfo.mimeType.startsWith('text/')) return 'Text Content';
+ return 'File Content';
+ };
+
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return "0 B";
+ const k = 1024;
+ const sizes = ["B", "KB", "MB", "GB"];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+ };
+
+ // Log preview consent
+ const logPreviewConsent = async () => {
+ if (hasConsentLogged) return;
+
+ try {
+ await fetch('/api/audit/preview-consent', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({
+ fileId: fileInfo.id,
+ shareId,
+ mimeType: fileInfo.mimeType,
+ fileName: fileInfo.originalName
+ }),
+ });
+ setHasConsentLogged(true);
+ } catch (error) {
+ console.error('Failed to log preview consent:', error);
+ // Continue anyway - don't block preview for logging failure
+ }
+ };
+
+ // Decrypt and prepare content for preview
+ const handleShowPreview = async () => {
+ if (!canPreview) {
+ setError('This file type cannot be previewed');
+ return;
+ }
+
+ setIsDecrypting(true);
+ setError(null);
+
+ try {
+ // Log consent first
+ await logPreviewConsent();
+
+ // Extract encryption key from URL fragment
+ const urlFragment = window.location.hash;
+ const keyMatch = urlFragment.match(/key=([^&]+)/);
+ const encryptionKey = keyMatch ? keyMatch[1] : null;
+
+ if (!encryptionKey && !fileInfo.passwordProtected) {
+ throw new Error('Encryption key not found in URL');
+ }
+
+ // Convert base64 back to ArrayBuffer
+ const binaryString = atob(encryptedContent);
+ const bytes = new Uint8Array(binaryString.length);
+ for (let i = 0; i < binaryString.length; i++) {
+ bytes[i] = binaryString.charCodeAt(i);
+ }
+ const encryptedBuffer = bytes.buffer;
+
+ // Decrypt file on client side
+ const cryptoService = new ClientCryptoService();
+ const { encryptedData, iv, salt } = cryptoService.separateEncryptedData(encryptedBuffer);
+
+ const decryptedData = await cryptoService.decryptFile(
+ { encryptedData, iv, salt, key: encryptionKey || '' },
+ password
+ );
+
+ const blob = new Blob([decryptedData], { type: fileInfo.mimeType });
+ setDecryptedContent(blob);
+
+ // Create preview URL
+ const url = URL.createObjectURL(blob);
+ setPreviewUrl(url);
+
+ setShowWarning(false);
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Failed to decrypt file for preview';
+ setError(errorMessage);
+ } finally {
+ setIsDecrypting(false);
+ }
+ };
+
+ // Cleanup preview URL on unmount
+ useEffect(() => {
+ return () => {
+ if (previewUrl) {
+ URL.revokeObjectURL(previewUrl);
+ }
+ };
+ }, [previewUrl]);
+
+ const renderPreviewContent = () => {
+ if (!previewUrl || !decryptedContent) return null;
+
+ if (fileInfo.mimeType.startsWith('image/')) {
+ return (
+
@@ -38,6 +47,47 @@ export function Header() {
{item.name}
))}
+
+ {/* Auth Section */}
+ {!isPending && (
+
)}
diff --git a/src/components/shared/secure-file-preview.tsx b/src/components/shared/secure-file-preview.tsx
new file mode 100644
index 0000000..9d1277d
--- /dev/null
+++ b/src/components/shared/secure-file-preview.tsx
@@ -0,0 +1,696 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { X, Download, Eye, EyeOff, AlertTriangle, FileIcon, Shield, Info, Copy } from "lucide-react";
+import { ClientCryptoService } from "@/lib/client-crypto";
+
+// Text file preview component
+interface TextFilePreviewProps {
+ blob: Blob;
+ filename: string;
+ onError: (error: string) => void;
+}
+
+function TextFilePreview({ blob, filename, onError }: TextFilePreviewProps) {
+ const [content, setContent] = useState
+ {session ? (
+
+ )}
{/* Mobile Menu Button */}
@@ -67,6 +117,48 @@ export function Header() {
{item.name}
))}
+
+ {/* Mobile Auth Section */}
+ {!isPending && (
+
+
+
+ ) : (
+
+
+ Sign In
+
+
+ Sign Up
+
+
+ )}
+
+ {session ? (
+ <>
+ setIsMenuOpen(false)}
+ >
+
+ )}
+
+ Loading content...
+
+ );
+ }
+
+ const language = getLanguageFromFilename(filename);
+
+ return (
+
+ {/* Header with file info and copy button */}
+
+ );
+}
+
+interface FileInfo {
+ id: string;
+ originalName: string;
+ mimeType: string;
+ size: number;
+ uploadedAt: string;
+ expiresAt: string;
+ passwordProtected?: boolean;
+}
+
+interface SecureFilePreviewProps {
+ shareId: string;
+ fileInfo: FileInfo;
+ encryptedContent: string;
+ password?: string;
+ onClose: () => void;
+ onDownload?: () => void;
+}
+
+// MIME types allowed for preview
+const PREVIEW_ALLOWED_TYPES = [
+ // Images
+ 'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
+
+ // Documents
+ 'application/pdf',
+
+ // Video/Audio
+ 'video/mp4', 'video/webm', 'video/ogg',
+ 'audio/mp3', 'audio/wav', 'audio/ogg', 'audio/mpeg', 'audio/mp4',
+
+ // Text files
+ 'text/plain', 'text/csv', 'text/html', 'text/css', 'text/javascript',
+ 'text/xml', 'text/markdown', 'text/x-markdown',
+
+ // Data formats
+ 'application/json', 'application/xml', 'text/json',
+ 'application/yaml', 'text/yaml', 'text/x-yaml',
+ 'application/toml', 'text/toml',
+
+ // Programming languages
+ 'application/javascript', 'text/javascript',
+ 'application/typescript', 'text/typescript',
+ 'text/x-python', 'application/x-python',
+ 'text/x-java', 'application/x-java',
+ 'text/x-c', 'text/x-c++', 'text/x-csharp',
+ 'text/x-php', 'application/x-php',
+ 'text/x-ruby', 'application/x-ruby',
+ 'text/x-go', 'application/x-go',
+ 'text/x-rust', 'application/x-rust',
+ 'text/x-scala', 'application/x-scala',
+ 'text/x-kotlin', 'application/x-kotlin',
+ 'text/x-swift', 'application/x-swift',
+
+ // Stylesheets
+ 'text/scss', 'text/sass', 'text/less',
+
+ // Config files
+ 'text/x-ini', 'application/x-ini',
+ 'text/x-properties', 'application/x-properties',
+ 'text/x-dockerfile', 'application/x-dockerfile',
+ 'text/x-nginx-conf', 'application/x-nginx-conf',
+ 'text/x-apache-conf', 'application/x-apache-conf',
+
+ // Shell scripts
+ 'text/x-shellscript', 'application/x-shellscript',
+ 'text/x-bash', 'application/x-bash',
+ 'text/x-powershell', 'application/x-powershell',
+
+ // SQL and databases
+ 'text/x-sql', 'application/sql',
+ 'text/x-mysql', 'text/x-postgresql',
+
+ // GraphQL
+ 'application/graphql', 'text/x-graphql',
+
+ // Log files
+ 'text/x-log', 'application/x-log',
+
+ // Environment files
+ 'text/x-env', 'application/x-env',
+
+ // Data files
+ 'text/tab-separated-values', 'application/x-tsv',
+
+ // Documentation
+ 'text/x-readme', 'text/x-license',
+
+ // Generic fallbacks for common extensions
+ 'application/octet-stream' // We'll handle this with file extension detection
+];
+
+// Sensitive types that require extra warning
+const SENSITIVE_TYPES = [
+ 'image/jpeg', 'image/png', 'image/gif', 'image/webp',
+ 'video/mp4', 'video/webm', 'video/ogg'
+];
+
+export function SecureFilePreview({
+ shareId,
+ fileInfo,
+ encryptedContent,
+ password,
+ onClose,
+ onDownload
+}: SecureFilePreviewProps) {
+ const [showWarning, setShowWarning] = useState(true);
+ const [isDecrypting, setIsDecrypting] = useState(false);
+ const [decryptedContent, setDecryptedContent] = useState
+
+
+ {/* Content area */}
+
+
+
+
+
+
+
+ {content}
+
+
+
+ 
setError('Failed to load image preview')}
+ />
+
+ );
+ }
+
+ if (fileInfo.mimeType === 'application/pdf') {
+ return (
+
+