xync-bot 0.3.24.dev3__tar.gz → 0.3.24.dev5__tar.gz

{xync_bot-0.3.24.dev3/xync_bot.egg-info → xync_bot-0.3.24.dev5}/PKG-INFO

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

@@ -0,0 +1,92 @@
+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=ex_id
+        ex_actors: dict[int, list[int]] = None  # key=ex_id
+        creds: dict[int, models.Cred] = None  # key=id
+        cur_creds: dict[int, list[int]] = None  # pmcur_id:[cred_ids]
+
+    class Current:
+        is_target: bool = None
+        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
+
+    glob: Global
+    perm: Permanent = Permanent()
+    pay: Payment = Payment()
+    curr: Current = Current()

{xync_bot-0.3.24.dev3 → xync_bot-0.3.24.dev5}/xync_bot/routers/pay/cd.py

@@ -3,7 +3,7 @@ from aiogram.filters.callback_data import CallbackData
 from xync_bot.routers.pay.dep import PayStep, ActionType
 
 
-class TargetType(CallbackData, prefix="target"):
+class MoneyType(CallbackData, prefix="target"):
     is_fiat: int  # bool
     is_target: int  # bool
 
@@ -24,13 +24,11 @@ class Cred(CallbackData, prefix="cred"):
 
 class Ex(CallbackData, prefix="ex"):
     id: int
-    name: str
     is_target: int  # bool
 
 
 class Pm(CallbackData, prefix="pm"):
     pmcur_id: int
-    name: str
     is_target: bool
 
 

{xync_bot-0.3.24.dev3 → xync_bot-0.3.24.dev5}/xync_bot/routers/pay/dep.py

@@ -1,6 +1,11 @@
+from asyncio import gather
 from enum import IntEnum
 
 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):
@@ -68,3 +73,43 @@ flags = {
     "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_ids = {
+        exi: ids for exi, ids in await aq.annotate(ids=ArrayAgg("id")).group_by("ex_id").values_list("ex_id", "ids")
+    }
+    return actors, ex_act_ids
+
+
+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=99)
+
+
+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:  # окно вызвано в ответ на текст, а не кнопку
+        await msg.bot.edit_message_text(txt, chat_id=msg.chat.id, message_id=msg.bot.store.perm.msg_id, reply_markup=rm)
+
+    await msg.edit_text(txt, reply_markup=rm)

{xync_bot-0.3.24.dev3 → xync_bot-0.3.24.dev5}/xync_bot/routers/pay/handler.py

@@ -1,190 +1,184 @@
-from asyncio import create_task
+from asyncio import create_task, gather
 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_bot.routers.pay.dep import fill_creds, fill_actors, dlt, ans
 from xync_schema import models
 from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from xync_bot import Store
 from xync_bot.routers.pay import cd, dep, window
 
 pay = Router()
 
 
 @pay.message(Command("pay"))
-async def h_start(msg: Message, state: FSMContext, **kwargs):
+async def h_start(msg: Message):
     """Step 1: Select target type"""
-    # await window.amount(msg, state)
-    await state.set_data({"is_target": True})
-    await window.type_select(msg, True)
+    store: Store = msg.bot.store
+    store.curr.is_target = True
+    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)
 
 
-@pay.callback_query(cd.TargetType.filter(F.is_fiat))
-async def h_got_fiat_type(query: CallbackQuery, state: FSMContext):
+@pay.callback_query(cd.MoneyType.filter(F.is_fiat))
+async def h_got_fiat_type(query: CallbackQuery, bot: PGram):
     """Step 2f: Select cur"""
-    await query.message.delete()
-    await state.update_data(is_fiat=True)
-    await query.answer("Понял, фиат")
-    await window.cur_select(query.message, state)
+    bot.store.curr.is_fiat = True
+    await gather(window.cur_select(query.message), ans(query, "Понял, фиат"))
 
 
-@pay.callback_query(cd.TargetType.filter(F.is_fiat.__eq__(0)))
-async def h_got_crypto_type(query: CallbackQuery, state: FSMContext):
+@pay.callback_query(cd.MoneyType.filter(F.is_fiat.__eq__(0)))
+async def h_got_crypto_type(query: CallbackQuery, bot: PGram):
     """Step 2c: Select coin"""
-    await query.message.delete()
-    await state.update_data(is_fiat=False)
-    await query.answer("Понял, крипта")
-    await window.coin_select(query.message, state)
+    bot.store.curr.is_fiat = False
+    (bot.store.perm.actors, bot.store.perm.cur_creds), *_ = await gather(
+        fill_actors(bot.store.perm.user.person_id), window.coin_select(query.message), ans(query, "Понял, крипта")
+    )
 
 
 @pay.callback_query(cd.Coin.filter())
-async def h_got_coin(query: CallbackQuery, callback_data: cd.Coin, state: FSMContext):
+async def h_got_coin(query: CallbackQuery, callback_data: cd.Coin, bot: PGram):
     """Step 3c: Select target ex"""
-    await query.message.delete()
-    await state.update_data({("t" if await state.get_value("is_target") else "s") + "_coin_id": callback_data.id})
-    await query.answer("Эта монета есть на следующих биржах")
-    await window.ex_select(query.message, state)
+    setattr(bot.store.pay, ("t" if bot.store.curr.is_target else "s") + "_coin_id", callback_data.id)
+    await gather(window.ex_select(query.message), ans(query, "Эта монета есть на следующих биржах"))
 
 
 @pay.callback_query(cd.Cur.filter())
-async def h_got_cur(query: CallbackQuery, callback_data: cd.Cur, state: FSMContext):
+async def h_got_cur(query: CallbackQuery, callback_data: cd.Cur, bot: PGram):
     """Step 3f: Select target pm"""
-    await query.message.delete()
-    await state.update_data({("t" if await state.get_value("is_target") else "s") + "_cur_id": callback_data.id})
-    await query.answer("Вот платежные системы доступные для этой валюты")
-    await window.pm(query.message, state)
+    setattr(bot.store.pay, ("t" if bot.store.curr.is_target else "s") + "_cur_id", callback_data.id)
+    await gather(window.pm(query.message), ans(query, "Вот платежные системы доступные для этой валюты"))
 
 
 @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)
+    query.message.bot.store.pay.t_pmcur_id = callback_data.pmcur_id
+    await gather(
+        window.fill_cred_dtl(query.message),
+        ans(query, "Теперь нужны реквизиты"),
+        state.set_state(dep.CredState.detail),
+    )
 
 
 @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)
+    query.message.bot.store.pay.cred_id = callback_data.id
+    await gather(
+        window.amount(query.message), ans(query, "Теперь нужна сумма"), state.set_state(dep.PaymentState.amount)
+    )
 
 
 @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)
+    msg.bot.store.pay.cred_dtl = msg.text
+    await gather(window.fill_cred_name(msg), dlt(msg), state.set_state(dep.CredState.name))
 
 
 @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)
+    store: Store = msg.bot.store
     cred, _ = await models.Cred.update_or_create(
-        {"name": msg.text}, detail=data["detail"], person_id=data["person_id"], pmcur_id=data["t_pmcur_id"]
+        {"name": msg.text},
+        detail=store.pay.cred_dtl,
+        person_id=store.perm.user.person_id,
+        pmcur_id=store.pay.t_pmcur_id,
     )
-    await state.update_data(cred_id=cred.id)
-    await window.amount(msg, state)
+    msg.bot.store.pay.cred_id = cred.id
+    await gather(window.amount(msg), dlt(msg), state.set_state(dep.PaymentState.amount))
 
 
 @pay.callback_query(cd.Ex.filter())
-async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext):
+async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex):
     """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))
+    store: Store = query.message.bot.store
+    ist = store.curr.is_target
+    setattr(store, ("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]} выбрана"),
+    )
 
 
 @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)
+    store: Store = msg.bot.store
+    if not msg.text.isnumeric():
+        store.curr.msg_to_del = await msg.answer("Пожалуйста, введите корректное число")
+        return
+    if store.curr.msg_to_del:
+        await store.curr.msg_to_del.delete()
+    store.pay.amount = float(msg.text)
     """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)  # сразу выбор валюты источника, тк если цель крипта
+    store.curr.is_target = False
+    await gather((window.type_select if store.curr.is_fiat else window.cur_select)(msg), dlt(msg), state.clear())
 
 
 @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)
+async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm):
+    query.message.bot.store.pay.s_pmcur_id = callback_data.pmcur_id
+    await gather(
+        window.set_ppo(query.message),
+        query.message.delete(),
+        ans(query, callback_data.name),
+    )
 
 
 @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)
+async def h_got_ppo(query: CallbackQuery, callback_data: cd.Ppo):
+    query.message.bot.store.pay.ppo = callback_data.num
+    await gather(window.set_urgency(query.message), query.message.delete(), ans(query, str(callback_data.num)))
 
 
 @pay.callback_query(cd.Time.filter())
-async def process_time_selection(callback: CallbackQuery, callback_data: cd.Time, state: FSMContext):
-    await callback.answer()
+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)
 
-    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"))
+    if ex_id := (store.pay.t_ex_id or store.pay.s_ex_id):
+        actor_id = store.perm.actors[ex_id]
+        if not (addr_id := store.pay.addr):
+            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)
-            await state.update_data(addr_id=addr_id)
+            store.pay.addr_id = addr_id
     else:
         addr_id = None
-
-    pay_req = await models.PayReq.create(
+    pr_data = dict(
         pay_until=pay_until,
-        amount=data["amount"],
-        parts=data["ppo"],
+        amount=store.pay.amount,
+        parts=store.pay.ppo,
         payed_at=None,
         addr_id=addr_id,
-        cred_id=data["cred_id"],
-        user_id=1,
+        cred_id=store.pay.cred_id,
+        user=store.perm.user,
     )
+    pay_req, *_ = await gather(
+        models.PayReq.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,
     )
-
-    await state.set_state(dep.PaymentState.timer)
-    create_task(window.run_timer(callback.message, state))
+    create_task(window.run_timer(query.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()
+    await ans(query, None)
     payed_at = datetime.now()
     await state.update_data(timer_active=False, payed_at_formatted=payed_at)
     data = await state.get_data()
@@ -202,7 +196,7 @@ async def payment_confirmed(query: CallbackQuery, state: FSMContext):
 
 @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 ans(query, None)
     await state.update_data(timer_active=False)
     await query.message.edit_text("Платеж не получен!")
     await query.message.answer("укажите детали платежа")
@@ -227,73 +221,73 @@ async def payment_not_specified(msg: Message, state: FSMContext):
 @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 ans(query, None)
     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()
+    await ans(query, None)
     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)
+    await window.coin_select(query.message)
 
 
 @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()
+    await ans(query, None)
     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)
+    await window.cur_select(query.message)
 
 
 @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)
+    await ans(query, None)
+    await window.pm(query.message)
 
 
 @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 ans(query, None)
     await state.update_data(detail=None)
-    await window.fill_cred_dtl(query.message, state)
+    await window.fill_cred_dtl(query.message)
     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 ans(query, None)
     await state.update_data(name=None)
-    await window.fill_cred_name(query.message, state)
+    await window.fill_cred_name(query.message)
     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 ans(query, None)
     await state.update_data({("t" if await state.get_value("is_target") else "s") + "ex_id": None})
-    await window.ex_select(query.message, state)
+    await window.ex_select(query.message)
 
 
 @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 ans(query, None)
     await state.update_data(amount=None)
-    await window.amount(query.message, state)
+    await window.amount(query.message)
 
 
 @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 ans(query, None)
     await state.update_data(payment=None)
-    await window.pm(query.message, state)
+    await window.pm(query.message)

xync_bot-0.3.24.dev5/xync_bot/routers/pay/window.py

@@ -0,0 +1,217 @@
+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_bot.routers.pay.dep import edt
+
+from xync_bot import Store
+from xync_bot.routers.pay import cd, dep
+
+
+async def type_select(msg: Message):
+    """Step 1: Select type"""
+    store: Store = msg.bot.store
+    ist: bool = store.curr.is_target
+    rm = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [
+                InlineKeyboardButton(
+                    text="Банковская валюта", callback_data=cd.MoneyType(is_fiat=1, is_target=ist).pack()
+                ),
+                InlineKeyboardButton(
+                    text="Крипта", callback_data=cd.MoneyType(is_fiat=0, is_target=store.curr.is_target).pack()
+                ),
+            ]
+        ]
+    )
+    txt = "Что нужно?" if store.curr.is_target else "Чем платишь?"
+    if store.perm.msg_id:
+        await edt(msg, txt, rm)
+    else:
+        msg = await msg.answer(txt, reply_markup=rm)
+        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, 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, 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.pay, ("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 "С какой биржи?", reply_markup=keyboard)
+
+
+async def pm(msg: Message):
+    store: Store = msg.bot.store
+    ist = store.curr.is_target
+    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="Назад к выбору валюты", 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 какой платежной системы?", reply_markup=keyboard)
+
+
+async def fill_cred_dtl(msg: Message):
+    builder = InlineKeyboardBuilder()
+    store: Store = msg.bot.store
+    txt = "В"
+    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))
+        txt = "Выберите реквизиты куда нужно получить деньги, если в списке нет нужных, то\nв"
+
+    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)
+
+    await msg.edit_text(
+        f"{txt}ведите номер для {store.glob.pms[store.pay.t_pmcur_id]}:", reply_markup=builder.as_markup()
+    )
+
+
+async def fill_cred_name(msg: Message):
+    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)
+    store: Store = msg.bot.store
+    cur = store.glob.curs[store.pay.t_cur_id]
+    payment = store.glob.pms[store.pay.t_pmcur_id]
+    detail = store.pay.cred_dtl
+    await edt(msg, f"{cur}:{payment}:{detail}: Введите имя получателя", builder.as_markup())
+
+
+async def amount(msg: Message):
+    """Step 5: Filling target amount"""
+    builder = InlineKeyboardBuilder()
+    store: Store = msg.bot.store
+    if store.curr.is_fiat:
+        cur_coin = store.glob.curs[store.pay.t_cur_id]
+        builder.button(text="Назад к вводу имени", callback_data=cd.PayNav(to=cd.PayStep.t_cred_name))
+        t_name = store.glob.pms[store.pay.t_pmcur_id]
+    else:
+        cur_coin = store.glob.curs[store.pay.t_coin_id]
+        builder.button(text="Назад к выбору биржи", callback_data=cd.PayNav(to=cd.PayStep.t_ex))
+        t_name = store.glob.exs[store.pay.t_ex_id]
+
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(2)
+
+    await msg.edit_text(f"Введите нужную сумму {cur_coin} для {t_name}", reply_markup=builder.as_markup())
+
+
+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.edit_text("На 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.edit_text("Сколько можешь ждать?", 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.24.dev3 → xync_bot-0.3.24.dev5/xync_bot.egg-info}/PKG-INFO

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

@@ -1,64 +0,0 @@
-from tortoise.functions import Min
-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")}
-            cls._store.curs = {
-                k: v
-                for k, v in await models.Cur.filter(ticker__in=flags.keys())
-                .order_by("ticker")
-                .values_list("id", "ticker")
-            }
-            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__id__in=cls._store.curs.keys())
-                .annotate(sname=Min("name"))
-                .group_by("pm_id")
-                .values_list("pm_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 = {
-                c.id: [pmc.pm_id for pmc in c.pmcurs]
-                for c in await models.Cur.filter(id__in=cls._store.curs.keys()).prefetch_related("pmcurs")
-            }
-
-        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
-        pms: dict[int, models.Pm]  # id:name
-
-    class Permanent:
-        user: models.User
-        actors: dict[int, models.Actor]  # key=ex_id
-
-    class Current:
-        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()
-    curr: Current = Current()

xync_bot-0.3.24.dev3/xync_bot/routers/pay/window.py

@@ -1,232 +0,0 @@
-from asyncio import sleep
-
-from aiogram.fsm.context import FSMContext
-from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
-from aiogram.utils.keyboard import InlineKeyboardBuilder
-from tortoise.functions import Max
-from xync_schema import models
-
-from xync_bot.routers.pay import cd, dep
-
-
-async def type_select(msg: Message, is_target: bool):
-    """Step 1: Select type"""
-    if is_target is False:
-        await msg.bot.delete_messages(chat_id=msg.chat.id, message_ids=[msg.message_id, msg.message_id - 1])
-    rm = InlineKeyboardMarkup(
-        inline_keyboard=[
-            [
-                InlineKeyboardButton(
-                    text="Банковская валюта", callback_data=cd.TargetType(is_fiat=1, is_target=is_target).pack()
-                ),
-                InlineKeyboardButton(text="Крипта", callback_data=cd.TargetType(is_fiat=0, is_target=is_target).pack()),
-            ]
-        ]
-    )
-    await msg.answer("Что нужно?" if is_target else "Чем платишь?", reply_markup=rm)
-
-
-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 cur_select(msg: Message, state: FSMContext):
-    """Common using cur func"""
-    if not (curs := await state.get_value("curs")):
-        await state.update_data(curs=curs)
-    builder = InlineKeyboardBuilder()
-    is_target = await state.get_value("is_target")
-    for cur_id, ticker in curs.items():
-        builder.button(text=ticker + dep.flags[ticker], callback_data=cd.Cur(id=cur_id, is_target=is_target))
-    builder.button(text="Назад к выбору типа", callback_data=cd.PayNav(to=cd.PayStep.t_type))
-    builder.adjust(3, 3, 3, 3, 3, 1)
-    sfx = "ую нужно" if is_target else "ой платишь"
-    await msg.answer("Выбери валюту котор" + sfx, reply_markup=builder.as_markup())
-
-
-async def coin_select(msg: Message, state: FSMContext):
-    """Common using coin func"""
-    builder = InlineKeyboardBuilder()
-    if not (coins := await state.get_value("coins")):
-        coins = {k: v for k, v in await models.Coin.all().values_list("id", "ticker")}
-        await state.update_data(coins=coins)
-    is_target = await state.get_value("is_target")
-    for coin_id, ticker in coins.items():
-        builder.button(text=ticker, callback_data=cd.Coin(id=coin_id, is_target=is_target))
-    builder.button(
-        text="Назад к выбору типа", callback_data=cd.PayNav(to=cd.PayStep.t_type if is_target else cd.PayStep.s_type)
-    )
-    builder.adjust(1)
-    sfx = "ую нужно" if is_target else "ой платишь"
-    await msg.answer("Выберите монету котор" + sfx, reply_markup=builder.as_markup())
-
-
-async def ex_select(msg: Message, state: FSMContext):
-    data = await state.get_data()
-    is_target = data["is_target"]
-    coin_id = data[("t" if is_target else "s") + "_coin_id"]
-    if not (exs := data.get("exs", {}).get(coin_id)):
-        await state.update_data({"exs": {coin_id: exs}})
-    builder = InlineKeyboardBuilder()
-    for eid, name in exs:
-        builder.button(text=name, callback_data=cd.Ex(id=eid, name=name, is_target=is_target))
-    builder.button(
-        text="Назад к выбору монеты", callback_data=cd.PayNav(to=cd.PayStep.t_coin if is_target 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.answer("На какую биржу?" if is_target else "С какой биржи?", reply_markup=keyboard)
-
-
-async def pm(msg: Message, state: FSMContext):
-    data = await state.get_data()
-    is_target = data["is_target"]
-    cur_id = data[("t" if is_target else "s") + "_cur_id"]
-    if not (pms := data.get("pms", {}).get(cur_id)):
-        pms = await (
-            models.Pmex.filter(pm__pmcurs__cur_id=cur_id)
-            .annotate(lname=Max("name"))
-            .group_by("pm__pmcurs__id")
-            .values_list("pm__pmcurs__id", "lname")
-        )
-        await state.update_data({"pms": {cur_id: pms}})
-    builder = InlineKeyboardBuilder()
-    for pmcur_id, name in pms:
-        builder.button(text=name, callback_data=cd.Pm(pmcur_id=pmcur_id, name=name[:50], is_target=is_target))
-    builder.button(
-        text="Назад к выбору валюты", callback_data=cd.PayNav(to=cd.PayStep.t_cur if is_target else cd.PayStep.s_cur)
-    )
-    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
-    builder.adjust(1)
-    keyboard = builder.as_markup()
-    txt = "На какую платежную систему?" if is_target else "C какой платежной системы?"
-    await msg.answer(txt, 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 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