Spaces:

sivakumar330
/

Quotes

Paused

App Files Files Community

sivakumar330 commited on Feb 21

Commit

1622e95

verified ·

1 Parent(s): f58a5f3

Update app.py

Browse files

Files changed (1) hide show

app.py +715 -137

app.py CHANGED Viewed

@@ -1,256 +1,834 @@
-# app.py - Production Ready eBook API (HuggingFace Compatible)
 import os
 import uuid
 import datetime
-import mimetypes
-from flask import Flask, request, jsonify, send_file
 from flask_cors import CORS
 from werkzeug.utils import secure_filename
 import json
 from pathlib import Path
 app = Flask(__name__)
-CORS(app)
 UPLOAD_FOLDER = 'uploads'
-METADATA_FILE = 'ebooks_metadata.json'
 ALLOWED_EXTENSIONS = {'pdf', 'epub', 'txt', 'docx'}
-MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB
 Path(UPLOAD_FOLDER).mkdir(parents=True, exist_ok=True)
-# -------------------- UTILITIES --------------------
 def load_metadata():
     if os.path.exists(METADATA_FILE):
-        with open(METADATA_FILE, 'r') as f:
-            return json.load(f)
     return {}
-def save_metadata(data):
-    with open(METADATA_FILE, 'w') as f:
-        json.dump(data, f, indent=2)
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
-# -------------------- UPLOAD --------------------
 @app.route('/api/upload', methods=['POST'])
 def upload_ebook():
     try:
         if 'file' not in request.files:
             return jsonify({'error': 'No file provided'}), 400
         file = request.files['file']
         if file.filename == '':
             return jsonify({'error': 'No file selected'}), 400
         if not allowed_file(file.filename):
-            return jsonify({'error': 'Invalid file type'}), 400
-        # 🔥 IMPORTANT FIX — read image_url + price
         title = request.form.get('title', '')
         author = request.form.get('author', '')
         category = request.form.get('category', 'General')
         uploaded_by = request.form.get('uploaded_by', '')
         image_url = request.form.get('image_url', '')
-        price = request.form.get('price', 0)
         if not uploaded_by:
             return jsonify({'error': 'User ID required'}), 400
         original_filename = secure_filename(file.filename)
         file_ext = original_filename.rsplit('.', 1)[1].lower()
         unique_id = str(uuid.uuid4())
-        stored_filename = f"{unique_id}.{file_ext}"
-        filepath = os.path.join(UPLOAD_FOLDER, stored_filename)
         file.save(filepath)
         file_size = os.path.getsize(filepath)
         if file_size > MAX_FILE_SIZE:
             os.remove(filepath)
-            return jsonify({'error': 'File too large (max 50MB)'}), 400
         ebooks_metadata = load_metadata()
-        ebook_data = {
-            "id": unique_id,
-            "filename": original_filename,
-            "stored_filename": stored_filename,
-            "title": title or original_filename,
-            "author": author,
-            "category": category,
-            "uploaded_by": uploaded_by,
-            "image_url": image_url,      # ✅ FIXED
-            "price": int(price) if str(price).isdigit() else 0,
-            "size": file_size,
-            "upload_date": datetime.datetime.now().isoformat(),
-            "download_count": 0
-        }
-        ebooks_metadata[unique_id] = ebook_data
         save_metadata(ebooks_metadata)
         return jsonify({
-            "message": "Upload successful",
-            "ebook": ebook_data
         }), 201
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# -------------------- GET ALL --------------------
 @app.route('/api/ebooks', methods=['GET'])
 def get_ebooks():
     try:
         ebooks_metadata = load_metadata()
-        ebook_list = list(ebooks_metadata.values())
-        ebook_list.sort(
-            key=lambda x: x.get('upload_date', ''),
-            reverse=True
-        )
         return jsonify(ebook_list), 200
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# -------------------- DOWNLOAD --------------------
 @app.route('/api/download/<ebook_id>', methods=['GET'])
 def download_ebook(ebook_id):
     try:
         ebooks_metadata = load_metadata()
         if ebook_id not in ebooks_metadata:
-            return jsonify({'error': 'Not found'}), 404
-        ebook = ebooks_metadata[ebook_id]
-        filepath = os.path.join(UPLOAD_FOLDER, ebook['stored_filename'])
         if not os.path.exists(filepath):
-            return jsonify({'error': 'File missing'}), 404
         # Increment download count
-        ebook['download_count'] += 1
         save_metadata(ebooks_metadata)
-        mime_type, _ = mimetypes.guess_type(filepath)
         return send_file(
             filepath,
             as_attachment=True,
-            download_name=ebook['filename'],
-            mimetype=mime_type or 'application/octet-stream'
         )
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# -------------------- DELETE --------------------
 @app.route('/api/ebooks/<ebook_id>', methods=['DELETE'])
 def delete_ebook(ebook_id):
     try:
         data = request.get_json()
         user_id = data.get('user_id')
         if not user_id:
             return jsonify({'error': 'User ID required'}), 400
         ebooks_metadata = load_metadata()
         if ebook_id not in ebooks_metadata:
-            return jsonify({'error': 'Not found'}), 404
-        ebook = ebooks_metadata[ebook_id]
-        if ebook['uploaded_by'] != user_id:
-            return jsonify({'error': 'Unauthorized'}), 403
-        filepath = os.path.join(UPLOAD_FOLDER, ebook['stored_filename'])
         if os.path.exists(filepath):
             os.remove(filepath)
         del ebooks_metadata[ebook_id]
         save_metadata(ebooks_metadata)
-        return jsonify({'message': 'Deleted'}), 200
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# -------------------- SEARCH --------------------
 @app.route('/api/ebooks/search', methods=['GET'])
 def search_ebooks():
     try:
         query = request.args.get('q', '').lower()
-        category = request.args.get('category', '').lower()
         ebooks_metadata = load_metadata()
         results = []
-        for ebook in ebooks_metadata.values():
             match = True
             if query:
                 match = match and (
-                    query in ebook.get('title', '').lower() or
-                    query in ebook.get('author', '').lower() or
-                    query in ebook.get('filename', '').lower()
                 )
             if category:
-                match = match and category == ebook.get('category', '').lower()
             if match:
-                results.append(ebook)
         return jsonify(results), 200
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# -------------------- USER EBOOKS --------------------
 @app.route('/api/ebooks/user/<user_id>', methods=['GET'])
 def get_user_ebooks(user_id):
     try:
         ebooks_metadata = load_metadata()
-        user_ebooks = [
-            ebook for ebook in ebooks_metadata.values()
-            if ebook.get('uploaded_by') == user_id
-        ]
         return jsonify(user_ebooks), 200
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# -------------------- HEALTH --------------------
-@app.route('/api/health', methods=['GET'])
-def health():
-    return jsonify({
-        "status": "healthy",
-        "time": datetime.datetime.now().isoformat()
-    }), 200
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)

+# app.py - Main Flask application for eBook management with Hugging Face Spaces support
 import os
 import uuid
 import datetime
+from flask import Flask, request, jsonify, send_file, render_template_string
 from flask_cors import CORS
 from werkzeug.utils import secure_filename
+import hashlib
 import json
 from pathlib import Path
 app = Flask(__name__)
+CORS(app)  # Enable CORS for frontend communication
+# Configuration
 UPLOAD_FOLDER = 'uploads'
 ALLOWED_EXTENSIONS = {'pdf', 'epub', 'txt', 'docx'}
+MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB limit
+# Create upload folder if it doesn't exist
 Path(UPLOAD_FOLDER).mkdir(parents=True, exist_ok=True)
+# Persistent storage using JSON file (works on Hugging Face)
+METADATA_FILE = 'ebooks_metadata.json'
 def load_metadata():
+    """Load eBook metadata from JSON file"""
     if os.path.exists(METADATA_FILE):
+        try:
+            with open(METADATA_FILE, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except:
+            return {}
     return {}
+def save_metadata(metadata):
+    """Save eBook metadata to JSON file"""
+    try:
+        with open(METADATA_FILE, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f, indent=2, ensure_ascii=False)
+    except Exception as e:
+        print(f"Error saving metadata: {e}")
 def allowed_file(filename):
+    """Check if file extension is allowed"""
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+def get_file_hash(file):
+    """Generate unique hash for file"""
+    hash_md5 = hashlib.md5()
+    for chunk in iter(lambda: file.read(4096), b""):
+        hash_md5.update(chunk)
+    file.seek(0)  # Reset file pointer
+    return hash_md5.hexdigest()
+# Default cover images for eBooks
+DEFAULT_COVERS = [
+    "https://images.unsplash.com/photo-1512820790803-83ca734da794?w=500",
+    "https://images.unsplash.com/photo-1495446815901-a7297e633e8d?w=500",
+    "https://images.unsplash.com/photo-1532012197267-da84d127e765?w=500",
+    "https://images.unsplash.com/photo-1456513080510-7bf3a84b82f8?w=500",
+    "https://images.unsplash.com/photo-1524995997946-a1c2e315a42f?w=500"
+]
+# HTML template for testing (optional)
+INDEX_TEMPLATE = '''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>📚 eBook Server - Hugging Face</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(10px);
+            border-radius: 20px;
+            padding: 30px;
+            box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+        }
+        h1 {
+            font-size: 2.5rem;
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 10px;
+        }
+        .subtitle {
+            color: #666;
+            margin-bottom: 30px;
+        }
+        .upload-section {
+            background: #f8f9fa;
+            border-radius: 15px;
+            padding: 25px;
+            margin-bottom: 30px;
+            border: 2px dashed #667eea;
+        }
+        .upload-section h3 {
+            color: #333;
+            margin-bottom: 20px;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        .form-group {
+            margin-bottom: 15px;
+        }
+        input, select {
+            width: 100%;
+            padding: 12px 15px;
+            border: 1px solid #ddd;
+            border-radius: 10px;
+            font-size: 14px;
+            transition: border-color 0.3s;
+        }
+        input:focus, select:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+        .btn {
+            padding: 12px 25px;
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            color: white;
+            border: none;
+            border-radius: 10px;
+            font-size: 16px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+        .btn:hover {
+            transform: translateY(-2px);
+        }
+        .btn-secondary {
+            background: linear-gradient(135deg, #10b981, #059669);
+        }
+        .btn-danger {
+            background: linear-gradient(135deg, #ef4444, #dc2626);
+        }
+        .ebooks-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+            gap: 20px;
+            margin-top: 20px;
+        }
+        .ebook-card {
+            background: white;
+            border-radius: 15px;
+            overflow: hidden;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+            transition: transform 0.3s;
+        }
+        .ebook-card:hover {
+            transform: translateY(-5px);
+        }
+        .ebook-cover {
+            width: 100%;
+            height: 200px;
+            object-fit: cover;
+            background: #f0f0f0;
+        }
+        .ebook-info {
+            padding: 15px;
+        }
+        .ebook-title {
+            font-size: 1.1rem;
+            font-weight: 700;
+            margin-bottom: 5px;
+            color: #333;
+        }
+        .ebook-meta {
+            font-size: 0.85rem;
+            color: #666;
+            margin-bottom: 10px;
+        }
+        .ebook-badge {
+            display: inline-block;
+            padding: 4px 10px;
+            background: linear-gradient(135deg, #f59e0b, #d97706);
+            color: white;
+            border-radius: 20px;
+            font-size: 0.7rem;
+            font-weight: 700;
+            margin-bottom: 10px;
+        }
+        .ebook-actions {
+            display: flex;
+            gap: 10px;
+            margin-top: 10px;
+        }
+        .ebook-actions button {
+            flex: 1;
+            padding: 8px;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 0.85rem;
+            font-weight: 600;
+            transition: opacity 0.2s;
+        }
+        .stats {
+            display: flex;
+            gap: 20px;
+            margin: 20px 0;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea10, #764ba210);
+            border-radius: 15px;
+        }
+        .stat-item {
+            flex: 1;
+            text-align: center;
+        }
+        .stat-value {
+            font-size: 2rem;
+            font-weight: 700;
+            color: #667eea;
+        }
+        .stat-label {
+            color: #666;
+            font-size: 0.9rem;
+        }
+        .search-bar {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+        .search-bar input {
+            flex: 1;
+        }
+        .toast {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            padding: 15px 25px;
+            background: #10b981;
+            color: white;
+            border-radius: 10px;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+            animation: slideIn 0.3s ease;
+            z-index: 1000;
+        }
+        .toast.error {
+            background: #ef4444;
+        }
+        @keyframes slideIn {
+            from { transform: translateX(100%); opacity: 0; }
+            to { transform: translateX(0); opacity: 1; }
+        }
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #666;
+        }
+        .loading::after {
+            content: '';
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid #f3f3f3;
+            border-top: 3px solid #667eea;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin-left: 10px;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>📚 eBook Management Server</h1>
+        <div class="subtitle">Hugging Face Backend for Quotes Platform</div>
+        <div class="stats" id="stats">
+            <div class="stat-item">
+                <div class="stat-value" id="totalEbooks">0</div>
+                <div class="stat-label">Total eBooks</div>
+            </div>
+            <div class="stat-item">
+                <div class="stat-value" id="totalDownloads">0</div>
+                <div class="stat-label">Total Downloads</div>
+            </div>
+            <div class="stat-item">
+                <div class="stat-value" id="storageUsed">0 MB</div>
+                <div class="stat-label">Storage Used</div>
+            </div>
+        </div>
+        <div class="upload-section">
+            <h3><span>📤</span> Upload New eBook</h3>
+            <form id="uploadForm" enctype="multipart/form-data">
+                <div class="form-group">
+                    <input type="file" name="file" accept=".pdf,.epub,.txt,.docx" required>
+                </div>
+                <div class="form-group">
+                    <input type="text" name="title" placeholder="Book Title (optional)">
+                </div>
+                <div class="form-group">
+                    <input type="text" name="author" placeholder="Author (optional)">
+                </div>
+                <div class="form-group">
+                    <select name="category">
+                        <option value="General">General</option>
+                        <option value="Fiction">Fiction</option>
+                        <option value="Non-Fiction">Non-Fiction</option>
+                        <option value="Poetry">Poetry</option>
+                        <option value="Philosophy">Philosophy</option>
+                        <option value="Self-Help">Self-Help</option>
+                        <option value="Science">Science</option>
+                        <option value="Technology">Technology</option>
+                    </select>
+                </div>
+                <div class="form-group">
+                    <input type="url" name="image_url" placeholder="Cover Image URL (optional)">
+                </div>
+                <div class="form-group">
+                    <input type="text" name="uploaded_by" placeholder="Your User ID" required>
+                </div>
+                <button type="submit" class="btn">📤 Upload eBook</button>
+            </form>
+        </div>
+        <div class="search-bar">
+            <input type="text" id="searchInput" placeholder="Search eBooks by title, author, or category...">
+            <button class="btn btn-secondary" onclick="searchEbooks()">🔍 Search</button>
+            <button class="btn" onclick="fetchEbooks()">⟲ Refresh</button>
+        </div>
+        <div class="ebooks-grid" id="ebooksGrid">
+            <div class="loading">Loading eBooks...</div>
+        </div>
+    </div>
+    <script>
+        // Show toast notification
+        function showToast(message, isError = false) {
+            const toast = document.createElement('div');
+            toast.className = `toast ${isError ? 'error' : ''}`;
+            toast.textContent = message;
+            document.body.appendChild(toast);
+            setTimeout(() => {
+                toast.style.opacity = '0';
+                setTimeout(() => toast.remove(), 300);
+            }, 3000);
+        }
+        // Load eBooks on page load
+        window.onload = function() {
+            fetchEbooks();
+        };
+        document.getElementById('uploadForm').onsubmit = async function(e) {
+            e.preventDefault();
+            const formData = new FormData(this);
+            try {
+                const response = await fetch('/api/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+                const data = await response.json();
+                if (response.ok) {
+                    showToast('✅ eBook uploaded successfully!');
+                    this.reset();
+                    fetchEbooks();
+                } else {
+                    showToast('❌ Upload failed: ' + data.error, true);
+                }
+            } catch (error) {
+                showToast('❌ Error uploading file', true);
+            }
+        };
+        async function fetchEbooks() {
+            document.getElementById('ebooksGrid').innerHTML = '<div class="loading">Loading eBooks...</div>';
+            try {
+                const response = await fetch('/api/ebooks');
+                const ebooks = await response.json();
+                displayEbooks(ebooks);
+                updateStats(ebooks);
+            } catch (error) {
+                document.getElementById('ebooksGrid').innerHTML = '<div style="text-align:center; padding:40px; color:#666;">❌ Error loading eBooks</div>';
+            }
+        }
+        async function searchEbooks() {
+            const query = document.getElementById('searchInput').value;
+            if (!query) {
+                fetchEbooks();
+                return;
+            }
+            document.getElementById('ebooksGrid').innerHTML = '<div class="loading">Searching...</div>';
+            try {
+                const response = await fetch(`/api/ebooks/search?q=${encodeURIComponent(query)}`);
+                const ebooks = await response.json();
+                displayEbooks(ebooks);
+            } catch (error) {
+                document.getElementById('ebooksGrid').innerHTML = '<div style="text-align:center; padding:40px; color:#666;">❌ Error searching eBooks</div>';
+            }
+        }
+        function updateStats(ebooks) {
+            document.getElementById('totalEbooks').textContent = ebooks.length;
+            const totalDownloads = ebooks.reduce((sum, ebook) => sum + (ebook.download_count || 0), 0);
+            document.getElementById('totalDownloads').textContent = totalDownloads;
+            const totalSizeMB = (ebooks.reduce((sum, ebook) => sum + (ebook.size || 0), 0) / (1024 * 1024)).toFixed(2);
+            document.getElementById('storageUsed').textContent = totalSizeMB + ' MB';
+        }
+        function displayEbooks(ebooks) {
+            const grid = document.getElementById('ebooksGrid');
+            if (!ebooks || ebooks.length === 0) {
+                grid.innerHTML = '<div style="text-align:center; padding:40px; color:#666;">📭 No eBooks available</div>';
+                return;
+            }
+            grid.innerHTML = ebooks.map(ebook => {
+                const coverImage = ebook.image_url || 'https://images.unsplash.com/photo-1512820790803-83ca734da794?w=500';
+                const uploadDate = new Date(ebook.upload_date).toLocaleDateString();
+                const sizeKB = (ebook.size / 1024).toFixed(2);
+                return `
+                    <div class="ebook-card">
+                        <img src="${coverImage}"
+                             class="ebook-cover"
+                             onerror="this.src='https://images.unsplash.com/photo-1512820790803-83ca734da794?w=500'">
+                        <div class="ebook-info">
+                            <div class="ebook-title">${ebook.title || ebook.filename}</div>
+                            <div class="ebook-meta">
+                                By ${ebook.author || 'Unknown'} • ${ebook.category || 'General'}<br>
+                                Uploaded: ${uploadDate}<br>
+                                Size: ${sizeKB} KB • Downloads: ${ebook.download_count || 0}
+                            </div>
+                            <span class="ebook-badge">FREE</span>
+                            <div class="ebook-actions">
+                                <button style="background: linear-gradient(135deg, #10b981, #059669); color: white;"
+                                        onclick="downloadEbook('${ebook.id}')">
+                                    📥 Download
+                                </button>
+                                <button style="background: linear-gradient(135deg, #ef4444, #dc2626); color: white;"
+                                        onclick="promptDelete('${ebook.id}', '${ebook.uploaded_by}')">
+                                    🗑️ Delete
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                `;
+            }).join('');
+        }
+        async function downloadEbook(ebookId) {
+            window.location.href = `/api/download/${ebookId}`;
+        }
+        function promptDelete(ebookId, uploadedBy) {
+            const userId = prompt('Enter your User ID to delete this eBook:');
+            if (!userId) return;
+            if (userId !== uploadedBy) {
+                showToast('❌ Only the uploader can delete this eBook', true);
+                return;
+            }
+            if (confirm('Are you sure you want to delete this eBook?')) {
+                deleteEbook(ebookId, userId);
+            }
+        }
+        async function deleteEbook(ebookId, userId) {
+            try {
+                const response = await fetch(`/api/ebooks/${ebookId}`, {
+                    method: 'DELETE',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ user_id: userId })
+                });
+                const data = await response.json();
+                if (response.ok) {
+                    showToast('✅ eBook deleted successfully');
+                    fetchEbooks();
+                } else {
+                    showToast('❌ Delete failed: ' + data.error, true);
+                }
+            } catch (error) {
+                showToast('❌ Error deleting eBook', true);
+            }
+        }
+        // Search on enter key
+        document.getElementById('searchInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                searchEbooks();
+            }
+        });
+    </script>
+</body>
+</html>
+'''
+@app.route('/')
+def index():
+    """Test interface (optional)"""
+    return render_template_string(INDEX_TEMPLATE)
 @app.route('/api/upload', methods=['POST'])
 def upload_ebook():
+    """Handle eBook upload"""
     try:
+        # Check if file exists in request
         if 'file' not in request.files:
             return jsonify({'error': 'No file provided'}), 400
         file = request.files['file']
         if file.filename == '':
             return jsonify({'error': 'No file selected'}), 400
         if not allowed_file(file.filename):
+            return jsonify({'error': f'File type not allowed. Allowed types: {", ".join(ALLOWED_EXTENSIONS)}'}), 400
+        # Get additional metadata
         title = request.form.get('title', '')
         author = request.form.get('author', '')
         category = request.form.get('category', 'General')
         uploaded_by = request.form.get('uploaded_by', '')
         image_url = request.form.get('image_url', '')
         if not uploaded_by:
             return jsonify({'error': 'User ID required'}), 400
+        # Generate unique filename
         original_filename = secure_filename(file.filename)
         file_ext = original_filename.rsplit('.', 1)[1].lower()
         unique_id = str(uuid.uuid4())
+        filename = f"{unique_id}_{original_filename}"
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        # Save file
         file.save(filepath)
         file_size = os.path.getsize(filepath)
+        # Check file size
         if file_size > MAX_FILE_SIZE:
             os.remove(filepath)
+            return jsonify({'error': f'File too large. Max size: {MAX_FILE_SIZE/1024/1024}MB'}), 400
+        # Select random default cover if no image URL provided
+        if not image_url:
+            import random
+            image_url = random.choice(DEFAULT_COVERS)
+        # Create metadata
+        metadata = {
+            'id': unique_id,
+            'filename': original_filename,
+            'stored_filename': filename,
+            'title': title or original_filename,
+            'author': author or 'Unknown',
+            'category': category,
+            'image_url': image_url,
+            'uploaded_by': uploaded_by,
+            'size': file_size,
+            'upload_date': datetime.datetime.now().isoformat(),
+            'download_count': 0
+        }
+        # Save metadata
         ebooks_metadata = load_metadata()
+        ebooks_metadata[unique_id] = metadata
         save_metadata(ebooks_metadata)
         return jsonify({
+            'message': 'eBook uploaded successfully',
+            'ebook': metadata
         }), 201
     except Exception as e:
+        return jsonify({'error': str(e)}), 500
 @app.route('/api/ebooks', methods=['GET'])
 def get_ebooks():
+    """Get list of all eBooks"""
     try:
         ebooks_metadata = load_metadata()
+        # Remove sensitive information and add download URL
+        ebook_list = []
+        for ebook_id, metadata in ebooks_metadata.items():
+            ebook_info = metadata.copy()
+            ebook_info['download_url'] = f'/api/download/{ebook_id}'
+            ebook_list.append(ebook_info)
+        # Sort by upload date (newest first)
+        ebook_list.sort(key=lambda x: x.get('upload_date', ''), reverse=True)
         return jsonify(ebook_list), 200
     except Exception as e:
+        return jsonify({'error': str(e)}), 500
 @app.route('/api/download/<ebook_id>', methods=['GET'])
 def download_ebook(ebook_id):
+    """Download specific eBook"""
     try:
         ebooks_metadata = load_metadata()
         if ebook_id not in ebooks_metadata:
+            return jsonify({'error': 'eBook not found'}), 404
+        metadata = ebooks_metadata[ebook_id]
+        filepath = os.path.join(UPLOAD_FOLDER, metadata['stored_filename'])
         if not os.path.exists(filepath):
+            return jsonify({'error': 'File not found on server'}), 404
         # Increment download count
+        metadata['download_count'] = metadata.get('download_count', 0) + 1
         save_metadata(ebooks_metadata)
         return send_file(
             filepath,
             as_attachment=True,
+            download_name=metadata['filename'],
+            mimetype='application/octet-stream'
         )
     except Exception as e:
+        return jsonify({'error': str(e)}), 500
 @app.route('/api/ebooks/<ebook_id>', methods=['DELETE'])
 def delete_ebook(ebook_id):
+    """Delete an eBook (only by uploader)"""
     try:
         data = request.get_json()
         user_id = data.get('user_id')
         if not user_id:
             return jsonify({'error': 'User ID required'}), 400
         ebooks_metadata = load_metadata()
         if ebook_id not in ebooks_metadata:
+            return jsonify({'error': 'eBook not found'}), 404
+        metadata = ebooks_metadata[ebook_id]
+        # Check if user is the uploader
+        if metadata['uploaded_by'] != user_id:
+            return jsonify({'error': 'Unauthorized: Only uploader can delete'}), 403
+        # Delete file
+        filepath = os.path.join(UPLOAD_FOLDER, metadata['stored_filename'])
         if os.path.exists(filepath):
             os.remove(filepath)
+        # Delete metadata
         del ebooks_metadata[ebook_id]
         save_metadata(ebooks_metadata)
+        return jsonify({'message': 'eBook deleted successfully'}), 200
     except Exception as e:
+        return jsonify({'error': str(e)}), 500
 @app.route('/api/ebooks/search', methods=['GET'])
 def search_ebooks():
+    """Search eBooks by title, author, or category"""
     try:
         query = request.args.get('q', '').lower()
+        category = request.args.get('category', '')
+        if not query and not category:
+            return get_ebooks()
         ebooks_metadata = load_metadata()
         results = []
+        for ebook_id, metadata in ebooks_metadata.items():
             match = True
             if query:
                 match = match and (
+                    query in metadata.get('title', '').lower() or
+                    query in metadata.get('author', '').lower() or
+                    query in metadata.get('filename', '').lower()
                 )
             if category:
+                match = match and category.lower() == metadata.get('category', '').lower()
             if match:
+                ebook_info = metadata.copy()
+                ebook_info['download_url'] = f'/api/download/{ebook_id}'
+                results.append(ebook_info)
         return jsonify(results), 200
     except Exception as e:
+        return jsonify({'error': str(e)}), 500
 @app.route('/api/ebooks/user/<user_id>', methods=['GET'])
 def get_user_ebooks(user_id):
+    """Get eBooks uploaded by specific user"""
     try:
         ebooks_metadata = load_metadata()
+        user_ebooks = []
+        for ebook_id, metadata in ebooks_metadata.items():
+            if metadata.get('uploaded_by') == user_id:
+                ebook_info = metadata.copy()
+                ebook_info['download_url'] = f'/api/download/{ebook_id}'
+                user_ebooks.append(ebook_info)
         return jsonify(user_ebooks), 200
     except Exception as e:
+        return jsonify({'error': str(e)}), 500
+# Health check endpoint
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Health check endpoint for monitoring"""
+    try:
+        ebooks_metadata = load_metadata()
+        total_size = sum(m.get('size', 0) for m in ebooks_metadata.values())
+        return jsonify({
+            'status': 'healthy',
+            'timestamp': datetime.datetime.now().isoformat(),
+            'stats': {
+                'total_ebooks': len(ebooks_metadata),
+                'total_size_mb': round(total_size / (1024 * 1024), 2),
+                'allowed_extensions': list(ALLOWED_EXTENSIONS),
+                'max_file_size_mb': MAX_FILE_SIZE / (1024 * 1024)
+            }
+        }), 200
+    except Exception as e:
+        return jsonify({'status': 'unhealthy', 'error': str(e)}), 500
+# Error handlers
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({'error': 'Endpoint not found'}), 404
+@app.errorhandler(500)
+def internal_error(error):
+    return jsonify({'error': 'Internal server error'}), 500
+# Clean up old files (optional - can be called periodically)
+@app.route('/api/cleanup', methods=['POST'])
+def cleanup_files():
+    """Remove orphaned files (files without metadata)"""
+    try:
+        ebooks_metadata = load_metadata()
+        stored_files = set(m['stored_filename'] for m in ebooks_metadata.values())
+        cleaned = 0
+        for filename in os.listdir(UPLOAD_FOLDER):
+            if filename not in stored_files:
+                filepath = os.path.join(UPLOAD_FOLDER, filename)
+                os.remove(filepath)
+                cleaned += 1
+        return jsonify({
+            'message': f'Cleaned up {cleaned} orphaned files',
+            'cleaned_count': cleaned
+        }), 200
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
 if __name__ == '__main__':
+    # For Hugging Face Spaces, use port 7860
+    port = int(os.environ.get('PORT', 7860))
+    app.run(host='0.0.0.0', port=port, debug=False)