आज मैं आपको दिखाऊंगा कि टेलीग्राम की आंतरिक मुद्रा, टेलीग्राम स्टार्स ⭐️ का उपयोग करके अपने बॉट में भुगतान कैसे सेट करें।

चरण 1: एक बॉट बनाएं

सबसे पहले, BotFather का उपयोग करके एक बॉट बनाएं। यदि आप इस प्रक्रिया से परिचित हैं, तो आप अपने स्वयं के परीक्षण बॉट का उपयोग कर सकते हैं। इस उदाहरण में, मैं बॉट @repeats_bot का उपयोग करूंगा।

चरण 2: परियोजना संरचना तैयार करें

यहां आपकी परियोजना संरचना का एक उदाहरण दिया गया है:

TelegramStarsBot (root)
|-img/
  |-img-X9ptcIuiOMICY0BUQukCpVYS.png
|-bot.py
|-config.py
|-database.py
|-.env

चरण 3: बॉट कोड

bot.py

import telebot
from telebot import types
from config import TOKEN
from database import init_db, save_payment
import os

bot = telebot.TeleBot(TOKEN)

# Initialize the database
init_db()

# Function to create a payment keyboard
def payment_keyboard():
    keyboard = types.InlineKeyboardMarkup()
    button = types.InlineKeyboardButton(text="Pay 1 XTR", pay=True)
    keyboard.add(button)
    return keyboard

# Function to create a keyboard with the "Buy Image" button
def start_keyboard():
    keyboard = types.InlineKeyboardMarkup()
    button = types.InlineKeyboardButton(text="Buy Image", callback_data="buy_image")
    keyboard.add(button)
    return keyboard

# /start command handler
@bot.message_handler(commands=['start'])
def handle_start(message):
    bot.send_message(
        message.chat.id,
        "Welcome! Click the button below to buy an image.",
        reply_markup=start_keyboard()
    )

# Handler for the "Buy Image" button press
@bot.callback_query_handler(func=lambda call: call.data == "buy_image")
def handle_buy_image(call):
    prices = [types.LabeledPrice(label="XTR", amount=1)]  # 1 XTR
    bot.send_invoice(
        call.message.chat.id,
        title="Image Purchase",
        description="Purchase an image for 1 star!",
        invoice_payload="image_purchase_payload",
        provider_token="",  # For XTR, this token can be empty
        currency="XTR",
        prices=prices,
        reply_markup=payment_keyboard()
    )

# Handler for pre-checkout queries
@bot.pre_checkout_query_handler(func=lambda query: True)
def handle_pre_checkout_query(pre_checkout_query):
    bot.answer_pre_checkout_query(pre_checkout_query.id, ok=True)

# Handler for successful payments
@bot.message_handler(content_types=['successful_payment'])
def handle_successful_payment(message):
    user_id = message.from_user.id
    payment_id = message.successful_payment.provider_payment_charge_id
    amount = message.successful_payment.total_amount
    currency = message.successful_payment.currency

    # Send a purchase confirmation message
    bot.send_message(message.chat.id, "✅ Payment accepted, please wait for the photo. It will arrive soon!")

    # Save payment information to the database
    save_payment(user_id, payment_id, amount, currency)

    # Send the image
    photo_path = 'img/img-X9ptcIuiOMICY0BUQukCpVYS.png'
    if os.path.exists(photo_path):
        with open(photo_path, 'rb') as photo:
            bot.send_photo(message.chat.id, photo, caption="?Thank you for your purchase!?")
    else:
        bot.send_message(message.chat.id, "Sorry, the image was not found.")

# /paysupport command handler
@bot.message_handler(commands=['paysupport'])
def handle_pay_support(message):
    bot.send_message(
        message.chat.id,
        "Purchasing an image does not imply a refund. "
        "If you have any questions, please contact us."
    )

# Start polling
bot.polling()

config.py

import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Get values from environment variables
TOKEN = os.getenv('TOKEN')
DATABASE = os.getenv('DATABASE')

डेटाबेस.py

import sqlite3
from config import DATABASE

def init_db():
    with sqlite3.connect(DATABASE) as conn:
        cursor = conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS payments (
                user_id INTEGER,
                payment_id TEXT,
                amount INTEGER,
                currency TEXT,
                PRIMARY KEY (user_id, payment_id)
            )
        ''')
        conn.commit()

def save_payment(user_id, payment_id, amount, currency):
    with sqlite3.connect(DATABASE) as conn:
        cursor = conn.cursor()
        cursor.execute('''
            INSERT INTO payments (user_id, payment_id, amount, currency)
            VALUES (?, ?, ?, ?)
        ''', (user_id, payment_id, amount, currency))
        conn.commit()

कोड स्पष्टीकरण

टेलीग्राम स्टार्स के साथ भुगतान

• पेमेंट_कीबोर्ड और स्टार्ट_कीबोर्ड उपयोगकर्ता इंटरैक्शन के लिए बटन बनाते हैं। पहला बटन भुगतान की अनुमति देता है, और दूसरा छवि खरीद आरंभ करता है।
• Handle_buy_image XTR मुद्रा का उपयोग करके भुगतान के लिए एक चालान बनाता है और भेजता है। यहां, प्रदाता_टोकन खाली हो सकता है क्योंकि एक्सटीआर को टोकन की आवश्यकता नहीं है।
• हैंडल_प्री_चेकआउट_क्वेरी और हैंडल_सक्सेसफुल_पेमेंट भुगतान सत्यापन और पुष्टिकरण प्रक्रिया को संभालते हैं।
• सफल भुगतान पर, बॉट उपयोगकर्ता को छवि भेजता है और भुगतान जानकारी को डेटाबेस में सहेजता है।

डेटाबेस के साथ कार्य करना

• यदि यह मौजूद नहीं है तो init_db भुगतान तालिका बनाता है। यह तालिका उपयोगकर्ता, भुगतान, राशि और मुद्रा के बारे में जानकारी संग्रहीत करती है।
• save_ payment भुगतान जानकारी को डेटाबेस में सहेजता है। संभावित रिफंड और लेनदेन रिपोर्ट के लिए यह आवश्यक है।

महत्वपूर्ण नोट्स

• बॉट मालिक भुगतान: यदि बॉट मालिक बॉट के भीतर खरीदारी करने का प्रयास करता है, तो खरीदारी पूरी नहीं होगी। यह व्यवस्थापक द्वारा की गई धोखाधड़ी या गलत खरीदारी को रोकता है।
• सितारों का प्रबंधन: तारे टेलीग्राम बॉट के भीतर संग्रहीत होते हैं। बैलेंस देखने के लिए, टेलीग्राम में बॉट सेटिंग्स पर जाएं, "बॉट प्रबंधित करें" चुनें और "बैलेंस" पर क्लिक करें। यहां, आप अर्जित सितारों को देख और प्रबंधित कर सकते हैं, उन्हें निकाल सकते हैं, या विज्ञापन पर खर्च कर सकते हैं।

निष्कर्ष

आपका बॉट अब टेलीग्राम स्टार्स के माध्यम से भुगतान स्वीकार करने और सफल खरीदारी के बाद एक छवि भेजने के लिए तैयार है। सुनिश्चित करें कि कॉन्फ़िगरेशन फ़ाइलों में सभी सेटिंग्स और डेटा सही हैं।

यदि आप कोई प्रतिक्रिया या टिप्पणी छोड़ते हैं तो मैं इसकी सराहना करूंगा! आप GitHub पर संपूर्ण स्रोत कोड भी पा सकते हैं।