xync-bot 0.3.7.dev1__py3-none-any.whl → 0.3.24__py3-none-any.whl

xync_bot/routers/pay/handler.py

@@ -0,0 +1,247 @@
+from asyncio import gather
+from datetime import datetime
+
+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, Store
+from xync_schema import models
+
+from xync_bot.routers.pay import cd, dep, window
+
+pr = Router(name="pay")
+
+
+@pr.message(Command("pay"))
+async def h_start(msg: Message, store: Store):
+    """Step 1: Select a target type"""
+    store.curr.is_target = True
+    await gather(window.type_select(msg, store), 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)
+
+
+@pr.callback_query(cd.MoneyType.filter(F.is_fiat))
+async def h_got_fiat_type(query: CallbackQuery, store: Store):
+    """Step 2f: Select cur"""
+    store.curr.is_fiat = True
+    await gather(window.cur_select(query.message, store), ans(query, "Понял, фиат"))
+
+
+@pr.callback_query(cd.MoneyType.filter(F.is_fiat.__eq__(0)))
+async def h_got_crypto_type(query: CallbackQuery, store: Store):
+    """Step 2c: Select coin"""
+    store.curr.is_fiat = False
+    await gather(window.coin_select(query.message, store), ans(query, "Понял, крипта"))
+
+
+@pr.callback_query(cd.Coin.filter())
+async def h_got_coin(query: CallbackQuery, callback_data: cd.Coin, store: Store):
+    """Step 3c: Select target ex"""
+    setattr(store.pay, ("t" if store.curr.is_target else "s") + "_coin_id", callback_data.id)
+    await gather(window.ex_select(query.message, store), ans(query, "Эта монета есть на следующих биржах"))
+
+
+@pr.callback_query(cd.Cur.filter())
+async def h_got_cur(query: CallbackQuery, callback_data: cd.Cur, store: Store):
+    """Step 3f: Select target pm"""
+    setattr(store.pay, ("t" if store.curr.is_target else "s") + "_cur_id", callback_data.id)
+    await gather(window.pm(query.message, store), ans(query, "Вот платежные системы доступные для этой валюты"))
+
+
+@pr.callback_query(cd.Pm.filter(F.is_target))
+async def h_got_target_pm(query: CallbackQuery, callback_data: cd.Pm, state: FSMContext, store: Store):
+    """Step 4f: Fill target cred.detail"""
+    store.pay.t_pmcur_id = callback_data.pmcur_id
+    await gather(
+        window.fill_cred_dtl(query.message, store),
+        ans(query, "Теперь нужны реквизиты"),
+        state.set_state(dep.CredState.detail),
+    )
+
+
+@pr.callback_query(cd.Cred.filter())
+async def h_got_cred(query: CallbackQuery, callback_data: cd.Cred, state: FSMContext, store: Store):
+    store.pay.cred_id = callback_data.id
+    await gather(
+        window.amount(query.message, store), ans(query, "Теперь нужна сумма"), state.set_state(dep.PaymentState.amount)
+    )
+
+
+@pr.message(dep.CredState.detail)
+async def h_got_cred_dtl(msg: Message, state: FSMContext, store: Store):
+    """Step 4.1f: Fill target cred.name"""
+    store.pay.cred_dtl = msg.text
+    await gather(window.fill_cred_name(msg, store), dlt(msg), state.set_state(dep.CredState.name))
+
+
+@pr.message(dep.CredState.name)
+async def h_got_cred_name(msg: Message, state: FSMContext, store: Store):
+    """Step 5f: Save target cred"""
+    cred, _ = await models.Cred.update_or_create(
+        {"name": msg.text},
+        detail=store.pay.cred_dtl,
+        person_id=store.perm.user.person_id,
+        pmcur_id=store.pay.t_pmcur_id,
+    )
+    store.pay.cred_id = cred.id
+    store.perm.creds[cred.id] = cred
+    await gather(window.amount(msg, store), dlt(msg), state.set_state(dep.PaymentState.amount))
+
+
+@pr.callback_query(cd.Ex.filter())
+async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext, store: Store):
+    """Step 4c: Save target"""
+    ist = store.curr.is_target
+    setattr(store.pay, ("t" if ist else "s") + "_ex_id", callback_data.id)
+    if ist:
+        await window.amount(query.message, store)
+        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, store)
+    await ans(query, f"Биржа {store.glob.exs[callback_data.id]} выбрана")
+    await state.set_state(dep.PaymentState.amount)
+
+
+@pr.message(dep.PaymentState.amount)
+async def h_got_amount(msg: Message, state: FSMContext, store: Store):
+    """Step 6: Save a target amount"""
+    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"""
+    store.curr.is_target = False
+    await gather((window.type_select if store.curr.is_fiat else window.cur_select)(msg, store), dlt(msg), state.clear())
+
+
+@pr.callback_query(cd.Pm.filter(F.is_target.__eq__(0)))
+async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm, store: Store):
+    store.pay.s_pmcur_id = callback_data.pmcur_id
+    await gather(
+        window.set_ppo(query.message, store),
+        ans(query, store.glob.pmcurs[callback_data.pmcur_id]),
+    )
+
+
+@pr.callback_query(cd.Ppo.filter())
+async def h_got_ppo(query: CallbackQuery, callback_data: cd.Ppo, store: Store):
+    store.pay.ppo = callback_data.num
+    await gather(window.set_urgency(query.message, store), ans(query, str(callback_data.num)))
+
+
+@pr.callback_query(cd.Time.filter())
+async def h_got_urgency(query: CallbackQuery, callback_data: cd.Time, store: Store):
+    store.pay.urg = callback_data.minutes
+    await window.create_payreq(query.message, store)
+    await ans(query, f"Ok {callback_data.minutes} min.")
+
+
+# ACTIONS
+@pr.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.received)))
+async def payment_confirmed(query: CallbackQuery, state: FSMContext):
+    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()
+    if data.get("pay_req_id"):
+        pay_req = await models.PayReq.get(id=data["pay_req_id"])
+        pay_req.payed_at = payed_at
+        await pay_req.save()
+    await state.clear()
+    await window.success(query.message)
+
+
+@pr.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.not_received)))
+async def no_payment(query: CallbackQuery, state: FSMContext):
+    await ans(query, None)
+    await state.update_data(timer_active=False)
+    await query.message.edit_text("Платеж не получен!")
+    await query.message.answer("укажите детали платежа")
+    await state.clear()
+    await state.set_state(dep.Report.text)
+
+
+@pr.message(dep.Report.text)
+async def payment_not_specified(msg: Message, state: FSMContext):
+    await state.update_data(text=msg.text)
+    data = await state.get_data()
+    complaint_text = (
+        f"Жалоба на неполученный платеж:\n"
+        f"Пользователь: @{msg.from_user.username or msg.from_user.id}\n"
+        f"Детали платежа: {data['text']}\n"
+        f"Время: {msg.date.strftime('%Y-%m-%d %H:%M:%S')}"
+    )
+    await msg.bot.send_message(chat_id="xyncpay", text=complaint_text)
+
+
+# NAVIGATION
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_type, cd.PayStep.s_type])))
+async def handle_home(query: CallbackQuery, state: FSMContext, store: Store):
+    await gather(window.type_select(query.message, store), state.clear(), ans(query, "Создаем платеж заново"))
+
+
+@pr.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, store: Store):
+    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, store)
+
+
+@pr.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, store: Store):
+    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, store)
+
+
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm, cd.PayStep.s_pm])))
+async def to_pm_select(query: CallbackQuery, store: Store):
+    await ans(query, None)
+    await window.pm(query.message, store)
+
+
+@pr.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_dtl)))
+async def back_to_cred_detail(query: CallbackQuery, state: FSMContext, store: Store):
+    await ans(query, None)
+    await state.update_data(detail=None)
+    await window.fill_cred_dtl(query.message, store)
+
+
+@pr.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_cred_name)))
+async def back_to_cred_name(query: CallbackQuery, state: FSMContext, store: Store):
+    await ans(query, None)
+    await state.update_data(name=None)
+    await window.fill_cred_name(query.message, store)
+
+
+@pr.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, store: Store):
+    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, store)
+
+
+@pr.callback_query(cd.PayNav.filter(F.to.__eq__(cd.PayStep.t_amount)))
+async def back_to_amount(query: CallbackQuery, state: FSMContext, store: Store):
+    await ans(query, None)
+    await state.update_data(amount=None)
+    await window.amount(query.message, store)
+    await state.set_state(dep.PaymentState.amount)
+
+
+@pr.callback_query(cd.PayNav.filter(F.to.in_([cd.PayStep.t_pm])))
+async def back_to_payment(query: CallbackQuery, state: FSMContext, store: Store):
+    await ans(query, None)
+    await state.update_data(payment=None)
+    await window.pm(query.message, store)

xync_bot/routers/pay/window.py

@@ -0,0 +1,244 @@
+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_schema import models
+
+from xync_bot.routers.pay.dep import edt, Store, fmt_sec
+from xync_bot.routers.pay import cd, dep
+
+
+async def type_select(msg: Message, store: Store):
+    """Step 1: Select type"""
+    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()
+                ),
+            ]
+        ]
+    )
+    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:
+        msg = await msg.answer(txt, reply_markup=rm)
+        store.perm.msg_id = msg.message_id
+
+
+async def cur_select(msg: Message, store: Store):
+    """Common using cur func"""
+    builder = InlineKeyboardBuilder()
+    ist: bool = store.curr.is_target
+    for cur_id, cur in 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 "ой платишь"
+    await edt(msg, "Выбери валюту котор" + sfx, builder.as_markup())
+
+
+async def coin_select(msg: Message, store: Store):
+    """Common using coin func"""
+    builder = InlineKeyboardBuilder()
+    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):
+    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):
+    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.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)
+    )
+    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, store: Store):
+    builder = InlineKeyboardBuilder()
+    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]
+            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))
+    builder.button(text="Домой", callback_data=cd.PayNav(to=cd.PayStep.t_type))
+    builder.adjust(2)
+
+    await msg.edit_text(
+        f"{txt}ведите номер для {store.glob.pmcurs[store.pay.t_pmcur_id]}:", reply_markup=builder.as_markup()
+    )
+
+
+async def fill_cred_name(msg: Message, store: Store):
+    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)
+    cur = store.glob.curs[store.pay.t_cur_id]
+    payment = store.glob.pmcurs[store.pay.t_pmcur_id]
+    detail = store.pay.cred_dtl
+    await edt(msg, f"{cur.ticker}:{payment}:{detail}: Введите имя получателя", builder.as_markup())
+
+
+async def amount(msg: Message, store: Store):
+    """Step 5: Filling target amount"""
+    builder = InlineKeyboardBuilder()
+    if store.curr.is_fiat:
+        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.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))
+        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 edt(msg, f"Введите нужную сумму {cur_coin} для {t_name}", builder.as_markup())
+
+
+async def set_ppo(msg: Message, store: Store):
+    ist = store.curr.is_target
+    if nppo := await store.need_ppo():
+        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):
+    if not store.curr.is_fiat or await store.client_have_coin_amount():
+        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):
+    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 store.get_merch_target()
+    ccred, ctxt = await store.client_target_repr()
+    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=cd.Action(act=cd.ActionType.sent).pack())],
+        ]
+    )
+    await edt(msg, f"Отправьте {100500} " + txt, rm)  # todo: get rate
+
+    # 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))
+
+    seconds = await state.get_value("timer") * 60
+
+    try:
+        await message.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
+    except Exception:
+        return
+
+    while seconds > 0:
+        await sleep(1)
+        seconds -= 1
+        try:
+            await message.edit_text(f"⏳ Осталось {fmt_sec(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
+
+
+async def success(msg: Message):
+    rm = InlineKeyboardMarkup(
+        inline_keyboard=[
+            [InlineKeyboardButton(text="Новый платеж💸", callback_data=cd.PayNav(to=cd.PayStep.t_type).pack())]
+        ]
+    )
+    await msg.edit_text("✅ Платеж успешно подтвержден", reply_markup=rm)

xync_bot/shared.py

@@ -3,3 +3,22 @@ from aiogram.filters.callback_data import CallbackData
 
 class NavCallbackData(CallbackData, prefix="nav"):  # navigate menu
     to: str
+
+
+flags = {
+    "RUB": "🇷🇺",
+    "THB": "🇹🇭",
+    "IDR": "🇮🇩",
+    "TRY": "🇹🇷",
+    "GEL": "🇬🇪",
+    "VND": "🇻🇳",
+    "AED": "🇦🇪",
+    "AMD": "🇦🇲",
+    "AZN": "🇦🇿",
+    "CNY": "🇨🇳",
+    "EUR": "🇪🇺",
+    "HKD": "🇭🇰",
+    "INR": "🇮🇳",
+    "PHP": "🇵🇭",
+    "USD": "🇺🇸",
+}

xync_bot/store.py

@@ -0,0 +1,150 @@
+import logging
+from aiogram.types import Message
+from tortoise.functions import Min
+from x_model.func import ArrayAgg
+from x_auth.enums import Role
+from xync_schema.models import Addr, Asset, Cred, Coin, Pmcur, Cur, User, Ex, Pmex
+
+from xync_bot.shared 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 Coin.all().order_by("ticker").values_list("id", "ticker")}
+            curs = {c.id: c for c in await Cur.filter(ticker__in=flags.keys()).order_by("ticker")}
+            cls._store.curs = curs
+            cls._store.exs = {k: v for k, v in await Ex.all().values_list("id", "name")}
+            cls._store.pmcurs = {
+                k: v
+                for k, v in await 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 Coin.all().prefetch_related("coinexs")
+            }
+            cls._store.curpms = {
+                cur_id: ids
+                for cur_id, ids in await 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 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, 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: User = None
+        actors: dict[int, int] = None  # key=ex_id
+        creds: dict[int, 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 xync_have_coin_amount(self) -> bool:
+        assets = await Asset.filter(
+            addr__coin_id=self.pay.t_coin_id, addr__ex_id=self.pay.t_ex_id, addr__actor__user__role__in=Role.ADMIN
+        )
+        return self.pay.amount <= sum(a.free for a in assets)
+
+    async def client_have_coin_amount(self) -> bool:
+        assets = await Asset.filter(addr__coin_id=self.pay.t_coin_id, addr__actor_id__in=self.perm.actors.values())
+        return self.pay.amount <= sum(a.free for a in assets)
+
+    async def need_ppo(self):
+        cur_id = getattr(self.pay, ("t" if self.curr.is_target else "s") + "_cur_id")
+        usd_amount = self.pay.amount * self.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(self) -> tuple[Addr | Cred, str]:
+        if self.pay.t_ex_id:
+            addr_to = (
+                await Addr.filter(actor__ex_id=self.pay.t_ex_id, coin_id=self.pay.t_coin_id, actor__user=self.perm.user)
+                .prefetch_related("actor")
+                .first()
+            )
+            ex, coin = self.glob.exs[self.pay.s_ex_id], self.glob.coins[self.pay.s_coin_id]
+            if not addr_to:
+                logging.error(f"No {coin} addr in {ex} for user: {self.perm.user.username_id}")
+            return addr_to, f"{coin} на {ex} по id: `{addr_to.actor.exid}`"
+        # иначе: реквизиты для фиата
+        cur, pm = self.glob.curs[self.pay.t_cur_id], self.glob.pmcurs[self.pay.t_pmcur_id]
+        cred = self.perm.creds[self.pay.cred_id]
+        return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
+
+    async def get_merch_target(self) -> tuple[Addr | Cred, str]:
+        if self.pay.s_ex_id:
+            addr_in = (
+                await Addr.filter(
+                    actor__ex_id=self.pay.s_ex_id, coin_id=self.pay.s_coin_id, actor__user__role__gte=Role.ADMIN
+                )
+                .prefetch_related("actor")
+                .first()
+            )
+            ex, coin = self.glob.exs[self.pay.s_ex_id], self.glob.coins[self.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 Pmcur.get(id=self.pay.s_pmcur_id).prefetch_related("pm__grp")
+        cred = await Cred.filter(
+            **({"pmcur__pm__grp": s_pmcur.pm.grp} if s_pmcur.pm.grp else {"pmcur_id": self.pay.s_pmcur_id}),
+            person__user__role__gte=Role.ADMIN,
+        ).first()  # todo: order by fiat.target-fiat.amount
+        cur, pm = self.glob.curs[self.pay.s_cur_id], self.glob.pmcurs[self.pay.s_pmcur_id]
+        if not cred:
+            logging.error(f"No {cur.ticker} cred for {pm}")
+        return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.7.dev1
+Version: 0.3.24
 Summary: Telegram bot with web app for xync net
 Author-email: Artemiev <mixartemev@gmail.com>
 License-Expression: GPL-3.0-or-later
@@ -8,6 +8,8 @@ Project-URL: Homepage, https://gitlab.com/xync/back/tg-bot
 Project-URL: Repository, https://gitlab.com/xync/back/tg-bot
 Keywords: aiogram,cyrtranslit,xync-net
 Requires-Python: >=3.12
+Requires-Dist: cyrtranslit
+Requires-Dist: xn-auth
 Requires-Dist: xync-schema
 Provides-Extra: dev
 Requires-Dist: PGram; extra == "dev"