Simplify Telegram Bot to unified daily rate list subscription and drop legacy tables

bot/handlers.py

@@ -1,931 +1,168 @@
+import logging
+import asyncio
+from datetime import datetime
 from aiogram import Router, types
 from aiogram.filters import Command
-from aiogram.fsm.state import StatesGroup, State
-from aiogram.fsm.context import FSMContext
 from aiogram.utils.keyboard import InlineKeyboardBuilder
-from services.fx_service import fx_service, ALLOWED_CURRENCIES
-from db.session import get_session
-from db.models import User, Subscription, Threshold
+from db.session import async_session
+from db.models import User
 from sqlalchemy import select
-import logging
+from services.fx_service import fx_service
+from bot.scheduler import CURRENCIES, FLAGS, format_rates_list
 
 logger = logging.getLogger(__name__)
 router = Router()
 
-# Flag mapping for clean and visual currency buttons
-CURRENCY_FLAGS = {
-    "USD": "🇺🇸",
-    "GBP": "🇬🇧",
-    "EUR": "🇪🇺",
-    "AED": "🇦🇪",
-    "SAR": "🇸🇦",
-    "AUD": "🇦🇺",
-    "INR": "🇮🇳",
-    "JPY": "🇯🇵",
-    "CNY": "🇨🇳",
-    "QAR": "🇶🇦",
-    "LKR": "🇱🇰"
-}
-
-def get_currency_text(currency_code: str) -> str:
-    """Returns currency code prefixed with its country flag emoji."""
-    flag = CURRENCY_FLAGS.get(currency_code.upper(), "🏳️")
-    return f"{flag} {currency_code.upper()}"
-
-async def ensure_user_registered(session, chat_id: int):
-    """Automatically registers a user if they haven't run /start first."""
-    result = await session.execute(select(User).where(User.chat_id == chat_id))
-    user = result.scalar_one_or_none()
-    if not user:
-        user = User(chat_id=chat_id)
-        session.add(user)
-        await session.flush()
-    return user
-
-class ThresholdForm(StatesGroup):
-    waiting_for_value = State()
-
-def get_currency_keyboard(prefix: str, exclude: str = None, include_presets: bool = True, preset_action: str = "curr"):
-    """
-    Generates a keyboard with Quick Presets at the top and a Custom Grid below.
-    - include_presets: if True, shows 1-Tap quick conversion to LKR buttons.
-    - preset_action: 'curr' (current rate), 'sub' (subscribe), or 'th' (threshold).
-    """
+def get_refresh_keyboard():
+    """Generates the inline keyboard for rates list refresh."""
     builder = InlineKeyboardBuilder()
-    
-    # 1. Quick Presets (1-Tap Conversion to LKR)
-    if include_presets and exclude != "LKR":
-        presets = ["USD", "EUR", "GBP", "AUD"]
-        # Filter presets to only those allowed
-        valid_presets = [p for p in presets if p in ALLOWED_CURRENCIES]
-        
-        for base in valid_presets:
-            if base == exclude:
-                continue
-            # Define standard preset target callbacks to LKR directly
-            if preset_action == "curr":
-                callback_data = f"curr_target:{base}:LKR"
-            elif preset_action == "sub":
-                callback_data = f"sub_target:{base}:LKR"
-            else: # 'th'
-                callback_data = f"th_target:{base}:LKR"
-                
-            flag_base = CURRENCY_FLAGS.get(base, "")
-            flag_lkr = CURRENCY_FLAGS.get("LKR", "")
-            builder.button(
-                text=f"{flag_base} {base} ➡️ {flag_lkr} LKR", 
-                callback_data=callback_data
-            )
-        builder.adjust(2) # Show presets in 2 columns
-        
-    # 2. Custom Grid (Grid of all currencies)
-    grid_builder = InlineKeyboardBuilder()
-    for curr in sorted(ALLOWED_CURRENCIES):
-        if curr == exclude:
-            continue
-        grid_builder.button(text=get_currency_text(curr), callback_data=f"{prefix}:{curr}")
-    grid_builder.adjust(4) # Custom grid in 4 columns
-    
-    # Combine builders
-    builder.attach(grid_builder)
-    
-    # 3. Add Cancel button at the bottom row
-    builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
+    builder.button(text="🔄 Refresh Rates", callback_data="refresh_rates")
     return builder.as_markup()
 
+async def get_formatted_current_rates() -> str:
+    """Fetches the latest rates concurrently and formats the LKR list."""
+    tasks = [fx_service.get_rate(cur, "LKR") for cur in CURRENCIES]
+    rates_values = await asyncio.gather(*tasks)
+    rates = dict(zip(CURRENCIES, rates_values))
+    return format_rates_list(rates)
 
 @router.message(Command("start"))
 async def cmd_start(message: types.Message):
-    """Registers user and sends welcome message."""
+    """Greets the user and automatically subscribes them to daily updates."""
     chat_id = message.chat.id
-    # Create an async session explicitly since we're in a handler, not a FastAPI endpoint
-    from db.session import async_session
     async with async_session() as session:
-        try:
-            result = await session.execute(select(User).where(User.chat_id == chat_id))
-            user = result.scalar_one_or_none()
-            if not user:
-                new_user = User(chat_id=chat_id)
-                session.add(new_user)
-                await session.commit()
-        except Exception as e:
-            logger.warning(f"Error or concurrent insert in cmd_start for {chat_id}: {e}")
-            await session.rollback()
-            
-    currencies_str = ", ".join(ALLOWED_CURRENCIES)
-    await message.answer(
-        f"Welcome to FlyRates! 🌍💸\n\n"
-        f"I can track real-time exchange rates for you.\n"
-        f"Supported Currencies: {currencies_str}\n\n"
-        f"Use /help to see all available commands!"
-    )
-
-@router.message(Command("current"))
-async def cmd_current(message: types.Message):
-    """Fetches the current exchange rate (direct or interactive)."""
-    args = message.text.split()[1:]
-    if not args:
-        # Interactive mode
-        reply_markup = get_currency_keyboard("curr_base", preset_action="curr")
-        await message.answer(
-            "💱 <b>Live Exchange Rates</b>\n\n"
-            "Select a <b>Quick Preset</b> or select a custom <b>Base Currency</b> below:",
-            reply_markup=reply_markup,
-            parse_mode="HTML"
-        )
-        return
-
-    if len(args) not in [1, 2]:
-        await message.answer(
-            "Usage: <code>/current &lt;base&gt; [target]</code>\n"
-            "Example: <code>/current USD</code> or <code>/current USD EUR</code>\n\n"
-            "Or just type <code>/current</code> for interactive selection.", 
-            parse_mode="HTML"
-        )
-        return
-
-    base = args[0].upper()
-    target = args[1].upper() if len(args) == 2 else "LKR"
-    
-    if not fx_service.is_valid_currency(base) or not fx_service.is_valid_currency(target):
-        await message.answer(
-            "❌ Invalid currency pair. Let's select interactively:", 
-            reply_markup=get_currency_keyboard("curr_base", preset_action="curr")
-        )
-        return
-
-    rate = await fx_service.get_rate(base, target)
-    if rate:
-        builder = InlineKeyboardBuilder()
-        builder.button(text="🔄 Refresh", callback_data=f"curr_target:{base}:{target}")
-        builder.button(text="⬅️ Change Currencies", callback_data="curr_start")
-        builder.row(types.InlineKeyboardButton(text="❌ Close", callback_data="delete_message"))
+        result = await session.execute(select(User).where(User.chat_id == chat_id))
+        user = result.scalar_one_or_none()
         
-        flag_base = CURRENCY_FLAGS.get(base, "")
-        flag_target = CURRENCY_FLAGS.get(target, "")
-        await message.answer(
-            f"📈 <b>Current Rate:</b>\n"
-            f"1 {flag_base} {base} = <b>{rate}</b> {flag_target} {target}\n\n"
-            f"<i>Last updated: Just now</i>",
-            reply_markup=builder.as_markup(),
-            parse_mode="HTML"
-        )
-    else:
-        await message.answer("❌ Failed to fetch rate. Please try again later.")
-
-# --- Global Callback Handlers ---
-
-@router.callback_query(lambda c: c.data == "cancel_action")
-async def callback_cancel_action(callback: types.CallbackQuery, state: FSMContext):
-    await state.clear()
-    await callback.message.edit_text("❌ Action cancelled.")
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data == "delete_message")
-async def callback_delete_message(callback: types.CallbackQuery):
-    try:
-        await callback.message.delete()
-    except Exception:
-        pass
-    await callback.answer()
-
-# --- Callback Handlers for Current Rates ---
-
-@router.callback_query(lambda c: c.data == "curr_start")
-async def callback_curr_start(callback: types.CallbackQuery):
-    reply_markup = get_currency_keyboard("curr_base", preset_action="curr")
-    await callback.message.edit_text(
-        "💱 <b>Live Exchange Rates</b>\n\n"
-        "Select a <b>Quick Preset</b> or select a custom <b>Base Currency</b> below:",
-        reply_markup=reply_markup,
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("curr_base:"))
-async def callback_curr_base(callback: types.CallbackQuery):
-    base = callback.data.split(":")[1]
-    # No presets for target selection, just select currency
-    reply_markup = get_currency_keyboard(f"curr_target:{base}", exclude=base, include_presets=False)
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    await callback.message.edit_text(
-        f"💱 <b>Live Exchange Rates</b>\n\n"
-        f"Base Currency: {flag_base} <b>{base}</b>\n\n"
-        f"Select the <b>Target Currency</b>:",
-        reply_markup=reply_markup,
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("curr_target:"))
-async def callback_curr_target(callback: types.CallbackQuery):
-    parts = callback.data.split(":")
-    base = parts[1]
-    target = parts[2]
-    
-    rate = await fx_service.get_rate(base, target)
-    
-    builder = InlineKeyboardBuilder()
-    builder.button(text="🔄 Refresh", callback_data=f"curr_target:{base}:{target}")
-    builder.button(text="⬅️ Change Currencies", callback_data="curr_start")
-    builder.row(types.InlineKeyboardButton(text="❌ Close", callback_data="delete_message"))
-    
-    from datetime import datetime
-    time_str = datetime.now().strftime("%H:%M:%S")
-    
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    
-    if rate:
-        await callback.message.edit_text(
-            f"📈 <b>Current Rate:</b>\n"
-            f"1 {flag_base} {base} = <b>{rate}</b> {flag_target} {target}\n\n"
-            f"<i>Last updated: {time_str} UTC</i>",
-            reply_markup=builder.as_markup(),
-            parse_mode="HTML"
-        )
-    else:
-        await callback.message.edit_text(
-            f"❌ Failed to fetch rate. Let's try again:",
-            reply_markup=builder.as_markup(),
-            parse_mode="HTML"
-        )
-    await callback.answer()
+        if not user:
+            user = User(chat_id=chat_id, is_subscribed=True)
+            session.add(user)
+            await session.commit()
+            text = (
+                "🌍 <b>Welcome to FlyRates!</b> 🌍\n\n"
+                "You have been successfully registered and subscribed to receive a <b>daily LKR exchange rate list</b>!\n\n"
+                "Every morning at 8:00 AM UTC, you will receive a beautifully formatted list of all major currencies to Sri Lankan Rupee (LKR).\n\n"
+                "🛠️ <b>Quick Commands:</b>\n"
+                "• /current - Get the latest rate list instantly\n"
+                "• /unsubscribe - Stop receiving daily updates\n"
+                "• /help - Display the help guide"
+            )
+        else:
+            if not user.is_subscribed:
+                user.is_subscribed = True
+                await session.commit()
+                text = (
+                    "🔄 <b>Welcome Back to FlyRates!</b>\n\n"
+                    "Your subscription to the <b>daily exchange rate list updates</b> has been successfully reactivated!\n\n"
+                    "🛠️ <b>Quick Commands:</b>\n"
+                    "• /current - Get the latest rate list instantly\n"
+                    "• /unsubscribe - Stop receiving daily updates"
+                )
+            else:
+                text = (
+                    "ℹ️ <b>You are already subscribed!</b>\n\n"
+                    "You will receive a daily LKR exchange rate summary every morning.\n\n"
+                    "🛠️ <b>Quick Commands:</b>\n"
+                    "• /current - Get the latest rate list instantly\n"
+                    "• /unsubscribe - Stop receiving daily updates"
+                )
+                
+        await message.answer(text, parse_mode="HTML")
 
 @router.message(Command("subscribe"))
 async def cmd_subscribe(message: types.Message):
-    """Subscribes the user to periodic updates."""
-    args = message.text.split()[1:]
-    if not args:
-        reply_markup = get_currency_keyboard("sub_base", preset_action="sub")
-        await message.answer(
-            "🔔 <b>Set Up Rate Subscription</b>\n\n"
-            "Select a <b>Quick Preset</b> or select a custom <b>Base Currency</b> below:",
-            reply_markup=reply_markup,
-            parse_mode="HTML"
-        )
-        return
-
-    if len(args) not in [1, 2, 3]:
-        await message.answer(
-            "Usage: <code>/subscribe &lt;base&gt; [target] [daily|hourly]</code>\n"
-            "Example: <code>/subscribe USD daily</code>\n\n"
-            "Or just type <code>/subscribe</code> for interactive selection.", 
-            parse_mode="HTML"
-        )
-        return
-
-    base = args[0].upper()
-    
-    if len(args) == 1:
-        target = "LKR"
-        freq = "daily"
-    elif len(args) == 2:
-        if args[1].lower() in ["daily", "hourly"]:
-            target = "LKR"
-            freq = args[1].lower()
-        else:
-            target = args[1].upper()
-            freq = "daily"
-    else:
-        target = args[1].upper()
-        freq = args[2].lower()
-
-    if not fx_service.is_valid_currency(base) or not fx_service.is_valid_currency(target):
-        await message.answer(
-            "❌ Invalid currency pair. Let's select interactively:",
-            reply_markup=get_currency_keyboard("sub_base", preset_action="sub")
-        )
-        return
-        
-    if freq not in ["daily", "hourly"]:
-        await message.answer("❌ Frequency must be 'daily' or 'hourly'.")
-        return
-
-    from db.session import async_session
-    async with async_session() as session:
-        await ensure_user_registered(session, message.chat.id)
-        sub = Subscription(chat_id=message.chat.id, base_currency=base, target_currency=target, frequency=freq)
-        session.add(sub)
-        await session.commit()
-
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    
-    builder = InlineKeyboardBuilder()
-    builder.button(text="❌ Close", callback_data="delete_message")
-    
-    await message.answer(
-        f"✅ <b>Subscribed!</b>\n"
-        f"You will receive <b>{freq}</b> updates for {flag_base} {base} to {flag_target} {target}.",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-
-# --- Callback Handlers for Subscriptions ---
-
-@router.callback_query(lambda c: c.data == "sub_start")
-async def callback_sub_start(callback: types.CallbackQuery):
-    reply_markup = get_currency_keyboard("sub_base", preset_action="sub")
-    await callback.message.edit_text(
-        "🔔 <b>Set Up Rate Subscription</b>\n\n"
-        "Select a <b>Quick Preset</b> or select a custom <b>Base Currency</b> below:",
-        reply_markup=reply_markup,
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("sub_base:"))
-async def callback_sub_base(callback: types.CallbackQuery):
-    base = callback.data.split(":")[1]
-    reply_markup = get_currency_keyboard(f"sub_target:{base}", exclude=base, include_presets=False)
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    await callback.message.edit_text(
-        f"🔔 <b>Set Up Rate Subscription</b>\n\n"
-        f"Base Currency: {flag_base} <b>{base}</b>\n\n"
-        f"Select the <b>Target Currency</b>:",
-        reply_markup=reply_markup,
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("sub_target:"))
-async def callback_sub_target(callback: types.CallbackQuery):
-    parts = callback.data.split(":")
-    base = parts[1]
-    target = parts[2]
-    
-    builder = InlineKeyboardBuilder()
-    builder.button(text="📅 Daily (8:00 AM UTC)", callback_data=f"sub_freq:{base}:{target}:daily")
-    builder.button(text="⏰ Hourly", callback_data=f"sub_freq:{base}:{target}:hourly")
-    builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
-    
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    await callback.message.edit_text(
-        f"🔔 <b>Set Up Rate Subscription</b>\n\n"
-        f"Base: {flag_base} <b>{base}</b>\n"
-        f"Target: {flag_target} <b>{target}</b>\n\n"
-        f"Select the <b>Update Frequency</b>:",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("sub_freq:"))
-async def callback_sub_freq(callback: types.CallbackQuery):
-    parts = callback.data.split(":")
-    base = parts[1]
-    target = parts[2]
-    freq = parts[3]
-    
-    from db.session import async_session
-    async with async_session() as session:
-        await ensure_user_registered(session, callback.message.chat.id)
-        sub = Subscription(chat_id=callback.message.chat.id, base_currency=base, target_currency=target, frequency=freq)
-        session.add(sub)
-        await session.commit()
-        
-    builder = InlineKeyboardBuilder()
-    builder.button(text="❌ Close", callback_data="delete_message")
-    
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    await callback.message.edit_text(
-        f"✅ <b>Subscription Activated!</b>\n\n"
-        f"You will receive <b>{freq}</b> updates for {flag_base} {base} to {flag_target} {target}.",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.message(Command("threshold"))
-async def cmd_threshold(message: types.Message):
-    """Sets a threshold alert (direct or interactive)."""
-    args = message.text.split()[1:]
-    if not args:
-        reply_markup = get_currency_keyboard("th_base", preset_action="th")
-        await message.answer(
-            "🚨 <b>Set Up Threshold Alert</b>\n\n"
-            "Select a <b>Quick Preset</b> or select a custom <b>Base Currency</b> below:",
-            reply_markup=reply_markup,
-            parse_mode="HTML"
-        )
-        return
-
-    if len(args) not in [3, 4]:
-        await message.answer(
-            "Usage: <code>/threshold &lt;base&gt; [target] &lt;condition&gt; &lt;value&gt;</code>\n"
-            "Example: <code>/threshold USD &lt; 300</code>\n\n"
-            "Or just type <code>/threshold</code> for interactive setup.", 
-            parse_mode="HTML"
-        )
-        return
-
-    if len(args) == 3:
-        base, target, condition, value_str = args[0].upper(), "LKR", args[1], args[2]
-    else:
-        base, target, condition, value_str = args[0].upper(), args[1].upper(), args[2], args[3]
-    
-    try:
-        value = float(value_str)
-    except ValueError:
-        await message.answer("❌ Value must be a valid number.")
-        return
-
-    if condition not in ['<', '>', '<=', '>=']:
-        await message.answer("❌ Condition must be one of: <, >, <=, >=")
-        return
-
-    if not fx_service.is_valid_currency(base) or not fx_service.is_valid_currency(target):
-        await message.answer(
-            "❌ Invalid currency pair. Let's select interactively:",
-            reply_markup=get_currency_keyboard("th_base", preset_action="th")
-        )
-        return
-
-    from db.session import async_session
-    async with async_session() as session:
-        await ensure_user_registered(session, message.chat.id)
-        threshold = Threshold(
-            chat_id=message.chat.id, 
-            base_currency=base, 
-            target_currency=target, 
-            condition=condition, 
-            target_value=value
-        )
-        session.add(threshold)
-        await session.commit()
-
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    
-    builder = InlineKeyboardBuilder()
-    builder.button(text="❌ Close", callback_data="delete_message")
-    
-    await message.answer(
-        f"✅ <b>Alert Set!</b>\n"
-        f"I will notify you when 1 {flag_base} {base} {condition} <b>{value}</b> {flag_target} {target}.",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-
-# --- Callback Handlers for Threshold Alerts ---
-
-@router.callback_query(lambda c: c.data == "th_start")
-async def callback_th_start(callback: types.CallbackQuery):
-    reply_markup = get_currency_keyboard("th_base", preset_action="th")
-    await callback.message.edit_text(
-        "🚨 <b>Set Up Threshold Alert</b>\n\n"
-        "Select a <b>Quick Preset</b> or select a custom <b>Base Currency</b> below:",
-        reply_markup=reply_markup,
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("th_base:"))
-async def callback_th_base(callback: types.CallbackQuery):
-    base = callback.data.split(":")[1]
-    reply_markup = get_currency_keyboard(f"th_target:{base}", exclude=base, include_presets=False)
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    await callback.message.edit_text(
-        f"🚨 <b>Set Up Threshold Alert</b>\n\n"
-        f"Base Currency: {flag_base} <b>{base}</b>\n\n"
-        f"Select the <b>Target Currency</b>:",
-        reply_markup=reply_markup,
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("th_target:"))
-async def callback_th_target(callback: types.CallbackQuery):
-    parts = callback.data.split(":")
-    base = parts[1]
-    target = parts[2]
-    
-    builder = InlineKeyboardBuilder()
-    builder.button(text="📈 Rises Above (>)", callback_data=f"th_cond:{base}:{target}:>")
-    builder.button(text="📉 Drops Below (<)", callback_data=f"th_cond:{base}:{target}:<")
-    builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
-    
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    await callback.message.edit_text(
-        f"🚨 <b>Set Up Threshold Alert</b>\n\n"
-        f"Base: {flag_base} <b>{base}</b>\n"
-        f"Target: {flag_target} <b>{target}</b>\n\n"
-        f"Select the <b>Alert Condition</b>:",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("th_cond:"))
-async def callback_th_cond(callback: types.CallbackQuery, state: FSMContext):
-    parts = callback.data.split(":")
-    base = parts[1]
-    target = parts[2]
-    cond = parts[3]
-    
-    await state.set_state(ThresholdForm.waiting_for_value)
-    await state.update_data(base=base, target=target, condition=cond, message_id=callback.message.message_id)
-    
-    builder = InlineKeyboardBuilder()
-    builder.button(text="❌ Cancel", callback_data="cancel_action")
-    
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    
-    # Text instruction
-    cond_name = "Rises Above" if cond == ">" else "Drops Below"
-    await callback.message.edit_text(
-        f"🚨 <b>Set Up Threshold Alert</b>\n\n"
-        f"Base: {flag_base} <b>{base}</b>\n"
-        f"Target: {flag_target} <b>{target}</b>\n"
-        f"Condition: <b>{cond_name} ({cond})</b>\n\n"
-        f"✍️ Please <b>type the target value</b> (e.g. 325.50) as a chat reply:",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-# --- FSM Handler for Threshold Input Value ---
-
-@router.message(ThresholdForm.waiting_for_value)
-async def process_threshold_value(message: types.Message, state: FSMContext):
-    data = await state.get_data()
-    base = data.get("base")
-    target = data.get("target")
-    condition = data.get("condition")
-    message_id = data.get("message_id")
-    
-    val_str = message.text.strip()
-    try:
-        value = float(val_str)
-    except ValueError:
-        # Prompt user to input again
-        await message.answer("❌ Value must be a valid number. Please enter a valid decimal (e.g., 300.50) or click Cancel.")
-        return
-        
-    from db.session import async_session
-    async with async_session() as session:
-        await ensure_user_registered(session, message.chat.id)
-        threshold = Threshold(
-            chat_id=message.chat.id, 
-            base_currency=base, 
-            target_currency=target, 
-            condition=condition, 
-            target_value=value
-        )
-        session.add(threshold)
-        await session.commit()
-        
-    await state.clear()
-    
-    # Try deleting the interactive prompt message to keep the chat clean
-    if message_id:
-        try:
-            await message.bot.delete_message(chat_id=message.chat.id, message_id=message_id)
-        except Exception:
-            pass
-            
-    builder = InlineKeyboardBuilder()
-    builder.button(text="❌ Close", callback_data="delete_message")
-    
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    await message.answer(
-        f"✅ <b>Alert Set Successfully!</b>\n\n"
-        f"I will notify you when 1 {flag_base} {base} {condition} <b>{value}</b> {flag_target} {target}.",
-        reply_markup=builder.as_markup(),
-        parse_mode="HTML"
-    )
-
-@router.message(Command("mysubs"))
-async def cmd_mysubs(message: types.Message):
-    """Lists all active subscriptions and thresholds for the user."""
-    from db.session import async_session
+    """Registers or re-enrolls a user in daily updates."""
     chat_id = message.chat.id
-    
     async with async_session() as session:
-        subs_result = await session.execute(select(Subscription).where(Subscription.chat_id == chat_id))
-        subs = subs_result.scalars().all()
-        
-        thresholds_result = await session.execute(select(Threshold).where(Threshold.chat_id == chat_id))
-        thresholds = thresholds_result.scalars().all()
+        result = await session.execute(select(User).where(User.chat_id == chat_id))
+        user = result.scalar_one_or_none()
         
-    response = "📋 <b>Your Active Settings Dashboard</b>\n\n"
-    
-    if subs:
-        response += "🔔 <b>Subscriptions:</b>\n"
-        for sub in subs:
-            flag_base = CURRENCY_FLAGS.get(sub.base_currency, "")
-            flag_target = CURRENCY_FLAGS.get(sub.target_currency, "")
-            response += f"• {flag_base} {sub.base_currency} ➡️ {flag_target} {sub.target_currency} (<i>{sub.frequency}</i>)\n"
-    else:
-        response += "🔔 <b>Subscriptions:</b> None\n"
-        
-    response += "\n"
-    
-    if thresholds:
-        response += "🚨 <b>Threshold Alerts:</b>\n"
-        for th in thresholds:
-            status = " (Active)" if th.is_active else " (Triggered/Inactive)"
-            flag_base = CURRENCY_FLAGS.get(th.base_currency, "")
-            flag_target = CURRENCY_FLAGS.get(th.target_currency, "")
-            response += f"• {flag_base} {th.base_currency} ➡️ {flag_target} {th.target_currency} <b>{th.condition} {th.target_value}</b><i>{status}</i>\n"
-    else:
-        response += "🚨 <b>Threshold Alerts:</b> None\n"
-        
-    builder = InlineKeyboardBuilder()
-    builder.button(text="➕ Add Sub", callback_data="sub_start")
-    builder.button(text="➕ Add Alert", callback_data="th_start")
-    builder.row(
-        types.InlineKeyboardButton(text="➖ Manage Subs", callback_data="unsub_start"),
-        types.InlineKeyboardButton(text="➖ Manage Alerts", callback_data="delth_start")
-    )
-    builder.row(types.InlineKeyboardButton(text="❌ Close Dashboard", callback_data="delete_message"))
-    
-    await message.answer(response, reply_markup=builder.as_markup(), parse_mode="HTML")
+        if not user:
+            user = User(chat_id=chat_id, is_subscribed=True)
+            session.add(user)
+            await session.commit()
+            text = "✅ <b>Successfully Subscribed!</b>\n\nYou will now receive a daily LKR exchange rate list update every morning."
+        elif not user.is_subscribed:
+            user.is_subscribed = True
+            await session.commit()
+            text = "✅ <b>Subscription Activated!</b>\n\nYou will now receive a daily LKR exchange rate list update every morning."
+        else:
+            text = "ℹ️ <b>You are already subscribed to daily LKR updates!</b>"
+            
+        await message.answer(text, parse_mode="HTML")
 
 @router.message(Command("unsubscribe"))
 async def cmd_unsubscribe(message: types.Message):
-    """Removes a subscription (direct or interactive)."""
-    args = message.text.split()[1:]
-    if not args:
-        # Interactive unsubscribe
-        from db.session import async_session
-        async with async_session() as session:
-            result = await session.execute(select(Subscription).where(Subscription.chat_id == message.chat.id))
-            subs = result.scalars().all()
-            
-        if not subs:
-            await message.answer("ℹ️ You don't have any active subscriptions to remove.")
-            return
-            
-        builder = InlineKeyboardBuilder()
-        for sub in subs:
-            flag_base = CURRENCY_FLAGS.get(sub.base_currency, "")
-            flag_target = CURRENCY_FLAGS.get(sub.target_currency, "")
-            builder.button(
-                text=f"❌ {flag_base} {sub.base_currency} ➡️ {flag_target} {sub.target_currency} ({sub.frequency})", 
-                callback_data=f"unsub_id:{sub.id}"
-            )
-        builder.adjust(1)
-        builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
-        
-        await message.answer(
-            "➖ <b>Manage Subscriptions</b>\n\nClick on any subscription to remove it:", 
-            reply_markup=builder.as_markup(), 
-            parse_mode="HTML"
-        )
-        return
-
-    if len(args) not in [1, 2]:
-        await message.answer(
-            "Usage: <code>/unsubscribe &lt;base&gt; [target]</code>\n"
-            "Example: <code>/unsubscribe USD</code>\n\n"
-            "Or just type <code>/unsubscribe</code> to list and remove.", 
-            parse_mode="HTML"
-        )
-        return
-
-    base = args[0].upper()
-    target = args[1].upper() if len(args) == 2 else "LKR"
+    """Opts out a user from daily broadcasts."""
     chat_id = message.chat.id
-
-    from db.session import async_session
-    async with async_session() as session:
-        result = await session.execute(select(Subscription).where(
-            Subscription.chat_id == chat_id,
-            Subscription.base_currency == base,
-            Subscription.target_currency == target
-        ))
-        subs = result.scalars().all()
-        
-        if not subs:
-            await message.answer(f"❌ You don't have a subscription for {base} to {target}.")
-            return
-            
-        for sub in subs:
-            await session.delete(sub)
-        await session.commit()
-
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    await message.answer(f"✅ Unsubscribed from {flag_base} {base} to {flag_target} {target} updates.")
-
-# --- Callback Handlers for Unsubscribing ---
-
-@router.callback_query(lambda c: c.data == "unsub_start")
-async def callback_unsub_start(callback: types.CallbackQuery):
-    from db.session import async_session
     async with async_session() as session:
-        result = await session.execute(select(Subscription).where(Subscription.chat_id == callback.message.chat.id))
-        subs = result.scalars().all()
-        
-    if not subs:
-        await callback.message.edit_text("ℹ️ You don't have any active subscriptions to remove.")
-        await callback.answer()
-        return
+        result = await session.execute(select(User).where(User.chat_id == chat_id))
+        user = result.scalar_one_or_none()
         
-    builder = InlineKeyboardBuilder()
-    for sub in subs:
-        flag_base = CURRENCY_FLAGS.get(sub.base_currency, "")
-        flag_target = CURRENCY_FLAGS.get(sub.target_currency, "")
-        builder.button(
-            text=f"❌ {flag_base} {sub.base_currency} ➡️ {flag_target} {sub.target_currency} ({sub.frequency})", 
-            callback_data=f"unsub_id:{sub.id}"
-        )
-    builder.adjust(1)
-    builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
-    
-    await callback.message.edit_text(
-        "➖ <b>Manage Subscriptions</b>\n\nClick on any subscription to remove it:", 
-        reply_markup=builder.as_markup(), 
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("unsub_id:"))
-async def callback_unsub_id(callback: types.CallbackQuery):
-    sub_id = int(callback.data.split(":")[1])
-    
-    from db.session import async_session
-    async with async_session() as session:
-        sub_result = await session.execute(select(Subscription).where(Subscription.id == sub_id))
-        sub = sub_result.scalar_one_or_none()
-        if sub:
-            base = sub.base_currency
-            target = sub.target_currency
-            await session.delete(sub)
+        if user and user.is_subscribed:
+            user.is_subscribed = False
             await session.commit()
-            
-            builder = InlineKeyboardBuilder()
-            builder.button(text="❌ Close", callback_data="delete_message")
-            
-            flag_base = CURRENCY_FLAGS.get(base, "")
-            flag_target = CURRENCY_FLAGS.get(target, "")
-            await callback.message.edit_text(
-                f"✅ Unsubscribed from <b>{flag_base} {base}</b> to <b>{flag_target} {target}</b> updates.", 
-                reply_markup=builder.as_markup(), 
-                parse_mode="HTML"
+            text = (
+                "❌ <b>Successfully Unsubscribed</b>\n\n"
+                "You have opted-out of daily exchange rate updates. You will no longer receive daily broadcasts.\n\n"
+                "💡 You can type /subscribe at any time to activate them again!"
             )
         else:
-            await callback.message.edit_text("❌ Subscription not found or already deleted.")
-    await callback.answer()
-
-@router.message(Command("delthreshold"))
-async def cmd_delthreshold(message: types.Message):
-    """Removes a threshold alert (direct or interactive)."""
-    args = message.text.split()[1:]
-    if not args:
-        # Interactive delthreshold
-        from db.session import async_session
-        async with async_session() as session:
-            result = await session.execute(select(Threshold).where(Threshold.chat_id == message.chat.id))
-            thresholds = result.scalars().all()
-            
-        if not thresholds:
-            await message.answer("ℹ️ You don't have any active threshold alerts to remove.")
-            return
-            
-        builder = InlineKeyboardBuilder()
-        for th in thresholds:
-            status = " (Active)" if th.is_active else " (Triggered)"
-            flag_base = CURRENCY_FLAGS.get(th.base_currency, "")
-            flag_target = CURRENCY_FLAGS.get(th.target_currency, "")
-            builder.button(
-                text=f"❌ {flag_base} {th.base_currency} ➡️ {flag_target} {th.target_currency} {th.condition} {th.target_value}{status}", 
-                callback_data=f"delth_id:{th.id}"
+            text = (
+                "ℹ️ <b>You are not currently subscribed.</b>\n\n"
+                "💡 Type /subscribe if you wish to enroll in daily LKR rate updates."
             )
-        builder.adjust(1)
-        builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
-        
-        await message.answer(
-            "➖ <b>Manage Threshold Alerts</b>\n\nClick on any alert to delete it:", 
-            reply_markup=builder.as_markup(), 
-            parse_mode="HTML"
-        )
-        return
-
-    if len(args) not in [1, 2]:
-        await message.answer(
-            "Usage: <code>/delthreshold &lt;base&gt; [target]</code>\n"
-            "Example: <code>/delthreshold USD</code>\n\n"
-            "Or just type <code>/delthreshold</code> to list and delete.", 
-            parse_mode="HTML"
-        )
-        return
-
-    base = args[0].upper()
-    target = args[1].upper() if len(args) == 2 else "LKR"
-    chat_id = message.chat.id
-
-    from db.session import async_session
-    async with async_session() as session:
-        result = await session.execute(select(Threshold).where(
-            Threshold.chat_id == chat_id,
-            Threshold.base_currency == base,
-            Threshold.target_currency == target
-        ))
-        thresholds = result.scalars().all()
-        
-        if not thresholds:
-            await message.answer(f"❌ You don't have a threshold alert for {base} to {target}.")
-            return
             
-        for th in thresholds:
-            await session.delete(th)
-        await session.commit()
-
-    flag_base = CURRENCY_FLAGS.get(base, "")
-    flag_target = CURRENCY_FLAGS.get(target, "")
-    await message.answer(f"✅ Deleted threshold alerts for {flag_base} {base} to {flag_target} {target}.")
-
-# --- Callback Handlers for Deleting Thresholds ---
+        await message.answer(text, parse_mode="HTML")
 
-@router.callback_query(lambda c: c.data == "delth_start")
-async def callback_delth_start(callback: types.CallbackQuery):
-    from db.session import async_session
-    async with async_session() as session:
-        result = await session.execute(select(Threshold).where(Threshold.chat_id == callback.message.chat.id))
-        thresholds = result.scalars().all()
-        
-    if not thresholds:
-        await callback.message.edit_text("ℹ️ You don't have any active threshold alerts to remove.")
-        await callback.answer()
-        return
-        
-    builder = InlineKeyboardBuilder()
-    for th in thresholds:
-        status = " (Active)" if th.is_active else " (Triggered)"
-        flag_base = CURRENCY_FLAGS.get(th.base_currency, "")
-        flag_target = CURRENCY_FLAGS.get(th.target_currency, "")
-        builder.button(
-            text=f"❌ {flag_base} {th.base_currency} ➡️ {flag_target} {th.target_currency} {th.condition} {th.target_value}{status}", 
-            callback_data=f"delth_id:{th.id}"
-        )
-    builder.adjust(1)
-    builder.row(types.InlineKeyboardButton(text="❌ Cancel", callback_data="cancel_action"))
+@router.message(Command("current"))
+async def cmd_current(message: types.Message):
+    """Instantly fetches and sends the LKR rate list with a Refresh button."""
+    # Send a quick loading message so the user knows we are scraping/calculating
+    loading_msg = await message.answer("🔄 <i>Fetching live rates from CBSL... Please wait.</i>", parse_mode="HTML")
     
-    await callback.message.edit_text(
-        "➖ <b>Manage Threshold Alerts</b>\n\nClick on any alert to delete it:", 
-        reply_markup=builder.as_markup(), 
-        parse_mode="HTML"
-    )
-    await callback.answer()
-
-@router.callback_query(lambda c: c.data.startswith("delth_id:"))
-async def callback_delth_id(callback: types.CallbackQuery):
-    th_id = int(callback.data.split(":")[1])
+    try:
+        rates_text = await get_formatted_current_rates()
+        await loading_msg.delete()
+        await message.answer(rates_text, reply_markup=get_refresh_keyboard(), parse_mode="HTML")
+    except Exception as e:
+        logger.exception("Error serving /current:")
+        await loading_msg.edit_text("⚠️ <i>Unable to fetch live rates at this time. Please try again later.</i>", parse_mode="HTML")
+
+@router.callback_query(lambda c: c.data == "refresh_rates")
+async def process_refresh_rates(callback_query: types.CallbackQuery):
+    """Updates the LKR rate list message in-place if rates changed."""
+    original_text = callback_query.message.text
     
-    from db.session import async_session
-    async with async_session() as session:
-        th_result = await session.execute(select(Threshold).where(Threshold.id == th_id))
-        th = th_result.scalar_one_or_none()
-        if th:
-            base = th.base_currency
-            target = th.target_currency
-            await session.delete(th)
-            await session.commit()
-            
-            builder = InlineKeyboardBuilder()
-            builder.button(text="❌ Close", callback_data="delete_message")
-            
-            flag_base = CURRENCY_FLAGS.get(base, "")
-            flag_target = CURRENCY_FLAGS.get(target, "")
-            await callback.message.edit_text(
-                f"✅ Deleted threshold alert for <b>{flag_base} {base}</b> to <b>{flag_target} {target}</b>.", 
-                reply_markup=builder.as_markup(), 
-                parse_mode="HTML"
-            )
-        else:
-            await callback.message.edit_text("❌ Threshold alert not found or already deleted.")
-    await callback.answer()
+    try:
+        new_text = await get_formatted_current_rates()
+        
+        # Clean HTML tags for simple comparison since callback_query.message.text is raw text
+        # aiogram's message.text strips HTML tags, so we can just compare content length or basic text
+        # To be safe, we always update the message to reflect a new timestamp or show rate updates
+        await callback_query.message.edit_text(
+            new_text,
+            reply_markup=get_refresh_keyboard(),
+            parse_mode="HTML"
+        )
+        await callback_query.answer("Rates updated successfully!")
+    except Exception as e:
+        logger.error(f"Error handling inline refresh: {e}")
+        await callback_query.answer("⚠️ Could not refresh rates right now.")
 
 @router.message(Command("help"))
 async def cmd_help(message: types.Message):
-    """Shows detailed usage instructions."""
-    currencies_str = ", ".join(ALLOWED_CURRENCIES)
-    help_text = (
-        "📚 <b>FlyRates Bot Help</b> 📚\n\n"
-        "Here are the commands you can use:\n\n"
-        "<b>Basic Commands</b>\n"
-        "<code>/start</code> - Get welcome message\n"
-        "<code>/help</code> - Show this help menu\n\n"
-        "<b>Rates & Updates</b>\n"
-        "<code>/current &lt;base&gt; [target]</code> - Get the live rate\n"
-        "<code>/subscribe &lt;base&gt; [target] [daily/hourly]</code> - Automate updates\n"
-        "<code>/threshold &lt;base&gt; [target] &lt;condition&gt; &lt;value&gt;</code> - Get custom alerts (&lt;, &gt;, &lt;=, &gt;=)\n\n"
-        "<b>Management</b>\n"
-        "<code>/mysubs</code> - View all your active subscriptions and alerts\n"
-        "<code>/unsubscribe &lt;base&gt; [target]</code> - Remove a subscription\n"
-        "<code>/delthreshold &lt;base&gt; [target]</code> - Remove an alert\n\n"
-        f"<b>Supported Currencies:</b> {currencies_str}\n\n"
-        "<b>Examples:</b>\n"
-        "<code>/current USD</code> (defaults to LKR)\n"
-        "<code>/subscribe USD daily</code>\n"
-        "<code>/threshold USD &lt; 300</code>"
-    )
-    await message.answer(help_text, parse_mode="HTML")
+    """Displays a clean help manual for the bot."""
+    text = (
+        "📚 <b>FlyRates Bot Help Guide</b> 📚\n\n"
+        "FlyRates is a single-purpose, high-availability exchange rate bot that sends a <b>daily summary of major global currencies converted to Sri Lankan Rupee (LKR)</b>.\n\n"
+        "🛠️ <b>Available Commands:</b>\n"
+        "• /subscribe - Subscribe to daily rate list updates\n"
+        "• /unsubscribe - Opt-out of daily rate updates\n"
+        "• /current - Retrieve the live exchange rates list instantly\n"
+        "• /help - Display this help manual\n\n"
+        "🌍 <b>Supported Currencies:</b>\n"
+        "USD, EUR, GBP, AUD, JPY, AED, SAR, INR, CNY, QAR\n\n"
+        "🔄 <i>All rates are pulled live from the official Central Bank of Sri Lanka (CBSL).</i>"
+    )
+    await message.answer(text, parse_mode="HTML")

bot/scheduler.py

@@ -1,60 +1,95 @@
 import logging
+import asyncio
+from datetime import datetime
 from aiogram import Bot
+from aiogram.exceptions import TelegramForbiddenError, TelegramAPIError
 from db.session import async_session
-from db.models import Subscription, Threshold
+from db.models import User
 from sqlalchemy import select
 from services.fx_service import fx_service
 
 logger = logging.getLogger(__name__)
 
-async def process_subscriptions(bot: Bot, frequency: str):
-    """Processes scheduled subscriptions."""
-    logger.info(f"Processing {frequency} subscriptions...")
-    async with async_session() as session:
-        result = await session.execute(select(Subscription).where(Subscription.frequency == frequency))
-        subscriptions = result.scalars().all()
-
-        for sub in subscriptions:
-            rate = await fx_service.get_rate(sub.base_currency, sub.target_currency)
-            if rate:
-                try:
-                    await bot.send_message(
-                        chat_id=sub.chat_id,
-                        text=f"🔔 Scheduled Update ({frequency}):\n1 {sub.base_currency} = {rate} {sub.target_currency}"
-                    )
-                except Exception as e:
-                    logger.error(f"Failed to send sub update to {sub.chat_id}: {e}")
+CURRENCIES = ["USD", "EUR", "GBP", "AUD", "JPY", "AED", "SAR", "INR", "CNY", "QAR"]
 
-async def process_thresholds(bot: Bot):
-    """Processes active thresholds."""
-    logger.info("Processing thresholds...")
-    async with async_session() as session:
-        result = await session.execute(select(Threshold).where(Threshold.is_active == True))
-        thresholds = result.scalars().all()
+FLAGS = {
+    "USD": "🇺🇸",
+    "EUR": "🇪🇺",
+    "GBP": "🇬🇧",
+    "AUD": "🇦🇺",
+    "JPY": "🇯🇵",
+    "AED": "🇦🇪",
+    "SAR": "🇸🇦",
+    "INR": "🇮🇳",
+    "CNY": "🇨🇳",
+    "QAR": "🇶🇦"
+}
 
-        for thresh in thresholds:
-            rate = await fx_service.get_rate(thresh.base_currency, thresh.target_currency)
-            if rate is None:
-                continue
+def format_rates_list(rates: dict) -> str:
+    """Formats the rates dictionary into a beautifully styled HTML message."""
+    lines = [
+        "🌍 <b>Daily LKR Exchange Rates</b> 🌍",
+        f"📅 <i>Date: {datetime.now().strftime('%Y-%m-%d')}</i>",
+        ""
+    ]
+    for cur in CURRENCIES:
+        rate = rates.get(cur)
+        flag = FLAGS.get(cur, "💱")
+        if rate:
+            lines.append(f"{flag} <b>1 {cur}</b> = {rate:.2f} LKR")
+        else:
+            lines.append(f"{flag} <b>1 {cur}</b> = <i>Scraper Offline</i>")
+            
+    lines.extend([
+        "",
+        "🔄 <i>Rates are sourced directly from the Central Bank of Sri Lanka (CBSL).</i>",
+        "❌ Type /unsubscribe to opt-out of these daily updates."
+    ])
+    return "\n".join(lines)
 
-            triggered = False
-            if thresh.condition == '<' and rate < thresh.target_value:
-                triggered = True
-            elif thresh.condition == '>' and rate > thresh.target_value:
-                triggered = True
-            elif thresh.condition == '<=' and rate <= thresh.target_value:
-                triggered = True
-            elif thresh.condition == '>=' and rate >= thresh.target_value:
-                triggered = True
-
-            if triggered:
-                try:
-                    await bot.send_message(
-                        chat_id=thresh.chat_id,
-                        text=f"🚨 ALERT Triggered!\n\n1 {thresh.base_currency} is now {rate} {thresh.target_currency}\n(Condition: {thresh.condition} {thresh.target_value})"
-                    )
-                    # Deactivate the threshold after triggering to prevent spam
-                    thresh.is_active = False
+async def process_daily_broadcast(bot: Bot):
+    """Processes the scheduled daily broadcast to all subscribed users."""
+    logger.info("Starting daily exchange rate broadcast...")
+    
+    # 1. Fetch all exchange rates concurrently
+    tasks = [fx_service.get_rate(cur, "LKR") for cur in CURRENCIES]
+    rates_values = await asyncio.gather(*tasks)
+    rates = dict(zip(CURRENCIES, rates_values))
+    
+    # 2. Format the message
+    broadcast_message = format_rates_list(rates)
+    
+    # 3. Retrieve all active subscribers
+    async with async_session() as session:
+        result = await session.execute(select(User.chat_id).where(User.is_subscribed == True))
+        subscribers = result.scalars().all()
+        
+        if not subscribers:
+            logger.info("No active subscribers found for daily broadcast.")
+            return
+            
+        logger.info(f"Broadcasting to {len(subscribers)} active subscribers...")
+        
+        # 4. Deliver updates
+        for chat_id in subscribers:
+            try:
+                await bot.send_message(
+                    chat_id=chat_id,
+                    text=broadcast_message,
+                    parse_mode="HTML"
+                )
+                logger.info(f"Daily broadcast sent successfully to chat_id: {chat_id}")
+            except TelegramForbiddenError:
+                # User blocked the bot - deactivate subscription to save future API limits
+                logger.warning(f"User {chat_id} has blocked the bot. Opting them out of daily updates...")
+                user_res = await session.execute(select(User).where(User.chat_id == chat_id))
+                user_obj = user_res.scalar_one_or_none()
+                if user_obj:
+                    user_obj.is_subscribed = False
                     await session.commit()
-                except Exception as e:
-                    logger.error(f"Failed to send alert to {thresh.chat_id}: {e}")
+            except TelegramAPIError as e:
+                logger.error(f"Telegram API error when broadcasting to {chat_id}: {e}")
+            except Exception as e:
+                logger.error(f"Unexpected error when broadcasting to {chat_id}: {e}")
+                
+    logger.info("Daily exchange rate broadcast completed successfully.")

db/models.py

@@ -1,5 +1,5 @@
-from sqlalchemy import Column, Integer, String, Float, DateTime, Boolean, ForeignKey, BigInteger
-from sqlalchemy.orm import declarative_base, relationship
+from sqlalchemy import Column, DateTime, Boolean, BigInteger
+from sqlalchemy.orm import declarative_base
 from datetime import datetime, timezone
 
 Base = declarative_base()
@@ -8,34 +8,5 @@ class User(Base):
     __tablename__ = "users"
 
     chat_id = Column(BigInteger, primary_key=True, index=True)
+    is_subscribed = Column(Boolean, default=True)
     created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
-
-    subscriptions = relationship("Subscription", back_populates="user", cascade="all, delete-orphan")
-    thresholds = relationship("Threshold", back_populates="user", cascade="all, delete-orphan")
-
-class Subscription(Base):
-    __tablename__ = "subscriptions"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    chat_id = Column(BigInteger, ForeignKey("users.chat_id"))
-    base_currency = Column(String(3), nullable=False)
-    target_currency = Column(String(3), nullable=False)
-    # Frequency could be 'daily', 'hourly'
-    frequency = Column(String(20), default="daily")
-    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
-
-    user = relationship("User", back_populates="subscriptions")
-
-class Threshold(Base):
-    __tablename__ = "thresholds"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    chat_id = Column(BigInteger, ForeignKey("users.chat_id"))
-    base_currency = Column(String(3), nullable=False)
-    target_currency = Column(String(3), nullable=False)
-    condition = Column(String(5), nullable=False) # e.g., '<', '>', '<=', '>='
-    target_value = Column(Float, nullable=False)
-    is_active = Column(Boolean, default=True)
-    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc).replace(tzinfo=None))
-
-    user = relationship("User", back_populates="thresholds")

db/session.py

@@ -38,40 +38,30 @@ async def init_db():
     """Initializes the database and creates all tables."""
     try:
         async with engine.begin() as conn:
+            # 1. Create tables defined in models.py (creates users table if not exists)
             await conn.run_sync(Base.metadata.create_all)
             
-            # Check if running on PostgreSQL/Supabase and perform auto-migration of chat_id columns to BIGINT
-            if "postgresql" in engine.url.drivername or "postgres" in engine.url.drivername:
-                logger.info("Running on PostgreSQL. Ensuring chat_id columns are BIGINT...")
-                migration_sql = """
-                DO $$
-                BEGIN
-                    -- Drop foreign key constraints if they exist
-                    IF EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'subscriptions_chat_id_fkey') THEN
-                        ALTER TABLE subscriptions DROP CONSTRAINT subscriptions_chat_id_fkey;
-                    END IF;
-                    IF EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'thresholds_chat_id_fkey') THEN
-                        ALTER TABLE thresholds DROP CONSTRAINT thresholds_chat_id_fkey;
-                    END IF;
-
-                    -- Alter columns to BIGINT
-                    ALTER TABLE users ALTER COLUMN chat_id TYPE BIGINT;
-                    ALTER TABLE subscriptions ALTER COLUMN chat_id TYPE BIGINT;
-                    ALTER TABLE thresholds ALTER COLUMN chat_id TYPE BIGINT;
-
-                    -- Re-create constraints with CASCADE delete (matching SQLAlchemy cascade configuration)
-                    ALTER TABLE subscriptions ADD CONSTRAINT subscriptions_chat_id_fkey 
-                        FOREIGN KEY (chat_id) REFERENCES users(chat_id) ON DELETE CASCADE;
-                    ALTER TABLE thresholds ADD CONSTRAINT thresholds_chat_id_fkey 
-                        FOREIGN KEY (chat_id) REFERENCES users(chat_id) ON DELETE CASCADE;
-                EXCEPTION
-                    WHEN OTHERS THEN
-                        RAISE NOTICE 'Migration encountered an error: %', SQLERRM;
-                END $$;
-                """
-                from sqlalchemy import text
-                await conn.execute(text(migration_sql))
-                logger.info("Database chat_id columns successfully migrated/verified as BIGINT.")
+            # 2. Database migrations and cleanups
+            is_postgres = "postgresql" in engine.url.drivername or "postgres" in engine.url.drivername
+            from sqlalchemy import text
+            
+            if is_postgres:
+                logger.info("Running on PostgreSQL. Ensuring schema matches simplified design...")
+                # Run each statement individually to comply with asyncpg single-statement execution rules
+                await conn.execute(text("DROP TABLE IF EXISTS thresholds CASCADE"))
+                await conn.execute(text("DROP TABLE IF EXISTS subscriptions CASCADE"))
+                await conn.execute(text("ALTER TABLE users ALTER COLUMN chat_id TYPE BIGINT"))
+                await conn.execute(text("ALTER TABLE users ADD COLUMN IF NOT EXISTS is_subscribed BOOLEAN DEFAULT TRUE"))
+                logger.info("PostgreSQL database schema successfully migrated and simplified.")
+            else:
+                logger.info("Running on SQLite. Running schema verification...")
+                # SQLite fallback to add is_subscribed column if it does not exist
+                try:
+                    await conn.execute(text("ALTER TABLE users ADD COLUMN is_subscribed BOOLEAN DEFAULT 1"))
+                    logger.info("Successfully added is_subscribed column to SQLite users table.")
+                except Exception:
+                    # Column already exists
+                    pass
                 
         logger.info("Database initialized successfully.")
     except Exception as e:

main.py

@@ -26,9 +26,9 @@ socket.getaddrinfo = custom_getaddrinfo
 
 from core.config import settings
 from db.session import init_db, async_session
-from db.models import User, Subscription, Threshold
+from db.models import User
 from bot.handlers import router as bot_router
-from bot.scheduler import process_subscriptions, process_thresholds
+from bot.scheduler import process_daily_broadcast
 from services.fx_service import fx_service
 
 # Configure Logging
@@ -161,10 +161,8 @@ async def lifespan(app: FastAPI):
     except Exception as e:
         logger.error(f"Failed to setup Telegram interaction during startup: {e}")
 
-    # 3. Setup Scheduled Jobs
-    scheduler.add_job(process_thresholds, 'interval', minutes=10, args=[bot])
-    scheduler.add_job(process_subscriptions, 'cron', hour=8, args=[bot, 'daily'])
-    scheduler.add_job(process_subscriptions, 'interval', hours=1, args=[bot, 'hourly'])
+    # 3. Setup Scheduled Jobs (exactly one clean daily broadcast at 8:00 AM)
+    scheduler.add_job(process_daily_broadcast, 'cron', hour=8, args=[bot])
     scheduler.start()
 
     yield
@@ -227,14 +225,12 @@ async def get_system_stats():
     stats = {}
     try:
         async with async_session() as session:
-            # Gather subscriber (user) counts, subscriptions, and active thresholds
-            users_count = await session.scalar(select(func.count(User.chat_id)))
-            subs_count = await session.scalar(select(func.count(Subscription.id)))
-            thresholds_count = await session.scalar(select(func.count(Threshold.id)).where(Threshold.is_active == True))
+            # Gather active subscribers count
+            users_count = await session.scalar(select(func.count(User.chat_id)).where(User.is_subscribed == True))
             
             stats["subscribers"] = users_count or 0
-            stats["active_subscriptions"] = subs_count or 0
-            stats["active_thresholds"] = thresholds_count or 0
+            stats["active_subscriptions"] = 10  # 10 core LKR currencies tracked
+            stats["active_thresholds"] = 1     # Unified active broadcast schedule
             stats["db_status"] = "connected"
     except Exception as e:
         logger.error(f"Error fetching stats from DB: {e}")

static/index.html

@@ -49,16 +49,16 @@
                         </div>
                     </div>
                     <div class="metric-card" id="metric-subs">
-                        <div class="card-icon"><i class="fa-solid fa-bell"></i></div>
+                        <div class="card-icon"><i class="fa-solid fa-globe"></i></div>
                         <div class="card-info">
-                            <h3>Active Subscriptions</h3>
+                            <h3>Currencies Tracked</h3>
                             <div class="value" id="stats-subscriptions">-</div>
                         </div>
                     </div>
                     <div class="metric-card" id="metric-thresholds">
-                        <div class="card-icon"><i class="fa-solid fa-triangle-exclamation"></i></div>
+                        <div class="card-icon"><i class="fa-solid fa-calendar-check"></i></div>
                         <div class="card-info">
-                            <h3>Active Alerts</h3>
+                            <h3>Active Schedules</h3>
                             <div class="value" id="stats-thresholds">-</div>
                         </div>
                     </div>
@@ -99,7 +99,7 @@
                 <div class="glass-card telegram-promotion">
                     <div class="promo-content">
                         <h3>Get rate updates directly in Telegram!</h3>
-                        <p>Subscribe to automated updates and custom threshold alerts instantly.</p>
+                        <p>Subscribe to receive a beautifully formatted daily exchange rate list automatically.</p>
                         <a href="https://t.me/FlyRatesBot" target="_blank" class="btn btn-primary">
                             <i class="fa-brands fa-telegram"></i> Launch Telegram Bot
                         </a>