feat: add Make integration with burn rate analysis and auto-renewal tracking

Author: Derssen

config.py

@@ -20,6 +20,10 @@ class Config:
     WAZZUP_TOKEN: str = os.getenv("WAZZUP_TOKEN")
     DIDWW_KEY: str = os.getenv("DIDWW_KEY")
 
+    # NEW: Make Credentials
+    MAKE_API_KEY: str = os.getenv("MAKE_API_KEY")
+    MAKE_ORG_ID: str = os.getenv("MAKE_ORG_ID")
+    
     # Financial Constants
     LOW_BALANCE_THRESHOLD: float = 10.0
     MIN_TOP_UP_AMOUNT: float = 5.0
@@ -42,22 +46,24 @@ class Config:
         'DIDWW': 'USD',
         'Streamtele': 'UAH',
         'Callii': 'USD',
+        'Make': 'Ops',  # Operations
     }
 
     CURRENCY_SIGNS: dict = {
         'USD': '$',
         'UAH': '₴',
         'RUB': '₽',
+        'Ops': '⚡', # Icon for operations
     }
 
     # API Service Toggle
     API_SERVICE_STATUSES: dict = {
         'Zadarma': os.getenv("ZADARMA_ENABLED", "True").lower() in ('true', '1', 't'),
         'DIDWW': os.getenv("DIDWW_ENABLED", "True").lower() in ('true', '1', 't'),
+        'Make': os.getenv("MAKE_ENABLED", "True").lower() in ('true', '1', 't'),
     }
 
 SETTINGS = Config()
 
-# Validation
 if not SETTINGS.BOT_TOKEN or SETTINGS.TARGET_CHAT_ID == -1:
     raise ValueError("Critical configuration missing: BOT_TOKEN or TARGET_CHAT_ID.")

db/models.py

@@ -1,129 +1,68 @@
-from datetime import datetime
-import pytz
 from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime, text
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, AsyncEngine
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
 from sqlalchemy.orm import sessionmaker, declarative_base
 from sqlalchemy.future import select
-
+from datetime import datetime
+import pytz
 from config import SETTINGS
 
-# Define Timezone
-TIMEZONE = pytz.timezone('Asia/Makassar')
+TIMEZONE = pytz.timezone('Asia/Makassar') 
 
 Base = declarative_base()
 
 class Service(Base):
-    """Database model representing a tracked service."""
     __tablename__ = 'services'
-    
     id = Column(Integer, primary_key=True)
     name = Column(String, unique=True, nullable=False)
-    
-    # Balance Monitoring
     last_balance = Column(Float, default=0.0)
     low_balance_alert_sent = Column(Boolean, default=False)
-    
-    # Financial Configuration
-    currency = Column(String, default="USD")     # USD, RUB, UAH
-    daily_cost = Column(Float, nullable=True)    # Estimated daily cost
-    monthly_fee = Column(Float, nullable=True)   # Fixed monthly fee
-    
-    # Alert Schedule
+    currency = Column(String, default="USD")
+    daily_cost = Column(Float, nullable=True)
+    monthly_fee = Column(Float, nullable=True)
     next_alert_date = Column(DateTime, nullable=True) 
     next_monthly_alert = Column(DateTime, nullable=True)
+    last_alert_at = Column(DateTime, nullable=True)
 
     def __repr__(self):
         return f"<Service(name='{self.name}', balance={self.last_balance})>"
 
-async def init_db(database_url: str) -> sessionmaker:
-    """Initialize the database engine and session factory."""
+async def init_db(database_url: str):
     engine = create_async_engine(database_url, echo=False)
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
-    
-    async_session = sessionmaker(
-        autocommit=False,
-        autoflush=False,
-        bind=engine,
-        class_=AsyncSession,
-        expire_on_commit=False,
-    )
-    return async_session
-
-async def initialize_services(session_factory) -> None:
-    """
-    Populate the database with default services and perform schema migrations if necessary.
-    """
-    async with session_factory() as session:
-        # 1. Simple schema migration (add columns if missing)
-        pragma_stmt = text("PRAGMA table_info(services)")
-        result = await session.execute(pragma_stmt)
-        existing_columns = {row[1] for row in result.fetchall()}
+    return sessionmaker(bind=engine, class_=AsyncSession, expire_on_commit=False)
 
+async def initialize_services(SessionLocal):
+    async with SessionLocal() as session:
+        # Schema migration
+        result = await session.execute(text("PRAGMA table_info(services)"))
+        columns = {row[1] for row in result.fetchall()}
         alter_statements = []
-        required_columns = ['currency', 'daily_cost', 'monthly_fee', 'next_monthly_alert']
 
-        for col in required_columns:
-            if col not in existing_columns:
-                col_type = 'DATETIME' if 'next' in col else ('FLOAT' if 'cost' in col or 'fee' in col else 'VARCHAR')
-                alter_statements.append(f"ALTER TABLE services ADD COLUMN {col} {col_type}")
-
-        for stmt in alter_statements:
-            try:
-                await session.execute(text(stmt))
-            except Exception:
-                pass # Ignore errors if column exists
+        for col in ['currency', 'daily_cost', 'monthly_fee', 'next_monthly_alert', 'last_alert_at']:
+            if col not in columns:
+                ctype = 'DATETIME' if 'alert' in col else ('FLOAT' if 'cost' in col or 'fee' in col else 'VARCHAR')
+                alter_statements.append(f"ALTER TABLE services ADD COLUMN {col} {ctype}")
 
-        if alter_statements:
-            await session.commit()
+        for stmt in alter_statements:
+            try: await session.execute(text(stmt))
+            except Exception: pass
+        if alter_statements: await session.commit()
 
-        # 2. Seed default data
-        services_to_seed = [
-            {
-                'name': 'Zadarma',
-                'last_balance': 0.0,
-                'currency': SETTINGS.SERVICE_CURRENCIES.get('Zadarma', 'USD'),
-            },
-            {
-                'name': 'Wazzup24 Подписка',
-                'last_balance': 0.0,
-                'currency': SETTINGS.SERVICE_CURRENCIES.get('Wazzup24 Подписка', 'RUB'),
-                'monthly_fee': SETTINGS.WAZZUP_MONTHLY_FEE,
-                'next_monthly_alert': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0)),
-            },
-            {
-                'name': 'Wazzup24 Баланс номера',
-                'last_balance': 0.0,
-                'currency': SETTINGS.SERVICE_CURRENCIES.get('Wazzup24 Баланс номера', 'RUB'),
-                'daily_cost': SETTINGS.WAZZUP_DAILY_COST,
-                'next_alert_date': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0)),
-            },
-            {
-                'name': 'DIDWW',
-                'last_balance': 0.0,
-                'currency': SETTINGS.SERVICE_CURRENCIES.get('DIDWW', 'USD'),
-                'monthly_fee': SETTINGS.DIDWW_MONTHLY_FEE,
-                'next_monthly_alert': TIMEZONE.localize(datetime(2025, 12, 20, 10, 0)),
-            },
-            {
-                'name': 'Callii',
-                'next_alert_date': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0)),
-                'currency': SETTINGS.SERVICE_CURRENCIES.get('Callii', 'USD'),
-                'daily_cost': SETTINGS.CALLII_DAILY_COST,
-            }, 
-            {
-                'name': 'Streamtele',
-                'currency': SETTINGS.SERVICE_CURRENCIES.get('Streamtele', 'UAH'),
-                'monthly_fee': SETTINGS.STREAMTELE_MONTHLY_FEE,
-                'next_monthly_alert': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0)),
-            },
+        # Seed Data
+        services_to_add = [
+            {'name': 'Zadarma', 'last_balance': 0.0, 'currency': 'USD'},
+            {'name': 'DIDWW', 'last_balance': 0.0, 'currency': 'USD', 'monthly_fee': SETTINGS.DIDWW_MONTHLY_FEE, 'next_monthly_alert': TIMEZONE.localize(datetime(2025, 12, 20, 10, 0))},
+            {'name': 'Make', 'last_balance': 0.0, 'currency': 'Ops'}, # NEW
+            {'name': 'Wazzup24 Подписка', 'last_balance': 0.0, 'currency': 'RUB', 'monthly_fee': SETTINGS.WAZZUP_MONTHLY_FEE, 'next_monthly_alert': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0))},
+            {'name': 'Wazzup24 Баланс номера', 'last_balance': 0.0, 'currency': 'RUB', 'daily_cost': SETTINGS.WAZZUP_DAILY_COST, 'next_alert_date': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0))},
+            {'name': 'Callii', 'next_alert_date': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0)), 'currency': 'USD', 'daily_cost': SETTINGS.CALLII_DAILY_COST}, 
+            {'name': 'Streamtele', 'currency': 'UAH', 'monthly_fee': SETTINGS.STREAMTELE_MONTHLY_FEE, 'next_monthly_alert': TIMEZONE.localize(datetime(2025, 12, 11, 10, 0))},
         ]
 
-        for data in services_to_seed:
-            stmt = select(Service).filter(Service.name == data['name'])
-            result = await session.execute(stmt)
-            exists = result.scalar_one_or_none()
-            
+        for data in services_to_add:
+            stmt = select(Service).where(Service.name == data['name'])
+            exists = (await session.execute(stmt)).scalar_one_or_none()
             if not exists:
                 session.add(Service(name=data['name'], **{k: v for k, v in data.items() if k != 'name'}))
 

handlers/balance.py

@@ -14,13 +14,15 @@
     'USD': '$',
     'EUR': '€',
     'RUB': '₽',
-    'UAH': '₴'
+    'UAH': '₴',
+    'Ops': '⚡',
 }
 
-# Display order configuration
+# Added 'Make' to the list
 DISPLAY_ORDER = [
     'Zadarma',
     'DIDWW',
+    'Make',
     'Streamtele',
     'Callii',
     'Wazzup24 Подписка',
@@ -29,37 +31,29 @@
 
 @router.message(Command("balance"))
 async def handle_balance_command(message: Message, session: AsyncSession):
-    """
-    Handles /balance command. Fetches data from APIs and DB to show a summary.
-    """
+    """Handles /balance command."""
     response_parts = ["💰 **Текущие балансы сервисов:**"]
 
-    # 1. Fetch all services
     stmt = select(Service)
     result = await session.execute(stmt)
     services_unsorted = result.scalars().all()
-    
     services_map = {s.name: s for s in services_unsorted}
 
-    # 2. Iterate based on predefined order
     for name in DISPLAY_ORDER:
         service = services_map.get(name)
-        if not service:
-            continue
+        if not service: continue
 
         sym = CURRENCY_SYMBOLS.get(service.currency, '$')
-        
         display_amount = 0.0
         status_suffix = ""
         is_subscription = False
 
-        # A. API Services (Zadarma, DIDWW)
+        # A. API Services
         if name in API_CLIENTS and SETTINGS.API_SERVICE_STATUSES.get(name, True):
             try:
                 client = API_CLIENTS[name]
                 real_balance = await client.get_balance()
 
-                # Update DB with fresh data
                 if real_balance is not None:
                     service.last_balance = real_balance
                     await session.commit()
@@ -68,33 +62,35 @@ async def handle_balance_command(message: Message, session: AsyncSession):
                 else:
                     display_amount = service.last_balance
                     status_suffix = "(Ошибка API)"
-
             except Exception:
                 display_amount = service.last_balance
                 status_suffix = "(Сбой API)"
 
-        # B. Subscription Services
+        # B. Subscriptions
         elif service.monthly_fee and service.monthly_fee > 0:
             display_amount = service.monthly_fee
             is_subscription = True
-            
-        # C. Manual Balance Services
+        
+        # C. Manual
         else:
             display_amount = service.last_balance
             status_suffix = "(примерно)"
 
-        # Formatting Output
+        # Formatting
+        amount_fmt = f"{int(display_amount)}" if service.currency == 'Ops' else f"{display_amount:.2f}"
+        
         if is_subscription:
-            line = f"• **{name}:** Подписка: {sym}{display_amount:.2f}"
+            line = f"• **{name}:** Подписка: `{sym}{amount_fmt}`"
         else:
-            line = f"• **{name}:** {sym}{display_amount:.2f} {status_suffix}"
+            line = f"• **{name}:** `{sym}{amount_fmt}` {status_suffix}"
 
         response_parts.append(line)
 
-        # Append Next Alert Date if available
+        # Alerts
         alert_date = service.next_alert_date or service.next_monthly_alert
         if alert_date:
             date_str = alert_date.strftime('%Y-%m-%d')
-            response_parts.append(f"  _След. оплата:_ {date_str}")
+            label = "Сброс:" if name == 'Make' else "След. оплата:"
+            response_parts.append(f"  _{label}_ {date_str}")
 
     await message.answer('\n'.join(response_parts))

handlers/callii.py

@@ -17,7 +17,6 @@ class CalliiPayment(StatesGroup):
 
 @router.callback_query(F.data == "callii_paid")
 async def process_callii_paid(callback: CallbackQuery, state: FSMContext):
-    """Callback for 'Paid' button on Callii alert."""
     await callback.message.edit_text(
         "Спасибо за оплату. **Введите сумму пополнения (числом в USD):**"
     )
@@ -26,37 +25,32 @@ async def process_callii_paid(callback: CallbackQuery, state: FSMContext):
 
 @router.message(CalliiPayment.waiting_for_amount, F.text.regexp(r'^\d+(\.\d{1,2})?$'))
 async def process_callii_amount(message: Message, state: FSMContext, session: AsyncSession):
-    """Process the entered amount and recalculate next alert date."""
     try:
-        amount = float(message.text)
+        top_up_amount = float(message.text)
         daily_cost = SETTINGS.CALLII_DAILY_COST
 
-        # Calculate coverage days
-        days = math.floor(amount / daily_cost)
-        
-        if days < 1:
-            await message.answer(
-                "Сумма слишком мала для покрытия дневного расхода. Введите большую сумму."
-            )
-            return
-
-        # Calculate next alert date (10:00 AM)
-        next_alert_datetime = datetime.now(TIMEZONE) + timedelta(days=days)
-        next_alert_datetime = next_alert_datetime.replace(hour=10, minute=0, second=0, microsecond=0)
-
-        # Update DB
         stmt = select(Service).where(Service.name == 'Callii')
         result = await session.execute(stmt)
         service = result.scalar_one()
 
+        current_balance = service.last_balance or 0.0
+        new_total_balance = current_balance + top_up_amount
+        
+        days_covered = math.floor(new_total_balance / daily_cost)
+        
+        next_alert_datetime = datetime.now(TIMEZONE) + timedelta(days=days_covered)
+        next_alert_datetime = next_alert_datetime.replace(hour=10, minute=0, second=0, microsecond=0)
+
+        service.last_balance = new_total_balance
         service.next_alert_date = next_alert_datetime
         await session.commit()
 
         await message.answer(
             f"💰 **Платеж Callii обработан!**\n"
-            f"Сумма: **${amount:.2f}**\n"
-            f"Дней покрытия (расход ${daily_cost}/день): **{days}**.\n"
-            f"Следующий контроль баланса запланирован на **{next_alert_datetime.strftime('%Y-%m-%d в 10:00')}**."
+            f"Было: `${current_balance:.2f}`\n"
+            f"Внесено: `${top_up_amount:.2f}`\n"
+            f"Стало: `${new_total_balance:.2f}`\n"
+            f"Хватит на дней: **{days_covered}** (до {next_alert_datetime.strftime('%Y-%m-%d')})."
         )
         await state.clear()
 
@@ -66,4 +60,4 @@ async def process_callii_amount(message: Message, state: FSMContext, session: As
 
 @router.message(CalliiPayment.waiting_for_amount)
 async def process_callii_amount_invalid(message: Message):
-    await message.answer("Неверный формат. Пожалуйста, введите число (например, 50 или 50.50).")
+    await message.answer("Неверный формат. Пожалуйста, введите число.")