Telegram-бот под ключ: ИИ-нейросеть для создания бота на Python онлайн

Хорошо, давай создадим Telegram-бота для маникюрного салона с указанными требованиями. Сначала представлю структуру проекта, а затем предоставлю необходимые файлы.

Дерево папок проекта

manicure_bot/
│
├── bot.py
├── handlers/
│   ├── __init__.py
│   ├── booking.py
│   └── menu.py
├── keyboards.py
├── db.py
├── config.py
├── requirements.txt
└── .env.example

Содержимое файлов

bot.py

import logging
from aiogram import Bot, Dispatcher
from aiogram.fsm.storage.memory import MemoryStorage
from aiogram.utils import start_polling
from handlers.menu import router as menu_router
from handlers.booking import router as booking_router
import config

logging.basicConfig(level=logging.INFO)

bot = Bot(token=config.BOT_TOKEN)
storage = MemoryStorage()
dp = Dispatcher(storage)

dp.include_router(menu_router)
dp.include_router(booking_router)

if __name__ == '__main__':
    start_polling(dp, skip_updates=True)

handlers/__init__.py

# Пустой файл, чтобы сделать папку пакетом

handlers/menu.py

from aiogram import Router
from aiogram.filters import Command
from aiogram.types import Message, ReplyKeyboardMarkup, KeyboardButton

router = Router()

@router.message(Command("start"))
async def start_command(message: Message):
    keyboard = ReplyKeyboardMarkup(
        keyboard=[
            [KeyboardButton(text="Записаться")],
            [KeyboardButton(text="Цены")],
            [KeyboardButton(text="Контакты")]
        ],
        resize_keyboard=True
    )
    await message.answer("Добро пожаловать в наш маникюрный салон! Выберите действие:", reply_markup=keyboard)

handlers/booking.py

from aiogram import Router
from aiogram.filters import Command
from aiogram.types import Message
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup

from db import save_booking
import config

router = Router()

class Form(StatesGroup):
    service = State()
    master = State()
    datetime = State()
    name = State()
    phone = State()

@router.message(Command("book"))
async def book_command(message: Message, state: FSMContext):
    await message.answer("Выберите услугу:")
    await state.set_state(Form.service)

@router.message(Form.service)
async def process_service(message: Message, state: FSMContext):
    await state.update_data(service=message.text)
    await message.answer("Выберите мастера (Мастер 1/Мастер 2):")
    await state.set_state(Form.master)

@router.message(Form.master)
async def process_master(message: Message, state: FSMContext):
    await state.update_data(master=message.text)
    await message.answer("Введите дату и время:")
    await state.set_state(Form.datetime)

@router.message(Form.datetime)
async def process_datetime(message: Message, state: FSMContext):
    await state.update_data(datetime=message.text)
    await message.answer("Введите ваше имя:")
    await state.set_state(Form.name)

@router.message(Form.name)
async def process_name(message: Message, state: FSMContext):
    await state.update_data(name=message.text)
    await message.answer("Введите ваш телефон:")
    await state.set_state(Form.phone)

@router.message(Form.phone)
async def process_phone(message: Message, state: FSMContext):
    user_data = await state.get_data()
    booking_info = f"Услуга: {user_data['service']}\nМастер: {user_data['master']}\nДата и время: {user_data['datetime']}\nИмя: {user_data['name']}\nТелефон: {user_data['phone']}"
    
    await save_booking(booking_info)
    await message.answer("Спасибо, ваша запись принята!")
    
    # Отправка администратора
    await bot.send_message(config.ADMIN_ID, booking_info)
    await state.clear()

keyboards.py

# Оставим этот файл пустым на данный момент

db.py

import aiosqlite

async def save_booking(booking_info: str):
    async with aiosqlite.connect('bookings.db') as db:
        await db.execute('CREATE TABLE IF NOT EXISTS bookings (info TEXT)')
        await db.execute('INSERT INTO bookings (info) VALUES (?)', (booking_info,))
        await db.commit()

config.py

import os
from dotenv import load_dotenv

load_dotenv()

BOT_TOKEN = os.getenv("BOT_TOKEN")
ADMIN_ID = os.getenv("ADMIN_ID")

requirements.txt

aiogram==3.13
aiosqlite
python-dotenv

.env.example

BOT_TOKEN=ваш_токен_бота
ADMIN_ID=ваш_идентификатор_пользователя

Инструкция по запуску на Ubuntu

1. Установите необходимые пакеты:

   sudo apt update
   sudo apt install python3-venv python3-pip

2. Создайте виртуальное окружение:

   mkdir manicure_bot
   cd manicure_bot
   python3 -m venv venv
   source venv/bin/activate

3. Установите зависимости:

   pip install -r requirements.txt

4. Создайте файл .env и заполните его:

   cp .env.example .env
   nano .env

5. Создайте службу systemd:

   sudo nano /etc/systemd/system/manicure_bot.service

   Вставьте следующую конфигурацию:

   [Unit]
   Description=Manicure Bot
   After=network.target
   
   [Service]
   User=your_user
   WorkingDirectory=/path/to/manicure_bot
   Environment="PATH=/path/to/manicure_bot/venv/bin"
   ExecStart=/path/to/manicure_bot/venv/bin/python3 bot.py
   Restart=always
   
   [Install]
   WantedBy=multi-user.target

6. Запустите и включите службу:

   sudo systemctl daemon-reload
   sudo systemctl start manicure_bot
   sudo systemctl enable manicure_bot

Теперь ваш бот должен быть запущен и работать!

Хорошо, давай разработаем техническое задание для Telegram-бота для студии ремонта квартир. Вот краткое описание структуры и функционала.

Назначение бота

Бот принимает заявки по анкете и отвечает на частые вопросы кнопками. Заявки отправляются в рабочую группу, где бот добавлен.

Команды и кнопки

1. Главное меню:
   • Оставить заявку
   • Частые вопросы
   • Наши работы
2. Анкета (последовательность вопросов):
   • Тип ремонта (текстовый ввод)
   • Площадь, м² (числовой ввод)
   • Район (текстовый ввод)
   • Имя и телефон (текстовый ввод, с шагом согласия о обработке данных согласно 152-ФЗ)

Шаги диалога

1. Пользователь нажимает кнопку Оставить заявку.
   1. Бот спрашивает: "Какой тип ремонта вам нужен?"
   2. Пользователь отвечает, бот сохраняет ответ.
   3. Бот спрашивает: "Какова площадь ремонта в м²?"
   4. Пользователь отвечает, бот сохраняет ответ.
   5. Бот спрашивает: "В каком районе вы находитесь?"
   6. Пользователь отвечает, бот сохраняет ответ.
   7. Бот спрашивает: "Как вас зовут и какой у вас телефон?"
   8. Пользователь отвечает, бот сохраняет ответ и запрашивает согласие на обработку данных.
   9. Бот подтверждает получение заявки и отправляет её в рабочую группу.

Состояния FSM

1. StateRepairType - ожидание типа ремонта.
2. StateArea - ожидание площади.
3. StateDistrict - ожидание района.
4. StateNamePhone - ожидание имени и телефона.
5. StateConsent - ожидание согласия на обработку данных.

Таблицы базы данных (SQLite)

• applications
  • id INTEGER PRIMARY KEY AUTOINCREMENT
  • repair_type TEXT
  • area REAL
  • district TEXT
  • name TEXT
  • phone TEXT
  • timestamp DATETIME DEFAULT CURRENT_TIMESTAMP

Структура файлов

• bot.py — основной файл с инициализацией бота и маршрутизаторами.
• handlers/ — директория для обработки команд и сообщений.
  • main.py — обработка главного меню.
  • application.py — обработка анкеты и отправка заявок.
• keyboards.py — определение клавиатур.
• states.py — описание состояний FSM.
• db.py — работа с базой данных (aiosqlite).
• requirements.txt — зависимости проекта.
• .env.example — пример файла окружения с ключами (ID группы, токен бота).

Инструкция по запуску на Ubuntu с venv и systemd

1. Установить Python 3.11 и необходимые библиотеки.
2. Создать виртуальное окружение:

   python3.11 -m venv venv
   source venv/bin/activate
   pip install -r requirements.txt

3. Настроить systemd для автозапуска:
   • Создать файл /etc/systemd/system/telegram_bot.service с содержимым:

     [Unit]
     Description=Telegram Bot Service
     
     [Service]
     ExecStart=/path/to/venv/bin/python /path/to/bot.py
     WorkingDirectory=/path/to/your/bot
     Restart=always
     
     [Install]
     WantedBy=multi-user.target

4. Активировать и запустить:

   sudo systemctl enable telegram_bot
   sudo systemctl start telegram_bot

Замечания

• Тексты, услуги, цены, имена мастеров, адреса и часы – только из запросов пользователя.
• Поддерживать лимиты по символам и обрабатывать ошибки ввода.

Если все согласовано, я могу предоставить код для реализации.

Для создания Telegram-бота для домашней кондитерской на Python 3.12 и aiogram 3, выполните следующие шаги.

Структура проекта

my_cake_bot/
│
├── bot.py
├── config.py
├── db.py
├── handlers/
│   ├── __init__.py
│   ├── main_handlers.py
│   └── payment_handlers.py
├── keyboards.py
├── requirements.txt
├── .env.example
└── docker-compose.yml
└── Dockerfile

Содержимое файлов

bot.py

import asyncio
import os
from aiogram import Bot, Dispatcher
from aiogram.webhook.aiohttp_server import SimpleRequestHandler, setup_application
from dotenv import load_dotenv
from config import WEBHOOK_URL, WEBHOOK_SECRET

load_dotenv()

TOKEN = os.getenv("TELEGRAM_TOKEN")
bot = Bot(token=TOKEN)
dp = Dispatcher()

async def on_startup(dp):
    await bot.set_webhook(WEBHOOK_URL, secret_token=WEBHOOK_SECRET)

async def on_shutdown(dp):
    await bot.delete_webhook()

if __name__ == "__main__":
    from handlers import main_handlers, payment_handlers
    
    dp.include_router(main_handlers.router)
    dp.include_router(payment_handlers.router)
    
    app = setup_application(dp)
    
    asyncio.run(on_startup(dp))
    import aiohttp
    aiohttp.web.run_app(app, host='0.0.0.0', port=3000, shutdown_timeout=60, on_shutdown=on_shutdown)

config.py

import os

WEBHOOK_URL = os.getenv("WEBHOOK_URL")
WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET")
PG_CONNECTION_STRING = os.getenv("DATABASE_URL")
ADMIN_ID = int(os.getenv("ADMIN_ID"))
PROVIDER_TOKEN = os.getenv("PROVIDER_TOKEN")

db.py

import asyncpg
from config import PG_CONNECTION_STRING

async def init_db():
    conn = await asyncpg.connect(PG_CONNECTION_STRING)
    # Добавьте здесь SQL для создания таблиц
    await conn.close()

async def add_order(order_data):
    conn = await asyncpg.connect(PG_CONNECTION_STRING)
    await conn.execute('''INSERT INTO orders(data) VALUES($1)''', order_data)
    await conn.close()

handlers/__init__.py

from .main_handlers import router as main_router
from .payment_handlers import router as payment_router

handlers/main_handlers.py

from aiogram import Router
from aiogram.filters import Command
from aiogram.types import Message, ReplyKeyboardMarkup, KeyboardButton
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup

router = Router()

class Form(StatesGroup):
    name = State()
    phone = State()

@router.message(Command("start"))
async def cmd_start(message: Message):
    keyboard = ReplyKeyboardMarkup(keyboard=[
        [KeyboardButton(text="Каталог")],
        [KeyboardButton(text="Корзина")],
        [KeyboardButton(text="Доставка")]
    ])
    await message.answer("Добро пожаловать в нашу кондитерскую!", reply_markup=keyboard)

@router.message(Command("cart"))
async def cmd_cart(message: Message):
    await message.answer("Ваша корзина пуста.")

handlers/payment_handlers.py

from aiogram import Router
from aiogram.types import Message, InputInvoiceMessageContent
from aiogram.fsm.context import FSMContext
from aiogram.types import PreCheckoutQuery, SuccessfulPayment
from config import PROVIDER_TOKEN, ADMIN_ID

router = Router()

@router.message(Command("pay"))
async def cmd_pay(message: Message):
    prices = [{"label": "Торт", "amount": 5000}]
    await message.answer_invoice(
        title="Заказ торта",
        description="Описание заказа",
        payload="unique-payload",
        provider_token=PROVIDER_TOKEN,
        currency="rub",
        prices=prices
    )

@router.pre_checkout_query()
async def pre_checkout_query_handler(pre_checkout_query: PreCheckoutQuery):
    await pre_checkout_query.answer(ok=True)

@router.message(SuccessfulPayment)
async def successful_payment_handler(message: Message):
    # Обработка успешной оплаты
    await message.answer("Спасибо за ваш заказ!")

keyboards.py

from aiogram.types import ReplyKeyboardMarkup, KeyboardButton

def main_menu_keyboard():
    return ReplyKeyboardMarkup(keyboard=[
        [KeyboardButton(text="Каталог")],
        [KeyboardButton(text="Корзина")],
        [KeyboardButton(text="Доставка")]
    ])

requirements.txt

aiogram==3.13
asyncpg
python-dotenv
aiohttp

.env.example

TELEGRAM_TOKEN=your_telegram_token
WEBHOOK_URL=your_webhook_url
WEBHOOK_SECRET=your_webhook_secret
DATABASE_URL=your_postgres_connection_string
ADMIN_ID=your_admin_id
PROVIDER_TOKEN=your_payment_provider_token

Dockerfile

FROM python:3.12

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

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

docker-compose.yml

version: '3.8'

services:
  bot:
    build: .
    ports:
      - "3000:3000"
    env_file:
      - .env

Инструкция по запуску

1. Создайте файл .env на основе .env.example и заполните его необходимыми данными.
2. Убедитесь, что установлен Docker и Docker Compose.
3. В корневом каталоге проекта выполните команду:

   docker-compose up --build

4. Бот будет доступен по адресу, указанному в WEBHOOK_URL.

Таким образом, бот будет обрабатывать заказы на торты и принимать оплату, а также отправлять заявки администратору.

Для создания Telegram-бота языковой школы с использованием Python 3.12 и aiogram 3, предлагаю следующую структуру проекта и реализацию. Бот будет выполнять рассылку, отвечать на частые вопросы и хранить данные в PostgreSQL через asyncpg.

Дерево папок

language_school_bot/
│
├── bot.py
├── handlers/
│   ├── __init__.py
│   ├── admin_handlers.py
│   └── user_handlers.py
├── keyboards.py
├── db.py
├── config.py
├── requirements.txt
└── .env.example

Файл bot.py

import logging
from aiogram import Bot, Dispatcher, F
from aiogram.fsm import FSMContext
from aiogram.fsm.storage.memory import MemoryStorage
from config import load_config
from handlers import admin_handlers, user_handlers

logging.basicConfig(level=logging.INFO)

async def main():
    config = load_config()
    bot = Bot(token=config.bot.token)
    storage = MemoryStorage()
    dp = Dispatcher(storage=storage)

    dp.include_router(admin_handlers.router)
    dp.include_router(user_handlers.router)

    await dp.start_polling(bot)

if __name__ == '__main__':
    import asyncio
    asyncio.run(main())

Файл handlers/admin_handlers.py

from aiogram import Router, F
from aiogram import types
from aiogram.fsm.context import FSMContext
from db import Database

router = Router()
db = Database()

@router.message(F.command('send_message'))
async def send_message(msg: types.Message, state: FSMContext):
    if msg.from_user.id in [int(id) for id in os.getenv('ADMIN_IDS').split(',')]:
        await state.set_state('send_message')
        await msg.answer("Введите сообщение для рассылки.")
    else:
        await msg.answer("У вас нет прав для этой команды.")

@router.message(F.state('send_message'))
async def process_send_message(msg: types.Message, state: FSMContext):
    users = await db.get_all_users()
    for user in users:
        await msg.bot.send_message(user['chat_id'], msg.text)
    await state.clear()
    await msg.answer("Рассылка завершена!")

Файл handlers/user_handlers.py

from aiogram import Router, F
from aiogram import types
from aiogram.fsm.context import FSMContext
from db import Database

router = Router()
db = Database()

@router.message(F.command('start'))
async def start(msg: types.Message):
    await msg.answer("Добро пожаловать в нашу языковую школу! Чем можем помочь?")

@router.message(F.text)
async def handle_faq(msg: types.Message):
    if msg.text.lower() in ['цены', 'услуги', 'расписание']:
        await msg.answer("Вот информация о наших услугах...")
    else:
        await msg.answer("Извините, я не понимаю ваш запрос.")

Файл keyboards.py

from aiogram.types import ReplyKeyboardMarkup, KeyboardButton

def get_main_keyboard():
    return ReplyKeyboardMarkup(
        keyboard=[
            [KeyboardButton(text="Цены"), KeyboardButton(text="Услуги")],
            [KeyboardButton(text="Расписание")]
        ],
        resize_keyboard=True
    )

Файл db.py

import asyncpg
import os

class Database:
    def __init__(self):
        self.connection = None

    async def connect(self):
        self.connection = await asyncpg.connect(os.getenv('DATABASE_URL'))

    async def get_all_users(self):
        return await self.connection.fetch("SELECT chat_id FROM users")

    async def close(self):
        await self.connection.close()

Файл config.py

import os
from dotenv import load_dotenv

class Config:
    def __init__(self):
        load_dotenv()
        self.bot = BotConfig()

class BotConfig:
    def __init__(self):
        self.token = os.getenv('BOT_TOKEN')

def load_config():
    return Config()

Файл requirements.txt

aiogram==3.13.0
asyncpg==0.26.0
python-dotenv==1.0.0

Файл .env.example

BOT_TOKEN=your_bot_token
DATABASE_URL=postgresql://user:password@localhost:5432/database
ADMIN_IDS=your_admin_id

Инструкция по запуску на Ubuntu

1. Установите Python 3.12 и pip, если еще не установлены.
2. Установите venv, если он не установлен:

   sudo apt install python3.12-venv

3. Создайте виртуальное окружение и активируйте его:

   python3.12 -m venv venv
   source venv/bin/activate

4. Установите зависимости:

   pip install -r requirements.txt

5. Создайте файл .env на основе .env.example и заполните его данными.
6. Создайте службу systemd для автозапуска бота:

   sudo nano /etc/systemd/system/language_school_bot.service

   Вставьте следующее:

   [Unit]
   Description=Language School Bot
   After=network.target
   
   [Service]
   User=YOUR_USER
   WorkingDirectory=/path/to/language_school_bot
   ExecStart=/path/to/language_school_bot/venv/bin/python3 bot.py
   Restart=always
   
   [Install]
   WantedBy=multi-user.target

7. Запустите службу:

   sudo systemctl start language_school_bot
   sudo systemctl enable language_school_bot

Теперь ваш бот запущен и готов к работе!

Для создания Telegram-бота автосервиса с описанными функциональными возможностями, ниже представлено полное описание проекта, включая структуру файлов, код и инструкции по запуску.

Структура проекта

autoserivce_bot/
├── handlers/
│   ├── __init__.py
│   ├── main.py
│   └── forms.py
├── db.py
├── bot.py
├── keyboards.py
├── config.py
├── requirements.txt
└── .env.example

Содержимое файлов

1. bot.py

import asyncio
import logging
from aiogram import Bot, Dispatcher
from aiogram.fsm.storage.memory import MemoryStorage
from handlers.main import router
from config import BOT_TOKEN

logging.basicConfig(level=logging.INFO)

async def main():
    bot = Bot(token=BOT_TOKEN)
    storage = MemoryStorage()
    dp = Dispatcher(storage=storage)
    dp.include_router(router)

    await dp.start_polling(bot)

if __name__ == '__main__':
    asyncio.run(main())

2. handlers/main.py

from aiogram import Router
from aiogram.filters import Command
from aiogram.types import Message
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import StatesGroup, State
from keyboards import main_menu
from handlers.forms import Form

router = Router()

class Form(StatesGroup):
    name = State()
    year = State()
    service = State()
    day = State()
    phone = State()

@router.message(Command("start"))
async def start_handler(message: Message, state: FSMContext):
    await message.answer("Добро пожаловать в автосервис! Выберите действие:", reply_markup=main_menu())
    await state.clear()

@router.message(Command("price"))
async def price_handler(message: Message):
    await message.answer("Цены на услуги:\n1) ТО - 5000 руб.\n2) Ремонт - 3000 руб.")

@router.message(Command("address"))
async def address_handler(message: Message):
    await message.answer("Мы находимся по адресу: ул. Примерная, 1")

@router.message(Command("record"))
async def record_handler(message: Message, state: FSMContext):
    await message.answer("Введите марку и модель автомобиля:")
    await state.set_state(Form.name)

@router.message(Form.name)
async def process_name(message: Message, state: FSMContext):
    await state.update_data(name=message.text)
    await message.answer("Введите год выпуска:")
    await state.set_state(Form.year)

@router.message(Form.year)
async def process_year(message: Message, state: FSMContext):
    await state.update_data(year=message.text)
    await message.answer("Что надо сделать?")
    await state.set_state(Form.service)

@router.message(Form.service)
async def process_service(message: Message, state: FSMContext):
    await state.update_data(service=message.text)
    await message.answer("Введите удобный день для записи:")
    await state.set_state(Form.day)

@router.message(Form.day)
async def process_day(message: Message, state: FSMContext):
    await state.update_data(day=message.text)
    await message.answer("Введите ваш телефон:")
    await state.set_state(Form.phone)

@router.message(Form.phone)
async def process_phone(message: Message, state: FSMContext):
    user_data = await state.get_data()
    name = user_data['name']
    year = user_data['year']
    service = user_data['service']
    day = user_data['day']
    phone = message.text

    # Здесь будет логика отправки данных в Google Таблицу
    await message.answer("Ваша заявка принята! Ожидайте звонка.")
    await state.clear()

3. handlers/forms.py (пока оставим этот файл пустым для будущих функций, связанных с формами)

# Логика для форм будет добавлена позже

4. db.py

import aiosqlite

async def init_db():
    async with aiosqlite.connect('autoserivce.db') as db:
        await db.execute(
            "CREATE TABLE IF NOT EXISTS records (id INTEGER PRIMARY KEY, name TEXT, year TEXT, service TEXT, day TEXT, phone TEXT)"
        )
        await db.commit()

5. keyboards.py

from aiogram.types import ReplyKeyboardMarkup, KeyboardButton

def main_menu():
    keyboard = ReplyKeyboardMarkup(resize_keyboard=True)
    buttons = [
        KeyboardButton(text="Записаться на ТО"),
        KeyboardButton(text="Узнать цену"),
        KeyboardButton(text="Адрес")
    ]
    keyboard.add(*buttons)
    return keyboard

6. config.py

import os
from dotenv import load_dotenv

load_dotenv()

BOT_TOKEN = os.getenv("BOT_TOKEN")

7. requirements.txt

aiogram==3.13
aiosqlite==0.17.0
gspread==5.4.0
python-dotenv==1.0.0

8. .env.example

BOT_TOKEN=ваш_токен_бота

Инструкции по запуску

1. Установка необходимых пакетов:

   python3.11 -m venv venv
   source venv/bin/activate
   pip install -r requirements.txt

2. Создание Google сервисного аккаунта:
   • Создайте проект в Google Cloud Console.
   • Включите Google Sheets API.
   • Создайте сервисный аккаунт и получите JSON-ключ.
   • Поделитесь Google таблицей с email вашего сервисного аккаунта.
3. Настройка переменных окружения:
   • Переименуйте .env.example в .env и вставьте ваш токен.
4. Запуск бота:

   python bot.py

Теперь ваш бот готов к использованию!

Конечно! Давайте разработаем техническое задание (ТЗ) для Telegram-бота психотерапевта на Python 3.13 с использованием aiogram 3. Вот детальный план:

Техническое задание (ТЗ)

Назначение бота

Бот предназначен для записи клиентов к психологу, управления записями, приема платежей и отправки уведомлений администратору о новых записях.

Основные команды и кнопки

1. Команды:
   • /start — Приветственное сообщение и меню.
   • /help — Информация о боте и его функциях.
   • /services — Список доступных услуг.
2. Кнопки:
   • Записаться на прием — Начало процесса записи.
   • Оплатить услугу — Процесс оплаты.
   • Проверить статус записи — Возможность уточнить статус записи.

Шаги диалога

1. /start
   • Бот приветствует пользователя и предлагает выбрать действие (Кнопки: Записаться на прием, Оплатить услугу, Проверить статус записи).
2. Записаться на прием
   • Запрос услуги (список услуг).
   • Запрос даты и времени.
   • Запрос контактных данных (имя и телефон).
   • Подтверждение записи (вывод всех введенных данных).
   • Отправка заявки администратору с данными клиента.
3. Оплатить услугу
   • Запрос услуги (список услуг).
   • Запрос суммы.
   • Генерация инвойса через send_invoice.
   • Обработка pre_checkout_query и successful_payment.
4. Проверить статус записи
   • Запрос информации о записи (имя и телефон).
   • Ответ с текущим статусом (если имеется).

Состояния FSM

1. WaitingForService — Ожидание выбора услуги.
2. WaitingForDateTime — Ожидание выбора даты и времени.
3. WaitingForContact — Ожидание ввода контактных данных.
4. WaitingForPayment — Ожидание платежа.

Куда уходят заявки

• Заявки с данными клиентов отправляются администратору (Telegram ID из переменных окружения).

Хранение данных

• Данные клиентов хранятся в памяти, после перезапуска они теряются. Структура данных может быть следующей:

clients = [
    {
        "service": "Услуга 1",
        "date_time": "2023-10-01 14:00",
        "contact": {"name": "Иван", "phone": "+79000000000"},
    },
    ...
]

Оплата

• Платежи осуществляется через Telegram API.
• Для физического товара и офлайн-услуг — использование токена из .env.
• Для цифровых услуг — использование Stars.

Структура файлов

/bot.py
/handlers/
    ├── __init__.py
    ├── commands.py
    ├── payments.py
    ├── fsm.py
/keysboards.py
/states.py
/db.py (если понадобится в будущем)
/requirements.txt
/.env.example

Инструкция по запуску на Ubuntu

1. Установите Python и необходимые пакеты:

   sudo apt update
   sudo apt install python3-pip python3-venv

2. Создайте виртуальное окружение:

   python3 -m venv myenv
   source myenv/bin/activate
   pip install aiogram

3. Создайте файл .env с переменными окружения:

   TELEGRAM_TOKEN="ваш_токен"
   PROVIDER_TOKEN="ваш_токен_провайдера"
   ADMIN_ID="ваш_admin_id"

4. Создайте файл службы systemd:

   sudo nano /etc/systemd/system/telegram_bot.service

   Пример содержимого:

   [Unit]
   Description=Telegram Bot
   
   [Service]
   WorkingDirectory=/путь/к/вашему/боту
   ExecStart=/путь/к/вашему/боту/myenv/bin/python /путь/к/вашему/боту/bot.py
   Restart=always
   
   [Install]
   WantedBy=multi-user.target

5. Запустите службу:

   sudo systemctl daemon-reload
   sudo systemctl start telegram_bot
   sudo systemctl enable telegram_bot

Теперь у вас есть полное ТЗ для создания Telegram-бота психотерапевта. Если у вас есть вопросы или хотите перейти к коду, дайте знать!