xync-bot 0.3.6__tar.gz → 0.3.7.dev4__tar.gz

{xync_bot-0.3.6/xync_bot.egg-info → xync_bot-0.3.7.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.6
+Version: 0.3.7.dev4
 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"

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4}/pyproject.toml

@@ -10,6 +10,8 @@ description = "Telegram bot with web app for xync net"
 license = "GPL-3.0-or-later"
 dynamic = ["version"]
 dependencies = [
+    "cyrtranslit",
+    "xn-auth",
     "xync-schema",
 ]
 [project.optional-dependencies]

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4}/xync_bot/__init__.py

@@ -5,16 +5,19 @@ from PGram import Bot
 from aiogram.client.default import DefaultBotProperties
 from x_model import init_db
 
-from xync_bot.routers.cond import r
+from xync_bot.routers.cond import cr
 
-if __name__ == '__main__':
-    from xync_bot.loader import dp, TOKEN, TORM
+# from xync_bot.routers.main import mr
+from xync_bot.routers.pay.main import pay as pay
+
+if __name__ == "__main__":
+    from xync_bot.loader import TOKEN, TORM
 
     logging.basicConfig(level=logging.INFO)
 
     async def main() -> None:
         cn = await init_db(TORM)
-        bot = Bot(TOKEN, [r], cn, default=DefaultBotProperties(parse_mode='HTML'))
+        bot = Bot(TOKEN, [cr, pay], cn, default=DefaultBotProperties(parse_mode="HTML"))
         await bot.start()
 
     run(main())

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4}/xync_bot/loader.py

@@ -1,5 +1,3 @@
-from aiogram import Bot, Dispatcher
-# from aiogram.client.default import DefaultBotProperties
 from dotenv import load_dotenv
 from os import getenv as env
 
@@ -15,9 +13,6 @@ TOKEN = env("TOKEN")
 # API_URL = "https://" + env("API_DOMAIN")
 # WH_URL = API_URL + "/wh/" + TOKEN
 
-bot: Bot = Bot(token=TOKEN)  # , default=DefaultBotProperties(parse_mode="HTML")
-dp: Dispatcher = Dispatcher(bot=bot)
-
 TORM = {
     "connections": {"default": PG_DSN},
     "apps": {"models": {"models": [models, "aerich.models"]}},

xync_bot-0.3.7.dev4/xync_bot/routers/cond/__init__.py

@@ -0,0 +1,97 @@
+from aiogram import Router, F
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.filters import Command
+from aiogram.fsm.context import FSMContext
+from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
+from xync_schema import models
+from xync_schema.enums import SynonymType
+
+from xync_bot.routers.cond.func import wrap_cond, get_val, btns, rkm, ikm, SynTypeCd, CondCd
+
+cr = Router()
+
+
+@cr.message(Command("cond"))
+async def start(msg: Message, state: FSMContext):
+    await msg.reply('Заполняем синонимы признаков условий объявлений: "ссылка на инструкцию"', reply_markup=rkm)
+    await show_new_cond(msg, state)
+
+
+async def show_new_cond(msg: Message, state: FSMContext):
+    cond = await models.Cond.filter(parsed__isnull=True).order_by("-created_at").first().prefetch_related("parsed")
+    await state.set_data({"cond": cond})
+    await show_cond(msg, cond)
+
+
+async def show_cond(msg: Message, cond: models.Cond):
+    await msg.answer(await wrap_cond(cond), reply_markup=ikm)
+
+
+@cr.message(F.quote)
+async def got_synonym(msg: Message, state: FSMContext):
+    if not (msg.text in {st.name for st in SynonymType} and SynonymType[msg.text]):
+        return await msg.reply_text(
+            f'Нет раздела "{msg.text}", не пиши текст сам, выдели кусок из моего сообщения,'
+            f"ответь на него, выбери кнопку раздела"
+        )
+    if not msg.quote:
+        return await msg.reply_text(f"Вы забыли выделить кусок текста для {msg.text}")
+    if typ := SynonymType[msg.text]:
+        await state.update_data({"syntext": msg.quote.text, "cmsg": msg.reply_to_message})
+        await models.Synonym.update_or_create({"typ": typ}, txt=msg.quote.text)
+        if rm := await btns(typ, msg.quote.text):
+            return await msg.answer("Уточните", reply_markup=rm, reply_to_message_id=msg.message_id)
+        await syn_result(msg, SynTypeCd(typ=typ.name, val=1), state)
+    return None
+
+
+@cr.callback_query(SynTypeCd.filter())
+async def got_synonym_val(cbq: CallbackQuery, callback_data: SynTypeCd, state: FSMContext):
+    await syn_result(cbq.message, callback_data, state)
+
+
+async def syn_result(msg: Message, cbd: SynTypeCd, state: FSMContext):
+    cond: models.Cond = await state.get_value("cond")
+    typ = SynonymType[cbd.typ]
+    val, hval = await get_val(typ, cbd.val)
+    syntext = await state.get_value("syntext")
+    syn, _ = await models.Synonym.update_or_create({"val": val}, typ=typ, txt=syntext)
+    await models.CondParsed.update_or_create({typ.name: val}, cond_id=cond.id)
+    await msg.answer(
+        f'Текст "{syntext}" определен как синоним для `{typ.name}` со значением {hval}',
+        reply_markup=InlineKeyboardMarkup(
+            inline_keyboard=[
+                [
+                    InlineKeyboardButton(text="Готово! Давай новый", callback_data="cond:complete"),
+                    InlineKeyboardButton(text="Продолжить с этим текстом", callback_data="cond:continue"),
+                ]
+            ]
+        ),
+    )
+
+
+@cr.callback_query(CondCd.filter())
+async def got_action(cbq: CallbackQuery, callback_data: CondCd, state: FSMContext):
+    cond: models.Cond = await state.get_value("cond")
+    if callback_data.act == "complete":
+        await models.CondParsed.update_or_create({"parsed": True}, cond=cond)
+        await show_new_cond(cbq.message, state)
+    elif callback_data.act == "pass":
+        await show_new_cond(cbq.message, state)
+    elif callback_data.act == "refresh":
+        try:
+            await cbq.message.edit_text(await wrap_cond(cond), reply_markup=ikm)
+        except TelegramBadRequest as e:
+            if "message is not modified:" in e.message:
+                return await cbq.answer("Текст не изменился")
+            raise e
+    elif callback_data.act == "continue":
+        await (await state.get_value("cmsg")).delete()
+        await show_cond(cbq.message, cond)
+    return await cbq.answer(callback_data.act)
+
+
+@cr.message()
+async def unknown(msg: Message):
+    # user = await User.get(username_id=msg.from_user.id)
+    await msg.delete()

xync_bot-0.3.7.dev4/xync_bot/routers/cond/func.py

@@ -0,0 +1,118 @@
+import re
+from enum import IntEnum
+from inspect import isclass
+from typing import Coroutine
+
+from aiogram.filters.callback_data import CallbackData
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
+from cyrtranslit import to_latin
+from xync_schema import models
+from xync_schema.enums import SynonymType, Boundary, Party, Slip, AbuserType, NameType
+
+
+class SynTypeCd(CallbackData, prefix="st"):
+    typ: str
+    val: int
+
+
+class CondCd(CallbackData, prefix="cond"):
+    act: str
+
+
+async def wrap_cond(cond: models.Cond):
+    bnks = await models.Synonym.filter(typ=SynonymType.bank)
+    bnks = "|".join("\\b" + b.txt + ("\\b" if b.boundary & Boundary.right else "") for b in bnks)
+    ad = await models.Ad.filter(cond=cond).order_by("-updated_at").prefetch_related("ex", "pair_side").first()
+    hdr = ("SELL" if ad.pair_side.is_sell else "BUY") + f":{ad.price} [{ad.min_fiat}]"
+    if (mx := (ad.max_fiat or ad.amount)) > ad.min_fiat:
+        hdr += f"->[{mx}]"
+    txt = cond.raw_txt
+    for syn in await models.Synonym.all():
+        lb, rb = "\\b" if syn.boundary & Boundary.left else "", "\\b" if syn.boundary & Boundary.right else ""
+        if syn.typ == SynonymType.bank_side:
+            syn.txt.replace("#banks#", f"({bnks})")
+        if syn.is_re or syn.txt in txt:
+            pattern = re.compile(lb + syn.txt + rb)
+            if match := re.search(pattern, txt):
+                g = match.group()
+                val, hval = await get_val(syn.typ, syn.val)
+                val = syn.typ.name + (f'="{hval}"' if hval else "")
+                txt = re.sub(pattern, f"<code>{g}</code><tg-spoiler>[{val}]</tg-spoiler>", txt)
+    return f"<blockquote>{hdr} {ad.ex.name}</blockquote>{txt}"
+
+
+async def cbanks(bnid: str) -> list[tuple[int, str]]:
+    beginning = to_latin(bnid[:2], lang_code="ru")
+    return await models.Pm.filter(norm__startswith=beginning, bank=True).values_list("id", "norm")
+
+
+async def cppo(txt: str) -> list[tuple[int, str]]:
+    opts = re.findall(r"\d+", txt) or [1, 1000, 5000]
+    return [(o, str(o)) for o in opts]
+
+
+async def contact(txt: str) -> list[tuple[int, str]]: ...
+
+
+synopts: dict[SynonymType, list[str] | type(IntEnum) | None | Coroutine] = {
+    SynonymType.name: ["not_slavic", "slavic"],
+    SynonymType.ppo: cppo,
+    SynonymType.from_party: Party,
+    SynonymType.to_party: Party,
+    SynonymType.slip_req: Slip,
+    SynonymType.slip_send: Slip,
+    SynonymType.abuser: AbuserType,
+    SynonymType.scale: ["1", "100", "1000", "5000"],
+    SynonymType.slavic: NameType,
+    SynonymType.mtl_like: None,
+    SynonymType.bank: cbanks,
+    SynonymType.bank_side: ["except", "only"],
+    SynonymType.sbp_strict: ["no", "sbp", "card"],
+    SynonymType.contact: contact,
+}
+
+rkm = ReplyKeyboardMarkup(
+    keyboard=[
+        [KeyboardButton(text="ppo"), KeyboardButton(text="abuser")],
+        [KeyboardButton(text="from_party"), KeyboardButton(text="to_party")],
+        [KeyboardButton(text="slip_send"), KeyboardButton(text="slip_req")],
+        [KeyboardButton(text="name"), KeyboardButton(text="slavic")],
+        [KeyboardButton(text="scale"), KeyboardButton(text="mtl_like")],
+        [KeyboardButton(text="bank"), KeyboardButton(text="bank_side")],
+        [KeyboardButton(text="sbp_strict"), KeyboardButton(text="contact")],
+    ],
+    # one_time_keyboard=True,
+)
+ikm = InlineKeyboardMarkup(
+    inline_keyboard=[
+        [
+            InlineKeyboardButton(text="Обновить", callback_data="cond:refresh"),
+            InlineKeyboardButton(text="Пропустить", callback_data="cond:pass"),
+        ]
+    ]
+)
+
+
+async def get_val(typ: SynonymType.__class__, val: str | int) -> tuple[SynonymType | int | bool, str]:
+    if isinstance(val, str) and val.isnumeric():
+        val = int(val)
+    if isclass(lst := synopts[typ]) and issubclass(lst, IntEnum):
+        return (v := lst(val)), v.name
+    elif isinstance(lst, list):
+        return val, lst[val]
+    elif typ == SynonymType.bank:
+        return val, (await models.Pm[val]).norm
+    return val, val
+
+
+async def btns(typ: SynonymType.__class__, txt: str = None) -> InlineKeyboardMarkup | None:
+    if lst := synopts[typ]:
+        if isinstance(lst, list):
+            kb = [[InlineKeyboardButton(text=n, callback_data=f"st:{typ.name}:{i}")] for i, n in enumerate(lst)]
+        elif isclass(lst) and issubclass(lst, IntEnum):
+            kb = [[InlineKeyboardButton(text=i.name, callback_data=f"st:{typ.name}:{i.value}")] for i in lst]
+        else:
+            kb = [[InlineKeyboardButton(text=n, callback_data=f"st:{typ.name}:{i}")] for i, n in await lst(txt)]
+        return InlineKeyboardMarkup(inline_keyboard=kb)
+    else:
+        return lst

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4}/xync_bot/routers/main.py

@@ -6,7 +6,7 @@ from aiogram.exceptions import TelegramBadRequest
 from aiogram.filters import CommandStart, CommandObject, ChatMemberUpdatedFilter, JOIN_TRANSITION, LEAVE_TRANSITION
 from aiogram.filters.callback_data import CallbackData
 from aiogram.types import (
-    User as TgUser,
+    User,
     ChatMemberUpdated,
     Message,
     InlineKeyboardMarkup,
@@ -15,12 +15,11 @@ from aiogram.types import (
     WebAppInfo,
 )
 from aiogram.utils.deep_linking import create_start_link
-from xync_bot.handlers import user_upsert
-from xync_schema.models import User, Order, Msg, Forum
+from xync_schema import models
 
 from xync_bot.shared import NavCallbackData
 
-main = Router()
+mr = Router()
 
 
 class RrCallbackData(CallbackData, prefix="reg_res"):  # registration response
@@ -38,19 +37,19 @@ home_btns = InlineKeyboardMarkup(
 )
 
 
-@main.message(CommandStart(deep_link=True, deep_link_encoded=True))
+@mr.message(CommandStart(deep_link=True, deep_link_encoded=True))
 async def start_handler(msg: Message, command: CommandObject):
-    me: TgUser = msg.from_user
+    me: User = msg.from_user
     ref_id: int = command.args.isnumeric() and int(command.args)
-    user = await User.get_or_none(id=me.id, blocked=False)
+    user = await models.User.get_or_none(id=me.id, blocked=False)
     rm = None
     logging.info(msg, {"src": "start"})
     if user:
         rs, rm = f"{me.full_name}, you have registered already😉", home_btns
-    elif not (ref := await User.get_or_none(id=ref_id)):
+    elif not (ref := await models.User.get_or_none(id=ref_id)):
         rs = f"No registered user #{ref_id}😬"
     else:  # new user created
-        user, cr = await user_upsert(me, False)
+        user, cr = await models.User.tg2in(me, False)
         await user.update_from_dict({"ref": ref}).save()
         approve_btns = InlineKeyboardMarkup(
             inline_keyboard=[
@@ -67,9 +66,9 @@ async def start_handler(msg: Message, command: CommandObject):
     return await msg.answer(rs, reply_markup=rm)
 
 
-@main.callback_query(RrCallbackData.filter())
+@mr.callback_query(RrCallbackData.filter())
 async def phrases_input_request(cb: CallbackQuery, callback_data: RrCallbackData) -> None:
-    protege = await User[callback_data.to]
+    protege = await models.User[callback_data.to]
     if callback_data.res:
         # protege.status = UserStatus.RESTRICTED
         await protege.save()
@@ -84,17 +83,17 @@ async def phrases_input_request(cb: CallbackQuery, callback_data: RrCallbackData
     await cb.message.edit_text(rs)
 
 
-@main.message(CommandStart(deep_link=True))  # attempt to reg by fake link
+@mr.message(CommandStart(deep_link=True))  # attempt to reg by fake link
 async def fraud_handler(msg: Message):
     logging.warning(f"Start: {msg.from_user.id}. Msg: {msg}")
     # todo: alert to admins! Fraud attempt!
     await msg.answer("🤔")
 
 
-@main.message(CommandStart())
+@mr.message(CommandStart())
 async def start_no_ref_handler(msg: Message):
     me = msg.from_user
-    user, cr = await user_upsert(me, False)
+    user, cr = await models.User.tg2in(me, False)
     rr = "сначала вы должны найти поручителя, и перейти по его реферальной ссылке.\nhttps://telegra.ph/XyncNet-02-13"
     if cr:  # has ref and created now
         await msg.answer(f"Здравствуйте {me.full_name}, что бы использовать возможности нашей сети, {rr}")
@@ -104,10 +103,10 @@ async def start_no_ref_handler(msg: Message):
         await msg.answer(f"{me.full_name}, не балуйтесь, вы и так уже активный участник👌🏼", reply_markup=home_btns)
 
 
-@main.callback_query(NavCallbackData.filter(F.to == "ref_link"))
+@mr.callback_query(NavCallbackData.filter(F.to == "ref_link"))
 async def ref_link_handler(cbq: CallbackQuery):
     me = cbq.from_user
-    if not (u := await User.get_or_none(id=me.id, blocked=False).prefetch_related("ref")):
+    if not (u := await models.User.get_or_none(id=me.id, blocked=False).prefetch_related("ref")):
         return await cbq.answer(f"{me.full_name}, сначала сами получите одобрение поручителя😉")
     link = await create_start_link(cbq.bot, str(u.id), encode=True)
     logging.info(f"Start: {me.id}. Msg: {cbq}")
@@ -119,36 +118,36 @@ async def ref_link_handler(cbq: CallbackQuery):
     await cbq.answer("Wait for your protege request..")
 
 
-@main.my_chat_member(F.chat.type == "private")  # my_chat_member is fired on add bot to any chat. filter for preventing
+@mr.my_chat_member(F.chat.type == "private")  # my_chat_member is fired on add bot to any chat. filter for preventing
 async def my_user_set_status(my_chat_member: ChatMemberUpdated):
     logging.info({"my_chat_member": my_chat_member.model_dump(exclude_none=True)})
-    u: TgUser = my_chat_member.from_user
+    u: User = my_chat_member.from_user
     blocked = my_chat_member.new_chat_member.status in ("left", "kicked")
-    await user_upsert(u, blocked)
+    await models.User.tg2in(u, blocked)
 
 
-@main.my_chat_member()
+@mr.my_chat_member()
 async def user_set_status(my_chat_member: ChatMemberUpdated):
     if my_chat_member.new_chat_member.user.username == "XyncNetBot":  # удалена группа где бот был добавлен админом
-        if forum := await Forum.get_or_none(id=my_chat_member.chat.id):
+        if forum := await models.Forum.get_or_none(id=my_chat_member.chat.id):
             await forum.delete()
         res = f"I {my_chat_member.new_chat_member.status} from {my_chat_member.chat.id}:{my_chat_member.chat.title}"
         return logging.info(res)
     logging.info({"my_chat_member": my_chat_member.model_dump(exclude_none=True)})
-    u: TgUser = my_chat_member.from_user
+    u: User = my_chat_member.from_user
     blocked = my_chat_member.new_chat_member.status in ("left", "kicked")
     if blocked:
-        if forum := await Forum.get_or_none(id=my_chat_member.chat.id, user_id=u.id):
+        if forum := await models.Forum.get_or_none(id=my_chat_member.chat.id, user_id=u.id):
             if forum.joined:
                 forum.joined = False
                 await forum.save()
-    await user_upsert(u, blocked)
+    return await models.User.tg2in(u, blocked)
 
 
-@main.chat_member(ChatMemberUpdatedFilter(LEAVE_TRANSITION))  # юзер покинул группу Ордеров
+@mr.chat_member(ChatMemberUpdatedFilter(LEAVE_TRANSITION))  # юзер покинул группу Ордеров
 async def on_user_leave(member: ChatMemberUpdated):
     logging.info({"user_leave": member.model_dump(exclude_none=True)})
-    if forum := await Forum[member.chat.id]:
+    if forum := await models.Forum[member.chat.id]:
         if forum.joined:
             forum.joined = False
             await forum.save()
@@ -156,10 +155,10 @@ async def on_user_leave(member: ChatMemberUpdated):
     return await member.bot.send_message(member.new_chat_member.user.id, resp)
 
 
-@main.chat_member(ChatMemberUpdatedFilter(JOIN_TRANSITION))  # Юзер добавился в группу Ордеров
+@mr.chat_member(ChatMemberUpdatedFilter(JOIN_TRANSITION))  # Юзер добавился в группу Ордеров
 async def on_user_join(member: ChatMemberUpdated, app_url: str):
     logging.info({"user_join": member.model_dump(exclude_none=True)})
-    if forum := await Forum.get_or_none(id=member.chat.id):
+    if forum := await models.Forum.get_or_none(id=member.chat.id):
         if not forum.joined:
             forum.joined = True
             await forum.save()
@@ -170,26 +169,26 @@ async def on_user_join(member: ChatMemberUpdated, app_url: str):
     return await member.bot.send_message(member.new_chat_member.user.id, resp, reply_markup=rm)
 
 
-@main.message(F.is_topic_message)
+@mr.message(F.is_topic_message)
 async def order_msg(msg: Message):
-    sender = await User[msg.from_user.id]
+    sender = await models.User[msg.from_user.id]
     cid = msg.chat.shifted_id
     assert sender.forum == cid, "sender is not client"
-    if order := await Order.get_or_none(taker__user_id=sender.id, taker_topic=msg.message_thread_id):
+    if order := await models.Order.get_or_none(taker__user_id=sender.id, taker_topic=msg.message_thread_id):
         is_taker = True
-    elif order := await Order.get_or_none(ad__agent__user_id=sender.id, maker_topic=msg.message_thread_id):
+    elif order := await models.Order.get_or_none(ad__agent__user_id=sender.id, maker_topic=msg.message_thread_id):
         is_taker = False
     else:
         return await msg.answer("No such order")
         # raise Exception("No such order")
-    receiver: User = await (order.ad.maker.user if is_taker else order.taker.user)
+    receiver: models.User = await (order.ad.maker.user if is_taker else order.taker.user)
     rcv_topic = order.taker_topic if is_taker else order.maker_topic
-    await Msg.create(tgid=msg.message_id, txt=msg.text, order_id=order.id, receiver=receiver)
+    await models.Msg.create(tgid=msg.message_id, txt=msg.text, order_id=order.id, receiver=receiver)
     logging.info(msg, {"src": "order_msg"})
     return await msg.send_copy(receiver.forum, message_thread_id=rcv_topic)
 
 
-@main.message(
+@mr.message(
     F.content_type.not_in(
         {
             ContentType.NEW_CHAT_MEMBERS,
@@ -211,7 +210,7 @@ async def del_cbq(msg: Message):
         logging.error({"NOT_DELETED": msg.model_dump(exclude_none=True)})
 
 
-@main.message()
+@mr.message()
 async def all_rest(msg: Message):
     logging.warning(
         {

xync_bot-0.3.7.dev4/xync_bot/routers/pay/main.py

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

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4/xync_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.6
+Version: 0.3.7.dev4
 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"

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4}/xync_bot.egg-info/SOURCES.txt

@@ -20,4 +20,5 @@ xync_bot/routers/photo.py
 xync_bot/routers/vpn.py
 xync_bot/routers/xicon.png
 xync_bot/routers/cond/__init__.py
-xync_bot/routers/cond/cond.py
+xync_bot/routers/cond/func.py
+xync_bot/routers/pay/main.py

{xync_bot-0.3.6 → xync_bot-0.3.7.dev4}/xync_bot.egg-info/requires.txt

@@ -1,3 +1,5 @@
+cyrtranslit
+xn-auth
 xync-schema
 
 [dev]

xync_bot-0.3.6/xync_bot/routers/__init__.py

@@ -1,8 +0,0 @@
-from aiogram.types import User
-from aiogram.utils.web_app import WebAppUser
-from xync_schema import models
-
-
-async def user_upsert(u: User | WebAppUser, blocked: bool = None) -> tuple[User, bool]:
-    user_in: models.User.Upd = await models.User.tg2in(u, blocked)
-    return await models.User.update_or_create(user_in.model_dump(exclude_none=True, exclude={"id"}), id=u.id)

xync_bot-0.3.6/xync_bot/routers/cond/__init__.py

@@ -1,153 +0,0 @@
-import re
-from asyncio import iscoroutinefunction
-from enum import IntEnum
-from inspect import isclass
-from typing import Coroutine
-
-from aiogram import Router, F
-from aiogram.filters import CommandStart
-from aiogram.fsm.context import FSMContext
-from aiogram.types import Message, ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton, \
-    CallbackQuery, ReplyKeyboardRemove
-from cyrtranslit import to_latin
-from xync_schema import models
-from xync_schema.enums import SynonymType, Party, Slip, AbuserType, NameType, Boundary
-
-r = Router()
-
-async def wrap_cond(txt: str):
-    bnks = await models.Synonym.filter(typ=SynonymType.bank)
-    bnks = '|'.join('\\b'+b.txt+('\\b' if b.boundary&Boundary.right else '') for b in bnks)
-    for syn in await models.Synonym.all():
-        lb, rb = "\\b" if syn.boundary&Boundary.left else "", "\\b" if syn.boundary&Boundary.right else ""
-        if syn.typ == SynonymType.bank_side:
-            syn.txt.replace('#banks#', f'({bnks})')
-        if syn.is_re or syn.txt in txt:
-            pattern = re.compile(lb+syn.txt+rb)
-            if match := re.search(pattern, txt):
-                g = match.group()
-                val, hval = await get_val(syn.typ, syn.val)
-                val = syn.typ.name + (f'="{hval}"' if hval else '')
-                txt = re.sub(pattern, f"<code>{g}</code><tg-spoiler>[{val}]</tg-spoiler>", txt)
-    return txt
-
-async def cbanks(bnid: str) -> list[tuple[int, str]]:
-    beginning = to_latin(bnid[:2], lang_code='ru')
-    return await models.Pm.filter(norm__startswith=beginning, bank=True).values_list('id', 'norm')
-
-async def cppo(txt: str) -> list[tuple[int, str]]:
-    opts = re.findall(r'\d+', txt) or [1, 2, 3, 5, 10]
-    return [(o, str(o)) for o in opts]
-
-synopts: dict[SynonymType, list[str] | type(IntEnum) | None | Coroutine] = {
-    SynonymType.name: ["not_slavic", "slavic"],
-    SynonymType.ppo: cppo,
-    SynonymType.from_party: Party,
-    SynonymType.to_party: Party,
-    SynonymType.slip_req: Slip,
-    SynonymType.slip_send: Slip,
-    SynonymType.abuser: AbuserType,
-    SynonymType.scale: ["1", "10", "100", "1000"],
-    SynonymType.slavic: NameType,
-    SynonymType.mtl_like: None,
-    SynonymType.bank: cbanks,
-    SynonymType.bank_side: ["except", "only"],
-}
-rkm = ReplyKeyboardMarkup(keyboard=[
-    [KeyboardButton(text="ppo"), KeyboardButton(text="abuser")],
-    [KeyboardButton(text="from_party"), KeyboardButton(text="to_party")],
-    [KeyboardButton(text="slip_send"), KeyboardButton(text="slip_req")],
-    [KeyboardButton(text="name"), KeyboardButton(text="slavic")],
-    [KeyboardButton(text="scale"), KeyboardButton(text="mtl_like")],
-    [KeyboardButton(text="bank"), KeyboardButton(text="bank_side")],
-], one_time_keyboard=True)
-
-async def get_val(typ: SynonymType.__class__, val: str) -> tuple[SynonymType | int | bool, str]:
-    if isinstance(val, str) and val.isnumeric():
-        val = int(val)
-    if isclass(lst := synopts[typ]) and issubclass(lst, IntEnum):
-        return (v:=lst(val)), v.name
-    elif isinstance(lst, list):
-        return val, lst[val]
-    elif typ == SynonymType.bank:
-        return val, (await models.Pm[val]).norm
-    return val, val
-
-async def btns(typ: SynonymType.__class__, txt: str = None) -> InlineKeyboardMarkup | None:
-    if lst := synopts[typ]:
-        if isinstance(lst, list):
-            kb = [[InlineKeyboardButton(text=n, callback_data=f'st:{typ.name}:{i}')] for i, n in enumerate(lst)]
-        elif isclass(lst) and issubclass(lst, IntEnum):
-            kb = [[InlineKeyboardButton(text=i.name, callback_data=f'st:{typ.name}:{i.value}')] for i in lst]
-        else:
-            kb = [[InlineKeyboardButton(text=n, callback_data=f'st:{typ.name}:{i}')] for i, n in await lst(txt)]
-        return InlineKeyboardMarkup(inline_keyboard=kb)
-    else:
-        return lst
-
-@r.message(CommandStart())
-async def start(msg: Message, state: FSMContext):
-    cond = await models.Cond.filter(parsed__isnull=True).order_by("-created_at").first().prefetch_related('parsed')
-    await state.set_data({"cid": cond.id, "cond_txt": cond.raw_txt})
-    await msg.reply(await wrap_cond(cond.raw_txt), reply_markup=rkm)
-
-
-@r.message(F.quote)
-async def got_synonym(msg: Message, state: FSMContext):
-    if not (msg.text in {st.name for st in SynonymType} and SynonymType[msg.text]):
-        return await msg.reply_text(f'Нет раздела "{msg.text}", не пиши текст сам, выдели кусок из моего сообщения,'
-                                    f'ответь на него, выбери кнопку раздела')
-    if not msg.quote:
-        return await msg.reply_text(f'Вы забыли выделить кусок текста для {msg.text}')
-    if typ := SynonymType[msg.text]:
-        await state.update_data({"syntext": msg.quote.text, "cmsg": msg.reply_to_message})
-        await models.Synonym.update_or_create({"typ": typ}, txt=msg.quote.text)
-        if rm := await btns(typ, msg.quote.text):
-            return await msg.answer("Уточните", reply_markup=rm, reply_to_message_id=msg.message_id)
-        await syn_result(msg, f'st:{typ.name}:1', state)
-    return None
-
-@r.callback_query()
-async def got_synonym_val(cbq: CallbackQuery, state: FSMContext):
-    await syn_result(cbq.message, cbq.data, state)
-
-async def syn_result(msg: Message, data: str, state: FSMContext):
-    t, st, sv = data.split(':')
-    if t == "st":
-        typ = SynonymType[st]
-        val, hval = await get_val(typ, sv)
-        syntext = await state.get_value('syntext')
-        cid = await state.get_value('cid')
-        syn, _ = await models.Synonym.update_or_create({"val": val}, typ=typ, txt=syntext)
-        await models.CondParsed.update_or_create({typ.name: val}, cond_id=cid)
-        await msg.reply(
-            f'Текст "{syntext}" определен как синоним для `{typ.name}` со значением {hval}',
-            reply_markup=InlineKeyboardMarkup(inline_keyboard=[[
-                InlineKeyboardButton(text='Готово! Давай новый', callback_data=f'cond:complete:{cid}'),
-                InlineKeyboardButton(text='Продолжить с этим текстом', callback_data=f'cond:process:{cid}')
-            ]])
-        )
-        # await msg.reply_to_message.delete()
-        # await msg.delete()
-        # await cmsg.edit_text(wrapped_txt)
-
-    elif t == "cond":
-        if st == 'complete':
-            await models.CondParsed.update_or_create({"parsed": True}, cond_id=int(sv))
-            await start(msg, state)
-        else:
-            wrapped_txt = await wrap_cond(await state.get_value('cond_txt'))
-            # cmsg: Message = await state.get_value('cmsg')
-            await msg.reply(wrapped_txt, reply_markup=rkm)
-    else:
-        await msg.reply("Где я?")
-
-@r.message(F.reply_to_message)
-async def clear(msg: Message):
-    await msg.reply_to_message.delete_reply_markup()
-    await msg.delete()
-
-@r.message()
-async def unknown(msg: Message):
-    # user = await User.get(username_id=msg.from_user.id)
-    await msg.delete()