/newbot - create new bot

Name: My Business Assistant
Username: mybusiness_assistant_bot
Token: 123456789:ABCdefGHIjklMNOpqrSTUvwxyz

/setname - change bot name
/setdescription - set description
/setabouttext - set about text
/setuserpic - set profile photo
/setcommands - define command list

/setdescription
I'm your business assistant. I can 
help dengan orders, support, dan 
provide information.

/setabouttext
🤖 Business Bot
📦 Order tracking
💬 Customer support
📅 Appointment booking

/setcommands
start - Start using bot
help - Show help menu
order - Track your order
support - Contact support
booking - Book appointment
products - Browse products

pip install python-telegram-bot

from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

# Bot token
TOKEN = "YOUR_BOT_TOKEN_HERE"

# Start command handler
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "Hello! I'm your business assistant.\n"
        "How can I help you today?"
    )

# Help command handler
async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    help_text = """
Available commands:
/start - Start the bot
/help - Show this help menu
/order - Track your order
/support - Contact customer support
/products - Browse products
"""
    await update.message.reply_text(help_text)

# Main function
if __name__ == "__main__":
    # Create application
    app = ApplicationBuilder().token(TOKEN).build()
    
    # Add handlers
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("help", help_command))
    
    # Run the bot
    print("Bot is running...")
    app.run_polling()

from telegram.ext import MessageHandler, filters

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text = update.message.text.lower()
    
    if "order" in text or "pesan" in text:
        await update.message.reply_text(
            "Untuk cek pesanan, gunakan perintah /order\n"
            "atau berikan nomor pesanan Anda."
        )
    elif "help" in text or "bantu" in text:
        await update.message.reply_text(
            "Saya bisa membantu dengan:\n"
            "- Cek status pesanan\n"
            "- Informasi produk\n"
            "- Customer service\n\n"
            "Gunakan /help untuk list lengkap."
        )
    else:
        await update.message.reply_text(
            "Maaf, saya tidak mengerti.\n"
            "Gunakan /help untuk melihat apa yang bisa saya bantu."
        )

# Add message handler
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))

import asyncio
from datetime import datetime, time
from telegram import Bot

TOKEN = "YOUR_BOT_TOKEN"
CHANNEL_ID = "@your_channel_username"  # atau -1001234567890

async def send_scheduled_message():
    bot = Bot(token=TOKEN)
    
    message = """
Good morning! ☀️

Daily tip untuk hari ini:
[Your daily tip content]

Have a productive day!
    """
    
    await bot.send_message(chat_id=CHANNEL_ID, text=message)

# Schedule untuk run daily at 8:00 AM
async def scheduler():
    while True:
        now = datetime.now()
        target_time = time(8, 0)  # 8:00 AM
        
        if now.time() >= target_time:
            # If already past 8 AM, schedule untuk tomorrow
            target = datetime.combine(now.date() + timedelta(days=1), target_time)
        else:
            target = datetime.combine(now.date(), target_time)
        
        wait_seconds = (target - now).total_seconds()
        await asyncio.sleep(wait_seconds)
        
        await send_scheduled_message()

if __name__ == "__main__":
    asyncio.run(scheduler())

import sqlite3

# Setup database
conn = sqlite3.connect('orders.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS orders
             (order_id TEXT, customer_id INTEGER, 
              status TEXT, created_date TEXT)''')
conn.commit()

async def track_order(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # Get order ID dari message
    if not context.args:
        await update.message.reply_text(
            "Silakan masukkan nomor pesanan.\n"
            "Contoh: /order ORD12345"
        )
        return
    
    order_id = context.args[0]
    
    # Query database
    c.execute("SELECT * FROM orders WHERE order_id=?", (order_id,))
    order = c.fetchone()
    
    if order:
        await update.message.reply_text(
            f"Pesanan #{order_id}:\n"
            f"Status: {order[2]}\n"
            f"Tanggal: {order[3]}"
        )
    else:
        await update.message.reply_text(
            "Pesanan tidak ditemukan.\n"
            "Pastikan nomor pesanan benar."
        )

# Add handler
app.add_handler(CommandHandler("order", track_order))

products = {
    "1": {"name": "Product A", "price": 100000, "stock": 10},
    "2": {"name": "Product B", "price": 200000, "stock": 5},
    "3": {"name": "Product C", "price": 150000, "stock": 8},
}

async def show_products(update: Update, context: ContextTypes.DEFAULT_TYPE):
    product_list = "Our Products:\n\n"
    for id, product in products.items():
        product_list += (
            f"{id}. {product['name']}\n"
            f"   Price: Rp {product['price']:,}\n"
            f"   Stock: {product['stock']}\n\n"
        )
    
    product_list += "To order, reply dengan ID produk."
    await update.message.reply_text(product_list)

app.add_handler(CommandHandler("products", show_products))

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    keyboard = [
        [InlineKeyboardButton("Products", callback_data='products')],
        [InlineKeyboardButton("Track Order", callback_data='track_order')],
        [InlineKeyboardButton("Support", callback_data='support')],
        [InlineKeyboardButton("FAQ", callback_data='faq')],
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await update.message.reply_text(
        "Main Menu:\nChoose an option:",
        reply_markup=reply_markup
    )

# Callback handler
async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()
    
    if query.data == 'products':
        await query.edit_message_text("Loading products...")
    elif query.data == 'support':
        await query.edit_message_text("Connecting untuk support...")
    # ... etc

app.add_handler(CommandHandler("menu", menu))
app.add_handler(CallbackQueryHandler(button_handler))

async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE):
    document = update.message.document
    file_name = document.file_name
    
    # Download file
    file = await document.get_file()
    await file.download(f"downloads/{file_name}")
    
    await update.message.reply_text(
        f"File '{file_name}' received!\n"
        "We'll process it dan get back untuk you."
    )

app.add_handler(MessageHandler(filters.Document.ALL, handle_document))

from telegram import LabeledPrice

async def send_invoice(update: Update, context: ContextTypes.DEFAULT_TYPE):
    chat_id = update.message.chat_id
    title = "Product Purchase"
    description = "Payment untuk Product A"
    payload = "custom_payload"
    provider_token = "YOUR_PAYMENT_PROVIDER_TOKEN"
    currency = "IDR"
    prices = [LabeledPrice("Product A", 10000000)]  # Amount dalam smallest unit
    
    await context.bot.send_invoice(
        chat_id, title, description, payload,
        provider_token, currency, prices
    )

# Instead dari polling, use webhooks untuk production

from telegram.ext import Application
import os

TOKEN = os.getenv("BOT_TOKEN")
WEBHOOK_URL = "https://your-domain.com/webhook"

app = Application.builder().token(TOKEN).build()

# Set webhook
await app.bot.set_webhook(WEBHOOK_URL)

# Run dengan webhook
app.run_webhook(
    listen="0.0.0.0",
    port=8443,
    webhook_url=WEBHOOK_URL
)

import requests

async def save_lead(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.message.from_user
    
    lead_data = {
        "name": user.full_name,
        "telegram_id": user.id,
        "username": user.username,
        "source": "telegram_bot"
    }
    
    # Send untuk CRM
    response = requests.post(
        "https://your-crm.com/api/leads",
        json=lead_data,
        headers={"Authorization": "Bearer YOUR_TOKEN"}
    )
    
    if response.status_code == 200:
        await update.message.reply_text(
            "Terima kasih! Data Anda telah tersimpan.\n"
            "Tim kami akan menghubungi Anda segera."
        )

from flask import Flask, request

app = Flask(__name__)

@app.route('/webhook/order', methods=['POST'])
def handle_order_webhook():
    data = request.json
    order_id = data['order_id']
    customer_chat_id = data['telegram_chat_id']
    status = data['status']
    
    # Send notification ke customer via bot
    bot = Bot(token=TOKEN)
    bot.send_message(
        chat_id=customer_chat_id,
        text=f"Pesanan #{order_id} update:\nStatus: {status}"
    )
    
    return "OK", 200

import smtplib
from email.mime.text import MIMEText

def send_email_notification(to_email, subject, body):
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = "your-email@domain.com"
    msg['To'] = to_email
    
    server = smtplib.SMTP('smtp.gmail.com', 587)
    server.starttls()
    server.login("your-email", "your-password")
    server.send_message(msg)
    server.quit()

async def notify_team(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # Send email notification ke team
    send_email_notification(
        "team@company.com",
        "New Telegram Message",
        f"From: {update.message.from_user.full_name}\nMessage: {update.message.text}"
    )

# SSH into server
ssh user@your-vps-ip

# Install dependencies
sudo apt-get update
sudo apt-get install python3-pip
pip3 install python-telegram-bot

# Upload bot code
scp bot.py user@your-vps-ip:/home/user/

# Run dengan screen atau tmux (untuk keep running)
screen -S telegram-bot
python3 bot.py
# Detach: Ctrl+A, D

FROM python:3.9-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .
CMD ["python", "bot.py"]

# /etc/systemd/system/telegram-bot.service
[Unit]
Description=Telegram Bot
After=network.target

[Service]
Type=simple
User=botuser
WorkingDirectory=/home/botuser
ExecStart=/usr/bin/python3 /home/botuser/bot.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

import os
from dotenv import load_dotenv

load_dotenv()

TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
DATABASE_URL = os.getenv("DATABASE_URL")

async def safe_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    try:
        order_id = context.args[0]
        # Validate input
        if not order_id.isalnum():
            raise ValueError("Invalid order ID")
        # Process...
    except (IndexError, ValueError) as e:
        await update.message.reply_text("Invalid input. Please try again.")

from functools import wraps
import time

user_last_message = {}

async def rate_limit(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.message.from_user.id
    now = time.time()
    
    if user_id in user_last_message:
        if now - user_last_message[user_id] < 1:  # 1 second limit
            await update.message.reply_text("Please wait a moment...")
            return
    
    user_last_message[user_id] = now
    # Continue dengan handler...