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

xync_bot/routers/{main.py → main/handler.py}

@@ -1,12 +1,10 @@
 import logging
 
 from aiogram import Router, F
-from aiogram.enums import ContentType
-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 +13,12 @@ from aiogram.types import (
     WebAppInfo,
 )
 from aiogram.utils.deep_linking import create_start_link
-from xync_schema.models import User, Order, Msg, Forum
+from xync_schema import models
 
-from xync_bot.routers import user_upsert
 from xync_bot.shared import NavCallbackData
+from xync_bot.store import Store
 
-main = Router()
+mr = Router(name="main")
 
 
 class RrCallbackData(CallbackData, prefix="reg_res"):  # registration response
@@ -31,6 +29,7 @@ class RrCallbackData(CallbackData, prefix="reg_res"):  # registration response
 home_btns = InlineKeyboardMarkup(
     inline_keyboard=[
         [
+            InlineKeyboardButton(text="Transfer", callback_data=NavCallbackData(to="transfer").pack()),
             InlineKeyboardButton(text="Invite", callback_data=NavCallbackData(to="ref_link").pack()),
             InlineKeyboardButton(text="Get VPN", callback_data=NavCallbackData(to="get_vpn").pack()),
         ]
@@ -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,36 +66,20 @@ async def start_handler(msg: Message, command: CommandObject):
     return await msg.answer(rs, reply_markup=rm)
 
 
-@main.callback_query(RrCallbackData.filter())
-async def phrases_input_request(cb: CallbackQuery, callback_data: RrCallbackData) -> None:
-    protege = await User[callback_data.to]
-    if callback_data.res:
-        # protege.status = UserStatus.RESTRICTED
-        await protege.save()
-        rs = f"{cb.from_user.full_name}, теперь Вы несете ответветвенность за {protege.username}"
-    else:
-        rs = f'Вы отклонили запрос юзера "{protege.username}" на Вашу протекцию'
-    res = {True: "одобрил", False: "отклонил"}
-    txt = f"{cb.from_user.full_name} {res[callback_data.res]} вашу регистрацию"
-    txt, rm = (f"Поздравляем! {txt}💥", home_btns) if callback_data.res else (f"К сожалению {txt}😢", None)
-    await cb.bot.send_message(protege.id, txt, reply_markup=rm)
-    await cb.answer("👌🏼")
-    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())
-async def start_no_ref_handler(msg: Message):
+@mr.message(CommandStart())  # обычный /start
+async def home(msg: Message, store: Store):
     me = msg.from_user
-    user, cr = await user_upsert(me, False)
+    user, is_new = await models.User.tg_upsert(me, False)
+
     rr = "сначала вы должны найти поручителя, и перейти по его реферальной ссылке.\nhttps://telegra.ph/XyncNet-02-13"
-    if cr:  # has ref and created now
+    if is_new:  # has ref and created now
         await msg.answer(f"Здравствуйте {me.full_name}, что бы использовать возможности нашей сети, {rr}")
     elif not user.ref_id:
         await msg.answer(rr.capitalize())
@@ -104,10 +87,27 @@ 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(RrCallbackData.filter())
+async def phrases_input_request(cb: CallbackQuery, callback_data: RrCallbackData) -> None:
+    protege = await models.User[callback_data.to]
+    if callback_data.res:
+        # protege.status = UserStatus.RESTRICTED
+        await protege.save()
+        rs = f"{cb.from_user.full_name}, теперь Вы несете ответветвенность за {protege.username}"
+    else:
+        rs = f'Вы отклонили запрос юзера "{protege.username}" на Вашу протекцию'
+    res = {True: "одобрил", False: "отклонил"}
+    txt = f"{cb.from_user.full_name} {res[callback_data.res]} вашу регистрацию"
+    txt, rm = (f"Поздравляем! {txt}💥", home_btns) if callback_data.res else (f"К сожалению {txt}😢", None)
+    await cb.bot.send_message(protege.id, txt, reply_markup=rm)
+    await cb.answer("👌🏼")
+    await cb.message.edit_text(rs)
+
+
+@mr.callback_query(NavCallbackData.filter(F.to.__eq__("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 +119,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 +156,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,53 +170,20 @@ 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(
-    F.content_type.not_in(
-        {
-            ContentType.NEW_CHAT_MEMBERS,
-            # ContentType.LEFT_CHAT_MEMBER,
-            # ContentType.SUPERGROUP_CHAT_CREATED,
-            # ContentType.NEW_CHAT_PHOTO,
-            # ContentType.FORUM_TOPIC_CREATED,
-            # ContentType.FORUM_TOPIC_EDITED,
-            ContentType.FORUM_TOPIC_CLOSED,
-            # ContentType.GENERAL_FORUM_TOPIC_HIDDEN, # deletable
-        }
-    )
-)
-async def del_cbq(msg: Message):
-    try:
-        await msg.delete()
-        logging.info({"DELETED": msg.model_dump(exclude_none=True)})
-    except TelegramBadRequest:
-        logging.error({"NOT_DELETED": msg.model_dump(exclude_none=True)})
-
-
-@main.message()
-async def all_rest(msg: Message):
-    logging.warning(
-        {
-            "NO_HANDLED": msg.model_dump(
-                exclude_none=True,
-            )
-        }
-    )

xync_bot/routers/pay/cd.py

@@ -0,0 +1,49 @@
+from aiogram.filters.callback_data import CallbackData
+
+from xync_bot.routers.pay.dep import PayStep, ActionType
+
+
+class MoneyType(CallbackData, prefix="target"):
+    is_fiat: int  # bool
+    is_target: int  # bool
+
+
+class Cur(CallbackData, prefix="cur"):
+    id: int
+    is_target: int  # bool
+
+
+class Coin(CallbackData, prefix="coin"):
+    id: int
+    is_target: int  # bool
+
+
+class Cred(CallbackData, prefix="cred"):
+    id: int
+
+
+class Ex(CallbackData, prefix="ex"):
+    id: int
+    is_target: int  # bool
+
+
+class Pm(CallbackData, prefix="pm"):
+    pmcur_id: int
+    is_target: bool
+
+
+class Ppo(CallbackData, prefix="ppo"):
+    num: int
+    is_target: int  # bool
+
+
+class PayNav(CallbackData, prefix="pay_nav"):
+    to: PayStep
+
+
+class Time(CallbackData, prefix="time"):
+    minutes: int  # время в минутах
+
+
+class Action(CallbackData, prefix="action"):
+    act: ActionType  # "received" или "not_received"

xync_bot/routers/pay/dep.py

@@ -0,0 +1,270 @@
+import logging
+from asyncio import gather
+from enum import IntEnum
+
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.fsm.state import StatesGroup, State
+from aiogram.types import Message, InlineKeyboardMarkup
+from pyrogram.types import CallbackQuery
+from tortoise.functions import Min
+from x_auth.enums import Role
+from x_model.func import ArrayAgg
+from xync_schema import models
+
+from xync_bot.shared import flags
+
+
+class Report(StatesGroup):
+    text = State()
+
+
+class CredState(StatesGroup):
+    detail = State()
+    name = State()
+
+
+class PaymentState(StatesGroup):
+    amount = State()
+    timer = State()
+    timer_active = State()
+
+
+class ActionType(IntEnum):
+    """Цель (назначение) платежа (target)"""
+
+    sent = 1  # Отправил
+    received = 2  # Получил
+    not_received = 3  # Не получил
+
+
+class PayStep(IntEnum):
+    """Цель (назначение) платежа (target)"""
+
+    t_type = 1  # Выбор типа
+    t_cur = 2  # Выбор валюты
+    t_coin = 3  # Выбор монеты
+    t_pm = 4  # Выбор платежки
+    t_ex = 5  # Выбор биржи
+    t_cred_dtl = 6  # Ввод номера карты
+    t_cred_name = 7  # Ввод имени
+    # t_addr = 8 # todo: позже добавим: Выбор/ввод крипто кошелька
+    t_amount = 9  # Ввод суммы
+    """ Источник платежа (source) """
+    s_type = 10  # Выбор типа
+    s_cur = 11  # Выбор типа
+    s_pm = 12  # Выбор типа
+    s_coin = 13  # Выбор типа
+    s_ex = 14  # Выбор типа
+    ppo = 15  # Выбор возможности разбивки платежа
+    urgency = 16  # Выбор срочности получения платежа
+    pending_send = 17  # Ожидание отправки (если мы платим фиатом)
+    pending_confirm = 18  # Ожидание пока на той стороне подтвердят получение нашего фиата (если мы платим фиатом)
+    pending_receive = 19  # Ожидание поступления (если мы получаем фиат)
+
+
+class SingleStore(type):
+    _store = None
+
+    async def __call__(cls):
+        if not cls._store:
+            cls._store = super(SingleStore, cls).__call__()
+            cls._store.coins = {k: v for k, v in await models.Coin.all().order_by("ticker").values_list("id", "ticker")}
+            curs = {c.id: c for c in await models.Cur.filter(ticker__in=flags.keys()).order_by("ticker")}
+            cls._store.curs = curs
+            cls._store.exs = {k: v for k, v in await models.Ex.all().values_list("id", "name")}
+            cls._store.pmcurs = {
+                k: v
+                for k, v in await models.Pmex.filter(pm__pmcurs__cur_id__in=cls._store.curs.keys())
+                .annotate(sname=Min("name"))
+                .group_by("pm__pmcurs__id")
+                .values_list("pm__pmcurs__id", "sname")
+            }
+            cls._store.coinexs = {
+                c.id: [ex.ex_id for ex in c.coinexs] for c in await models.Coin.all().prefetch_related("coinexs")
+            }
+            cls._store.curpms = {
+                cur_id: ids
+                for cur_id, ids in await models.Pmcur.filter(cur_id__in=curs.keys())
+                .annotate(ids=ArrayAgg("id"))
+                .group_by("cur_id")
+                .values_list("cur_id", "ids")
+            }
+            cls._store.curpms = {
+                cur_id: ids
+                for cur_id, ids in await models.Pmcur.filter(cur_id__in=curs.keys())
+                .annotate(ids=ArrayAgg("id"))
+                .group_by("cur_id")
+                .values_list("cur_id", "ids")
+            }
+
+        return cls._store
+
+
+class Store:
+    class Global(metaclass=SingleStore):
+        coins: dict[int, str]  # id:ticker
+        curs: dict[int, models.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: models.User = None
+        actors: dict[int, int] = None  # key=ex_id
+        creds: dict[int, models.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 models.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 models.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[models.Addr | models.Cred, str]:
+        if self.pay.t_ex_id:
+            addr_to = (
+                await models.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[models.Addr | models.Cred, str]:
+        if self.pay.s_ex_id:
+            addr_in = (
+                await models.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 models.Pmcur.get(id=self.pay.s_pmcur_id).prefetch_related("pm__grp")
+        cred = await models.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()}"
+
+
+async def fill_creds(person_id: int) -> tuple[dict[int, models.Cred], dict[int, list[int]]]:
+    cq = models.Cred.filter(person_id=person_id)
+    creds = {c.id: c for c in await cq}
+    cur_creds = {
+        pci: ids
+        for pci, ids in await cq.annotate(ids=ArrayAgg("id")).group_by("pmcur_id").values_list("pmcur_id", "ids")
+    }
+    return creds, cur_creds
+
+
+async def fill_actors(person_id: int) -> dict[int, int]:
+    ex_actors = {
+        # todo: check len(ids) == 1
+        exi: ids[0]
+        for exi, ids in await models.Actor.filter(person_id=person_id)
+        .annotate(ids=ArrayAgg("id"))
+        .group_by("ex_id")
+        .values_list("ex_id", "ids")
+    }
+    return ex_actors
+
+
+async def edit(msg: Message, txt: str, rm: InlineKeyboardMarkup):
+    await gather(msg.edit_text(txt), msg.edit_reply_markup(reply_markup=rm))
+
+
+async def ans(cbq: CallbackQuery, txt: str = None):
+    await cbq.answer(txt, cache_time=0)
+
+
+async def dlt(msg: Message):
+    await msg.delete()
+
+
+async def edt(msg: Message, txt: str, rm: InlineKeyboardMarkup):
+    if msg.message_id == msg.bot.store.perm.msg_id:
+        await msg.edit_text(txt, reply_markup=rm)
+    else:  # окно вызвано в ответ на текст, а не кнопку
+        try:
+            await msg.bot.edit_message_text(
+                txt, chat_id=msg.chat.id, message_id=msg.bot.store.perm.msg_id, reply_markup=rm
+            )
+        except TelegramBadRequest as e:
+            print(msg.bot.store.perm.msg_id, e)
+
+
+def fmt_sec(sec: int):
+    days = sec // (24 * 3600)
+    sec %= 24 * 3600
+    hours = sec // 3600
+    sec %= 3600
+    minutes = sec // 60
+    sec %= 60
+
+    if days > 0:
+        return f"{days}д {hours:02d}:{minutes:02d}:{sec:02d}"
+    elif hours > 0:
+        return f"{hours:02d}:{minutes:02d}:{sec:02d}"
+    else:
+        return f"{minutes:02d}:{sec:02d}"