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

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

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

@@ -1,4 +1,5 @@
 from tortoise.functions import Min
+from x_model.func import ArrayAgg
 from xync_schema import models
 
 from xync_bot.routers.pay.dep import flags
@@ -11,26 +12,30 @@ class SingleStore(type):
         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 = {
+            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__id__in=cls._store.curs.keys())
+                for k, v in await models.Pmex.filter(pm__pmcurs__cur_id__in=cls._store.curs.keys())
                 .annotate(sname=Min("name"))
-                .group_by("pm_id")
-                .values_list("pm_id", "sname")
+                .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 = {
-                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")
+                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
@@ -41,13 +46,20 @@ class Store:
         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
+        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:
-        user: models.User
-        actors: dict[int, models.Actor]  # key=ex_id
+        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
@@ -61,4 +73,5 @@ class Store:
 
     glob: Global
     perm: Permanent = Permanent()
+    pay: Payment = Payment()
     curr: Current = Current()

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

@@ -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.dev4}/xync_bot/routers/pay/handler.py

@@ -1,5 +1,7 @@
 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
@@ -12,47 +14,43 @@ 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)
+    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, state: FSMContext):
+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 window.cur_select(query.message)
 
 
 @pay.callback_query(cd.TargetType.filter(F.is_fiat.__eq__(0)))
-async def h_got_crypto_type(query: CallbackQuery, state: FSMContext):
+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)
+    bot.store.curr.is_fiat = False
     await query.answer("Понял, крипта")
-    await window.coin_select(query.message, state)
+    await window.coin_select(query.message)
 
 
 @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})
+    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, state)
+    await window.ex_select(query.message)
 
 
 @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})
+    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, state)
+    await window.pm(query.message)
 
 
 @pay.callback_query(cd.Pm.filter(F.is_target))

{xync_bot-0.3.24.dev3 → xync_bot-0.3.24.dev4}/xync_bot/routers/pay/window.py

@@ -3,122 +3,97 @@ 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 import Store
 from xync_bot.routers.pay import cd, dep
 
 
-async def type_select(msg: Message, is_target: bool):
+async def type_select(msg: Message):
     """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])
+    ist: bool = msg.bot.store.curr.is_target
     rm = InlineKeyboardMarkup(
         inline_keyboard=[
             [
                 InlineKeyboardButton(
-                    text="Банковская валюта", callback_data=cd.TargetType(is_fiat=1, is_target=is_target).pack()
+                    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()
                 ),
-                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))
+    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:
-        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))
+        msg = await msg.answer(txt, reply_markup=rm)
+        msg.bot.store.perm.msg_id = msg.message_id
 
-    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):
+async def cur_select(msg: Message):
     """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))
+    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 is_target else "ой платишь"
-    await msg.answer("Выбери валюту котор" + sfx, reply_markup=builder.as_markup())
+    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, state: FSMContext):
+async def coin_select(msg: Message):
     """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))
+    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 is_target else cd.PayStep.s_type)
+        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 is_target else "ой платишь"
-    await msg.answer("Выберите монету котор" + sfx, reply_markup=builder.as_markup())
+    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, 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}})
+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 eid, name in exs:
-        builder.button(text=name, callback_data=cd.Ex(id=eid, name=name, is_target=is_target))
+    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 is_target else cd.PayStep.s_coin)
+        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.answer("На какую биржу?" if is_target else "С какой биржи?", reply_markup=keyboard)
+    await msg.edit_text("На какую биржу?" if ist else "С какой биржи?")
+    await msg.edit_reply_markup(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}})
+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, name in pms:
-        builder.button(text=name, callback_data=cd.Pm(pmcur_id=pmcur_id, name=name[:50], is_target=is_target))
+    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 is_target else cd.PayStep.s_cur)
+        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()
-    txt = "На какую платежную систему?" if is_target else "C какой платежной системы?"
-    await msg.answer(txt, reply_markup=keyboard)
+    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):
@@ -160,6 +135,27 @@ async def fill_cred_name(msg: Message, state: FSMContext):
     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=[

{xync_bot-0.3.24.dev3 → xync_bot-0.3.24.dev4/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.dev4
 Summary: Telegram bot with web app for xync net
 Author-email: Artemiev <mixartemev@gmail.com>
 License-Expression: GPL-3.0-or-later