xync-bot 0.3.7.dev4__py3-none-any.whl → 0.3.24.dev4__py3-none-any.whl

xync_bot/__init__.py

@@ -5,10 +5,11 @@ from PGram import Bot
 from aiogram.client.default import DefaultBotProperties
 from x_model import init_db
 
-from xync_bot.routers.cond import cr
+from xync_bot.routers import Store
+from xync_bot.routers.cond import cr as cr
 
 # from xync_bot.routers.main import mr
-from xync_bot.routers.pay.main import pay as pay
+from xync_bot.routers.pay.handler import pay as pay
 
 if __name__ == "__main__":
     from xync_bot.loader import TOKEN, TORM
@@ -17,7 +18,9 @@ if __name__ == "__main__":
 
     async def main() -> None:
         cn = await init_db(TORM)
-        bot = Bot(TOKEN, [cr, pay], cn, default=DefaultBotProperties(parse_mode="HTML"))
+        store = Store()
+        store.glob = await Store.Global()
+        bot = Bot(TOKEN, [pay], cn, default=DefaultBotProperties(parse_mode="HTML"), store=store)
         await bot.start()
 
     run(main())

xync_bot/loader.py

@@ -19,3 +19,5 @@ TORM = {
     "use_tz": False,
     "timezone": "UTC",
 }
+
+glob = object

xync_bot/routers/__init__.py

@@ -0,0 +1,77 @@
+from tortoise.functions import Min
+from x_model.func import ArrayAgg
+from xync_schema import models
+
+from xync_bot.routers.pay.dep import flags
+
+
+class SingleStore(type):
+    _store = None
+
+    async def __call__(cls):
+        if not cls._store:
+            cls._store = super(SingleStore, cls).__call__()
+            cls._store.coins = {k: v for k, v in await models.Coin.all().order_by("ticker").values_list("id", "ticker")}
+            curs = {
+                k: v
+                for k, v in await models.Cur.filter(ticker__in=flags.keys())
+                .order_by("ticker")
+                .values_list("id", "ticker")
+            }
+            cls._store.curs = curs
+            cls._store.exs = {k: v for k, v in await models.Ex.all().values_list("id", "name")}
+            cls._store.pms = {
+                k: v
+                for k, v in await models.Pmex.filter(pm__pmcurs__cur_id__in=cls._store.curs.keys())
+                .annotate(sname=Min("name"))
+                .group_by("pm__pmcurs__id")
+                .values_list("pm__pmcurs__id", "sname")
+            }
+            cls._store.coinexs = {
+                c.id: [ex.ex_id for ex in c.coinexs] for c in await models.Coin.all().prefetch_related("coinexs")
+            }
+            cls._store.curpms = {
+                cur_id: ids
+                for cur_id, ids in await models.Pmcur.filter(cur_id__in=curs.keys())
+                .annotate(ids=ArrayAgg("id"))
+                .group_by("cur_id")
+                .values_list("cur_id", "ids")
+            }
+
+        return cls._store
+
+
+class Store:
+    class Global(metaclass=SingleStore):
+        coins: dict[int, str]  # id:ticker
+        curs: dict[int, str]  # id:ticker
+        exs: dict[int, str]  # id:name
+        coinexs: dict[int, list[int]]  # id:[ex_ids]
+        pms: dict[int, str]  # pmcur_id:name
+        curpms: dict[int, list[int]]  # id:[pmcur_ids]
+
+    class Permanent:
+        msg_id: int = None
+        user: models.User = None
+        actors: dict[int, models.Actor] = None  # key=ex_id
+
+    class Current:
+        is_target: bool = None
+        is_fiat: bool = None
+
+    class Payment:
+        t_cur_id: int = None
+        s_cur_id: int = None
+        t_coin_id: int = None
+        s_coin_id: int = None
+        t_pm_id: int = None
+        s_pm_id: int = None
+        t_ex_id: int = None
+        s_ex_id: int = None
+        addr: models.Addr = None
+        cred: models.Cred = None
+
+    glob: Global
+    perm: Permanent = Permanent()
+    pay: Payment = Payment()
+    curr: Current = Current()

xync_bot/routers/pay/cd.py

@@ -0,0 +1,48 @@
+from aiogram.filters.callback_data import CallbackData
+
+from xync_bot.routers.pay.dep import PayStep, ActionType
+
+
+class TargetType(CallbackData, prefix="target"):
+    is_fiat: int  # bool
+    is_target: int  # bool
+
+
+class Cur(CallbackData, prefix="cur"):
+    id: int
+    is_target: int  # bool
+
+
+class Coin(CallbackData, prefix="coin"):
+    id: int
+    is_target: int  # bool
+
+
+class Cred(CallbackData, prefix="cred"):
+    id: int
+
+
+class Ex(CallbackData, prefix="ex"):
+    id: int
+    is_target: int  # bool
+
+
+class Pm(CallbackData, prefix="pm"):
+    pmcur_id: int
+    is_target: bool
+
+
+class Ppo(CallbackData, prefix="ppo"):
+    num: int
+
+
+class PayNav(CallbackData, prefix="pay_nav"):
+    to: PayStep
+
+
+class Time(CallbackData, prefix="time"):
+    minutes: int  # время в минутах
+
+
+class Action(CallbackData, prefix="action"):
+    act: ActionType  # "received" или "not_received"

xync_bot/routers/pay/dep.py

@@ -0,0 +1,70 @@
+from enum import IntEnum
+
+from aiogram.fsm.state import StatesGroup, State
+
+
+class Report(StatesGroup):
+    text = State()
+
+
+class CredState(StatesGroup):
+    detail = State()
+    name = State()
+
+
+class PaymentState(StatesGroup):
+    amount = State()
+    timer = State()
+    timer_active = State()
+
+
+class ActionType(IntEnum):
+    """Цель (назначение) платежа (target)"""
+
+    sent = 1  # Отправил
+    received = 2  # Получил
+    not_received = 3  # Не получил
+
+
+class PayStep(IntEnum):
+    """Цель (назначение) платежа (target)"""
+
+    t_type = 1  # Выбор типа
+    t_cur = 2  # Выбор валюты
+    t_coin = 3  # Выбор монеты
+    t_pm = 4  # Выбор платежки
+    t_ex = 5  # Выбор биржи
+    t_cred_dtl = 6  # Ввод номера карты
+    t_cred_name = 7  # Ввод имени
+    # t_addr = 8 # todo: позже добавим: Выбор/ввод крипто кошелька
+    t_amount = 9  # Ввод суммы
+    """ Источник платежа (source) """
+    s_type = 10  # Выбор типа
+    s_cur = 11  # Выбор типа
+    s_pm = 12  # Выбор типа
+    s_coin = 13  # Выбор типа
+    s_ex = 14  # Выбор типа
+    ppo = 15  # Выбор возможности разбивки платежа
+    urgency = 16  # Выбор срочности получения платежа
+    pending_send = 17  # Ожидание отправки (если мы платим фиатом)
+    pending_confirm = 18  # Ожидание пока на той стороне подтвердят получение нашего фиата (если мы платим фиатом)
+    pending_receive = 19  # Ожидание поступления (если мы получаем фиат)
+
+
+flags = {
+    "RUB": "🇷🇺",
+    "THB": "🇹🇭",
+    "IDR": "🇮🇩",
+    "TRY": "🇹🇷",
+    "GEL": "🇬🇪",
+    "VND": "🇻🇳",
+    "AED": "🇦🇪",
+    "AMD": "🇦🇲",
+    "AZN": "🇦🇿",
+    "CNY": "🇨🇳",
+    "EUR": "🇪🇺",
+    "HKD": "🇭🇰",
+    "INR": "🇮🇳",
+    "PHP": "🇵🇭",
+    "USD": "🇺🇸",
+}

xync_bot/routers/pay/handler.py

@@ -0,0 +1,297 @@
+from asyncio import create_task
+from datetime import timedelta, datetime
+
+import PGram
+from aiogram import Router, F
+from aiogram.filters import Command
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from xync_schema import models
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from xync_bot.routers.pay import cd, dep, window
+
+pay = Router()
+
+
+@pay.message(Command("pay"))
+async def h_start(msg: Message):
+    """Step 1: Select target type"""
+    msg.bot.store.curr.is_target = True
+    await msg.delete()
+    await window.type_select(msg)
+
+
+@pay.callback_query(cd.TargetType.filter(F.is_fiat))
+async def h_got_fiat_type(query: CallbackQuery, bot: PGram):
+    """Step 2f: Select cur"""
+    await query.answer("Понял, фиат")
+    bot.store.curr.is_fiat = True
+    await window.cur_select(query.message)
+
+
+@pay.callback_query(cd.TargetType.filter(F.is_fiat.__eq__(0)))
+async def h_got_crypto_type(query: CallbackQuery, bot: PGram):
+    """Step 2c: Select coin"""
+    bot.store.curr.is_fiat = False
+    await query.answer("Понял, крипта")
+    await window.coin_select(query.message)
+
+
+@pay.callback_query(cd.Coin.filter())
+async def h_got_coin(query: CallbackQuery, callback_data: cd.Coin, bot: PGram):
+    """Step 3c: Select target ex"""
+    setattr(bot.store.curr, ("t" if bot.store.curr.is_target else "s") + "_coin_id", callback_data.id)
+    await query.answer("Эта монета есть на следующих биржах")
+    await window.ex_select(query.message)
+
+
+@pay.callback_query(cd.Cur.filter())
+async def h_got_cur(query: CallbackQuery, callback_data: cd.Cur, bot: PGram):
+    """Step 3f: Select target pm"""
+    setattr(bot.store.curr, ("t" if bot.store.curr.is_target else "s") + "_cur_id", callback_data.id)
+    await query.answer("Вот платежные системы доступные для этой валюты")
+    await window.pm(query.message)
+
+
+@pay.callback_query(cd.Pm.filter(F.is_target))
+async def h_got_target_pm(query: CallbackQuery, callback_data: cd.Pm, state: FSMContext):
+    """Step 4f: Fill target cred.detail"""
+    await query.message.delete()
+    await state.update_data(t_pmcur_id=callback_data.pmcur_id, t_name=callback_data.name)
+    await query.answer("Теперь нужны реквизиты")
+    await window.fill_cred_dtl(query.message, state)
+
+
+@pay.callback_query(cd.Cred.filter())
+async def h_got_cred(query: CallbackQuery, callback_data: cd.Cred, state: FSMContext):
+    await query.message.delete()
+    await state.update_data(cred_id=callback_data.id)
+    await query.answer("Теперь нужна сумма")
+    await window.amount(query.message, state)
+
+
+@pay.message(dep.CredState.detail)
+async def h_got_cred_dtl(msg: Message, state: FSMContext):
+    """Step 4.1f: Fill target cred.name"""
+    while True:
+        if msg.text.isdigit():
+            await state.update_data(detail=int(msg.text))
+            break
+        else:
+            await msg.answer("Пожалуйста, введите корректное число")
+            return
+    await window.fill_cred_name(msg, state)
+
+
+@pay.message(dep.CredState.name)
+async def h_got_cred_name(msg: Message, state: FSMContext):
+    """Step 5f: Save target cred"""
+    data = await state.get_data()
+    await state.set_state(None)
+    cred, _ = await models.Cred.update_or_create(
+        {"name": msg.text}, detail=data["detail"], person_id=data["person_id"], pmcur_id=data["t_pmcur_id"]
+    )
+    await state.update_data(cred_id=cred.id)
+    await window.amount(msg, state)
+
+
+@pay.callback_query(cd.Ex.filter())
+async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext):
+    """Step 4c: Save target"""
+    await query.message.delete()
+    if is_target := await state.get_value("is_target"):
+        await state.update_data(t_name=callback_data.name)
+    await state.update_data({("t" if is_target else "s") + "_ex_id": callback_data.id})
+    await query.answer(f"Биржа {callback_data.name} выбрана")
+    await (window.amount(query.message, state) if is_target else window.set_ppo(query.message))
+
+
+@pay.message(dep.PaymentState.amount)
+async def h_got_amount(msg: Message, state: FSMContext):
+    """Step 6: Save target amount"""
+    while True:
+        if msg.text.isdigit():
+            await state.update_data(amount=int(msg.text))
+            break
+        else:
+            await msg.answer("Пожалуйста, введите корректное число")
+            return
+    await state.set_state(None)
+    """Step 7: Select source type"""
+    await state.update_data(is_target=False)
+    if await state.get_value("is_fiat"):
+        await window.type_select(msg, False)
+    else:
+        await window.cur_select(msg, state)  # сразу выбор валюты источника, тк если цель крипта
+
+
+@pay.callback_query(cd.Pm.filter(F.is_target.__eq__(0)))
+async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm, state: FSMContext):
+    await query.message.delete()
+    await state.update_data(s_pmcur_id=callback_data.pmcur_id)
+    await query.answer(callback_data.name)
+    await window.set_ppo(query.message)
+
+
+@pay.callback_query(cd.Ppo.filter())
+async def h_got_ppo(query: CallbackQuery, state: FSMContext, callback_data: cd.Ppo):
+    await query.message.delete()
+    await state.update_data(ppo=callback_data.num)
+    await query.answer(str(callback_data.num))
+    await window.set_urgency(query.message)
+
+
+@pay.callback_query(cd.Time.filter())
+async def process_time_selection(callback: CallbackQuery, callback_data: cd.Time, state: FSMContext):
+    await callback.answer()
+    pay_until = datetime.now() + timedelta(minutes=callback_data.minutes)
+
+    data = await state.get_data()
+    if ex_id := data.get("t_ex_id", data.get("s_ex_id")):
+        if not (actor_id := data.get("actor_id")):
+            person_id = data.get("person_id")
+            actor_id = await models.Actor.get(ex_id=ex_id, person_id=person_id).values_list("id", flat=True)
+            await state.update_data(actor_id=actor_id)
+        if not (addr_id := data.get("addr_id")):
+            coin_id = data.get("t_coin_id", data.get("s_coin_id"))
+            addr_id = await models.Addr.get(coin_id=coin_id, actor_id=actor_id).values_list("id", flat=True)
+            await state.update_data(addr_id=addr_id)
+    else:
+        addr_id = None
+
+    pay_req = await models.PayReq.create(
+        pay_until=pay_until,
+        amount=data["amount"],
+        parts=data["ppo"],
+        payed_at=None,
+        addr_id=addr_id,
+        cred_id=data["cred_id"],
+        user_id=1,
+    )
+    await state.update_data(
+        timer=callback_data.minutes,
+        timer_active=True,
+        pay_until=pay_until,
+        pay_req_id=pay_req.id,
+    )
+
+    await state.set_state(dep.PaymentState.timer)
+    create_task(window.run_timer(callback.message, state))
+
+
+# ACTIONS
+@pay.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.received)))
+async def payment_confirmed(query: CallbackQuery, state: FSMContext):
+    await query.answer()
+    payed_at = datetime.now()
+    await state.update_data(timer_active=False, payed_at_formatted=payed_at)
+    data = await state.get_data()
+    if data.get("pay_req_id"):
+        pay_req = await models.PayReq.get(id=data["pay_req_id"])
+        pay_req.payed_at = payed_at
+        await pay_req.save()
+
+    builder = InlineKeyboardBuilder()
+    builder.button(text="Новый платеж💸", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    await query.message.answer("✅ Платеж успешно подтвержден", reply_markup=builder.as_markup())
+    await query.message.delete()
+    await state.clear()
+
+
+@pay.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.not_received)))
+async def no_payment(query: CallbackQuery, state: FSMContext):
+    await query.answer()
+    await state.update_data(timer_active=False)
+    await query.message.edit_text("Платеж не получен!")
+    await query.message.answer("укажите детали платежа")
+    await state.clear()
+    await state.set_state(dep.Report.text)
+
+
+@pay.message(dep.Report.text)
+async def payment_not_specified(msg: Message, state: FSMContext):
+    await state.update_data(text=msg.text)
+    data = await state.get_data()
+    complaint_text = (
+        f"Жалоба на неполученный платеж:\n"
+        f"Пользователь: @{msg.from_user.username or msg.from_user.id}\n"
+        f"Детали платежа: {data["text"]}\n"
+        f"Время: {msg.date.strftime('%Y-%m-%d %H:%M:%S')}"
+    )
+    await msg.bot.send_message(chat_id="1779829771", text=complaint_text)
+
+
+# NAVIGATION
+@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_type, cd.PayStep.s_type])))
+async def handle_home(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    await window.type_select(query.message, await state.get_value("is_target"))
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_coin, cd.PayStep.s_coin])))
+async def to_coin_select(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    is_target = await state.get_value("is_target")
+    pref = "t" if is_target else "s"
+    await state.update_data({pref + "_ex_id": None, pref + "_coin_id": None})
+    await window.coin_select(query.message, state)
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_cur, cd.PayStep.s_cur])))
+async def to_cur_select(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    is_target = await state.get_value("is_target")
+    pref = "t" if is_target else "s"
+    await state.update_data({pref + "_pmcur_id": None, pref + "_cur_id": None})
+    await window.cur_select(query.message, state)
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm, cd.PayStep.s_pm])))
+async def to_pm_select(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    await window.pm(query.message, state)
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_dtl)))
+async def back_to_cred_detail(query: CallbackQuery, state: FSMContext):
+    await query.answer()
+    await state.update_data(detail=None)
+    await window.fill_cred_dtl(query.message, state)
+    await query.message.delete()
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_name)))
+async def back_to_cred_name(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    await state.update_data(name=None)
+    await window.fill_cred_name(query.message, state)
+    await query.message.delete()
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_ex, cd.PayStep.s_ex])))
+async def back_to_ex_select(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    await state.update_data({("t" if await state.get_value("is_target") else "s") + "ex_id": None})
+    await window.ex_select(query.message, state)
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_amount)))
+async def back_to_amount(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    await state.update_data(amount=None)
+    await window.amount(query.message, state)
+
+
+@pay.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm])))
+async def back_to_payment(query: CallbackQuery, state: FSMContext):
+    await query.message.delete()
+    await query.answer()
+    await state.update_data(payment=None)
+    await window.pm(query.message, state)

xync_bot/routers/pay/window.py

@@ -0,0 +1,228 @@
+from asyncio import sleep
+
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from xync_schema import models
+
+from xync_bot import Store
+from xync_bot.routers.pay import cd, dep
+
+
+async def type_select(msg: Message):
+    """Step 1: Select type"""
+    ist: bool = msg.bot.store.curr.is_target
+    rm = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="Банковская валюта", callback_data=cd.TargetType(is_fiat=1, is_target=ist).pack()
+                ),
+                InlineKeyboardButton(
+                    text="Крипта", callback_data=cd.TargetType(is_fiat=0, is_target=msg.bot.store.curr.is_target).pack()
+                ),
+            ]
+        ]
+    )
+    txt = "Что нужно?" if msg.bot.store.curr.is_target else "Чем платишь?"
+    if msg.bot.store.perm.msg_id:
+        await msg.edit_text(txt)
+        await msg.edit_reply_markup(reply_markup=rm)
+    else:
+        msg = await msg.answer(txt, reply_markup=rm)
+        msg.bot.store.perm.msg_id = msg.message_id
+
+
+async def cur_select(msg: Message):
+    """Common using cur func"""
+    builder = InlineKeyboardBuilder()
+    ist: bool = msg.bot.store.curr.is_target
+    for cur_id, ticker in msg.bot.store.glob.curs.items():
+        builder.button(text=ticker + dep.flags[ticker], callback_data=cd.Cur(id=cur_id, is_target=ist))
+    builder.button(text="Назад к выбору типа", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(3, 3, 3, 3, 3, 1)
+    sfx = "ую нужно" if ist else "ой платишь"
+    await msg.edit_text("Выбери валюту котор" + sfx)
+    await msg.edit_reply_markup(reply_markup=builder.as_markup())
+
+
+async def coin_select(msg: Message):
+    """Common using coin func"""
+    builder = InlineKeyboardBuilder()
+    store: Store = msg.bot.store
+    for coin_id, ticker in store.glob.coins.items():
+        builder.button(text=ticker, callback_data=cd.Coin(id=coin_id, is_target=store.curr.is_target))
+    builder.button(
+        text="Назад к выбору типа",
+        callback_data=cd.PayNav(to=cd.PayStep.t_type if store.curr.is_target else cd.PayStep.s_type),
+    )
+    builder.adjust(1)
+    sfx = "ую нужно" if store.curr.is_target else "ой платишь"
+    await msg.edit_text("Выберите монету котор" + sfx)
+    await msg.edit_reply_markup(reply_markup=builder.as_markup())
+
+
+async def ex_select(msg: Message):
+    store: Store = msg.bot.store
+    ist = store.curr.is_target
+    coin_id = getattr(store.curr, ("t" if ist else "s") + "_coin_id")
+    builder = InlineKeyboardBuilder()
+    for ex_id in store.glob.coinexs[coin_id]:
+        builder.button(text=store.glob.exs[ex_id], callback_data=cd.Ex(id=ex_id, is_target=ist))
+    builder.button(
+        text="Назад к выбору монеты", callback_data=cd.PayNav(to=cd.PayStep.t_coin if ist else cd.PayStep.s_coin)
+    )
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(1)
+    keyboard = builder.as_markup()
+    await msg.edit_text("На какую биржу?" if ist else "С какой биржи?")
+    await msg.edit_reply_markup(reply_markup=keyboard)
+
+
+async def pm(msg: Message):
+    store: Store = msg.bot.store
+    ist = store.curr.is_target
+    cur_id = getattr(store.curr, ("t" if ist else "s") + "_cur_id")
+    builder = InlineKeyboardBuilder()
+    for pmcur_id in store.glob.curpms[cur_id]:
+        builder.button(text=store.glob.pms[pmcur_id], callback_data=cd.Pm(pmcur_id=pmcur_id, is_target=ist))
+    builder.button(
+        text="Назад к выбору валюты", callback_data=cd.PayNav(to=cd.PayStep.t_cur if ist else cd.PayStep.s_cur)
+    )
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(1)
+    keyboard = builder.as_markup()
+    await msg.edit_text("На какую платежную систему?" if ist else "C какой платежной системы?")
+    await msg.edit_reply_markup(reply_markup=keyboard)
+
+
+async def fill_cred_dtl(msg: Message, state: FSMContext):
+    builder = InlineKeyboardBuilder()
+    data = await state.get_data()
+    if not (person_id := data.get("person_id")):
+        person_id = await models.User.get(username_id=193017646).values_list("person_id", flat=True)
+        await state.update_data(person_id=person_id)
+    pmcur_id = data["t_pmcur_id"]
+    if not (creds := data.get("creds", {}).get(pmcur_id)):
+        creds = await models.Cred.filter(person_id=person_id, pmcur_id=pmcur_id)
+        await state.update_data({"creds": {pmcur_id: creds}})
+    for cred in creds:
+        txt = f"{cred.detail}\n{cred.name}"
+        if cred.extra:
+            txt += f" ({cred.extra})"
+        builder.button(text=txt, callback_data=cd.Cred(id=cred.id))
+
+    builder.button(text="Назад к выбору платежной системы", callback_data=cd.PayNav(to=cd.PayStep.t_pm))
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(2)
+    txt = "Выберите реквизиты куда нужно получить деньги, если в списке нет нужных, то\n"
+    await msg.answer(f"{txt}Введите номер для {await state.get_value('t_name')}:", reply_markup=builder.as_markup())
+    await state.set_state(dep.CredState.detail)
+
+
+async def fill_cred_name(msg: Message, state: FSMContext):
+    await msg.bot.delete_messages(chat_id=msg.chat.id, message_ids=[msg.message_id, msg.message_id - 1])
+    await state.update_data(detail=msg.text)
+    builder = InlineKeyboardBuilder()
+    builder.button(text="Назад к вводу реквизитов", callback_data=cd.PayNav(to=cd.PayStep.t_cred_dtl))
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(2)
+    data = await state.get_data()
+    cur = data["curs"].get(data["t_cur_id"])
+    payment = data["t_name"]
+    detail = data["detail"]
+    await msg.answer(f"{cur}:{payment}:{detail}: Введите имя получателя", reply_markup=builder.as_markup())
+    await state.set_state(dep.CredState.name)
+
+
+async def amount(msg: Message, state: FSMContext):
+    await msg.bot.delete_messages(chat_id=msg.chat.id, message_ids=[msg.message_id, msg.message_id - 1])
+    """Step 5: Filling target amount"""
+    builder = InlineKeyboardBuilder()
+
+    if await state.get_value("is_fiat"):
+        cur_coin = (await state.get_value("curs"))[await state.get_value("t_cur_id")]
+        builder.button(text="Назад к вводу имени", callback_data=cd.PayNav(to=cd.PayStep.t_cred_name))
+    else:
+        cur_coin = (await state.get_value("coins"))[await state.get_value("t_coin_id")]
+        builder.button(text="Назад к выбору биржи", callback_data=cd.PayNav(to=cd.PayStep.t_ex))
+
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(2)
+
+    await msg.answer(
+        f"Введите нужную сумму {cur_coin} для {await state.get_value('t_name')}", reply_markup=builder.as_markup()
+    )
+    await state.set_state(dep.PaymentState.amount)
+
+
+async def set_ppo(msg: Message):
+    rm = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(text="Нет", callback_data="ppo:1"),
+                InlineKeyboardButton(text="Да", callback_data="ppo:2"),
+            ],
+            [InlineKeyboardButton(text="Да хоть на 3", callback_data="ppo:3")],
+        ]
+    )
+    await msg.answer("На 2 платежа сможем разбить?", reply_markup=rm)
+
+
+async def set_urgency(msg: Message):
+    builder = InlineKeyboardBuilder()
+    builder.button(text="1 мин", callback_data=cd.Time(minutes=1))
+    builder.button(text="5 мин", callback_data=cd.Time(minutes=5))
+    builder.button(text="30 мин", callback_data=cd.Time(minutes=30))
+    builder.button(text="3 часа", callback_data=cd.Time(minutes=180))
+    builder.button(text="сутки", callback_data=cd.Time(minutes=60 * 24))
+    builder.button(text="Назад к вводу платежей", callback_data=cd.PayNav(to=cd.PayStep.t_pm))
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(2, 2, 1, 1, 1)
+    await msg.answer("Сколько можешь ждать?", reply_markup=builder.as_markup())
+
+
+async def run_timer(message, state: FSMContext):
+    builder = InlineKeyboardBuilder()
+    builder.button(text="Платеж получен", callback_data=cd.Action(act=cd.ActionType.received))
+
+    data = await state.get_value("timer")
+    seconds = data * 60
+
+    def format(sec):
+        days = sec // (24 * 3600)
+        sec %= 24 * 3600
+        hours = sec // 3600
+        sec %= 3600
+        minutes = sec // 60
+        sec %= 60
+
+        if days > 0:
+            return f"{days}д {hours:02d}:{minutes:02d}:{sec:02d}"
+        elif hours > 0:
+            return f"{hours:02d}:{minutes:02d}:{sec:02d}"
+        else:
+            return f"{minutes:02d}:{sec:02d}"
+
+    try:
+        await message.edit_text(f"⏳ Осталось {format(seconds)}", reply_markup=builder.as_markup())
+    except Exception:
+        return
+
+    while seconds > 0:
+        await sleep(1)
+        seconds -= 1
+        try:
+            await message.edit_text(f"⏳ Осталось {format(seconds)}", reply_markup=builder.as_markup())
+            await state.update_data(timer=seconds)
+        except Exception:
+            break
+
+    if seconds <= 0:
+        builder = InlineKeyboardBuilder()
+        builder.button(text="Платеж получен", callback_data=cd.Action(act=cd.ActionType.received))
+        builder.button(text="Денег нет", callback_data=cd.Action(act=cd.ActionType.not_received))
+        try:
+            await message.edit_text("⏳ Время вышло!", reply_markup=builder.as_markup())
+        except Exception:
+            pass

{xync_bot-0.3.7.dev4.dist-info → xync_bot-0.3.24.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.7.dev4
+Version: 0.3.24.dev4
 Summary: Telegram bot with web app for xync net
 Author-email: Artemiev <mixartemev@gmail.com>
 License-Expression: GPL-3.0-or-later

xync_bot-0.3.24.dev4.dist-info/RECORD

@@ -0,0 +1,20 @@
+xync_bot/__init__.py,sha256=0m9zUYZUJHEJUMb24CU10wYfCIAg8eourNFlBLsHgWU,705
+xync_bot/loader.py,sha256=4ZeR-yVMoOmswdLS0UEBG19K7JVcuvH6WpP-_0yAK3I,573
+xync_bot/shared.py,sha256=MlKkTrsT29l7fF6-qAN9FO14cSuXuOuYxbNY5F4S2w4,137
+xync_bot/typs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xync_bot/routers/__init__.py,sha256=NvHk-tI-27BBtI8HGB95s46xo5_z5jNEYqeEeUfVWw8,2544
+xync_bot/routers/main.py,sha256=FumWa48ORhV77Df6NbEosHfgmFIe_Y2ci6IkJCvU4Zs,9535
+xync_bot/routers/order.py,sha256=ZKWDLyiWrXzcR-aHKLBTBCACwp-P0Vvnr22T-EuLHaM,274
+xync_bot/routers/photo.py,sha256=aq6ImIOoZQYTW-lEy26qjgj5TYAuk4bQjgiCv64mPJs,1203
+xync_bot/routers/vpn.py,sha256=qKK55UrjEZeDvu7ljWXNUFBFgXTPTIEaCT2OAmKWky4,2219
+xync_bot/routers/xicon.png,sha256=O57_kvzhVcCXSoGYZ61m0dW9pizY6gxR8Yj5aeCP0RQ,429283
+xync_bot/routers/cond/__init__.py,sha256=It4djVO8AxXL1I76buRz8yYF12dsjXaa4WNtPdb7CFc,4333
+xync_bot/routers/cond/func.py,sha256=m0NWDKunbqDJQmhv_5UnpjxjRzn78GFG94ThOFLVlQo,4720
+xync_bot/routers/pay/cd.py,sha256=Ia0fN8B6ZPKi45z_k1f7O55C9n4PnX-EhebSHRiszSs,901
+xync_bot/routers/pay/dep.py,sha256=QoOhmqKj8QesiIT6QqEomR2xu83cg9Z8mh6oquJKZnM,2208
+xync_bot/routers/pay/handler.py,sha256=bTczwWws5lQj8sbnw0Vo-uZl5RApAVTSj_SEHsRGUwE,11691
+xync_bot/routers/pay/window.py,sha256=h3jk42RJphD0TtX7IMCrXQERS2jGdRFuBf9oGJjRd0k,10184
+xync_bot-0.3.24.dev4.dist-info/METADATA,sha256=Df0VsJlwjs2TZ9S5S1GJzzfhmOdouuhqmsnem0EqzLk,751
+xync_bot-0.3.24.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xync_bot-0.3.24.dev4.dist-info/top_level.txt,sha256=O2IjMc1ryAf0rwIXWohSNT5Kzcs9johgKRDz8lCC0rs,9
+xync_bot-0.3.24.dev4.dist-info/RECORD,,

xync_bot/routers/pay/main.py

@@ -1,133 +0,0 @@
-from aiogram import Router, F
-from aiogram.filters import Command
-from aiogram.types import Message
-from xync_schema import models
-from aiogram.types import ReplyKeyboardMarkup, KeyboardButton
-from aiogram.utils.keyboard import InlineKeyboardMarkup, InlineKeyboardButton
-from aiogram import types
-
-from aiogram.fsm.state import State, StatesGroup
-from aiogram.fsm.context import FSMContext
-
-pay = Router()
-
-
-class Cred(StatesGroup):
-    detail = State()
-    extra = State()
-
-
-class Addr(StatesGroup):
-    name = State()
-
-
-@pay.message(Command("pay"))
-async def main(msg: Message):
-    start = ReplyKeyboardMarkup(
-        keyboard=[[KeyboardButton(text="крипта"), KeyboardButton(text="валюта (фиат)")]], resize_keyboard=True
-    )
-    await msg.answer("что нужно?", reply_markup=start)
-
-
-@pay.message(F.text == "валюта (фиат)")
-async def cur(msg: types.Message):
-    currencies = await models.Cur.all()
-    buttons = [[InlineKeyboardButton(text=cur.ticker, callback_data=f"cur_{cur.id}")] for cur in currencies]
-    keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-    await msg.answer("Выберите валюту:", reply_markup=keyboard)
-
-
-@pay.message(F.text == "крипта")
-async def coin(msg: types.Message):
-    crypt = await models.Coin.all()
-    buttons = [[InlineKeyboardButton(text=coin.ticker, callback_data=f"coin_{coin.id}")] for coin in crypt]
-    keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-    await msg.answer("Выберите крипту:", reply_markup=keyboard)
-
-
-@pay.callback_query(F.data.startswith("coin_"))
-async def coinex(query: types.CallbackQuery):
-    ticker = query.data.replace("coin_", "")
-    ex_id = await models.Coinex.filter(coin_id=ticker).values_list("ex_id", flat=True)
-    ex = await models.Ex.filter(id__in=ex_id).values_list("name", flat=True)
-    if not ex:
-        await query.message.answer("Такой биржи нет")
-    else:
-        buttons = [[InlineKeyboardButton(text=i, callback_data=f"ad_{i}")] for i in ex]
-        keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-        await query.message.answer("Выберите биржу", reply_markup=keyboard)
-
-
-@pay.callback_query(F.data.startswith("cur_"))
-async def pm(query: types.CallbackQuery, state: FSMContext):
-    ticker = query.data.replace("cur_", "")
-    pmcur = await models.Pmcur.filter(cur_id=ticker).values_list("pm_id", flat=True)
-    pmex = await models.Pmex.filter(pm_id__in=pmcur).values_list("id", flat=True)
-    pm = await models.PmexBank.filter(pmex_id__in=pmex).values_list("name", flat=True)
-    if not pm:
-        await query.message.answer("Такой платежки нет")
-    else:
-        buttons = [[InlineKeyboardButton(text=i, callback_data=f"pm_{i}")] for i in pm]
-        keyboard = InlineKeyboardMarkup(inline_keyboard=buttons)
-        await query.message.answer("Выберите платежку", reply_markup=keyboard)
-
-
-# 4) для cur
-@pay.callback_query(F.data.startswith("pm_"))
-async def cred(query: types.CallbackQuery, state: FSMContext):
-    name = query.data.replace("pm_", "")
-    await state.update_data(name=name)
-    pmex_id = await models.PmexBank.filter(name=name).values_list("pmex_id", flat=True)
-    pm_id = await models.Pmex.filter(id__in=pmex_id).values_list("pm_id", flat=True)
-    pmcur = await models.Pmcur.get(id__in=pm_id)
-    await state.update_data(pmcur_id=pmcur.id)
-    await query.message.answer("Введите реквизиты")
-    await state.set_state(Cred.detail)
-
-
-@pay.message(Cred.detail)
-async def cred_detail(msg: types.Message, state: FSMContext):
-    user_id = msg.from_user.id
-    # user_id = 193017646
-    person_id = await models.User.get(username_id=user_id)
-    await state.update_data(person_id=person_id.person_id)
-    await state.update_data(detail=msg.text)
-    await msg.answer("Введите доп информацию")
-    await state.set_state(Cred.extra)
-
-
-@pay.message(Cred.extra)
-async def create_cred(msg: types.Message, state: FSMContext):
-    await state.update_data(extra=msg.text)
-    data = await state.get_data()
-    await state.clear()
-    # print(data)
-    data_create = {
-        "detail": data["detail"],
-        "name": data["name"],
-        "extra": data["extra"],
-        "person_id": data["person_id"],
-        "pmcur_id": data["pmcur_id"],
-    }
-    await models.Cred.create(**data_create)
-
-
-# 4) для coin
-@pay.callback_query(F.data.startswith("ad_"))
-async def addr(query: types.CallbackQuery, state: FSMContext):
-    name = query.data.replace("ad_", "")
-    ex = await models.Ex.filter(name=name).values_list("id", flat=True)
-    await state.update_data(ex_id=ex)
-    await query.message.answer("Введите имя")
-    await state.set_state(Addr.name)
-
-
-@pay.message(Addr.name)
-async def addr_name(msg: types.Message, state: FSMContext):
-    # user_id = msg.from_user.id
-    user_id = 193017646
-    person_id = await models.User.get(username_id=user_id)
-    await state.update_data(person_id=person_id.person_id)
-    await state.update_data(name=msg.text)
-    await state.get_data()
-    await state.clear()

xync_bot-0.3.7.dev4.dist-info/RECORD

@@ -1,17 +0,0 @@
-xync_bot/__init__.py,sha256=wiZpB8Bv4jjaHeGS_yt9HKtuLTHwx4nCsCgcrMesCFE,586
-xync_bot/loader.py,sha256=wnhRRMJ6KSFAFZnDBGg9mbbktq34VHtcNSt89WuPn04,558
-xync_bot/shared.py,sha256=MlKkTrsT29l7fF6-qAN9FO14cSuXuOuYxbNY5F4S2w4,137
-xync_bot/typs.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xync_bot/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xync_bot/routers/main.py,sha256=FumWa48ORhV77Df6NbEosHfgmFIe_Y2ci6IkJCvU4Zs,9535
-xync_bot/routers/order.py,sha256=ZKWDLyiWrXzcR-aHKLBTBCACwp-P0Vvnr22T-EuLHaM,274
-xync_bot/routers/photo.py,sha256=aq6ImIOoZQYTW-lEy26qjgj5TYAuk4bQjgiCv64mPJs,1203
-xync_bot/routers/vpn.py,sha256=qKK55UrjEZeDvu7ljWXNUFBFgXTPTIEaCT2OAmKWky4,2219
-xync_bot/routers/xicon.png,sha256=O57_kvzhVcCXSoGYZ61m0dW9pizY6gxR8Yj5aeCP0RQ,429283
-xync_bot/routers/cond/__init__.py,sha256=It4djVO8AxXL1I76buRz8yYF12dsjXaa4WNtPdb7CFc,4333
-xync_bot/routers/cond/func.py,sha256=m0NWDKunbqDJQmhv_5UnpjxjRzn78GFG94ThOFLVlQo,4720
-xync_bot/routers/pay/main.py,sha256=5swOvvKF2XA2UAwHewdidMoMONV4acTwR0mPyzA0ezA,5116
-xync_bot-0.3.7.dev4.dist-info/METADATA,sha256=4T0s0NFTh9QNuQ3JpSLKarYsXY-OZjN0vTjGrkNbeQI,750
-xync_bot-0.3.7.dev4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xync_bot-0.3.7.dev4.dist-info/top_level.txt,sha256=O2IjMc1ryAf0rwIXWohSNT5Kzcs9johgKRDz8lCC0rs,9
-xync_bot-0.3.7.dev4.dist-info/RECORD,,