Telegram-бот з FopPay

"""
Telegram-бот + FopPay: менеджер командою /pay створює посилання на оплату й надсилає його в чат,
а вебхук payment_link.opened повідомляє менеджера, що клієнт відкрив посилання.

    pip install aiogram aiohttp

Змінні середовища:
    BOT_TOKEN                 — токен бота від @BotFather
    ALLOWED_USER_IDS          — Telegram ID менеджерів через кому; лише вони можуть викликати /pay
    MANAGER_CHAT_ID           — чат, куди надсилати сповіщення
    FOPPAY_API_SECRET         — ключ з кабінету FopPay → «API ключі»
    FOPPAY_BANK_ACCOUNT_CODE  — account_code_6 рахунку (GET /api/v1/fops)
    FOPPAY_WEBHOOK_SECRET     — секрет whsec_… з кабінету FopPay → «Вебхуки»
"""
import asyncio
import hashlib
import hmac
import json
import os
import re
import time
import uuid

from aiogram import Bot, Dispatcher
from aiogram.filters import Command, CommandObject
from aiogram.types import Message
from aiohttp import ClientSession, ClientTimeout, web

BOT_TOKEN = os.environ["BOT_TOKEN"]
ALLOWED_USER_IDS = {int(user_id) for user_id in os.environ["ALLOWED_USER_IDS"].split(",") if user_id.strip()}
MANAGER_CHAT_ID = int(os.environ["MANAGER_CHAT_ID"])
FOPPAY_API_SECRET = os.environ["FOPPAY_API_SECRET"]
FOPPAY_BANK_ACCOUNT_CODE = os.environ["FOPPAY_BANK_ACCOUNT_CODE"]
FOPPAY_WEBHOOK_SECRET = os.environ["FOPPAY_WEBHOOK_SECRET"]
FOPPAY_INVOICES_URL = "https://foppay.com.ua/api/v1/invoices"

TIMESTAMP_FORMAT = re.compile(r"[0-9]{1,10}")
SIGNATURE_FORMAT = re.compile(r"[0-9a-f]{64}")

bot = Bot(BOT_TOKEN)
dp = Dispatcher()

# Для прикладу — у памʼяті. У продакшні — таблиця в БД
# (link_id → замовлення, і UNIQUE на оброблені X-Idempotency-Key).
orders_by_link_id: dict[str, dict] = {}
processed_keys: set[str] = set()
in_flight_keys: set[str] = set()


async def create_payment_link(amount: str, order_number: str) -> dict:
    payload = {
        "bank_account_code": FOPPAY_BANK_ACCOUNT_CODE,
        # title потрапляє в призначення платежу — номер замовлення в ньому
        # допоможе знайти оплату у виписці банку.
        "title": f"Оплата замовлення {order_number}",
        "amount": amount,  # рядок із крапкою: "250.00"
        "invoice_number": order_number,
        "ttl_days": 3,
    }
    headers = {
        "X-API-Secret": FOPPAY_API_SECRET,
        "X-Idempotency-Key": str(uuid.uuid4()),
    }
    async with ClientSession(timeout=ClientTimeout(total=15)) as session:
        async with session.post(FOPPAY_INVOICES_URL, json=payload, headers=headers) as response:
            data = await response.json()
            if response.status != 201:
                raise RuntimeError(f"{data.get('code')}: {data.get('message')}")
            return data


@dp.message(Command("pay"))
async def pay_command(message: Message, command: CommandObject) -> None:
    # Посилання створюється ключем власника — команда лише для менеджерів.
    # У боті для покупців беріть суму із замовлення у вашій БД, а не з тексту повідомлення.
    if message.from_user is None or message.from_user.id not in ALLOWED_USER_IDS:
        await message.answer("Немає доступу.")
        return

    # /pay 250.00 ORD-1024
    args = (command.args or "").split()
    if len(args) != 2:
        await message.answer("Формат: /pay 250.00 ORD-1024")
        return

    amount, order_number = args
    link = await create_payment_link(amount, order_number)
    orders_by_link_id[link["link_id"]] = {
        "order_number": order_number,
        "chat_id": message.chat.id,
    }
    # Надсилайте саме short_url: вебхук спрацьовує на відкриття короткого посилання.
    await message.answer(f"Посилання на оплату: {link['short_url']}")


def verify_foppay_signature(raw_body: bytes, signature_header: str, idempotency_key: str) -> bool:
    timestamps, signatures = [], []
    for item in signature_header.split(","):
        key, _, value = item.strip().partition("=")
        if key == "t":
            timestamps.append(value)
        elif key == "v1":
            signatures.append(value)

    if len(timestamps) != 1 or not TIMESTAMP_FORMAT.fullmatch(timestamps[0]):
        return False
    timestamp = timestamps[0]
    if abs(time.time() - int(timestamp)) > 300:
        return False

    signed = timestamp.encode() + b"." + idempotency_key.encode() + b"." + raw_body
    expected = hmac.new(FOPPAY_WEBHOOK_SECRET.encode(), signed, hashlib.sha256).hexdigest()
    return any(
        SIGNATURE_FORMAT.fullmatch(signature) and hmac.compare_digest(expected, signature)
        for signature in signatures
    )


async def foppay_webhook(request: web.Request) -> web.Response:
    raw_body = await request.read()  # сирі байти — саме їх підписано
    idempotency_key = request.headers.get("X-Idempotency-Key", "")
    if not verify_foppay_signature(raw_body, request.headers.get("X-Signature", ""), idempotency_key):
        return web.Response(status=401)

    if idempotency_key in processed_keys:
        return web.Response(status=200)  # повтор уже обробленої події
    if idempotency_key in in_flight_keys:
        # Ту саму подію саме зараз обробляє паралельний запит.
        # Не 2xx — FopPay повторить пізніше, коли ключ уже буде оброблено.
        return web.Response(status=409)

    in_flight_keys.add(idempotency_key)
    try:
        event = json.loads(raw_body)
        if event.get("event") == "payment_link.opened":
            order = orders_by_link_id.get(event["link_id"])
            if order is not None:
                # Якщо Telegram не відповість, виняток дасть 500, ключ не позначиться
                # обробленим, і FopPay повторить доставку. Якщо ж Telegram прийняв
                # повідомлення, а процес упав до наступного рядка, повтор надішле його
                # ще раз: «рівно один раз» для зовнішнього повідомлення не гарантується.
                await bot.send_message(
                    MANAGER_CHAT_ID,
                    f"Клієнт відкрив посилання на оплату замовлення {order['order_number']}",
                )
        processed_keys.add(idempotency_key)
    finally:
        in_flight_keys.discard(idempotency_key)

    return web.Response(status=200)


async def main() -> None:
    app = web.Application()
    app.router.add_post("/foppay/webhook", foppay_webhook)
    runner = web.AppRunner(app)
    await runner.setup()
    # Слухаємо локально; назовні — nginx/Caddy з HTTPS на порту 443.
    await web.TCPSite(runner, "127.0.0.1", 8080).start()
    try:
        await dp.start_polling(bot)
    finally:
        await runner.cleanup()


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

location /foppay/webhook {
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $host;
}