web.py cleanup

routes/web.py

@@ -1,22 +1,22 @@
 from flask import Blueprint, render_template, request, send_file, jsonify
-import math, time
+import math
 from helpers.db import db_get_videos, db_get_video, db_get_recent
 from helpers.favorites import mark_favorites, db_get_favorites, db_get_fav_set
 from helpers.cache import build_cache
 from config import VIDEOS_PER_PAGE, DASHBOARD_PER_PAGE, get_local_db_connection
+from datetime import date, datetime, timedelta
+import requests
 
 web = Blueprint("web", __name__)
 
-import requests
 def _get_recording_streamers() -> set[str]:
     try:
-        resp = requests.get("http://localhost:5000/api/get_recording/", timeout=3)
+        resp = requests.get("http://127.0.0.1:5000/api/get_recording/")
         resp.raise_for_status()
         return resp.json()
     except Exception:
         return set()
 
-from datetime import date, datetime, timedelta
 def _parse_dates(timeframe: str, start_str: str | None, end_str: str | None):
     """Return (start, end) as date objects or (None, None). End inclusive by day."""
     today = date.today()
@@ -47,13 +47,12 @@ def dashboard():
     timeframe = request.args.get("timeframe", "all")
     start_str = request.args.get("start")
     end_str = request.args.get("end")
-    show_online_first = request.args.get("online") == "1"
 
     start, end = _parse_dates(timeframe, start_str, end_str)
 
     # ---- build cache over timeframe ----
     cache = build_cache(start=start, end=end)
-    items = list(cache["storage_usage"].items())  # [("user::platform", {...}), ...]
+    items = list(cache["storage_usage"].items())
 
     # ---- search ----
     if query:
@@ -80,20 +79,6 @@ def dashboard():
     online_usernames: set[str] = set()
     recording_offline_usernames: set[str] = set()
 
-    if show_online_first:
-        try:
-            rec_list = _get_recording_streamers()
-            for s in rec_list or []:
-                u = (s.get("username") or "").lower()
-                if not u:
-                    continue
-                if s.get("is_online"):
-                    online_usernames.add(u)
-                else:
-                    recording_offline_usernames.add(u)
-        except Exception:
-            pass
-
     def user_of(item) -> str:
         return item[0].split("::")[0]
     def is_online(item) -> bool:
@@ -102,19 +87,29 @@ def dashboard():
         u = user_of(item).lower()
         return (u in recording_offline_usernames) and (u not in online_usernames)
 
+    try:
+        rec_list = _get_recording_streamers()
+        for s in rec_list or []:
+            u = (s.get("username") or "").lower()
+            if not u:
+                continue
+            if s.get("is_online"):
+                online_usernames.add(u)
+            else:
+                recording_offline_usernames.add(u)
+    except Exception:
+        pass
+
     # ---- sort with optional grouping ----
-    if show_online_first:
+    online_items           = [x for x in items if is_online(x)]
-        online_items           = [x for x in items if is_online(x)]
+    recording_offline_items= [x for x in items if is_recording_offline(x)]
-        recording_offline_items= [x for x in items if is_recording_offline(x)]
+    the_rest               = [x for x in items if (x not in online_items) and (x not in recording_offline_items)]
-        the_rest               = [x for x in items if (x not in online_items) and (x not in recording_offline_items)]
 
-        online_items.sort(key=base_key, reverse=reverse)
+    online_items.sort(key=base_key, reverse=reverse)
-        recording_offline_items.sort(key=base_key, reverse=reverse)
+    recording_offline_items.sort(key=base_key, reverse=reverse)
-        the_rest.sort(key=base_key, reverse=reverse)
+    the_rest.sort(key=base_key, reverse=reverse)
 
-        items = online_items + recording_offline_items + the_rest
+    items = online_items + recording_offline_items + the_rest
-    else:
-        items.sort(key=base_key, reverse=reverse)
 
     # ---- paginate ----
     page = max(1, int(request.args.get("page", 1)))
@@ -134,21 +129,10 @@ def dashboard():
         timeframe=timeframe,
         start_date=start_str,
         end_date=end_str,
-        online="1" if show_online_first else "0",
-        # send both sets so we can color dots
         online_set=online_usernames,
         recording_offline_set=recording_offline_usernames,
     )
 
-@web.route("/refresh")
-def refresh():
-    cache = build_cache()
-    return jsonify({
-        "status": "ok",
-        "videos": sum(x["video_count"] for x in cache["storage_usage"].values()),
-        "updated": time.ctime(cache["timestamp"])
-    })
-
 @web.route("/user/<username>")
 def user_page(username):
     videos = db_get_videos(username=username)
@@ -211,7 +195,6 @@ def favorites_page():
     
 @web.route("/users")
 def users():
-    import math
     # ---- filters ----
     q         = (request.args.get("q") or "").lower().strip()
     sort      = request.args.get("sort", "total_size")  # user|site|total_size|video_count
@@ -283,7 +266,6 @@ def users():
     """
     params.update({"limit": per_page, "offset": offset})
 
-    from config import get_local_db_connection
     conn, cur = get_local_db_connection()
     cur = conn.cursor()