Upload app.py

app.py

@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import os
+import uuid
+import json
+import threading
+from datetime import datetime
+from flask import Flask, request, jsonify, render_template, send_from_directory, redirect, url_for, session
+from werkzeug.utils import secure_filename
+from werkzeug.exceptions import RequestEntityTooLarge
+from PIL import Image
+import hashlib
+
+app = Flask(__name__)
+app.config['MAX_CONTENT_LENGTH'] = 8 * 1024 * 1024 * 1024  # 8GB
+app.config['UPLOAD_FOLDER'] = 'uploads'
+app.config['THUMBNAILS_FOLDER'] = 'thumbnails'
+app.secret_key = 'votre-cle-secrete-super-secure'
+
+# Fichier pour stocker les utilisateurs
+USERS_FILE = 'users.json'
+
+# Utilisateurs par défaut
+DEFAULT_USERS = {
+    'admin': {
+        'password': hashlib.sha256('admin123'.encode()).hexdigest(),
+        'role': 'admin'
+    },
+    'user1': {
+        'password': hashlib.sha256('password1'.encode()).hexdigest(),
+        'role': 'user'
+    },
+    'user2': {
+        'password': hashlib.sha256('password2'.encode()).hexdigest(),
+        'role': 'user'
+    },
+    'demo': {
+        'password': hashlib.sha256('demo'.encode()).hexdigest(),
+        'role': 'user'
+    }
+}
+
+def load_users():
+    """Charger les utilisateurs depuis le fichier JSON"""
+    if os.path.exists(USERS_FILE):
+        try:
+            with open(USERS_FILE, 'r') as f:
+                return json.load(f)
+        except:
+            pass
+    return DEFAULT_USERS.copy()
+
+def save_users(users):
+    """Sauvegarder les utilisateurs dans le fichier JSON"""
+    with open(USERS_FILE, 'w') as f:
+        json.dump(users, f, indent=2)
+
+# Dictionnaire pour stocker les progrès d'upload
+upload_progress = {}
+upload_lock = threading.Lock()
+
+# Types de fichiers autorisés
+ALLOWED_EXTENSIONS = {
+    'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'tiff',
+    'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'zip', 'rar', '7z', 
+    'mp3', 'wav', 'flac', 'mp4', 'avi', 'mov', 'mkv', 'webm', 'wmv',
+    'py', 'js', 'html', 'css', 'json', 'xml', 'csv','heic'
+}
+
+# Types de fichiers pour aperçu
+IMAGE_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'tiff'}
+VIDEO_EXTENSIONS = {'mp4', 'avi', 'mov', 'mkv', 'webm', 'wmv'}
+
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def get_file_size(filepath):
+    try:
+        return os.path.getsize(filepath)
+    except:
+        return 0
+
+def format_file_size(size_bytes):
+    if size_bytes == 0:
+        return "0 B"
+    size_names = ["B", "KB", "MB", "GB"]
+    i = 0
+    while size_bytes >= 1024 and i < len(size_names) - 1:
+        size_bytes /= 1024.0
+        i += 1
+    return f"{size_bytes:.1f} {size_names[i]}"
+
+def is_image(filename):
+    ext = filename.rsplit('.', 1)[1].lower() if '.' in filename else ''
+    return ext in IMAGE_EXTENSIONS
+
+def is_video(filename):
+    ext = filename.rsplit('.', 1)[1].lower() if '.' in filename else ''
+    return ext in VIDEO_EXTENSIONS
+
+def create_thumbnail(filepath, filename):
+    """Créer une vignette pour les images"""
+    try:
+        if not is_image(filename):
+            return None
+            
+        thumbnails_dir = app.config['THUMBNAILS_FOLDER']
+        os.makedirs(thumbnails_dir, exist_ok=True)
+        
+        # Nom de la vignette
+        name, ext = os.path.splitext(filename)
+        thumbnail_name = f"{name}_thumb.jpg"
+        thumbnail_path = os.path.join(thumbnails_dir, thumbnail_name)
+        
+        # Créer la vignette
+        with Image.open(filepath) as img:
+            # Convertir en RGB si nécessaire
+            if img.mode in ('RGBA', 'LA', 'P'):
+                img = img.convert('RGB')
+            
+            # Redimensionner en gardant les proportions
+            img.thumbnail((200, 200), Image.Resampling.LANCZOS)
+            img.save(thumbnail_path, 'JPEG', quality=85)
+            
+        return thumbnail_name
+    except Exception as e:
+        print(f"Erreur création vignette: {e}")
+        return None
+
+def get_user_folder(username):
+    """Obtenir le dossier utilisateur"""
+    user_folder = os.path.join(app.config['UPLOAD_FOLDER'], username)
+    os.makedirs(user_folder, exist_ok=True)
+    return user_folder
+
+def require_auth(f):
+    """Décorateur pour vérifier l'authentification"""
+    def decorated_function(*args, **kwargs):
+        if 'username' not in session:
+            if request.is_json or request.headers.get('Content-Type') == 'application/json':
+                return jsonify({'error': 'Non authentifié', 'redirect': '/login'}), 401
+            return redirect('/login')
+        return f(*args, **kwargs)
+    decorated_function.__name__ = f.__name__
+    return decorated_function
+
+def require_admin(f):
+    """Décorateur pour vérifier les droits admin"""
+    def decorated_function(*args, **kwargs):
+        if 'username' not in session:
+            return redirect('/login')
+        
+        users = load_users()
+        user_info = users.get(session['username'], {})
+        if user_info.get('role') != 'admin':
+            return jsonify({'error': 'Accès refusé - Droits administrateur requis'}), 403
+        
+        return f(*args, **kwargs)
+    decorated_function.__name__ = f.__name__
+    return decorated_function
+
+@app.before_request
+def check_auth():
+    """Vérifier l'authentification pour toutes les routes sauf login"""
+    public_routes = ['/login', '/static']
+    
+    is_public = any(request.path.startswith(route) for route in public_routes)
+    
+    if not is_public and 'username' not in session:
+        if request.is_json or request.headers.get('Content-Type') == 'application/json':
+            return jsonify({'error': 'Non authentifié', 'redirect': '/login'}), 401
+        return redirect('/login')
+
+@app.route('/')
+def index():
+    if 'username' not in session:
+        return redirect('/login')
+    
+    users = load_users()
+    user_info = users.get(session['username'], {})
+    is_admin = user_info.get('role') == 'admin'
+    
+    return render_template('index.html', username=session['username'], is_admin=is_admin)
+
+@app.route('/login')
+def login_page():
+    if 'username' in session:
+        return redirect('/')
+    return render_template('login.html')
+
+@app.route('/login', methods=['POST'])
+def login():
+    data = request.get_json()
+    username = data.get('username', '').strip()
+    password = data.get('password', '').strip()
+    
+    if not username or not password:
+        return jsonify({'success': False, 'error': 'Identifiant et mot de passe requis'})
+    
+    users = load_users()
+    password_hash = hashlib.sha256(password.encode()).hexdigest()
+    
+    if username in users and users[username]['password'] == password_hash:
+        session['username'] = username
+        return jsonify({'success': True, 'redirect': '/'})
+    else:
+        return jsonify({'success': False, 'error': 'Identifiants incorrects'})
+
+@app.route('/logout')
+def logout():
+    session.pop('username', None)
+    return redirect('/login')
+
+@app.route('/api/files')
+@require_auth
+def api_files():
+    files = []
+    user_folder = get_user_folder(session['username'])
+    
+    if os.path.exists(user_folder):
+        for filename in os.listdir(user_folder):
+            filepath = os.path.join(user_folder, filename)
+            if os.path.isfile(filepath):
+                file_size = get_file_size(filepath)
+                
+                file_info = {
+                    'name': filename,
+                    'size': format_file_size(file_size),
+                    'size_bytes': file_size,
+                    'date': datetime.fromtimestamp(os.path.getmtime(filepath)).strftime('%Y-%m-%d %H:%M:%S'),
+                    'is_image': is_image(filename),
+                    'is_video': is_video(filename),
+                    'thumbnail': None
+                }
+                
+                if is_image(filename):
+                    thumbnail_name = create_thumbnail(filepath, filename)
+                    if thumbnail_name:
+                        file_info['thumbnail'] = thumbnail_name
+                
+                files.append(file_info)
+    
+    files.sort(key=lambda x: x['date'], reverse=True)
+    total_size = sum(f['size_bytes'] for f in files)
+    
+    return jsonify({
+        'files': files,
+        'total_files': len(files),
+        'total_size': format_file_size(total_size)
+    })
+
+@app.route('/upload', methods=['POST'])
+@require_auth
+def upload_file():
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'Aucun fichier sélectionné'}), 400
+        
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({'error': 'Aucun fichier sélectionné'}), 400
+        
+        if not allowed_file(file.filename):
+            return jsonify({'error': 'Type de fichier non autorisé'}), 400
+        
+        user_folder = get_user_folder(session['username'])
+        filename = secure_filename(file.filename)
+        
+        base_name, ext = os.path.splitext(filename)
+        counter = 1
+        while os.path.exists(os.path.join(user_folder, filename)):
+            filename = f"{base_name}_{counter}{ext}"
+            counter += 1
+        
+        filepath = os.path.join(user_folder, filename)
+        file.save(filepath)
+        
+        thumbnail_name = None
+        if is_image(filename):
+            thumbnail_name = create_thumbnail(filepath, filename)
+        
+        file_size = get_file_size(filepath)
+        
+        return jsonify({
+            'success': True,
+            'message': f'Fichier {filename} uploadé avec succès!',
+            'filename': filename,
+            'size': format_file_size(file_size),
+            'thumbnail': thumbnail_name
+        })
+        
+    except RequestEntityTooLarge:
+        return jsonify({'error': 'Fichier trop volumineux (max 8GB)'}), 413
+    except Exception as e:
+        return jsonify({'error': f'Erreur lors de l\'upload: {str(e)}'}), 500
+
+@app.route('/download/<filename>')
+@require_auth
+def download_file(filename):
+    try:
+        user_folder = get_user_folder(session['username'])
+        return send_from_directory(user_folder, filename, as_attachment=True)
+    except FileNotFoundError:
+        return jsonify({'error': 'Fichier non trouvé'}), 404
+
+@app.route('/delete/<filename>', methods=['DELETE'])
+@require_auth
+def delete_file(filename):
+    try:
+        user_folder = get_user_folder(session['username'])
+        filepath = os.path.join(user_folder, filename)
+        
+        if os.path.exists(filepath):
+            os.remove(filepath)
+            
+            if is_image(filename):
+                name, ext = os.path.splitext(filename)
+                thumbnail_name = f"{name}_thumb.jpg"
+                thumbnail_path = os.path.join(app.config['THUMBNAILS_FOLDER'], thumbnail_name)
+                if os.path.exists(thumbnail_path):
+                    os.remove(thumbnail_path)
+            
+            return jsonify({'success': True, 'message': f'Fichier {filename} supprimé'})
+        else:
+            return jsonify({'error': 'Fichier non trouvé'}), 404
+    except Exception as e:
+        return jsonify({'error': f'Erreur lors de la suppression: {str(e)}'}), 500
+
+@app.route('/thumbnail/<thumbnail_name>')
+@require_auth
+def get_thumbnail(thumbnail_name):
+    try:
+        return send_from_directory(app.config['THUMBNAILS_FOLDER'], thumbnail_name)
+    except FileNotFoundError:
+        return jsonify({'error': 'Vignette non trouvée'}), 404
+
+@app.route('/preview/<filename>')
+@require_auth
+def preview_file(filename):
+    try:
+        user_folder = get_user_folder(session['username'])
+        return send_from_directory(user_folder, filename)
+    except FileNotFoundError:
+        return jsonify({'error': 'Fichier non trouvé'}), 404
+
+# Routes d'administration
+@app.route('/admin/users')
+@require_admin
+def admin_users():
+    users = load_users()
+    user_list = []
+    for username, info in users.items():
+        user_list.append({
+            'username': username,
+            'role': info.get('role', 'user')
+        })
+    return jsonify({'users': user_list})
+
+@app.route('/admin/users', methods=['POST'])
+@require_admin
+def add_user():
+    data = request.get_json()
+    username = data.get('username', '').strip()
+    password = data.get('password', '').strip()
+    role = data.get('role', 'user')
+    
+    if not username or not password:
+        return jsonify({'success': False, 'error': 'Nom d\'utilisateur et mot de passe requis'})
+    
+    users = load_users()
+    if username in users:
+        return jsonify({'success': False, 'error': 'Utilisateur déjà existant'})
+    
+    users[username] = {
+        'password': hashlib.sha256(password.encode()).hexdigest(),
+        'role': role
+    }
+    
+    save_users(users)
+    return jsonify({'success': True, 'message': f'Utilisateur {username} créé avec succès'})
+
+@app.route('/admin/users/<username>', methods=['DELETE'])
+@require_admin
+def delete_user(username):
+    if username == 'admin':
+        return jsonify({'success': False, 'error': 'Impossible de supprimer l\'administrateur principal'})
+    
+    users = load_users()
+    if username not in users:
+        return jsonify({'success': False, 'error': 'Utilisateur non trouvé'})
+    
+    # Supprimer les fichiers de l'utilisateur
+    user_folder = get_user_folder(username)
+    if os.path.exists(user_folder):
+        import shutil
+        shutil.rmtree(user_folder)
+    
+    del users[username]
+    save_users(users)
+    
+    return jsonify({'success': True, 'message': f'Utilisateur {username} supprimé avec succès'})
+
+@app.errorhandler(413)
+def too_large(e):
+    return jsonify({'error': 'Fichier trop volumineux (max 8GB)'}), 413
+
+@app.errorhandler(404)
+def not_found(e):
+    return jsonify({'error': 'Page non trouvée'}), 404
+
+@app.errorhandler(500)
+def server_error(e):
+    return jsonify({'error': 'Erreur serveur interne'}), 500
+
+if __name__ == '__main__':
+    os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+    os.makedirs(app.config['THUMBNAILS_FOLDER'], exist_ok=True)
+    
+    print("🚀 Démarrage du serveur de gestion de fichiers...")
+    print("🌐 Accédez au site sur: http://0.0.0.0:7777")
+    print("📱 Interface optimisée pour mobile et desktop")
+    print("👥 Utilisateurs disponibles:")
+    print("   • admin / admin123 (Administrateur)")
+    print("   • user1 / password1") 
+    print("   • user2 / password2")
+    print("   • demo / demo")
+    print("⚡ Fonctionnalités:")
+    print("   • Authentification multi-utilisateurs")
+    print("   • Gestion des utilisateurs (admin)")
+    print("   • Upload de fichiers (jusqu'à 8GB)")
+    print("   • Aperçu des images et vidéos")
+    print("   • Vignettes automatiques")
+    print("   • Download et suppression de fichiers")
+    print("   • Interface responsive")
+    print("   • API JSON disponible sur /api/files")
+    print("\n🛑 Appuyez sur Ctrl+C pour arrêter le serveur")
+    
+    app.run(host='0.0.0.0', port=7777, debug=True, threaded=True)