Интеграция Robokassa: полное руководство разработчика

 1MerchantLogin:OutSum:InvId:Password1[:ФДП]

 1import hashlib
 2
 3def generate_signature_md5(login: str, out_sum: str, inv_id: int, password: str, 
 4                            shp_params: dict = None) -> str:
 5    """Генерация подписи для запроса оплаты (MD5)"""
 6    # Базовая строка подписи
 7    signature_string = f"{login}:{out_sum}:{inv_id}:{password}"
 8    
 9    # Добавляем shp_ параметры (в алфавитном порядке!)
10    if shp_params:
11        sorted_params = sorted(shp_params.items())
12        for key, value in sorted_params:
13            signature_string += f":{key}={value}"
14    
15    return hashlib.md5(signature_string.encode()).hexdigest()
16
17# Пример использования
18signature = generate_signature_md5(
19    login="my_shop",
20    out_sum="1500.00",
21    inv_id=12345,
22    password="password1",
23    shp_params={"user_id": "123456789", "order_id": "abc"}
24)
25# Результат: "a1b2c3d4e5f6..."

 1def verify_signature_md5(out_sum: str, inv_id: int, password: str, 
 2                          shp_params: dict = None) -> str:
 3    """Генерация ожидаемой подписи для проверки ответа"""
 4    signature_string = f"{out_sum}:{inv_id}:{password}"
 5    
 6    if shp_params:
 7        sorted_params = sorted(shp_params.items())
 8        for key, value in sorted_params:
 9            signature_string += f":{key}={value}"
10    
11    return hashlib.md5(signature_string.encode()).hexdigest()
12
13# Проверка подписи
14expected_signature = verify_signature_md5(
15    out_sum="1500.00",
16    inv_id=12345,
17    password="password2",  # Пароль №2!
18    shp_params={"user_id": "123456789", "order_id": "abc"}
19)
20
21if expected_signature == received_signature:
22    print("Подпись верна!")
23else:
24    print("Подпись НЕ верна! Возможна подделка.")

 1import hashlib
 2
 3# SHA256
 4signature_sha = hashlib.sha256(signature_string.encode()).hexdigest()
 5
 6# MD5
 7signature_md5 = hashlib.md5(signature_string.encode()).hexdigest()

 1import hashlib
 2from urllib.parse import urlencode
 3
 4MERCHANT_LOGIN = "my_shop"
 5PASSWORD1 = "password1"
 6ROBOKASSA_URL = "https://auth.robokassa.ru/Merchant/Index.aspx"
 7
 8def create_payment_url(out_sum: float, inv_id: int, description: str, 
 9                        shp_params: dict = None) -> str:
10    """Формирование URL для оплаты через Robokassa"""
11    
12    # Формируем подпись
13    signature_string = f"{MERCHANT_LOGIN}:{out_sum:.2f}:{inv_id}:{PASSWORD1}"
14    
15    if shp_params:
16        sorted_params = sorted(shp_params.items())
17        for key, value in sorted_params:
18            signature_string += f":{key}={value}"
19    
20    signature = hashlib.sha256(signature_string.encode()).hexdigest()
21    
22    # Параметры запроса
23    params = {
24        "MerchantLogin": MERCHANT_LOGIN,
25        "OutSum": f"{out_sum:.2f}",
26        "InvId": inv_id,
27        "Description": description,
28        "SignatureValue": signature,
29    }
30    
31    # Добавляем shp_ параметры
32    if shp_params:
33        for key, value in shp_params.items():
34            params[f"shp_{key} = value"
35    
36    return f"{ROBOKASSA_URL}?{urlencode(params)}"
37
38# Использование
39url = create_payment_url(
40    out_sum=1500.00,
41    inv_id=12345,
42    description="Курс по йоге",
43    shp_params={"user_id": "123456789", "order_id": "abc"}
44)
45print(url)
46# https://auth.robokassa.ru/Merchant/Index.aspx?MerchantLogin=...

 1from aiogram import Router, F
 2from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
 3
 4router = Router()
 5
 6@router.message(F.text == "🛒 Купить")
 7async def buy_handler(message: Message):
 8    """Обработчик кнопки «Купить»"""
 9    user_id = message.from_user.id
10    order_id = generate_order_id()
11    amount = 1500.00
12    
13    # Генерируем URL оплаты
14    payment_url = create_payment_url(
15        out_sum=amount,
16        inv_id=order_id,
17        description="Курс по йоге — базовый уровень",
18        shp_params={"user_id": str(user_id), "order_id": str(order_id)}
19    )
20    
21    # Сохраняем заказ в БД
22    await save_order(order_id, user_id, amount, "pending")
23    
24    keyboard = InlineKeyboardMarkup(inline_keyboard=[
25        [InlineKeyboardButton(
26            text=f"💳 Оплатить {amount:.0f} ₽",
27            url=payment_url
28        )]
29    ])
30    
31    await message.answer(
32        "🛒 **Курс по йоге — базовый уровень**\n\n"
33        f"Стоимость: {amount:.0f} ₽\n"
34        "Доступ: навсегда\n\n"
35        "Нажмите кнопку ниже для оплаты:",
36        reply_markup=keyboard,
37        parse_mode="Markdown"
38    )

 1from aiohttp import web
 2import hashlib
 3
 4PASSWORD2 = "password2"
 5
 6async def handle_result_url(request: web.Request) -> web.Response:
 7    """Обработка Result URL от Robokassa"""
 8    # Получаем параметры из GET-запроса
 9    out_sum = request.query.get("OutSum")
10    inv_id = request.query.get("InvId")
11    received_signature = request.query.get("SignatureValue")
12    
13    # Собираем shp_ параметры
14    shp_params = {}
15    for key, value in request.query.items():
16        if key.startswith("shp_"):
17            shp_params[key] = value
18    
19    # Формируем ожидаемую подпись
20    signature_string = f"{out_sum}:{inv_id}:{PASSWORD2}"
21    
22    if shp_params:
23        sorted_params = sorted(shp_params.items())
24        for key, value in sorted_params:
25            signature_string += f":{key}={value}"
26    
27    expected_signature = hashlib.sha256(
28        signature_string.encode()
29    ).hexdigest()
30    
31    # Проверяем подпись
32    if expected_signature != received_signature:
33        return web.Response(
34            text="Invalid signature",
35            status=400
36        )
37    
38    # Подпись верна — обрабатываем платёж
39    user_id = shp_params.get("shp_user_id")
40    order_id = shp_params.get("shp_order_id")
41    
42    # Обновляем статус заказа
43    await update_order_status(int(inv_id), "paid")
44    
45    # Выдаём товар пользователю
46    await give_access(int(user_id), order_id)
47    
48    # Уведомляем пользователя
49    await bot.send_message(
50        int(user_id),
51        f"✅ Оплата получена! Сумма: {out_sum} ₽"
52    )
53    
54    # ВАЖНО: возвращаем текст с InvId
55    return web.Response(text=f"OK{inv_id}")
56
57# Настройка маршрутов
58app = web.Application()
59app.router.add_get('/robokassa/result', handle_result_url)

 1from fastapi import FastAPI, Query, HTTPException
 2import hashlib
 3
 4app = FastAPI()
 5PASSWORD2 = "password2"
 6
 7@app.get("/robokassa/result")
 8async def robokassa_result(
 9    OutSum: str = Query(...),
10    InvId: str = Query(...),
11    SignatureValue: str = Query(...),
12    # shp_ параметры
13    shp_user_id: str = Query(None),
14    shp_order_id: str = Query(None),
15):
16    """Обработка Result URL от Robokassa"""
17    # Формируем подпись
18    sig_string = f"{OutSum}:{InvId}:{PASSWORD2}"
19    
20    if shp_user_id and shp_order_id:
21        sig_string += f":shp_order_id={shp_order_id}:shp_user_id={shp_user_id}"
22    
23    expected = hashlib.sha256(sig_string.encode()).hexdigest()
24    
25    if expected != SignatureValue:
26        raise HTTPException(status_code=400)
27    
28    # Обработка платежа
29    await process_payment(InvId, OutSum, shp_user_id)
30    
31    return f"OK{InvId}"

 1from aiogram import Router, F
 2from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
 3import hashlib
 4import uuid
 5
 6router = Router()
 7
 8COURSES = {
 9    "yoga_basic": {"name": "Йога — базовый", "price": 2500.00},
10    "yoga_advanced": {"name": "Йога — продвинутый", "price": 4500.00},
11    "yoga_master": {"name": "Йога — мастер", "price": 8000.00},
12}
13
14@router.message(F.text == "📚 Курсы")
15async def show_courses(message: Message):
16    """Показать каталог курсов"""
17    keyboard = InlineKeyboardMarkup(inline_keyboard=[
18        [InlineKeyboardButton(
19            text=f"{c['name']} — {c['price']:.0f} ₽",
20            callback_data=f"buy:{course_id}"
21        )]
22        for course_id, c in COURSES.items()
23    ])
24    
25    await message.answer(
26        "📚 **Наши курсы:**\nВыберите курс для покупки:",
27        reply_markup=keyboard,
28        parse_mode="Markdown"
29    )
30
31@router.callback_query(F.data.startswith("buy:"))
32async def buy_course(callback):
33    """Обработка покупки курса"""
34    course_id = callback.data.split(":")[1]
35    course = COURSES[course_id]
36    user_id = callback.from_user.id
37    inv_id = int(uuid.uuid4().int % 1000000)
38    
39    # Генерируем URL оплаты
40    payment_url = create_payment_url(
41        out_sum=course['price'],
42        inv_id=inv_id,
43        description=course['name'],
44        shp_params={
45            "user_id": str(user_id),
46            "course_id": course_id
47        }
48    )
49    
50    keyboard = InlineKeyboardMarkup(inline_keyboard=[
51        [InlineKeyboardButton(
52            text=f"💳 Оплатить {course['price']:.0f} ₽",
53            url=payment_url
54        )]
55    ])
56    
57    await callback.message.answer(
58        f"🛒 **{course['name']}**\n\n"
59        f"Стоимость: {course['price']:.0f} ₽\n"
60        "Доступ: навсегда\n\n"
61        "Нажмите кнопку для оплаты:",
62        reply_markup=keyboard,
63        parse_mode="Markdown"
64    )

 1params = {
 2    "MerchantLogin": MERCHANT_LOGIN,
 3    "OutSum": "50.00",
 4    "InvId": inv_id,
 5    "Currency": "USD",  # Валюта оплаты
 6    "SignatureValue": signature,
 7}