telegram_libs 0.1.19__py3-none-any.whl → 0.1.20__py3-none-any.whl

telegram_libs/error.py

@@ -0,0 +1,9 @@
+from logging import getLogger
+from telegram import Update
+from telegram.ext import ContextTypes
+
+logger = getLogger(__name__)
+
+
+async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    logger.error(f"Update {update} caused error {context.error}")

telegram_libs/handlers.py

@@ -0,0 +1,56 @@
+from functools import partial
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    CallbackQueryHandler,
+    MessageHandler,
+    filters,
+    PreCheckoutQueryHandler,
+)
+from telegram_libs.mongo import MongoManager
+from telegram_libs.subscription import subscription_callback, subscribe_command, check_subscription_command
+from telegram_libs.payment import precheckout_handler, successful_payment
+from telegram_libs.support import (
+    handle_support_command,
+    _handle_user_response,
+    SupportFilter,
+)
+from telegram_libs.utils import more_bots_list_command
+from telegram_libs.error import error_handler
+
+
+def register_subscription_handlers(
+    app: Application, mongo_manager: MongoManager
+) -> None:
+    """Register subscription-related handlers."""
+    app.add_handler(CallbackQueryHandler(subscription_callback, pattern="^sub_"))
+    app.add_handler(CommandHandler("subscribe", partial(subscribe_command, mongo_manager=mongo_manager)))
+    app.add_handler(CommandHandler("status", partial(check_subscription_command, mongo_manager=mongo_manager)))
+
+    # Payment handlers
+    app.add_handler(PreCheckoutQueryHandler(precheckout_handler))
+    app.add_handler(MessageHandler(filters.SUCCESSFUL_PAYMENT, partial(successful_payment, mongo_manager=mongo_manager)))
+
+
+def register_support_handlers(app: Application, bot_name: str) -> None:
+    """Register support handlers for the bot"""
+    app.add_handler(CommandHandler("support", handle_support_command))
+    app.add_handler(
+        MessageHandler(
+            filters.TEXT & ~filters.COMMAND & SupportFilter(),
+            partial(_handle_user_response, bot_name=bot_name),
+        )
+    )
+
+
+def register_common_handlers(
+    app: Application, bot_name: str, mongo_manager: MongoManager
+) -> None:
+    """Register common handlers for the bot"""
+    app.add_handler(CommandHandler("more", more_bots_list_command))
+    
+    register_support_handlers(app, bot_name)
+    register_subscription_handlers(app, mongo_manager)
+    
+    # Error handler
+    app.add_error_handler(error_handler)

telegram_libs/locales/en.json

@@ -1,10 +1,13 @@
 {
   "subscription": {
     "choose_plan": "Choose a subscription plan:",
+    "payment_issue": "Thank you for your payment, but we couldn't determine your subscription plan.",
+    "success": "🎉 Thank you for your subscription! You now have premium access until {date}.",
+    "active": "✅ You have an active premium subscription!\nExpires in {days} days on {date}",
     "plans": {
-      "1month": "1 Month - 1400 Stars",
-      "3months": "3 Months - 3500 Stars",
-      "1year": "1 Year - 12000 Stars"
+      "1month": "1 Month - 400 Stars",
+      "3months": "3 Months - 1100 Stars",
+      "1year": "1 Year - 3600 Stars"
     },
     "info": "Buying a subscription you will get unlimited access to other {0} bots, to see all bots click /more"
   },

telegram_libs/locales/ru.json

@@ -1,10 +1,13 @@
 {
   "subscription": {
     "choose_plan": "Выберите план подписки:",
+    "payment_issue": "Спасибо за ваш платеж, но мы не смогли определить ваш план подписки.",
+    "success": "🎉 Спасибо за вашу подписку! У вас теперь есть премиум доступ до {date}.",
+    "active": "✅ У вас активная премиум подписка!\nИстекает через {days} дней, {date}",
     "plans": {
-      "1month": "1 месяц - 1400 Stars",
-      "3months": "3 месяца - 3500 Stars",
-      "1year": "1 год - 12000 Stars"
+      "1month": "1 месяц - 400 Stars",
+      "3months": "3 месяца - 1100 Stars",
+      "1year": "1 год - 3600 Stars"
     },
     "info": "Купив подписку, вы получите неограниченный доступ к другим {0} ботам, чтобы увидеть всех ботов, нажмите /more"
   },

telegram_libs/mongo.py

@@ -2,16 +2,25 @@ from pymongo.mongo_client import MongoClient
 from pymongo.server_api import ServerApi
 from telegram_libs.constants import MONGO_URI, DEBUG
 
-mongo_client = MongoClient(MONGO_URI, server_api=ServerApi("1"))
+
+# mongo_client = MongoClient(MONGO_URI, server_api=ServerApi("1"))
 
 
 class MongoManager:
+    _mongo_client = None
+
+    @property
+    def mongo_client(self):
+        if self._mongo_client is None:
+            self._mongo_client = MongoClient(MONGO_URI, server_api=ServerApi("1"))
+        return self._mongo_client
+
     def __init__(self, mongo_database_name: str, **kwargs):
-        self.client = kwargs.get("client") or mongo_client
+        self.client = kwargs.get("client") or self.mongo_client
         self.db = self.client[mongo_database_name]
         self.users_collection = self.db["users_test"] if DEBUG else self.db["users"]
         self.payments_collection = self.db["order_test"] if DEBUG else self.db["order"]
-        self.user_schema = {"user_id": None, **kwargs.get("user_schema")}
+        self.user_schema = {"user_id": None, **(kwargs.get("user_schema") or {})}
 
     def create_user(self, user_id: int) -> None:
         """Create a new user in the database."""

telegram_libs/payment.py

@@ -0,0 +1,94 @@
+from datetime import datetime, timedelta
+from logging import getLogger
+from telegram import Update
+from telegram.ext import ContextTypes
+from telegram_libs.translation import t
+from telegram_libs.subscription import add_subscription_payment
+from telegram_libs.utils import get_user_info
+from telegram_libs.mongo import MongoManager
+
+logger = getLogger(__name__)
+
+
+async def precheckout_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle the pre-checkout query"""
+    query = update.pre_checkout_query
+    user_id = query.from_user.id
+
+    # Always accept the pre-checkout query in this basic implementation
+    # You could add additional validation here if needed (e.g., check user status, inventory, etc.)
+
+    try:
+        await query.answer(ok=True)
+        logger.info(f"Pre-checkout approved for user {user_id}")
+    except Exception as e:
+        logger.error(f"Error answering pre-checkout query: {e}")
+        # Try to answer with error if something went wrong
+        try:
+            await query.answer(
+                ok=False,
+                error_message="An error occurred while processing your payment",
+            )
+        except Exception as e2:
+            logger.error(f"Error sending pre-checkout error: {e2}")
+
+
+async def successful_payment(update: Update, context: ContextTypes.DEFAULT_TYPE, mongo_manager: MongoManager) -> None:
+    """Handle successful payments"""
+    user_info = get_user_info(update, mongo_manager)
+    user_id = user_info["user_id"]
+    lang = user_info["lang"]
+    payment_info = update.message.successful_payment
+    logger.info(f"Payment info received: {payment_info}")
+
+    # Determine which plan was purchased
+    plans = {"1month_sub": 30, "3months_sub": 90, "1year_sub": 365}
+
+    duration_days = plans.get(payment_info.invoice_payload, 0)
+    if duration_days == 0:
+        logger.warning(f"Invalid subscription plan: {payment_info.invoice_payload}")
+        await update.message.reply_text(
+            t("subscription.payment_issue", lang, common=True)
+        )
+        return
+
+    # Add order to bot-specific database
+    mongo_manager.add_order(
+        user_id,
+        {
+            "order_id": payment_info.provider_payment_charge_id,
+            "amount": payment_info.total_amount,
+            "currency": payment_info.currency,
+            "status": "completed",
+            "date": datetime.now().isoformat(),
+        },
+    )
+
+    # Calculate expiration date
+    expiration_date = datetime.now() + timedelta(days=duration_days)
+    current_time = datetime.now()
+
+    # Add subscription payment to shared subscription database
+    add_subscription_payment(
+        user_id,
+        {
+            "order_id": payment_info.provider_payment_charge_id,
+            "amount": payment_info.total_amount,
+            "currency": payment_info.currency,
+            "status": "completed",
+            "date": current_time.isoformat(),
+            "expiration_date": expiration_date.isoformat(),
+            "plan": payment_info.invoice_payload,
+            "duration_days": duration_days
+        }
+    )
+
+    logger.info(
+        f"User {user_id} subscribed successfully. Premium expires on {expiration_date.isoformat()}."
+    )
+
+    await update.message.reply_text(
+        t("subscription.success", lang, common=True).format(
+            date=expiration_date.strftime("%Y-%m-%d")
+        )
+    )

telegram_libs/subscription.py

@@ -1,10 +1,19 @@
 from datetime import datetime
-from telegram_libs.constants import SUBSCRIPTION_DB_NAME
-from telegram_libs.mongo import mongo_client
+from telegram import Update, LabeledPrice, InlineKeyboardMarkup, InlineKeyboardButton
+from telegram.ext import ContextTypes
+from telegram_libs.constants import SUBSCRIPTION_DB_NAME, DEBUG, BOTS_AMOUNT
+from telegram_libs.mongo import MongoManager
+from telegram_libs.utils import get_user_info
+from telegram_libs.translation import t
+
 
 # Define the subscription database and collection
-subscription_db = mongo_client[SUBSCRIPTION_DB_NAME]
-subscription_collection = subscription_db["subscriptions"]
+mongo_manager_instance = MongoManager(mongo_database_name=SUBSCRIPTION_DB_NAME)
+subscription_collection = (
+    mongo_manager_instance.client[SUBSCRIPTION_DB_NAME]["subscriptions"]
+    if not DEBUG
+    else mongo_manager_instance.client[SUBSCRIPTION_DB_NAME]["subscriptions_test"]
+)
 
 
 def get_subscription(user_id: int) -> dict:
@@ -18,9 +27,7 @@ def get_subscription(user_id: int) -> dict:
 def update_subscription(user_id: int, updates: dict) -> None:
     """Update user's subscription data in the shared subscription database."""
     subscription_collection.update_one(
-        {"user_id": user_id},
-        {"$set": updates},
-        upsert=True
+        {"user_id": user_id}, {"$set": updates}, upsert=True
     )
 
 
@@ -33,19 +40,143 @@ def add_subscription_payment(user_id: int, payment_data: dict) -> None:
             "$set": {
                 "is_premium": True,
                 "premium_expiration": payment_data["expiration_date"],
-                "last_payment": payment_data["date"]
-            }
+                "last_payment": payment_data["date"],
+            },
         },
-        upsert=True
+        upsert=True,
     )
 
 
 def check_subscription_status(user_id: int) -> bool:
     """Check if user has an active subscription."""
     subscription = get_subscription(user_id)
-    
+
     if not subscription.get("is_premium"):
         return False
-        
+
     expiration = datetime.fromisoformat(subscription["premium_expiration"])
-    return expiration > datetime.now()
+    return expiration > datetime.now()
+
+
+async def get_subscription_keyboard(update: Update, lang: str) -> InlineKeyboardMarkup:
+    """Get subscription keyboard
+
+    Args:
+        update (Update): Update object
+        lang (str): Language code
+
+    Returns:
+        InlineKeyboardMarkup: Inline keyboard markup
+    """
+    await update.message.reply_text(
+        t("subscription.info", lang, common=True).format(int(BOTS_AMOUNT) - 1)
+    )
+    return InlineKeyboardMarkup([
+        [
+            InlineKeyboardButton(
+                t("subscription.plans.1month", lang, common=True), callback_data="sub_1month"
+            ),
+            InlineKeyboardButton(
+                t("subscription.plans.3months", lang, common=True), callback_data="sub_3months"
+            ),
+        ],
+        [
+            InlineKeyboardButton(
+                t("subscription.plans.1year", lang, common=True), callback_data="sub_1year"
+            ),
+        ],
+    ])
+
+
+async def subscription_callback(
+    update: Update, context: ContextTypes.DEFAULT_TYPE
+) -> None:
+    """Handle subscription button clicks"""
+    query = update.callback_query
+    await query.answer()
+    plan = query.data
+
+    # Define subscription plans
+    plans = {
+        "sub_1month": {
+            "title": "1 Month Subscription",
+            "description": "Premium access for 1 month",
+            "payload": "1month_sub",
+            "price": 400 if not DEBUG else 1,
+            "duration": 30,
+        },
+        "sub_3months": {
+            "title": "3 Months Subscription",
+            "description": "Premium access for 3 months",
+            "payload": "3months_sub",
+            "price": 1100 if not DEBUG else 1,
+            "duration": 90,
+        },
+        "sub_1year": {
+            "title": "1 Year Subscription",
+            "description": "Premium access for 1 year",
+            "payload": "1year_sub",
+            "price": 3600 if not DEBUG else 1,
+            "duration": 365,
+        },
+    }
+
+    selected_plan = plans.get(plan)
+    if not selected_plan:
+        await query.message.reply_text("Invalid subscription option")
+        return
+
+    # Create invoice for Telegram Stars
+    prices = [LabeledPrice(selected_plan["title"], selected_plan["price"])]
+
+    await context.bot.send_invoice(
+        chat_id=query.message.chat_id,
+        title=selected_plan["title"],
+        description=selected_plan["description"],
+        payload=selected_plan["payload"],
+        provider_token="",
+        currency="XTR",
+        prices=prices,
+        start_parameter="subscription",
+    )
+
+
+async def subscribe_command(
+    update: Update, context: ContextTypes.DEFAULT_TYPE, mongo_manager: MongoManager
+) -> None:
+    """Show subscription options"""
+    user_info = get_user_info(update, mongo_manager)
+    lang = user_info["lang"]
+
+    reply_markup = await get_subscription_keyboard(update, lang)
+
+    await update.message.reply_text(
+        t("subscription.choose_plan", lang, common=True), reply_markup=reply_markup
+    )
+
+
+async def check_subscription_command(
+    update: Update, context: ContextTypes.DEFAULT_TYPE, mongo_manager: MongoManager
+):
+    """Check user's subscription status"""
+    user_info = get_user_info(update, mongo_manager)
+    user_id = user_info["user_id"]
+    lang = user_info["lang"]
+
+    subscription = get_subscription(user_id)
+    if subscription.get("is_premium"):
+        expiration = datetime.fromisoformat(subscription["premium_expiration"])
+        remaining = (expiration - datetime.now()).days
+
+        if remaining > 0:
+            await update.message.reply_text(
+                t("subscription.active", lang, common=True).format(
+                    days=remaining,
+                    date=expiration.strftime("%Y-%m-%d"),
+                )
+            )
+        else:
+            update_subscription(user_id, {"is_premium": False})
+            await update.message.reply_text(t("subscription.expired", lang))
+    else:
+        await update.message.reply_text(t("subscription.none", lang))

telegram_libs/{support_handlers.py → support.py}

@@ -3,13 +3,15 @@ from datetime import datetime
 from telegram import Update
 from telegram.ext import ContextTypes, Application, CommandHandler, MessageHandler, filters
 from telegram.ext.filters import BaseFilter
-from telegram_libs.mongo import mongo_client
-from telegram_libs.constants import DEBUG
+from telegram_libs.mongo import MongoManager
+from telegram_libs.constants import DEBUG, SUBSCRIPTION_DB_NAME
 from telegram_libs.translation import t
 
 
 SUPPORT_WAITING = "support_waiting"
 
+mongo_manager_instance = MongoManager(mongo_database_name=SUBSCRIPTION_DB_NAME) # Use an existing or create a new MongoManager instance
+
 
 async def handle_support_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Support command handler"""
@@ -32,7 +34,7 @@ async def _handle_user_response(update: Update, context: ContextTypes.DEFAULT_TY
         # Should not happen if filter is correct
         return
 
-    db = mongo_client[db_name]
+    db = mongo_manager_instance.client[db_name]
     collection = db[collection_name]
     doc = {
         "user_id": update.effective_user.id,
@@ -52,7 +54,8 @@ class SupportFilter(BaseFilter):
         return context.user_data.get(SUPPORT_WAITING, False)
 
 
-def register_support_handlers(app: Application, bot_name: str) -> None:
-    """Register support handlers for the bot"""
-    app.add_handler(CommandHandler("support", handle_support_command))
-    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND & SupportFilter(), partial(_handle_user_response, bot_name=bot_name))) 
+def register_support_handlers(application: Application, bot_name: str):
+    application.add_handler(CommandHandler("support", handle_support_command))
+    application.add_handler(
+        MessageHandler(SupportFilter() & filters.TEXT, partial(_handle_user_response, bot_name=bot_name))
+    )

telegram_libs/utils.py

@@ -4,10 +4,11 @@ from telegram import (
     InlineKeyboardMarkup,
 )
 from telegram import Update
-from telegram.ext import ContextTypes, Application, CommandHandler
+from telegram.ext import ContextTypes, Application, CommandHandler, CallbackQueryHandler
 from telegram_libs.constants import BOTS_AMOUNT
 from telegram_libs.translation import t
-from telegram_libs.support_handlers import register_support_handlers
+from telegram_libs.support import register_support_handlers
+from telegram_libs.mongo import MongoManager
 
 
 basicConfig(
@@ -58,8 +59,22 @@ async def more_bots_list_command(update: Update, context: ContextTypes.DEFAULT_T
     """
     await update.message.reply_text(message, disable_web_page_preview=True, parse_mode='HTML')
     
+    
+def get_user_info(update: Update, mongo_manager: MongoManager) -> dict:
+    """Get user information from the update object."""
+    user = update.effective_user
+    user_data = mongo_manager.get_user_data(user.id)
+    
+    return {
+        "user_id": user.id,
+        "username": user.username,
+        "first_name": user.first_name,
+        "last_name": user.last_name,
+        "lang": user_data.get("language", "en"),
+        **user_data,
+    }
 
-def register_common_handlers(app: Application, bot_name: str) -> None:
-    """Register common handlers for the bot"""
-    app.add_handler(CommandHandler("more", more_bots_list_command))
-    register_support_handlers(app, bot_name)
+def register_common_handlers(application: Application, bot_name: str) -> None:
+    """Register common handlers to the application."""
+    application.add_handler(CommandHandler("more", more_bots_list_command))
+    register_support_handlers(application, bot_name)

{telegram_libs-0.1.19.dist-info → telegram_libs-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: telegram_libs
-Version: 0.1.19
+Version: 0.1.20
 Summary: Common libraries for Telegram bots
 Author: Andrey Gritsaenko gricaenko.95a@gmail.com
 Requires-Python: >=3.11,<4.0

telegram_libs-0.1.20.dist-info/RECORD

@@ -0,0 +1,16 @@
+telegram_libs/__init__.py,sha256=xrsD5r6ZiJxPapHf1UhQ61z2gHtCCWrzW0CZHvlvXRc,82
+telegram_libs/constants.py,sha256=7-L1uK9UKCVAZNKYnqmM4B18JDxfxHMpZgTIjh0rATg,606
+telegram_libs/error.py,sha256=YtI2qCweDmANzPp3jae6yNzMQMtC9Z5TIeZ2-utGi_4,270
+telegram_libs/handlers.py,sha256=5c8jRL4eEC4UyCugi5SaoUM7zEbgPHZum9i6Jh8WswM,2059
+telegram_libs/locales/en.json,sha256=4VVkME7lCKW6ZjkopaoA6Uq3DLbEVkWacGei3GNSXFM,843
+telegram_libs/locales/ru.json,sha256=LYI6rAlwdNLaTGgkrALn31Lt7jC3SZteei8P_i7ZpQI,1208
+telegram_libs/mongo.py,sha256=urUvtIamU_WAqf1S6fDiX4ZOzOaTuRph-ovACKIAjlM,2519
+telegram_libs/payment.py,sha256=CCB7xtODlR_0o3layVjtE9hhHxJTZ3mhptDPDqfqYSg,3381
+telegram_libs/subscription.py,sha256=0ubzbDeyENMAdB2shH9qgH_eNzxr_zRsYgkhjolZqHo,6047
+telegram_libs/support.py,sha256=UCgJPLJdQUfsbKTIIsNfOpP9CCdw5GjlcSl6aBwNw1U,2378
+telegram_libs/translation.py,sha256=8Kb2cgqKKZH4X_i2Le0V_K1imZdoaCzYAca831DOBig,2049
+telegram_libs/utils.py,sha256=OuFcSZ8LEqfDlW5F5t-R7qpjfBwmrRGfsbgIWdh23OI,2772
+telegram_libs-0.1.20.dist-info/LICENSE,sha256=ZXkWPZbCc61L29Gz6ZHPwn1c4Pm0TnfIqtx8jGWi9F4,1069
+telegram_libs-0.1.20.dist-info/METADATA,sha256=4A6P8BJTeYj_O-lFDkJb_J2vGsjPB1MXRt14cPl2QQM,804
+telegram_libs-0.1.20.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+telegram_libs-0.1.20.dist-info/RECORD,,

telegram_libs-0.1.19.dist-info/RECORD

@@ -1,13 +0,0 @@
-telegram_libs/__init__.py,sha256=xrsD5r6ZiJxPapHf1UhQ61z2gHtCCWrzW0CZHvlvXRc,82
-telegram_libs/constants.py,sha256=7-L1uK9UKCVAZNKYnqmM4B18JDxfxHMpZgTIjh0rATg,606
-telegram_libs/locales/en.json,sha256=TDueYazTaytYCs8_6Z7-HeulGyqz5ze3Cm4mXYKFX8Q,549
-telegram_libs/locales/ru.json,sha256=bHIuq9MFIhqIEvbf5j5HM1E9egtsjrTTIx50s6C9PpY,785
-telegram_libs/mongo.py,sha256=TzCOB4rXiYQ6Y0ptDXqrJmoGcnZuxYPRPdC7GkDZiDs,2278
-telegram_libs/subscription.py,sha256=d7xmzplUrm1nNlWlkqW6dddOYa3t_7PAM3iPme0K5F0,1690
-telegram_libs/support_handlers.py,sha256=SrJGmP9WJp6vpsCE6k0lgs5ftlZR_mRBf-NQThIXkmU,2240
-telegram_libs/translation.py,sha256=8Kb2cgqKKZH4X_i2Le0V_K1imZdoaCzYAca831DOBig,2049
-telegram_libs/utils.py,sha256=0eBy7psB0XJQL9dPUeq5c2Ymg7ZPA54sdYJW3x2fI4M,2231
-telegram_libs-0.1.19.dist-info/LICENSE,sha256=ZXkWPZbCc61L29Gz6ZHPwn1c4Pm0TnfIqtx8jGWi9F4,1069
-telegram_libs-0.1.19.dist-info/METADATA,sha256=FM92PKEb7fmGx8KgyoHhm6J0KqAwj9z5Jjgx01BVd_M,804
-telegram_libs-0.1.19.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-telegram_libs-0.1.19.dist-info/RECORD,,