Update app.py

app.py

@@ -13,6 +13,29 @@ import httpx
 app = FastAPI()
 
 DENO_API_URL = "https://dataerrr99.deno.dev"
+
+async def save_album_to_db(album_name: str, album_id: str):
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(DENO_API_URL, json={
+                "albumName": album_name,
+                "albumLink": album_id
+            })
+            return response.json()
+        except Exception as e:
+            print(f"Error saving to DB: {str(e)}")
+            return None
+
+async def get_albums_from_db():
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(DENO_API_URL)
+            return response.json()
+        except Exception as e:
+            print(f"Error fetching from DB: {str(e)}")
+            return {"data": []}
+
+# In-memory storage for albums
 albums = {}
 
 HTML_CONTENT = """
@@ -287,39 +310,6 @@ SEARCH_RESULTS_HTML = """
 </html>
 """
 
-async def save_album_to_db(album_name: str, album_id: str, album_files: list):
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.post(DENO_API_URL, json={
-                "albumName": album_name,
-                "albumLink": album_id,
-                "files": album_files,
-                "createdAt": datetime.now().isoformat()
-            })
-            return response.json()
-        except Exception as e:
-            print(f"Error saving to DB: {str(e)}")
-            return None
-
-async def load_albums_from_db():
-    async with httpx.AsyncClient() as client:
-        try:
-            response = await client.get(DENO_API_URL)
-            if response.status_code == 200:
-                albums_data = response.json()['data']
-                for album in albums_data:
-                    albums[album['albumLink']] = {
-                        'name': album['albumName'],
-                        'created_at': album['createdAt'],
-                        'files': album.get('files', [])
-                    }
-        except Exception as e:
-            print(f"Error loading albums from DB: {str(e)}")
-
-@app.on_event("startup")
-async def startup_event():
-    await load_albums_from_db()
-
 def get_file_type(filename):
     mime_type, _ = mimetypes.guess_type(filename)
     if mime_type:
@@ -339,38 +329,28 @@ async def search_albums(query: str = ""):
     db_albums = await get_albums_from_db()
     
     matching_albums = {
-        album_id: album for album_id, album in albums.items()
-        if query in album['name'].lower()
+        album['link']: albums[album['link']]
+        for album in db_albums['data']
+        if album['link'] in albums and query in album['name'].lower()
     }
     
+    results_html = ""
+    for album_id, album in matching_albums.items():
+        results_html += f"""
+        <div class="album-item">
+            <h3>{album['name']}</h3>
+            <p>Created: {album['created_at']}</p>
+            <p>Files: {len(album['files'])}</p>
+            <a href="/album/{album_id}" class="button">View Album</a>
+        </div>
+        """
+    
     return SEARCH_RESULTS_HTML.format(
         query=query,
         result_count=len(matching_albums),
-        results=format_search_results(matching_albums)
+        results=results_html
     )
 
-@app.post("/upload")
-async def handle_upload(request: Request, file: UploadFile = File(...)):
-    if not file:
-        return {"error": "No file uploaded"}, 400
-
-    cookies = await get_cookies()
-    if 'csrftoken' not in cookies or 'sessionid' not in cookies:
-        return {"error": "Failed to get cookies"}, 500
-
-    upload_result = await initiate_upload(cookies, file.filename, file.content_type)
-    if not upload_result or 'upload_url' not in upload_result:
-        return {"error": "Failed to initiate upload"}, 500
-
-    file_content = await file.read()
-    upload_success = await retry_upload(upload_result['upload_url'], file_content, file.content_type)
-    if not upload_success:
-        return {"error": "Upload failed"}, 500
-
-    base_url = str(request.base_url).rstrip('/')
-    redirect_url = f"{base_url}/upload/{upload_result['serving_url'].split('/pbxt/')[1]}"
-    return RedirectResponse(url=redirect_url, status_code=303)
-
 @app.post("/album/create")
 async def create_album(
     request: Request,
@@ -390,22 +370,21 @@ async def create_album(
             upload_success = await retry_upload(upload_result['upload_url'], file_content, file.content_type)
             if upload_success:
                 serving_path = upload_result['serving_url'].split('/pbxt/')[1]
-                file_data = {
+                album_files.append({
                     'filename': file.filename,
                     'path': serving_path,
                     'content_type': file.content_type,
                     'uploaded_at': datetime.now().isoformat()
-                }
-                album_files.append(file_data)
+                })
 
-    album_data = {
+    albums[album_id] = {
         'name': album_name,
         'created_at': datetime.now().isoformat(),
         'files': album_files
     }
-    
-    albums[album_id] = album_data
-    await save_album_to_db(album_name, album_id, album_files)
+
+    # Save to Deno KV database
+    await save_album_to_db(album_name, album_id)
 
     base_url = str(request.base_url).rstrip('/')
     return RedirectResponse(url=f"{base_url}/album/{album_id}", status_code=303)
@@ -416,10 +395,48 @@ async def view_album(album_id: str):
         return "Album not found", 404
 
     album = albums[album_id]
+    file_list_html = ""
+    
+    for file in album['files']:
+        file_url = f"/upload/{file['path']}"
+        file_type = get_file_type(file['filename'])
+        
+        preview_html = ""
+        if file_type == 'image':
+            preview_html = f"""
+                <div class="preview-container">
+                    <img src="{file_url}" alt="{file['filename']}" onclick="openModal('{file_url}')">
+                </div>
+            """
+        elif file_type == 'video':
+            preview_html = f"""
+                <div class="preview-container">
+                    <video onclick="openModal('{file_url}')" style="cursor: pointer;">
+                        <source src="{file_url}" type="{file['content_type']}">
+                        Your browser does not support the video tag.
+                    </video>
+                </div>
+            """
+        else:
+            preview_html = f"""
+                <div class="preview-container">
+                    <p>No preview available for {file['filename']}</p>
+                </div>
+            """
+
+        file_list_html += f"""
+        <div class="file-item">
+            {preview_html}
+            <p>{file['filename']}</p>
+            <a href="{file_url}" class="button" onclick="openModal('{file_url}'); return false;">View</a>
+            <a href="{file_url}?download=true" class="button" target="_blank">Download</a>
+        </div>
+        """
+
     return ALBUM_VIEW_HTML.format(
         album_name=album['name'],
         album_id=album_id,
-        file_list=format_file_list(album['files'])
+        file_list=file_list_html
     )
 
 @app.get("/album/{album_id}/download")
@@ -497,4 +514,4 @@ async def retry_upload(upload_url, file_content, content_type, max_retries=5):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)