Add script to generate share hashes for audio archives from FileBrowser

Author: Jared-Gross

add_share_hashes.py

@@ -0,0 +1,126 @@
+import asyncio
+import os
+from urllib.parse import unquote, urlparse
+
+import aiohttp
+import asyncpg
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Database settings
+db_settings = {
+    "host": os.getenv("POSTGRES_HOST"),
+    "port": int(os.getenv("POSTGRES_PORT", 5434)),
+    "database": os.getenv("POSTGRES_DB"),
+    "user": os.getenv("POSTGRES_USER"),
+    "password": os.getenv("POSTGRES_PASSWORD"),
+}
+
+FILEBROWSER_URL = os.getenv("FILEBROWSER_URL")
+FILEBROWSER_USERNAME = os.getenv("FILEBROWSER_USERNAME")
+FILEBROWSER_PASSWORD = os.getenv("FILEBROWSER_PASSWORD")
+FILEBROWSER_UPLOAD_PATH = os.getenv("FILEBROWSER_UPLOAD_PATH", "HBNI-Audio/Recordings")
+
+# Global dict of filebrowser items {name: full_path}
+FILEBROWSER_ITEMS = {}
+
+
+async def get_filebrowser_token():
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            f"{FILEBROWSER_URL}/api/login",
+            json={"username": FILEBROWSER_USERNAME, "password": FILEBROWSER_PASSWORD},
+        ) as response:
+            token = await response.text()
+            return token.strip()
+
+
+async def get_public_share_url(file_relative_path: str, token: str) -> str:
+    headers = {"X-Auth": token.strip(), "accept": "*/*"}
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            f"{FILEBROWSER_URL}/api/share/{file_relative_path}",
+            headers=headers,
+            json={"path": f"/{file_relative_path}"},
+        ) as response:
+            if response.status != 200:
+                body = await response.text()
+                raise Exception(
+                    f"Failed to create share link: {response.status} - {body}"
+                )
+            data = await response.json()
+            return data["hash"]
+
+
+async def list_filebrowser_items():
+    global FILEBROWSER_ITEMS
+    token = await get_filebrowser_token()
+    headers = {"X-Auth": token, "Accept": "application/json"}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(
+            f"{FILEBROWSER_URL}/api/resources/{FILEBROWSER_UPLOAD_PATH}",
+            headers=headers,
+        ) as response:
+            if response.status != 200:
+                body = await response.text()
+                raise Exception(f"Failed to list items: {response.status} - {body}")
+            data = await response.json()
+
+    items = data.get("items", [])
+    FILEBROWSER_ITEMS = {
+        item["name"]: item["path"].lstrip("/") for item in items if not item["isDir"]
+    }
+
+    print(f"📂 Loaded {len(FILEBROWSER_ITEMS)} files from FileBrowser.")
+
+
+def extract_filename_from_download_link(download_link: str) -> str:
+    path = urlparse(download_link).path
+    return unquote(os.path.basename(path)).replace("&", "&").replace("&Amp;", "&")
+
+
+async def list_audioarchives():
+    await list_filebrowser_items()
+    token = await get_filebrowser_token()
+    pool = await asyncpg.create_pool(**db_settings)
+
+    async with pool.acquire() as conn:
+        query = """
+        SELECT * FROM audioarchives
+        WHERE download_link LIKE '%play_recording%'
+        ORDER BY date DESC;
+        """
+        rows = await conn.fetch(query)
+        print(f"🎵 Found {len(rows)} rows missing share_hash:")
+
+        for row in rows:
+            download_link = row["download_link"]
+            filename = extract_filename_from_download_link(download_link)
+            current_hash = row["share_hash"]
+
+            # if current_hash:
+            #     print(f"✅ Already has share_hash: {filename} → {current_hash}")
+            #     continue
+
+            filebrowser_path = FILEBROWSER_ITEMS.get(filename)
+            if not filebrowser_path:
+                print(f"⚠️ File not found in FileBrowser: {filename}")
+                continue
+
+            try:
+                share_hash = await get_public_share_url(filebrowser_path, token)
+                update_query = (
+                    "UPDATE audioarchives SET share_hash = $1 WHERE download_link = $2;"
+                )
+                await conn.execute(update_query, share_hash, download_link)
+                print(f"✅ Added share_hash for: {filename} → {share_hash}")
+            except Exception as e:
+                print(f"❌ Failed to create share for {filename}: {str(e)}")
+
+    await pool.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(list_audioarchives())

main.py

@@ -9,18 +9,17 @@
 import threading
 import time
 from datetime import datetime, timedelta
-from logging.handlers import RotatingFileHandler
-from typing import Callable, Literal
+from typing import Callable
 
 import asyncpg
 import requests
 from dotenv import load_dotenv
+from natsort import natsorted
 
 import filebrowser_uploader
 import firebase_android_notification
 import firebase_web_notification
 import send_email
-import synology_uploader
 import zip_file
 
 load_dotenv()
@@ -295,7 +294,7 @@ def remove_stream(self, host: str):
             self.loop.create_task(self.update_recording_status())
 
     def run(self):
-        self.send_notification()
+        # self.send_notification()
 
         # stream = Stream("Springhill", "http://hbniaudio.hbni.net:443", "springhill", "Springhill/Odanah/Cascade singing in memory of Dave Stahl(Bon Homme)", self.remove_stream)
         # self.active_streams["springhill"] = stream
@@ -398,21 +397,38 @@ def send_notification(self):
 
 class CustomHandler(http.server.SimpleHTTPRequestHandler):
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, directory="logs", **kwargs)
+        # Serve from root so we can access logs/ directory
+        super().__init__(*args, directory=".", **kwargs)
         load_dotenv()
 
     def do_GET(self):
-        if self.path.endswith(".log"):  # Check if the requested file is a log file
-            log_file_path = os.path.join("logs", self.path.lstrip("/"))
-            if os.path.exists(log_file_path):  # Ensure the file exists
-                self.send_response(200)
-                self.send_header("Content-type", "text/plain")
-                self.end_headers()
-                with open(log_file_path, "r", encoding="utf-8") as log_file:
-                    self.wfile.write(log_file.read().encode("utf-8"))
-                return
-        # Default behavior for other files
-        super().do_GET()
+        # Show a custom index with log links
+        if self.path == "/":
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+
+            html = "<html><body><h1>Log Files</h1><ul>"
+            for filename in natsorted(os.listdir("logs")):
+
+                if filename.endswith(".log"):
+                    html += f'<li><a href="/logs/{filename}">{filename}</a></li>'
+            html += "</ul></body></html>"
+
+            self.wfile.write(html.encode("utf-8"))
+            return
+
+        # Serve logs with text/plain so they show in browser
+        if self.path.startswith("/logs/") and self.path.endswith(".log"):
+            self.send_response(200)
+            self.send_header("Content-type", "text/plain")
+            self.end_headers()
+            filepath = os.path.join("logs", os.path.basename(self.path))
+            with open(filepath, "r", encoding="utf-8") as f:
+                self.wfile.write(f.read().encode("utf-8"))
+            return
+
+        return super().do_GET()
 
 
 def start_log_server():