xync-bot 0.3.24.dev9__tar.gz → 0.3.24.dev12__tar.gz

{xync_bot-0.3.24.dev9/xync_bot.egg-info → xync_bot-0.3.24.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.24.dev9
+Version: 0.3.24.dev12
 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.dev9 → xync_bot-0.3.24.dev12}/xync_bot/__init__.py

@@ -5,8 +5,8 @@ from PGram import Bot
 from aiogram.client.default import DefaultBotProperties
 from x_model import init_db
 
-from xync_bot.routers import Store
 from xync_bot.routers.cond import cr as cr
+from xync_bot.routers.pay.dep import Store
 
 # from xync_bot.routers.main import mr
 from xync_bot.routers.pay.handler import pay as pay

{xync_bot-0.3.24.dev9 → xync_bot-0.3.24.dev12}/xync_bot/routers/pay/cd.py

@@ -34,6 +34,7 @@ class Pm(CallbackData, prefix="pm"):
 
 class Ppo(CallbackData, prefix="ppo"):
     num: int
+    is_target: int  # bool
 
 
 class PayNav(CallbackData, prefix="pay_nav"):

xync_bot-0.3.24.dev12/xync_bot/routers/pay/dep.py

@@ -0,0 +1,290 @@
+import logging
+from asyncio import gather
+from enum import IntEnum
+
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.fsm.state import StatesGroup, State
+from aiogram.types import Message, InlineKeyboardMarkup
+from pyrogram.types import CallbackQuery
+from tortoise.functions import Min
+from x_auth.enums import Role
+from x_model.func import ArrayAgg
+from xync_schema import models
+
+
+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": "🇺🇸",
+}
+
+
+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 = {c.id: c for c in await models.Cur.filter(ticker__in=flags.keys()).order_by("ticker")}
+            cls._store.curs = curs
+            cls._store.exs = {k: v for k, v in await models.Ex.all().values_list("id", "name")}
+            cls._store.pmcurs = {
+                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")
+            }
+            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, models.Cur]  # id:Cur
+        exs: dict[int, str]  # id:name
+        coinexs: dict[int, list[int]]  # id:[ex_ids]
+        pmcurs: 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, int] = None  # key=ex_id
+        creds: dict[int, models.Cred] = None  # key=cred_id
+        cur_creds: dict[int, list[int]] = None  # pmcur_id:[cred_ids]
+
+    class Current:
+        is_target: bool = True
+        is_fiat: bool = None
+        msg_to_del: Message = None
+
+    class Payment:
+        t_cur_id: int = None
+        s_cur_id: int = None
+        t_coin_id: int = None
+        s_coin_id: int = None
+        t_pmcur_id: int = None
+        s_pmcur_id: int = None
+        t_ex_id: int = None
+        s_ex_id: int = None
+        amount: int | float = None
+        ppo: int = 1
+        addr_id: int = None
+        cred_dtl: str = None
+        cred_id: int = None
+        urg: int = 5
+        pr_id: int = None
+
+    glob: Global
+    perm: Permanent = Permanent()
+    pay: Payment = Payment()
+    curr: Current = Current()
+
+
+async def fill_creds(person_id: int) -> tuple[dict[int, models.Cred], dict[int, list[int]]]:
+    cq = models.Cred.filter(person_id=person_id)
+    creds = {c.id: c for c in await cq}
+    cur_creds = {
+        pci: ids
+        for pci, ids in await cq.annotate(ids=ArrayAgg("id")).group_by("pmcur_id").values_list("pmcur_id", "ids")
+    }
+    return creds, cur_creds
+
+
+async def fill_actors(person_id: int) -> dict[int, int]:
+    ex_actors = {
+        # todo: check len(ids) == 1
+        exi: ids[0]
+        for exi, ids in await models.Actor.filter(person_id=person_id)
+        .annotate(ids=ArrayAgg("id"))
+        .group_by("ex_id")
+        .values_list("ex_id", "ids")
+    }
+    return ex_actors
+
+
+async def edit(msg: Message, txt: str, rm: InlineKeyboardMarkup):
+    await gather(msg.edit_text(txt), msg.edit_reply_markup(reply_markup=rm))
+
+
+async def ans(cbq: CallbackQuery, txt: str = None):
+    await cbq.answer(txt, cache_time=0)
+
+
+async def dlt(msg: Message):
+    await msg.delete()
+
+
+async def edt(msg: Message, txt: str, rm: InlineKeyboardMarkup):
+    if msg.message_id == msg.bot.store.perm.msg_id:
+        await msg.edit_text(txt, reply_markup=rm)
+    else:  # окно вызвано в ответ на текст, а не кнопку
+        try:
+            await msg.bot.edit_message_text(
+                txt, chat_id=msg.chat.id, message_id=msg.bot.store.perm.msg_id, reply_markup=rm
+            )
+        except TelegramBadRequest as e:
+            print(msg.bot.store.perm.msg_id, e)
+
+
+async def xync_have_coin_amount(store: Store) -> bool:
+    assets = await models.Asset.filter(
+        addr__coin_id=store.pay.t_coin_id, addr__ex_id=store.pay.t_ex_id, addr__actor__user__role__in=Role.ADMIN
+    )
+    return store.pay.amount <= sum(a.free for a in assets)
+
+
+async def client_have_coin_amount(store: Store) -> bool:
+    assets = await models.Asset.filter(addr__coin_id=store.pay.t_coin_id, addr__actor_id__in=store.perm.actors.values())
+    return store.pay.amount <= sum(a.free for a in assets)
+
+
+async def need_ppo(store: Store):
+    cur_id = getattr(store.pay, ("t" if store.curr.is_target else "s") + "_cur_id")
+    usd_amount = store.pay.amount * store.glob.curs[cur_id].rate
+    if usd_amount < 50:
+        return 0
+    elif usd_amount > 100:
+        return 2
+    else:
+        return 1
+
+
+async def client_target_repr(store: Store) -> tuple[models.Addr | models.Cred, str]:
+    if store.pay.t_ex_id:
+        addr_to = (
+            await models.Addr.filter(
+                actor__ex_id=store.pay.t_ex_id, coin_id=store.pay.t_coin_id, actor__user=store.perm.user
+            )
+            .prefetch_related("actor")
+            .first()
+        )
+        ex, coin = store.glob.exs[store.pay.s_ex_id], store.glob.coins[store.pay.s_coin_id]
+        if not addr_to:
+            logging.error(f"No {coin} addr in {ex} for user: {store.perm.user.username_id}")
+        return addr_to, f"{coin} на {ex} по id: `{addr_to.actor.exid}`"
+    # иначе: реквизиты для фиата
+    cur, pm = store.glob.curs[store.pay.t_cur_id], store.glob.pmcurs[store.pay.t_pmcur_id]
+    cred = store.perm.creds[store.pay.cred_id]
+    return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
+
+
+async def get_merch_target(store: Store) -> tuple[models.Addr | models.Cred, str]:
+    if store.pay.s_ex_id:
+        addr_in = (
+            await models.Addr.filter(
+                actor__ex_id=store.pay.s_ex_id, coin_id=store.pay.s_coin_id, actor__user__role__gte=Role.ADMIN
+            )
+            .prefetch_related("actor")
+            .first()
+        )
+        ex, coin = store.glob.exs[store.pay.s_ex_id], store.glob.coins[store.pay.s_coin_id]
+        if not addr_in:
+            logging.error(f"No {coin} addr in {ex}")
+        return addr_in, f"{coin} на {ex} по id: `{addr_in.actor.exid}`"
+    # иначе: реквизиты для фиатной оплаты
+    s_pmcur = await models.Pmcur.get(id=store.pay.s_pmcur_id).prefetch_related("pm__grp")
+    cred = await models.Cred.filter(
+        **({"pmcur__pm__grp": s_pmcur.pm.grp} if s_pmcur.pm.grp else {"pmcur_id": store.pay.s_pmcur_id}),
+        person__user__role__gte=Role.ADMIN,
+    ).first()  # todo: order by fiat.target-fiat.amount
+    cur, pm = store.glob.curs[store.pay.s_cur_id], store.glob.pmcurs[store.pay.s_pmcur_id]
+    if not cred:
+        logging.error(f"No {cur.ticker} cred for {pm}")
+    return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
+
+
+def fmt_sec(sec: int):
+    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}"

{xync_bot-0.3.24.dev9 → xync_bot-0.3.24.dev12}/xync_bot/routers/pay/handler.py

@@ -1,15 +1,14 @@
-from asyncio import create_task, gather
-from datetime import timedelta, datetime
+from asyncio import gather
+from datetime import 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_bot.routers.pay.dep import fill_creds, fill_actors, dlt, ans
+from xync_bot.routers.pay.dep import fill_creds, fill_actors, dlt, ans, Store
 from xync_schema import models
 
-from xync_bot import Store
 from xync_bot.routers.pay import cd, dep, window
 
 pay = Router()
@@ -23,6 +22,7 @@ async def h_start(msg: Message):
     await gather(window.type_select(msg), dlt(msg))
     store.perm.user = await models.User.get(username_id=msg.from_user.id)
     store.perm.creds, store.perm.cur_creds = await fill_creds(store.perm.user.person_id)
+    store.perm.actors = await fill_actors(store.perm.user.person_id)
 
 
 @pay.callback_query(cd.MoneyType.filter(F.is_fiat))
@@ -36,9 +36,7 @@ async def h_got_fiat_type(query: CallbackQuery, bot: PGram):
 async def h_got_crypto_type(query: CallbackQuery, bot: PGram):
     """Step 2c: Select coin"""
     bot.store.curr.is_fiat = False
-    (bot.store.perm.actors, bot.store.perm.ex_actors), *_ = await gather(
-        fill_actors(bot.store.perm.user.person_id), window.coin_select(query.message), ans(query, "Понял, крипта")
-    )
+    await gather(window.coin_select(query.message), ans(query, "Понял, крипта"))
 
 
 @pay.callback_query(cd.Coin.filter())
@@ -91,7 +89,8 @@ async def h_got_cred_name(msg: Message, state: FSMContext):
         person_id=store.perm.user.person_id,
         pmcur_id=store.pay.t_pmcur_id,
     )
-    msg.bot.store.pay.cred_id = cred.id
+    store.pay.cred_id = cred.id
+    store.perm.creds[cred.id] = cred
     await gather(window.amount(msg), dlt(msg), state.set_state(dep.PaymentState.amount))
 
 
@@ -101,11 +100,15 @@ async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext
     store: Store = query.message.bot.store
     ist = store.curr.is_target
     setattr(store.pay, ("t" if ist else "s") + "_ex_id", callback_data.id)
-    await gather(
-        (window.amount if ist else window.set_ppo)(query.message),
-        ans(query, f"Биржа {store.glob.exs[callback_data.id]} выбрана"),
-        state.set_state(dep.PaymentState.amount),
-    )
+    if ist:
+        await window.amount(query.message)
+        actor_id = store.perm.actors[store.pay.t_ex_id]
+        addr = await models.Addr.get(coin_id=store.pay.t_coin_id, actor_id=actor_id)
+        store.pay.addr_id = addr.id
+    else:
+        await window.set_ppo(query.message)
+    await ans(query, f"Биржа {store.glob.exs[callback_data.id]} выбрана")
+    await state.set_state(dep.PaymentState.amount)
 
 
 @pay.message(dep.PaymentState.amount)
@@ -129,7 +132,7 @@ async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm):
     store.pay.s_pmcur_id = callback_data.pmcur_id
     await gather(
         window.set_ppo(query.message),
-        ans(query, store.glob.pms[callback_data.pmcur_id]),
+        ans(query, store.glob.pmcurs[callback_data.pmcur_id]),
     )
 
 
@@ -140,39 +143,10 @@ async def h_got_ppo(query: CallbackQuery, callback_data: cd.Ppo):
 
 
 @pay.callback_query(cd.Time.filter())
-async def process_time_selection(query: CallbackQuery, callback_data: cd.Time, state: FSMContext):
-    store: Store = query.message.bot.store
-
-    pay_until = datetime.now() + timedelta(minutes=callback_data.minutes)
-
-    if ex_id := (store.pay.t_ex_id or store.pay.s_ex_id):
-        actor_id = store.perm.ex_actors[ex_id]
-        if not (addr_id := store.pay.addr_id):
-            coin_id = store.pay.t_coin_id or store.pay.s_coin_id
-            addr_id = await models.Addr.get(coin_id=coin_id, actor_id=actor_id).values_list("id", flat=True)
-            store.pay.addr_id = addr_id
-    else:
-        addr_id = None
-    pr_data = dict(
-        pay_until=pay_until,
-        amount=store.pay.amount,
-        parts=store.pay.ppo,
-        payed_at=None,
-        addr_id=addr_id,
-        cred_id=store.pay.cred_id,
-        user=store.perm.user,
-    )
-    (pay_req, _), *__ = await gather(
-        models.PayReq.update_or_create(**pr_data), ans(query, None), state.set_state(dep.PaymentState.timer)
-    )
-
-    await state.update_data(
-        timer=callback_data.minutes,
-        timer_active=True,
-        pay_until=pay_until,
-        pay_req_id=pay_req.id,
-    )
-    create_task(window.run_timer(query.message, state))
+async def h_got_urgency(query: CallbackQuery, callback_data: cd.Time):
+    query.message.bot.store.pay.urg = callback_data.minutes
+    await window.create_payreq(query.message)
+    await ans(query, f"Ok {callback_data.minutes} min.")
 
 
 # ACTIONS

{xync_bot-0.3.24.dev9 → xync_bot-0.3.24.dev12}/xync_bot/routers/pay/window.py

@@ -1,11 +1,21 @@
 from asyncio import sleep
+from datetime import datetime, timedelta
 
 from aiogram.fsm.context import FSMContext
 from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
 from aiogram.utils.keyboard import InlineKeyboardBuilder
-from xync_bot.routers.pay.dep import edt
+from xync_schema import models
+
+from xync_bot.routers.pay.dep import (
+    edt,
+    need_ppo,
+    Store,
+    get_merch_target,
+    fmt_sec,
+    client_have_coin_amount,
+    client_target_repr,
+)
 
-from xync_bot import Store
 from xync_bot.routers.pay import cd, dep
 
 
@@ -25,7 +35,16 @@ async def type_select(msg: Message):
             ]
         ]
     )
-    txt = "Что нужно?" if store.curr.is_target else "Чем платишь?"
+    if store.curr.is_target:
+        txt = "Что нужно?"
+    else:
+        if store.pay.t_coin_id:
+            inf = f"{store.glob.coins[store.pay.t_coin_id]} на {store.glob.exs[store.pay.t_ex_id]}:{store.pay.addr_id}"
+        else:
+            cur = store.glob.curs[store.pay.t_cur_id].ticker
+            cred: models.Cred = store.perm.creds[store.pay.cred_id]
+            inf = f"{cur} на {store.glob.pmcurs[store.pay.t_pmcur_id]}: {cred.repr()}"
+        txt = f"Нужен платеж: {store.pay.amount} {inf}\nЧем будете платить?"
     if store.perm.msg_id:
         await edt(msg, txt, rm)
     else:
@@ -37,8 +56,8 @@ 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))
+    for cur_id, cur in msg.bot.store.glob.curs.items():
+        builder.button(text=cur.ticker + dep.flags[cur.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 "ой платишь"
@@ -82,7 +101,7 @@ async def pm(msg: Message):
     cur_id = getattr(store.pay, ("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=store.glob.pmcurs[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)
     )
@@ -99,10 +118,7 @@ async def fill_cred_dtl(msg: Message):
     if cred_ids := store.perm.cur_creds.get(store.pay.t_pmcur_id):
         for cred_id in cred_ids:
             cred = store.perm.creds[cred_id]
-            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=cred.repr(), callback_data=cd.Cred(id=cred_id))
         txt = "Выберите реквизиты куда нужно получить деньги, если в списке нет нужных, то\nв"
 
     builder.button(text="Назад к выбору платежной системы", callback_data=cd.PayNav(to=cd.PayStep.t_pm))
@@ -110,7 +126,7 @@ async def fill_cred_dtl(msg: Message):
     builder.adjust(2)
 
     await msg.edit_text(
-        f"{txt}ведите номер для {store.glob.pms[store.pay.t_pmcur_id]}:", reply_markup=builder.as_markup()
+        f"{txt}ведите номер для {store.glob.pmcurs[store.pay.t_pmcur_id]}:", reply_markup=builder.as_markup()
     )
 
 
@@ -121,9 +137,9 @@ async def fill_cred_name(msg: Message):
     builder.adjust(2)
     store: Store = msg.bot.store
     cur = store.glob.curs[store.pay.t_cur_id]
-    payment = store.glob.pms[store.pay.t_pmcur_id]
+    payment = store.glob.pmcurs[store.pay.t_pmcur_id]
     detail = store.pay.cred_dtl
-    await edt(msg, f"{cur}:{payment}:{detail}: Введите имя получателя", builder.as_markup())
+    await edt(msg, f"{cur.ticker}:{payment}:{detail}: Введите имя получателя", builder.as_markup())
 
 
 async def amount(msg: Message):
@@ -131,9 +147,9 @@ async def amount(msg: Message):
     builder = InlineKeyboardBuilder()
     store: Store = msg.bot.store
     if store.curr.is_fiat:
-        cur_coin = store.glob.curs[store.pay.t_cur_id]
+        cur_coin = store.glob.curs[store.pay.t_cur_id].ticker
         builder.button(text="Назад к вводу имени", callback_data=cd.PayNav(to=cd.PayStep.t_cred_name))
-        t_name = store.glob.pms[store.pay.t_pmcur_id]
+        t_name = store.glob.pmcurs[store.pay.t_pmcur_id]
     else:
         cur_coin = store.glob.coins[store.pay.t_coin_id]
         builder.button(text="Назад к выбору биржи", callback_data=cd.PayNav(to=cd.PayStep.t_ex))
@@ -146,55 +162,76 @@ async def amount(msg: Message):
 
 
 async def set_ppo(msg: Message):
+    store: Store = msg.bot.store
+    ist = store.curr.is_target
+    if nppo := await need_ppo(store):
+        builder = InlineKeyboardBuilder()
+        builder.button(text="Нет", callback_data=cd.Ppo(num=1, is_target=ist)).button(
+            text="Да", callback_data=cd.Ppo(num=2, is_target=ist)
+        )
+        if nppo > 1:
+            builder.button(text="Да хоть 3мя", callback_data=cd.Ppo(num=3, is_target=ist))
+        builder.adjust(2)
+        await edt(msg, f"2мя платежами сможете {'принять' if ist else 'отравить'}?", builder.as_markup())
+    elif ist:
+        store.curr.is_target = False
+        await type_select(msg)
+    else:
+        await set_urgency(msg)
+
+
+async def set_urgency(msg: Message):
+    store: Store = msg.bot.store
+    if not store.curr.is_fiat or await client_have_coin_amount(store):
+        return await create_payreq(msg)  # next
+    builder = InlineKeyboardBuilder()
+    (
+        builder.button(text="1 мин", callback_data=cd.Time(minutes=1))
+        .button(text="5 мин", callback_data=cd.Time(minutes=5))
+        .button(text="30 мин", callback_data=cd.Time(minutes=30))
+        .button(text="3 часа", callback_data=cd.Time(minutes=180))
+        .button(text="сутки", callback_data=cd.Time(minutes=60 * 24))
+        .button(text="Назад к выбору платежной\nсистемы для отправки", callback_data=cd.PayNav(to=cd.PayStep.s_pm))
+        .button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+        .adjust(2, 2, 1, 1, 1)
+    )
+    return await edt(msg, "Сколько можешь ждать?", builder.as_markup())
+
+
+async def create_payreq(msg: Message):
+    store: Store = msg.bot.store
+    pay_req, _ = await models.PayReq.update_or_create(
+        {"pay_until": datetime.now() + timedelta(minutes=store.pay.urg)},
+        amount=store.pay.amount,
+        parts=store.pay.ppo,
+        addr_id=store.pay.addr_id,
+        cred_id=store.pay.cred_id,
+        user=store.perm.user,
+    )
+    store.pay.pr_id = pay_req.id
+    inp, txt = await get_merch_target(store)
+    ccred, ctxt = await client_target_repr(store)
+    txt += f"\nИ получите {store.pay.amount} {ctxt} в течение {fmt_sec(store.pay.urg * 60)}"
+    if store.pay.ppo > 1:
+        txt += f" максимум {store.pay.ppo} платежами"
     rm = InlineKeyboardMarkup(
         inline_keyboard=[
-            [
-                InlineKeyboardButton(text="Нет", callback_data="ppo:1"),
-                InlineKeyboardButton(text="Да", callback_data="ppo:2"),
-            ],
-            [InlineKeyboardButton(text="Да хоть на 3", callback_data="ppo:3")],
+            [InlineKeyboardButton(text="Отправил", callback_data=cd.Action(act=cd.ActionType.sent).pack())],
         ]
     )
-    await msg.edit_text("На 2 платежа сможем разбить?", reply_markup=rm)
+    await edt(msg, f"Отправьте {100500} " + txt, rm)  # todo: get rate
 
-
-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.edit_text("Сколько можешь ждать?", reply_markup=builder.as_markup())
+    # create_task(window.run_timer(msg))В
 
 
 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}"
+    seconds = await state.get_value("timer") * 60
 
     try:
-        await message.edit_text(f"⏳ Осталось {format(seconds)}", reply_markup=builder.as_markup())
+        await message.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
     except Exception:
         return
 
@@ -202,7 +239,7 @@ async def run_timer(message, state: FSMContext):
         await sleep(1)
         seconds -= 1
         try:
-            await message.edit_text(f"⏳ Осталось {format(seconds)}", reply_markup=builder.as_markup())
+            await message.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
             await state.update_data(timer=seconds)
         except Exception:
             break

{xync_bot-0.3.24.dev9 → xync_bot-0.3.24.dev12/xync_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.24.dev9
+Version: 0.3.24.dev12
 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.dev9/xync_bot/routers/__init__.py

@@ -1,98 +0,0 @@
-from aiogram.types import Message
-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")
-            }
-            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=actor_id
-        ex_actors: dict[int, list[int]] = None  # key=ex_id
-        creds: dict[int, models.Cred] = None  # key=cred_id
-        cur_creds: dict[int, list[int]] = None  # pmcur_id:[cred_ids]
-
-    class Current:
-        is_target: bool = True
-        is_fiat: bool = None
-        msg_to_del: Message = None
-
-    class Payment:
-        t_cur_id: int = None
-        s_cur_id: int = None
-        t_coin_id: int = None
-        s_coin_id: int = None
-        t_pmcur_id: int = None
-        s_pmcur_id: int = None
-        t_ex_id: int = None
-        s_ex_id: int = None
-        amount: int | float = None
-        ppo: int = None
-        addr_id: int = None
-        cred_dtl: str = None
-        cred_id: int = None
-
-    class Payreq:
-        id: int = None
-        created_at: int = None
-        payed_at: int = None
-
-    glob: Global
-    perm: Permanent = Permanent()
-    pay: Payment = Payment()
-    pr: Payreq = Payreq()
-    curr: Current = Current()

xync_bot-0.3.24.dev9/xync_bot/routers/pay/dep.py

@@ -1,122 +0,0 @@
-from asyncio import gather
-from enum import IntEnum
-
-from aiogram.exceptions import TelegramBadRequest
-from aiogram.fsm.state import StatesGroup, State
-from aiogram.types import Message, InlineKeyboardMarkup
-from pyrogram.types import CallbackQuery
-from x_model.func import ArrayAgg
-from xync_schema import models
-
-
-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": "🇺🇸",
-}
-
-
-async def fill_creds(person_id: int) -> tuple[dict[int, models.Cred], dict[int, list[int]]]:
-    cq = models.Cred.filter(person_id=person_id)
-    creds = {c.id: c for c in await cq}
-    cur_creds = {
-        pci: ids
-        for pci, ids in await cq.annotate(ids=ArrayAgg("id")).group_by("pmcur_id").values_list("pmcur_id", "ids")
-    }
-    return creds, cur_creds
-
-
-async def fill_actors(person_id: int) -> tuple[dict[int, models.Actor], dict[int, list[int]]]:
-    aq = models.Actor.filter(person_id=person_id)
-    actors = {a.id: a for a in await aq}
-    ex_act_id = {
-        exi: ids[0]
-        for exi, ids in await aq.annotate(ids=ArrayAgg("id"))  # todo: check len(ids) == 1
-        .group_by("ex_id")
-        .values_list("ex_id", "ids")
-    }
-    return actors, ex_act_id
-
-
-async def edit(msg: Message, txt: str, rm: InlineKeyboardMarkup):
-    await gather(msg.edit_text(txt), msg.edit_reply_markup(reply_markup=rm))
-
-
-async def ans(cbq: CallbackQuery, txt: str = None):
-    await cbq.answer(txt, cache_time=0)
-
-
-async def dlt(msg: Message):
-    await msg.delete()
-
-
-async def edt(msg: Message, txt: str, rm: InlineKeyboardMarkup):
-    if msg.message_id == msg.bot.store.perm.msg_id:
-        await msg.edit_text(txt, reply_markup=rm)
-    else:  # окно вызвано в ответ на текст, а не кнопку
-        try:
-            await msg.bot.edit_message_text(
-                txt, chat_id=msg.chat.id, message_id=msg.bot.store.perm.msg_id, reply_markup=rm
-            )
-        except TelegramBadRequest as e:
-            print(msg.bot.store.perm.msg_id, e)