hh

handlers/user.py

@@ -1,6 +1,10 @@
 """
 handlers/user.py — Handles all interactions for regular users.
 Users can only browse and view content; no editing capability.
+
+FIX: Replaced callback.bot.get("view_states", {}) with a direct import of
+     VIEW_STATES from handlers.admin. The Bot object in aiogram v3 does not
+     support dictionary-style access.
 """
 
 import logging
@@ -12,130 +16,146 @@ from config import config
 from database.db import AsyncSessionFactory
 from database import crud
 from keyboards.inline import (
-    main_menu_user, folder_list_keyboard, item_view_keyboard
+    main_menu_user, folder_list_keyboard, item_view_keyboard, back_home_keyboard
 )
 
 logger = logging.getLogger(__name__)
 router = Router()
 
 
+# ── Shared view-toggle state (defined in admin.py, imported here) ─────────
+# We do a lazy import inside functions to avoid circular imports at module load.
+def _get_view_states() -> dict:
+    """Returns the shared VIEW_STATES dict from handlers.admin."""
+    from handlers.admin import VIEW_STATES
+    return VIEW_STATES
+
+
+# ─────────────────────────── ROLE HELPER ─────────────────────────────────
+
 async def _get_role(session, user_id: int, username: str | None) -> str:
-    """Helper to determine user's role: 'owner', 'admin', or 'user'."""
+    """Returns 'owner', 'admin', or 'user'."""
     if username and username.lower() == config.OWNER_USERNAME.lower():
         return "owner"
-    admin = await crud.get_admin(session, user_id)
-    if admin:
+    admin_rec = await crud.get_admin(session, user_id)
+    if admin_rec:
         return "admin"
     return "user"
 
 
+# ─────────────────────────── /start ──────────────────────────────────────
+
 @router.message(CommandStart())
 async def cmd_start(message: Message):
     """
-    Entry point for all users. Registers them in the DB and shows
-    the appropriate main menu based on their role.
+    Entry point for regular users.
+    Admin/Owner /start is handled first by their own routers (higher priority).
+    This handler only fires if neither owner.router nor admin.router claimed it.
     """
     user = message.from_user
     async with AsyncSessionFactory() as session:
         await crud.upsert_user(session, user.id, user.username, user.full_name)
-        role = await _get_role(session, user.id, user.username)
 
     welcome_text = (
         f"👋 <b>Welcome, {user.first_name}!</b>\n\n"
         f"🧠 This is your interactive <b>Knowledge Base</b>.\n"
-        f"Browse through organized folders to find information, "
-        f"files, links, and more.\n\n"
+        f"Browse through organised folders to find documents, "
+        f"videos, links, and more.\n\n"
         f"<i>Use the buttons below to navigate.</i>"
     )
+    await message.answer(welcome_text, reply_markup=main_menu_user(), parse_mode="HTML")
 
-    # Show role-specific menu — imported and used in main.py via the
-    # role-based dispatcher. This handler only runs for pure 'user' role.
-    if role == "user":
-        await message.answer(welcome_text, reply_markup=main_menu_user(), parse_mode="HTML")
-    # Admin/Owner start is handled in their respective routers
 
+# ─────────────────────────── HOME ────────────────────────────────────────
 
 @router.callback_query(F.data == "home")
 async def cb_home(callback: CallbackQuery):
-    """Return to the main menu (role-determined)."""
-    # This callback is used as a catch-all; role-specific routers intercept first.
+    """Return to the main menu for regular users."""
     user = callback.from_user
     async with AsyncSessionFactory() as session:
         role = await _get_role(session, user.id, user.username)
 
+    # Admin/Owner home is handled by admin.router (registered before this router).
+    # This handler only runs for pure 'user' role.
     if role == "user":
         await callback.message.edit_text(
             "🏠 <b>Main Menu</b>\n\nChoose an option below:",
             reply_markup=main_menu_user(),
-            parse_mode="HTML"
+            parse_mode="HTML",
         )
     await callback.answer()
 
 
+# ─────────────────────────── BROWSE ──────────────────────────────────────
+
 @router.callback_query(F.data.startswith("browse:"))
 async def cb_browse(callback: CallbackQuery):
     """
-    Handles folder browsing navigation.
-    Format: browse:root:page OR browse:folder:folder_id:page
+    Folder browsing navigation.
+
+    Callback formats:
+      browse:root:<page>
+      browse:folder:<folder_id>:<page>
     """
-    parts = callback.data.split(":")
-    # browse:root:page  → parts = ["browse","root","0"]
-    # browse:folder:ID:page → parts = ["browse","folder","123","0"]
-    user = callback.from_user
+    parts   = callback.data.split(":")
+    user    = callback.from_user
 
     async with AsyncSessionFactory() as session:
         role = await _get_role(session, user.id, user.username)
         is_admin = role in ("admin", "owner")
 
-        # Check if admin is in user-view mode (stored in bot's state or session)
-        # We'll use a simple DB-less approach: check callback origin
-        # Full view-toggle logic lives in admin handler; here we just render
-
         if parts[1] == "root":
-            page = int(parts[2]) if len(parts) > 2 else 0
+            page      = int(parts[2]) if len(parts) > 2 else 0
             parent_id = None
-            folders = await crud.get_root_folders(session)
-            items = []  # Root level shows only folders
-            location_name = "📚 Knowledge Base"
+            folders   = await crud.get_root_folders(session)
+            items     = []
+            loc_name  = "📚 Knowledge Base"
         else:
-            # parts = ["browse", "folder", "123", "0"]
+            # browse:folder:<id>:<page>
             folder_id = int(parts[2])
-            page = int(parts[3]) if len(parts) > 3 else 0
+            page      = int(parts[3]) if len(parts) > 3 else 0
             parent_id = folder_id
-            folders = await crud.get_subfolders(session, folder_id)
-            items = await crud.get_folder_items(session, folder_id)
-            folder = await crud.get_folder(session, folder_id)
-            location_name = f"{folder.emoji} <b>{folder.name}</b>" if folder else "📁 Folder"
+            folders   = await crud.get_subfolders(session, folder_id)
+            items     = await crud.get_folder_items(session, folder_id)
+            folder    = await crud.get_folder(session, folder_id)
+            loc_name  = (
+                f"{folder.emoji} <b>{folder.name}</b>"
+                if folder else "📁 Folder"
+            )
 
-        # Log this navigation event
-        await crud.log_user_action(session, user.id, f"Browsed: {location_name.replace('<b>','').replace('</b>','')}")
+        # Log navigation
+        clean = loc_name.replace("<b>", "").replace("</b>", "")
+        await crud.log_user_action(session, user.id, f"Browsed: {clean}")
 
-    # Determine if showing admin controls (admin not in user-view mode)
-    # View toggle state is managed via user data (see admin handler)
-    view_state = callback.bot.get("view_states", {})
-    in_user_view = view_state.get(user.id, False) if view_state else False
-    show_admin = is_admin and not in_user_view
+    # Determine whether to show admin controls
+    # (hidden when the admin toggled "View as User")
+    in_user_view = _get_view_states().get(user.id, False)
+    show_admin   = is_admin and not in_user_view
 
-    total_items = len(folders) + len(items)
     text = (
-        f"{location_name}\n\n"
+        f"{loc_name}\n\n"
         f"📊 <i>{len(folders)} folder(s) · {len(items)} item(s)</i>\n\n"
         f"<i>Select an item to view its content.</i>"
     )
 
     await callback.message.edit_text(
         text,
-        reply_markup=folder_list_keyboard(folders, items, parent_id, page, show_admin, role == "owner"),
-        parse_mode="HTML"
+        reply_markup=folder_list_keyboard(
+            folders, items, parent_id, page,
+            show_admin, role == "owner",
+        ),
+        parse_mode="HTML",
     )
     await callback.answer()
 
 
+# ─────────────────────────── VIEW ITEM ───────────────────────────────────
+
 @router.callback_query(F.data.startswith("view:item:"))
 async def cb_view_item(callback: CallbackQuery):
-    """Displays a specific content item to the user."""
+    """Displays a specific content item."""
     item_id = int(callback.data.split(":")[2])
-    user = callback.from_user
+    user    = callback.from_user
 
     async with AsyncSessionFactory() as session:
         item = await crud.get_item(session, item_id)
@@ -147,57 +167,51 @@ async def cb_view_item(callback: CallbackQuery):
         await callback.answer("❌ Item not found.", show_alert=True)
         return
 
-    view_state = callback.bot.get("view_states", {})
-    in_user_view = view_state.get(user.id, False) if view_state else False
-    is_admin = role in ("admin", "owner") and not in_user_view
-
-    caption = f"<b>{item.title}</b>"
-    markup = item_view_keyboard(item.id, item.folder_id, is_admin)
+    in_user_view = _get_view_states().get(user.id, False)
+    is_admin     = role in ("admin", "owner") and not in_user_view
+    caption      = f"<b>{item.title}</b>"
+    markup       = item_view_keyboard(item.id, item.folder_id, is_admin)
 
     try:
         if item.content_type == "photo":
             await callback.message.delete()
             await callback.bot.send_photo(
-                callback.from_user.id,
-                photo=item.file_id,
-                caption=caption,
-                reply_markup=markup,
-                parse_mode="HTML"
+                user.id, photo=item.file_id,
+                caption=caption, reply_markup=markup, parse_mode="HTML",
             )
+
         elif item.content_type == "video":
             await callback.message.delete()
             await callback.bot.send_video(
-                callback.from_user.id,
-                video=item.file_id,
-                caption=caption,
-                reply_markup=markup,
-                parse_mode="HTML"
+                user.id, video=item.file_id,
+                caption=caption, reply_markup=markup, parse_mode="HTML",
             )
+
         elif item.content_type == "document":
             await callback.message.delete()
             await callback.bot.send_document(
-                callback.from_user.id,
-                document=item.file_id,
-                caption=caption,
-                reply_markup=markup,
-                parse_mode="HTML"
+                user.id, document=item.file_id,
+                caption=caption, reply_markup=markup, parse_mode="HTML",
             )
+
         elif item.content_type == "audio":
             await callback.message.delete()
             await callback.bot.send_audio(
-                callback.from_user.id,
-                audio=item.file_id,
-                caption=caption,
-                reply_markup=markup,
-                parse_mode="HTML"
+                user.id, audio=item.file_id,
+                caption=caption, reply_markup=markup, parse_mode="HTML",
             )
+
         elif item.content_type == "link":
             text = f"🔗 <b>{item.title}</b>\n\n{item.text_content}"
-            await callback.message.edit_text(text, reply_markup=markup, parse_mode="HTML",
-                                             disable_web_page_preview=False)
+            await callback.message.edit_text(
+                text, reply_markup=markup,
+                parse_mode="HTML", disable_web_page_preview=False,
+            )
+
         elif item.content_type == "text":
             text = f"📝 <b>{item.title}</b>\n\n{item.text_content}"
             await callback.message.edit_text(text, reply_markup=markup, parse_mode="HTML")
+
     except Exception as e:
         logger.error(f"Error sending item {item_id}: {e}")
         await callback.answer("❌ Failed to load content.", show_alert=True)
@@ -206,16 +220,21 @@ async def cb_view_item(callback: CallbackQuery):
     await callback.answer()
 
 
+# ─────────────────────────── ABOUT ───────────────────────────────────────
+
 @router.callback_query(F.data == "about")
 async def cb_about(callback: CallbackQuery):
     text = (
         "ℹ️ <b>About This Knowledge Base</b>\n\n"
-        "This bot is an interactive, organized repository of "
+        "This bot is an interactive, organised repository of "
         "documents, videos, links, and text resources.\n\n"
         "📁 Use folders to navigate topics.\n"
         "📄 Click any item to view its content.\n\n"
-        "<i>Content is managed by authorized administrators.</i>"
+        "<i>Content is managed by authorised administrators.</i>"
+    )
+    await callback.message.edit_text(
+        text,
+        reply_markup=back_home_keyboard(),
+        parse_mode="HTML",
     )
-    from keyboards.inline import back_home_keyboard
-    await callback.message.edit_text(text, reply_markup=back_home_keyboard(), parse_mode="HTML")
     await callback.answer()

main.py

@@ -5,8 +5,9 @@ Runs TWO concurrent async services:
 1. An aiohttp web server on port 7860 (Hugging Face keepalive — starts FIRST)
 2. The aiogram Telegram bot (long polling)
 
-⚠️  FIX APPLIED: Web server starts immediately so HF Space doesn't time out
-    while the DB is still connecting. DB errors won't kill the web server.
+FIX: Removed bot["view_states"] assignment — aiogram v3 Bot object does NOT
+     support item assignment. VIEW_STATES is a plain module-level dict in
+     handlers/admin.py and is imported directly by any handler that needs it.
 """
 
 import asyncio
@@ -77,7 +78,7 @@ async def handle_health(request: web.Request) -> web.Response:
 async def run_web_server() -> None:
     """
     Starts aiohttp on 0.0.0.0:7860.
-    This coroutine NEVER exits — it keeps looping so asyncio.gather keeps it alive.
+    This coroutine NEVER exits — keeps the HF Space alive.
     """
     app = web.Application()
     app.router.add_get("/",       handle_root)
@@ -102,21 +103,20 @@ async def run_web_server() -> None:
 def build_dispatcher() -> Dispatcher:
     """
     Creates the Dispatcher and registers all routers.
-    Order matters: owner > admin > user so privileged handlers
-    intercept callbacks before the generic user handlers do.
+    Order: owner > admin > user — privileged handlers intercept first.
     """
     dp = Dispatcher(storage=MemoryStorage())
-    dp.include_router(owner.router)   # Owner-only actions
-    dp.include_router(admin.router)   # Admin actions + FSM
-    dp.include_router(user.router)    # Public browsing
+    dp.include_router(owner.router)
+    dp.include_router(admin.router)
+    dp.include_router(user.router)
     return dp
 
 
 async def run_bot() -> None:
     """
     Initialises the database, then starts the Telegram bot.
-    Retries the DB connection up to 5 times before giving up,
-    so a slow Supabase cold-start doesn't crash the whole app.
+    Retries the DB connection up to 5 times before giving up.
+    The web server keeps running even if the bot fails to start.
     """
     # ── 1. Config validation ──────────────────────────────────
     try:
@@ -124,11 +124,11 @@ async def run_bot() -> None:
     except EnvironmentError as e:
         logger.critical(str(e))
         BOT_STATUS["error"] = str(e)
-        return   # Web server keeps running so HF shows a page
+        return
 
     # ── 2. DB initialisation with retry ──────────────────────
-    MAX_RETRIES   = 5
-    RETRY_DELAY   = 5   # seconds between retries
+    MAX_RETRIES = 5
+    RETRY_DELAY = 5   # seconds
 
     for attempt in range(1, MAX_RETRIES + 1):
         try:
@@ -143,8 +143,8 @@ async def run_bot() -> None:
                 logger.info(f"⏳ Retrying in {RETRY_DELAY}s…")
                 await asyncio.sleep(RETRY_DELAY)
             else:
-                logger.critical("💥 Could not connect to database after all retries. Bot will NOT start.")
-                return   # Web server stays alive
+                logger.critical("💥 Could not connect to database after all retries.")
+                return
 
     # ── 3. Create Bot instance ────────────────────────────────
     bot = Bot(
@@ -152,9 +152,10 @@ async def run_bot() -> None:
         default=DefaultBotProperties(parse_mode=ParseMode.HTML),
     )
 
-    # Share the VIEW_STATES dict across handlers via the bot object
-    from handlers.admin import VIEW_STATES
-    bot["view_states"] = VIEW_STATES
+    # NOTE: VIEW_STATES is a plain module-level dict in handlers/admin.py.
+    #       Any handler that needs it imports it directly:
+    #           from handlers.admin import VIEW_STATES
+    #       No need to attach anything to the Bot object.
 
     dp = build_dispatcher()
 
@@ -165,7 +166,6 @@ async def run_bot() -> None:
     logger.info("🚀 Bot is now polling for updates…")
 
     try:
-        # Drop stale updates from while the bot was offline
         await bot.delete_webhook(drop_pending_updates=True)
         await dp.start_polling(
             bot,
@@ -186,21 +186,17 @@ async def run_bot() -> None:
 
 async def main() -> None:
     """
-    Runs the web server and the bot concurrently.
-
-    ⚠️  IMPORTANT ORDER:
-    asyncio.gather starts both coroutines "at the same time", but
-    run_web_server() has no awaits before site.start(), so it binds
-    port 7860 within milliseconds. The bot's DB retry loop can take
-    up to 25 s without blocking the web server.
+    Runs the web server and the bot concurrently via asyncio.gather.
+    The web server binds port 7860 within milliseconds.
+    The bot's DB retry loop runs in the background without blocking it.
     """
     print(f"\n{'='*50}")
     print(f"  Application Startup at {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')} UTC")
     print(f"{'='*50}\n")
 
     await asyncio.gather(
-        run_web_server(),   # Never exits — keeps the Space alive
-        run_bot(),          # Polls Telegram; restarts on /start after crash
+        run_web_server(),
+        run_bot(),
     )