| from datetime import datetime, timedelta |
|
|
| from pyrogram import Client, filters |
| from pyrogram.types import ( |
| CallbackQuery, |
| ForceReply, |
| InlineKeyboardButton, |
| InlineKeyboardMarkup, |
| Message, |
| ) |
|
|
| from Backend import db |
| from Backend.config import Telegram |
| from Backend.helper.settings_manager import SettingsManager |
| from Backend.logger import LOGGER |
|
|
|
|
| |
| def _approver_ids() -> list: |
| return SettingsManager.current().approver_ids or [Telegram.OWNER_ID] |
|
|
|
|
| |
| async def _resolve_target_info(client: Client, target_user_id: int): |
| try: |
| target_user = await client.get_users(target_user_id) |
| return target_user.mention, (f"@{target_user.username}" if target_user.username else "N/A") |
| except Exception: |
| return f"User {target_user_id}", "N/A" |
|
|
|
|
| |
| def _plan_info_text(mention: str, username_str: str, user_id: int, duration, price) -> str: |
| return ( |
| f"👤 <b>User:</b> {mention}\n" |
| f"🆔 <b>User ID:</b> <code>{user_id}</code>\n" |
| f"🔗 <b>Username:</b> {username_str}\n\n" |
| f"📦 <b>Plan:</b> {duration} days (₹{price})" |
| ) |
|
|
|
|
| |
| async def _apply_admin_captions(client: Client, callback_query: CallbackQuery, admin_messages: list, status_caption: str): |
| await callback_query.message.edit_caption(status_caption) |
| acting_msg_id = callback_query.message.id |
| for am in admin_messages: |
| if am["message_id"] == acting_msg_id: |
| continue |
| try: |
| await client.edit_message_caption(chat_id=am["chat_id"], message_id=am["message_id"], caption=status_caption) |
| except Exception: |
| pass |
|
|
|
|
| |
| @Client.on_callback_query(filters.regex(r"^plan_([a-fA-F0-9]{24})$")) |
| async def plan_selection(client: Client, callback_query: CallbackQuery): |
| if not SettingsManager.current().subscription: |
| return await callback_query.answer("Subscriptions are not enabled.", show_alert=True) |
|
|
| plan_id = callback_query.matches[0].group(1) |
| plans = await db.get_subscription_plans() |
| plan = next((p for p in plans if p["_id"] == plan_id), None) |
| if not plan: |
| return await callback_query.answer("Invalid plan.", show_alert=True) |
|
|
| duration = plan["days"] |
| await callback_query.answer() |
|
|
| user_id = callback_query.from_user.id if callback_query.from_user else callback_query.message.chat.id |
| first_name = callback_query.from_user.first_name if callback_query.from_user else callback_query.message.chat.title |
| username = callback_query.from_user.username if callback_query.from_user else callback_query.message.chat.username |
|
|
| await db.update_user_interaction(user_id, first_name, username) |
|
|
| user = await db.get_user(user_id) |
| now = datetime.utcnow() |
| current_expiry = user.get("subscription_expiry") if user else None |
| if current_expiry and current_expiry > now: |
| new_expiry = current_expiry + timedelta(days=int(duration)) |
| else: |
| new_expiry = now + timedelta(days=int(duration)) |
| expiry_str = new_expiry.strftime("%Y-%m-%d %H:%M UTC") |
|
|
| settings = SettingsManager.current() |
| payment_instructions = settings.payment_instructions |
| payment_qr_url = settings.payment_qr_url |
|
|
| text = ( |
| f"<b>✅ Plan Selected: {plan['days']} Days</b>\n\n" |
| f"<b>💰 Price:</b> ₹{plan['price']}\n" |
| f"<b>📅 Expiry (if approved now):</b> {expiry_str}\n\n" |
| f"<b>📋 How to Pay:</b>\n" |
| ) |
| text += f"{payment_instructions}\n\n" if payment_instructions else f"Pay ₹{plan['price']} to the admin.\n\n" |
| text += ( |
| "<b>After paying:</b> send your payment screenshot directly here " |
| "(in this chat). The admin will review and activate your subscription." |
| ) |
|
|
| await db.set_pending_payment(user_id, int(duration), 0, price=plan.get("price", 0)) |
|
|
| |
| dm_sent = False |
| try: |
| if payment_qr_url: |
| try: |
| await client.send_photo(chat_id=user_id, photo=payment_qr_url, caption=f"📷 Scan to pay ₹{plan['price']}") |
| except Exception as qe: |
| LOGGER.warning(f"Could not send payment QR to {user_id}: {qe}") |
| await client.send_message(chat_id=user_id, text=text, reply_markup=ForceReply(selective=True)) |
| dm_sent = True |
| except Exception as e: |
| LOGGER.warning(f"Could not DM user {user_id}: {e}") |
|
|
| if dm_sent: |
| await callback_query.answer("✅ Check your DM for payment instructions!", show_alert=True) |
| else: |
| await callback_query.message.reply_text( |
| text + "\n\n⚠️ <i>Please start a DM with the bot first by clicking its username, then send your screenshot there.</i>", |
| reply_markup=ForceReply(selective=True), |
| quote=True, |
| ) |
| await callback_query.answer() |
|
|
|
|
| |
| @Client.on_message(filters.photo & filters.private) |
| async def handle_payment_screenshot(client: Client, message: Message): |
| if not SettingsManager.current().subscription: |
| return |
|
|
| sender_id = (message.from_user.id if message.from_user else None) \ |
| or (message.sender_chat.id if message.sender_chat else None) \ |
| or message.chat.id |
|
|
| try: |
| LOGGER.debug(f"handle_payment_screenshot triggered by {sender_id}") |
| user = await db.get_user(sender_id) |
| LOGGER.debug(f"user from DB = {user}") |
| if not user or "pending_payment" not in user: |
| LOGGER.debug(f"No pending_payment found for {sender_id}") |
| await message.reply_text( |
| "ℹ️ We received your photo, but you don't have an active payment request.\n\n" |
| "Please use /start to select a subscription plan first, then send your payment screenshot.", |
| quote=True |
| ) |
| return |
|
|
| pending = user["pending_payment"] |
| duration = pending.get("duration", "?") |
| price = pending.get("price", "?") |
|
|
| keyboard = InlineKeyboardMarkup([[ |
| InlineKeyboardButton("✅ Approve", callback_data=f"approve_{sender_id}"), |
| InlineKeyboardButton("❌ Reject", callback_data=f"reject_{sender_id}") |
| ]]) |
|
|
| user_mention = message.from_user.mention if message.from_user else f"User {sender_id}" |
| username_str = f"@{message.from_user.username}" if (message.from_user and message.from_user.username) else "N/A" |
|
|
| admin_text = ( |
| f"<b>💰 New Payment Screenshot Received</b>\n\n" |
| f"<b>👤 User:</b> {user_mention}\n" |
| f"<b>🆔 User ID:</b> <code>{sender_id}</code>\n" |
| f"<b>🔗 Username:</b> {username_str}\n\n" |
| f"<b>📦 Plan Details:</b>\n" |
| f" • Duration: <b>{duration} days</b>\n" |
| f" • Price: <b>₹{price}</b>\n\n" |
| f"Please review the screenshot above and approve or reject." |
| ) |
|
|
| admin_messages = [] |
| for approver_id in _approver_ids(): |
| try: |
| sent = await message.copy(approver_id, caption=admin_text, reply_markup=keyboard) |
| admin_messages.append({"chat_id": approver_id, "message_id": sent.id}) |
| except Exception as e: |
| LOGGER.error(f"Failed to forward screenshot to approver {approver_id}: {e}") |
|
|
| await db.set_pending_payment(sender_id, duration, message.id, price=price, admin_messages=admin_messages) |
|
|
| if admin_messages: |
| await message.reply_text( |
| "✅ <b>Screenshot Received!</b>\n\n" |
| "Your payment screenshot has been forwarded to the admin for review.\n" |
| "You will be notified once it's approved. Thank you! 🙏", |
| quote=True |
| ) |
| else: |
| await message.reply_text( |
| "⚠️ Your screenshot was received but we could not reach the admin. " |
| "Please contact the admin directly.", |
| quote=True |
| ) |
|
|
| except Exception as e: |
| LOGGER.error(f"Error in handle_payment_screenshot: {e}") |
| await message.reply_text( |
| f"⚠️ Something went wrong while processing your screenshot. Please try again or contact the admin.\n\nError: {e}", |
| quote=True |
| ) |
|
|
|
|
| |
| @Client.on_callback_query(filters.regex(r"^(approve|reject)_(\d+)$")) |
| async def admin_review(client: Client, callback_query: CallbackQuery): |
| if callback_query.from_user.id not in _approver_ids(): |
| return await callback_query.answer("You are not authorized to perform this action.", show_alert=True) |
|
|
| action = callback_query.matches[0].group(1) |
| target_user_id = int(callback_query.matches[0].group(2)) |
| acting_admin = callback_query.from_user |
| admin_name = acting_admin.first_name or acting_admin.username or f"Admin {acting_admin.id}" |
|
|
| |
| user_pre = await db.get_user(target_user_id) |
| if not user_pre or "pending_payment" not in user_pre: |
| return await callback_query.answer("This request has already been processed.", show_alert=True) |
|
|
| admin_messages = user_pre["pending_payment"].get("admin_messages", []) |
| duration = user_pre["pending_payment"].get("duration", "?") |
| price = user_pre["pending_payment"].get("price", "?") |
|
|
| if action == "approve": |
| user_data = await db.approve_payment(target_user_id) |
| if not user_data: |
| return await callback_query.answer("Could not approve — no pending payment found.", show_alert=True) |
|
|
| try: |
| user_obj = await db.get_user(target_user_id) |
| user_name = (user_obj.get("first_name") or user_obj.get("username") or str(target_user_id)) if user_obj else str(target_user_id) |
| token_doc = await db.add_api_token(name=user_name, user_id=target_user_id) |
| addon_url = f"{SettingsManager.current().base_url}/stremio/{token_doc.get('token')}/manifest.json" |
| except Exception: |
| addon_url = None |
|
|
| try: |
| invite_link = await client.create_chat_invite_link( |
| chat_id=SettingsManager.current().subscription_group_id, |
| member_limit=1, |
| expire_date=datetime.utcnow() + timedelta(days=1) |
| ) |
| invite_text = f"\n\n🔗 <b>Group Invite:</b> {invite_link.invite_link}" |
| except Exception: |
| invite_text = "" |
|
|
| expiry_str = user_data["subscription_expiry"].strftime("%Y-%m-%d") |
| success_text = ( |
| f"🎉 <b>Payment Approved!</b>\n\n" |
| f"Your subscription is now active until <b>{expiry_str}</b>." |
| f"{invite_text}" |
| ) |
| if addon_url: |
| success_text += ( |
| f"\n\n🎬 <b>Stremio Addon — Install Link:</b>\n" |
| f"<code>{addon_url}</code>\n\n" |
| f"Tap the link above → <b>Install</b> in Stremio to start watching!" |
| ) |
| await client.send_message(target_user_id, success_text) |
|
|
| mention, username_str = await _resolve_target_info(client, target_user_id) |
| info_text = _plan_info_text(mention, username_str, target_user_id, duration, price) |
| await _apply_admin_captions(client, callback_query, admin_messages, f"✅ <b>Approved by {admin_name}</b>\n\n{info_text}") |
|
|
| elif action == "reject": |
| if not await db.reject_payment(target_user_id): |
| return await callback_query.answer("Could not reject — no pending payment found.", show_alert=True) |
|
|
| await client.send_message( |
| target_user_id, |
| "❌ <b>Payment Rejected</b>\n\nYour recent payment submission was rejected by the admin. Please contact the admin or try submitting again." |
| ) |
| mention, username_str = await _resolve_target_info(client, target_user_id) |
| info_text = _plan_info_text(mention, username_str, target_user_id, duration, price) |
| await _apply_admin_captions(client, callback_query, admin_messages, f"❌ <b>Rejected by {admin_name}</b>\n\n{info_text}") |
|
|
|
|
| |
| @Client.on_message(filters.command("status")) |
| async def check_status(client: Client, message: Message): |
| if not SettingsManager.current().subscription: |
| return |
|
|
| user_id = (message.from_user.id if message.from_user else None) or (message.sender_chat.id if message.sender_chat else None) or message.chat.id |
|
|
| user = await db.get_user(user_id) |
| if not user or user.get("subscription_status") != "active": |
| return await message.reply_text("You do not have an active subscription.") |
|
|
| expiry = user.get("subscription_expiry") |
| if not expiry: |
| return await message.reply_text("Error retrieving expiry date.") |
|
|
| now = datetime.utcnow() |
| if now > expiry: |
| return await message.reply_text("Your subscription has expired.") |
|
|
| remaining = expiry - now |
| days = remaining.days |
| hours = remaining.seconds // 3600 |
| await message.reply_text( |
| f"<b>Subscription Status:</b> Active ✅\n" |
| f"<b>Expiry Date:</b> {expiry.strftime('%Y-%m-%d %H:%M UTC')}\n" |
| f"<b>Time Remaining:</b> {days} days and {hours} hours" |
| ) |
|
|
