xync-bot 0.3.25.dev1__tar.gz → 0.3.26.dev0__tar.gz

{xync_bot-0.3.25.dev1/xync_bot.egg-info → xync_bot-0.3.26.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.25.dev1
+Version: 0.3.26.dev0
 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.25.dev1 → xync_bot-0.3.26.dev0}/xync_bot/__main__.py

@@ -6,11 +6,12 @@ from aiogram.client.default import DefaultBotProperties
 from aiogram.enums import UpdateType
 from x_model import init_db
 
+from xync_bot.store import Store
 from xync_bot.routers.main.handler import mr
 from xync_bot.routers.cond import cr
 from xync_bot.routers.pay.handler import pr
 from xync_bot.routers import last
-from xync_bot.store import Store
+from xync_bot.routers.send import sd
 
 au = [
     UpdateType.MESSAGE,
@@ -18,7 +19,7 @@ au = [
     UpdateType.CHAT_MEMBER,
     UpdateType.MY_CHAT_MEMBER,
 ]  # , UpdateType.CHAT_JOIN_REQUEST
-bot = Bot([cr, pr, mr, last], Store(), au, default=DefaultBotProperties(parse_mode="HTML"))
+bot = Bot([sd, cr, pr, mr, last], Store(), au, default=DefaultBotProperties(parse_mode="HTML"))
 
 if __name__ == "__main__":
     from xync_bot.loader import TOKEN, TORM

{xync_bot-0.3.25.dev1 → xync_bot-0.3.26.dev0}/xync_bot/routers/pay/handler.py

@@ -15,46 +15,53 @@ pr = Router(name="pay")
 
 
 @pr.message(Command("pay"))
-async def h_start(msg: Message, store: Store):
+async def h_start(msg: Message, store: Store, **kwargs):
     """Step 1: Select a target type"""
-    store.curr.is_target = True
+    uid = msg.from_user.id
+    store.pers[uid] = Store.Personal(1)
+    store.pers[uid].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)
+    store.pers[uid].user = await models.User.get(username_id=msg.from_user.id)
+    store.pers[uid].creds, store.pers[uid].cur_creds = await fill_creds(store.pers[uid].user.person_id)
+    store.pers[uid].actors = await fill_actors(store.pers[uid].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
+    uid = query.from_user.id
+    store.pers[uid].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
+    uid = query.from_user.id
+    store.pers.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)
+    uid = query.from_user.id
+    setattr(store.pay, ("t" if store.pers.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)
+    uid = query.from_user.id
+    setattr(store.pay, ("t" if store.pers.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"""
+    uid = query.from_user.id
     store.pay.t_pmcur_id = callback_data.pmcur_id
     await gather(
         window.fill_cred_dtl(query.message, store),
@@ -65,6 +72,7 @@ async def h_got_target_pm(query: CallbackQuery, callback_data: cd.Pm, state: FSM
 
 @pr.callback_query(cd.Cred.filter())
 async def h_got_cred(query: CallbackQuery, callback_data: cd.Cred, state: FSMContext, store: Store):
+    uid = query.from_user.id
     store.pay.cred_id = callback_data.id
     await gather(
         window.amount(query.message, store), ans(query, "Теперь нужна сумма"), state.set_state(dep.PaymentState.amount)
@@ -81,25 +89,27 @@ async def h_got_cred_dtl(msg: Message, state: FSMContext, store: Store):
 @pr.message(dep.CredState.name)
 async def h_got_cred_name(msg: Message, state: FSMContext, store: Store):
     """Step 5f: Save target cred"""
+    uid = msg.from_user.id
     cred, _ = await models.Cred.update_or_create(
         {"name": msg.text},
         detail=store.pay.cred_dtl,
-        person_id=store.perm.user.person_id,
+        person_id=store.pers[uid].user.person_id,
         pmcur_id=store.pay.t_pmcur_id,
     )
     store.pay.cred_id = cred.id
-    store.perm.creds[cred.id] = cred
+    store.pers[uid].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
+    uid = query.from_user.id
+    ist = store.pers.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]
+        actor_id = store.pers[uid].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:
@@ -111,19 +121,23 @@ async def h_got_ex(query: CallbackQuery, callback_data: cd.Ex, state: FSMContext
 @pr.message(dep.PaymentState.amount)
 async def h_got_amount(msg: Message, state: FSMContext, store: Store):
     """Step 6: Save a target amount"""
+    uid = msg.from_user.id
     if not msg.text.isnumeric():
-        store.curr.msg_to_del = await msg.answer("Пожалуйста, введите корректное число")
+        store.pers.curr.msg_to_del = await msg.answer("Пожалуйста, введите корректное число")
         return
-    if store.curr.msg_to_del:
-        await store.curr.msg_to_del.delete()
+    if store.pers.curr.msg_to_del:
+        await store.pers.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())
+    store.pers.curr.is_target = False
+    await gather(
+        (window.type_select if store.pers.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):
+    uid = query.from_user.id
     store.pay.s_pmcur_id = callback_data.pmcur_id
     await gather(
         window.set_ppo(query.message, store),
@@ -133,12 +147,14 @@ async def h_got_source_pm(query: CallbackQuery, callback_data: cd.Pm, store: Sto
 
 @pr.callback_query(cd.Ppo.filter())
 async def h_got_ppo(query: CallbackQuery, callback_data: cd.Ppo, store: Store):
+    uid = query.from_user.id
     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):
+    # payreq_id = store.pers[query.from_user.id].
     store.pay.urg = callback_data.minutes
     await window.create_payreq(query.message, store)
     await ans(query, f"Ok {callback_data.minutes} min.")
@@ -147,6 +163,7 @@ async def h_got_urgency(query: CallbackQuery, callback_data: cd.Time, store: Sto
 # ACTIONS
 @pr.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.received)))
 async def payment_confirmed(query: CallbackQuery, state: FSMContext):
+    uid = query.from_user.id
     await ans(query, None)
     payed_at = datetime.now()
     await state.update_data(timer_active=False, payed_at_formatted=payed_at)
@@ -161,6 +178,7 @@ async def payment_confirmed(query: CallbackQuery, state: FSMContext):
 
 @pr.callback_query(cd.Action.filter(F.act.__eq__(cd.ActionType.not_received)))
 async def no_payment(query: CallbackQuery, state: FSMContext):
+    uid = query.from_user.id
     await ans(query, None)
     await state.update_data(timer_active=False)
     await query.message.edit_text("Платеж не получен!")
@@ -171,6 +189,7 @@ async def no_payment(query: CallbackQuery, state: FSMContext):
 
 @pr.message(dep.Report.text)
 async def payment_not_specified(msg: Message, state: FSMContext):
+    uid = msg.from_user.id
     await state.update_data(text=msg.text)
     data = await state.get_data()
     complaint_text = (

{xync_bot-0.3.25.dev1 → xync_bot-0.3.26.dev0}/xync_bot/routers/pay/window.py

@@ -13,7 +13,8 @@ from xync_bot.store import Store
 
 async def type_select(msg: Message, store: Store):
     """Step 1: Select type"""
-    ist: bool = store.curr.is_target
+    uid = msg.from_user.id
+    ist: bool = store.pers[uid].curr.is_target
     rm = InlineKeyboardMarkup(
         inline_keyboard=[
             [
@@ -21,26 +22,27 @@ async def type_select(msg: Message, store: Store):
                     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()
+                    text="Крипта",
+                    callback_data=cd.MoneyType(is_fiat=0, is_target=store.pers[uid].curr.is_target).pack(),
                 ),
             ]
         ]
     )
-    if store.curr.is_target:
+    if store.pers[uid].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}"
+        if store.pers[uid].pay.t_coin_id:
+            inf = f"{store.glob.coins[store.pers[uid].pay.t_coin_id]} на {store.glob.exs[store.pers[uid].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]
+            cred: models.Cred = store.pers[uid].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:
+    if store.pers[uid].msg_id:
         await edt(msg, txt, rm)
     else:
         msg = await msg.answer(txt, reply_markup=rm)
-        store.perm.msg_id = msg.message_id
+        store.pers[uid].msg_id = msg.message_id
 
 
 async def cur_select(msg: Message, store: Store):
@@ -100,11 +102,12 @@ async def pm(msg: Message, store: Store):
 
 
 async def fill_cred_dtl(msg: Message, store: Store):
+    uid = msg.from_user.id
     builder = InlineKeyboardBuilder()
     txt = "В"
-    if cred_ids := store.perm.cur_creds.get(store.pay.t_pmcur_id):
+    if cred_ids := store.pers[uid].cur_creds.get(store.pay.t_pmcur_id):
         for cred_id in cred_ids:
-            cred = store.perm.creds[cred_id]
+            cred = store.pers[uid].creds[cred_id]
             builder.button(text=cred.repr(), callback_data=cd.Cred(id=cred_id))
         txt = "Выберите реквизиты куда нужно получить деньги, если в списке нет нужных, то\nв"
 
@@ -182,13 +185,14 @@ async def set_urgency(msg: Message, store: Store):
 
 
 async def create_payreq(msg: Message, store: Store):
+    uid = msg.from_user.id
     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,
+        user=store.pers[uid].user,
     )
     store.pay.pr_id = pay_req.id
     inp, txt = await store.get_merch_target()
@@ -206,14 +210,14 @@ async def create_payreq(msg: Message, store: Store):
     # create_task(window.run_timer(msg))В
 
 
-async def run_timer(message, state: FSMContext):
+async def run_timer(msg, 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())
+        await msg.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
     except Exception:
         return
 
@@ -221,7 +225,7 @@ async def run_timer(message, state: FSMContext):
         await sleep(1)
         seconds -= 1
         try:
-            await message.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
+            await msg.edit_text(f"⏳ Осталось {fmt_sec(seconds)}", reply_markup=builder.as_markup())
             await state.update_data(timer=seconds)
         except Exception:
             break
@@ -231,7 +235,7 @@ async def run_timer(message, state: FSMContext):
         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())
+            await msg.edit_text("⏳ Время вышло!", reply_markup=builder.as_markup())
         except Exception:
             pass
 

xync_bot-0.3.26.dev0/xync_bot/routers/send/__init__.py

@@ -0,0 +1,117 @@
+from aiogram import Router
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import StatesGroup, State
+from aiogram.types import Message
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from aiogram.filters import Command
+from xync_schema import models
+from aiogram.filters.callback_data import CallbackData
+from aiogram import types
+
+sd = Router()
+
+
+class SendStates(StatesGroup):
+    waiting_for_recipient = State()
+    waiting_for_amount = State()
+
+
+class Cur(CallbackData, prefix="Сur"):
+    id: int
+
+
+@sd.message(Command("send"))
+async def start(message: Message, state: FSMContext):
+    await message.answer(
+        "Введите ID/username получателя:",
+    )
+
+    await state.set_state(SendStates.waiting_for_recipient)
+
+
+@sd.message(SendStates.waiting_for_recipient)
+async def process_recipient(message: Message, state: FSMContext):
+    recipient = message.text
+
+    if recipient.isdigit():
+        user_id = int(recipient)
+        user_receiver = await models.User.get_or_none(username_id=user_id)
+
+        if not user_receiver:
+            my_id = message.from_user.id
+            await message.answer(
+                f"Такого пользователя еще нет в XyncPay, вот ссылка для регистрации с вашим реферальным бонусом: \n"
+                f"https://t.me/XyncPayBot?start={my_id}"
+            )
+            return
+        else:
+            await state.update_data(receiver=user_receiver)
+    else:
+        user_receiver = await models.User.get_or_none(username__username=recipient)
+
+        if not user_receiver:
+            my_id = message.from_user.id
+            await message.answer(
+                f"Такого пользователя еще нет в XyncPay, вот ссылка для регистрации с вашим реферальным бонусом: \n"
+                f"https://t.me/XyncPayBot?start={my_id}"
+            )
+            return
+        await state.update_data(receiver=user_receiver)
+
+    # Продолжаем процесс выбора валюты
+    builder = InlineKeyboardBuilder()
+    curs = await models.Cur.filter(
+        ticker__in=[
+            "CNY",
+            "HKD",
+            "USD",
+            "VND",
+            "MYR",
+            "TWD",
+            "RUB",
+            "AUD",
+            "CAD",
+            "SGD",
+            "GBP",
+            "EUR",
+            "PHP",
+            "INR",
+            "CHF",
+            "IDR",
+            "BRL",
+            "SAR",
+            "AED",
+            "TRY",
+            "THB",
+        ]
+    )
+
+    for cur in curs:
+        builder.button(text=cur.ticker, callback_data=Cur(id=cur.id).pack())
+
+    builder.adjust(3, 3, 3)
+    await message.answer("Выбери валюту", reply_markup=builder.as_markup())
+
+
+@sd.callback_query(Cur.filter())
+async def waiting_for_amount(query: types.CallbackQuery, state: FSMContext, callback_data: Cur):
+    await state.update_data(cur=callback_data.id)
+    await query.message.answer("Введите сумму: ")
+    await state.set_state(SendStates.waiting_for_amount)
+
+
+@sd.message(SendStates.waiting_for_amount)
+async def waiting_for_recipient(message: Message, state: FSMContext):
+    amount = int(message.text)
+    if amount < 0:
+        await message.answer("Введите положительное число")
+    else:
+        await state.update_data(amount=amount)
+        my_id = message.from_user.id
+        await state.update_data(sender=my_id)
+        data = await state.get_data()
+        await state.clear()
+        me = await models.User.get(username_id=my_id)
+        await models.Transfer.create(
+            amount=data["amount"], cur_id=data["cur"], receiver_id=data["receiver"].id, sender=me
+        )

{xync_bot-0.3.25.dev1 → xync_bot-0.3.26.dev0}/xync_bot/store.py

@@ -62,17 +62,15 @@ class Store:
             msg_to_del: Message = None
 
         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]
 
-        def __init__(self, order_id: int):
-            self.order_id = order_id
+        def __init__(self, user: User):
+            self.user: User = user
+            self.curr = self.Current()
 
-        curr: Current = Current()
-
-    class PayReq:
+    class Pr:
         t_cur_id: int = None
         s_cur_id: int = None
         t_coin_id: int = None
@@ -151,7 +149,3 @@ class Store:
             if not cred:
                 logging.error(f"No {cur.ticker} cred for {pm}")
             return cred, f"{cur.ticker} на {pm} по номеру: {cred.repr()}"
-
-    glob: Global
-    pers: dict[int, Personal] = {}
-    payreq: dict[int, PayReq] = {}

{xync_bot-0.3.25.dev1 → xync_bot-0.3.26.dev0/xync_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-bot
-Version: 0.3.25.dev1
+Version: 0.3.26.dev0
 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.25.dev1 → xync_bot-0.3.26.dev0}/xync_bot.egg-info/SOURCES.txt

@@ -27,4 +27,5 @@ xync_bot/routers/main/handler.py
 xync_bot/routers/pay/cd.py
 xync_bot/routers/pay/dep.py
 xync_bot/routers/pay/handler.py
-xync_bot/routers/pay/window.py
+xync_bot/routers/pay/window.py
+xync_bot/routers/send/__init__.py