xync-client 0.0.141__py3-none-any.whl → 0.0.155__py3-none-any.whl

xync_client/Abc/xtype.py

@@ -3,7 +3,7 @@ from typing import Literal
 from pydantic import BaseModel, model_validator
 from x_model.types import BaseUpd
 from xync_schema.enums import PmType
-from xync_schema.models import Country, Pm, Ex
+from xync_schema.models import Country, Pm, Ex, CredEx
 from xync_schema.xtype import PmExBank
 
 from xync_client.pm_unifier import PmUni
@@ -53,7 +53,9 @@ class BaseOrderReq(BaseModel):
     asset_amount: float | None = None
     fiat_amount: float | None = None
 
-    # todo: mv from to base to special ex class
+    pmex_exid: str = None  # int
+
+    # todo: mv from base to special ex class
     amount_is_fiat: bool = True
     is_sell: bool = None
     cur_exid: int | str = None
@@ -106,3 +108,23 @@ class BaseCad(BaseAdUpdate):
     side: Literal[0, 1]  # 0 - покупка, 1 - продажа
     tokenId: str
     userId: str
+
+
+class GetAds(BaseModel):
+    coin_id: int | str
+    cur_id: int | str
+    is_sell: bool
+    pm_ids: list[int | str] | None = None
+    amount: int | None = None
+
+
+class AdUpd(BaseAdUpdate, GetAds):
+    price: float
+    pm_ids: list[int | str]
+    amount: float
+    premium: float | None = None
+    credexs: list[CredEx] | None = None
+    quantity: float | None = None
+
+    class Config:
+        arbitrary_types_allowed = True

xync_client/Bybit/InAgent.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import re
+import traceback
 from datetime import datetime, timezone, timedelta
 from uuid import uuid4
 
@@ -8,12 +9,15 @@ import websockets
 from asyncio import run, sleep
 from decimal import Decimal
 
+from bybit_p2p import P2P
 from playwright.async_api import async_playwright
 from pydantic import ValidationError
 from pyro_client.client.file import FileClient
 from tortoise.exceptions import IntegrityError
 from tortoise.timezone import now
 from tortoise.transactions import in_transaction
+from xync_bot import XyncBot
+from xync_client.Bybit.ex import ExClient
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_schema import models
@@ -28,18 +32,21 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     StatusApi,
 )
-from xync_client.loader import NET_TOKEN
+from xync_client.loader import NET_TOKEN, PAY_TOKEN
 from xync_client.Abc.InAgent import BaseInAgentClient
-from xync_client.Bybit.agent import AgentClient
 
 
 class InAgentClient(BaseInAgentClient):
-    agent_client: AgentClient
+    actor: models.Actor
+    agent: models.Agent
+    api: P2P
+    ex_client: ExClient
+    pm_clients: dict[int, PmAgentClient]
 
     async def start_listen(self):
-        t = await self.agent_client.ott()
+        t = await self.ott()
         ts = int(float(t["time_now"]) * 1000)
-        await self.ws_prv(self.agent_client.actor.agent.auth["deviceId"], t["result"], ts)
+        await self.ws_prv(self.agent.auth["deviceId"], t["result"], ts)
 
     # 3N: [T] - Уведомление об одобрении запроса на сделку
     async def request_accepted_notify(self) -> int: ...  # id
@@ -75,7 +82,7 @@ class InAgentClient(BaseInAgentClient):
             while resp := await websocket.recv():
                 if data := json.loads(resp):
                     upd, order_db = None, None
-                    logging.info(f" {datetime.now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
+                    logging.info(f" {now().strftime('%H:%M:%S')} upd: {data.get('topic')}:{data.get('type')}")
                     match data.get("topic"):
                         case "OTC_ORDER_STATUS":
                             match data["type"]:
@@ -85,31 +92,32 @@ class InAgentClient(BaseInAgentClient):
                                     except ValidationError as e:
                                         logging.error(e)
                                         logging.error(data["data"])
-                                    order = self.agent_client.api.get_order_details(orderId=upd.id)
+                                    order = self.api.get_order_details(orderId=upd.id)
                                     order = OrderFull.model_validate(order["result"])
                                     order_db = await models.Order.get_or_none(
                                         exid=order.id, ad__exid=order.itemId
-                                    ) or await self.agent_client.create_order(order)
+                                    ) or await self.create_order(order)
                                     match upd.status:
                                         case StatusApi.created:
                                             logging.info(f"Order {order.id} created at {order.createDate}")
                                             # сразу уменьшаем доступный остаток монеты/валюты
                                             await self.money_upd(order_db)
                                             if upd.side:  # я покупатель - ждем мою оплату
-                                                dest = order.paymentTermList[0].accountNo
-                                                if not re.match(r"^([PpРр])\d{7,10}\b", dest):
+                                                _dest = order.paymentTermList[0].accountNo
+                                                if not re.match(r"^([PpРр])\d{7,10}\b", _dest):
                                                     continue
                                                 await order_db.fetch_related("ad__pair_side__pair", "cred__pmcur__cur")
-                                                await self.send_payment(order_db, dest)
+                                                await self.send_payment(order_db)
                                         case StatusApi.wait_for_buyer:
                                             if upd.side == 0:  # ждем когда покупатель оплатит
                                                 if not (pmacdx := await self.get_pma_by_cdex(order)):
                                                     continue
                                                 pma, cdx = pmacdx
-                                                am, tid = pma.check_in(
+                                                am, tid = await pma.check_in(
                                                     Decimal(order.amount),
                                                     cdx.cred.pmcur.cur.ticker,
-                                                    datetime.fromtimestamp(float(order.createDate) / 1000),
+                                                    # todo: почему в московском час.поясе?
+                                                    datetime.fromtimestamp(float(order.transferDate) / 1000),
                                                 )
                                                 if not tid:
                                                     logging.info(
@@ -133,44 +141,48 @@ class InAgentClient(BaseInAgentClient):
                                                     continue
 
                                                 # если висят незавершенные продажи с такой же суммой
-                                                pos = (await self.agent_client.get_orders_active(1))["result"]
+                                                pos = (await self.get_orders_active(1))["result"]
                                                 pos = [
                                                     o
                                                     for o in pos.get("items", [])
                                                     if (
                                                         o["amount"] == order.amount
                                                         and o["id"] != upd.id
-                                                        and o.paymentTermList[0].accountNo
+                                                        and int(order.createDate)
+                                                        < int(o["createDate"]) + 15 * 60 * 1000
+                                                        # get full_order from o, and cred or pm from full_order:
+                                                        and self.api.get_order_details(orderId=o["id"])["result"][
+                                                            "paymentTermList"
+                                                        ][0]["accountNo"]
                                                         == order.paymentTermList[0].accountNo
-                                                        and int(order.createDate) < int(o["createDate"]) + 3600 * 000
                                                     )
                                                 ]
                                                 curex = await models.CurEx.get(
-                                                    cur__ticker=order.currencyId, ex=self.agent_client.ex_client.ex
+                                                    cur__ticker=order.currencyId, ex=self.ex_client.ex
                                                 )
                                                 pos_db = await models.Order.filter(
                                                     exid__not=order.id,
                                                     cred_id=order_db.cred_id,
                                                     amount=int(float(order.amount) * 10**curex.scale),
                                                     status__not_in=[OrderStatus.completed, OrderStatus.canceled],
-                                                    created_at__gt=now() - timedelta(hours=1),
+                                                    created_at__gt=now() - timedelta(minutes=15),
                                                 )
                                                 if pos or pos_db:
-                                                    await self.agent_client.ex_client.bot.send(
+                                                    await self.ex_client.bot.send(
                                                         f"[Duplicate amount!]"
                                                         f"(https://www.bybit.com/ru-RU/p2p/orderList/{order.id})",
-                                                        self.agent_client.actor.person.user.username_id,
+                                                        self.actor.person.user.username_id,
                                                     )
                                                     logging.warning("Duplicate amount!")
                                                     continue
 
                                                 # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
-                                                self.agent_client.api.release_assets(orderId=upd.id)
+                                                self.api.release_assets(orderId=upd.id)
                                                 logging.info(
-                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {datetime.now()}"
+                                                    f"Order {order.id} created, paid before #{tid}:{am} at {order.createDate}, and RELEASED at {now()}"
                                                 )
                                             elif upd.side == 1:  # я покупатель - ждем мою оплату
-                                                continue  # logging.warning(f"Order {order.id} PAID at {datetime.now()}: {int_am}")
+                                                continue  # logging.warning(f"Order {order.id} PAID at {now()}: {int_am}")
                                             else:
                                                 ...
                                             # todo: check is always canceling
@@ -229,14 +241,14 @@ class InAgentClient(BaseInAgentClient):
                                 case "RECEIVE":
                                     upd = Receive.model_validate(data["data"])
                                     if order_db := await models.Order.get_or_none(
-                                        exid=upd.orderId, ad__maker__ex=self.agent_client.actor.ex
+                                        exid=upd.orderId, ad__maker__ex=self.actor.ex
                                     ).prefetch_related("ad__pair_side__pair", "cred__pmcur__cur"):
-                                        im_taker = order_db.taker_id == self.agent_client.actor.id
+                                        im_taker = order_db.taker_id == self.actor.id
                                         im_buyer = order_db.ad.pair_side.is_sell == im_taker
                                         if order_db.ad.auto_msg != upd.message and upd.roleType == "user":
                                             msg, _ = await models.Msg.update_or_create(
                                                 {
-                                                    "to_maker": upd.userId == self.agent_client.actor.exid and im_taker,
+                                                    "to_maker": upd.userId == self.actor.exid and im_taker,
                                                     "sent_at": datetime.fromtimestamp(float(upd.createDate) / 1000),
                                                 },
                                                 txt=upd.message,
@@ -245,14 +257,17 @@ class InAgentClient(BaseInAgentClient):
                                             if not upd.message:
                                                 ...
                                             if im_buyer and (g := re.match(r"^[PpРр]\d{7,10}\b", upd.message)):
-                                                await self.send_payment(order_db, g.group())
+                                                if not order_db.cred.detail.startswith(dest := g.group()):
+                                                    order_db.cred.detail = dest
+                                                    await order_db.save()
+                                                await self.send_payment(order_db)
                                 case "READ":
                                     upd = Read.model_validate(data["data"])
                                     # if upd.status not in (StatusWs.created, StatusWs.canceled, 10, StatusWs.completed):
                                     if upd.orderStatus in (
                                         StatusApi.wait_for_buyer,
                                     ):  # todo: тут приходит ордер.статус=10, хотя покупатель еще не нажал оплачено
-                                        order = self.agent_client.api.get_order_details(orderId=upd.orderId)["result"]
+                                        order = self.api.get_order_details(orderId=upd.orderId)["result"]
                                         order = OrderFull.model_validate(order)
 
                                 case "CLEAR":
@@ -282,52 +297,63 @@ class InAgentClient(BaseInAgentClient):
                     if not upd:
                         logging.warning(data, "NOT PROCESSED UPDATE")
 
-    async def money_upd(self, order_db: models.Order):
+    async def money_upd(self, odb: models.Order):
         # обновляем остаток монеты
-        await order_db.fetch_related("ad__pair_side__pair", "cred", "transfer")
-        ass = await models.Asset.get(
-            addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.agent_client.actor
-        )
+        await odb.fetch_related("ad__pair_side__pair", "ad__my_ad__credexs__cred__fiat", "cred__pmcur", "transfer")
+        ass = await models.Asset.get(addr__coin_id=odb.ad.pair_side.pair.coin_id, addr__actor=self.actor)
         # обновляем остаток валюты
-        fiat = await models.Fiat.get(
-            cred__person_id=self.agent_client.actor.person_id, cred__pmcur_id=order_db.cred.pmcur_id
-        ).prefetch_related("cred__pmcur__pm")
-        fee = round(order_db.amount * (fiat.cred.pmcur.pm.fee or 0) * 0.0001)
-        im_seller = order_db.ad.pair_side.is_sell == (_im_maker := order_db.ad.maker_id == self.agent_client.actor.id)
+        im_maker = odb.ad.maker_id == self.actor.id
+        im_seller = odb.ad.pair_side.is_sell == im_maker
+        if im_maker:
+            if _fiats := [cx.cred.fiat for cx in odb.ad.my_ad.credexs if cx.cred.fiat]:
+                fiat = _fiats[0]
+                await fiat.fetch_related("cred__pmcur__pm")
+            else:
+                raise ValueError(odb, "No Fiat")
+        elif im_seller:  # im taker
+            fltr = dict(cred__person_id=self.actor.person_id)
+            fltr |= (
+                {"cred__ovr_pm_id": odb.cred.ovr_pm_id, "cred__pmcur__cur_id": odb.cred.pmcur.cur_id}
+                if odb.cred.ovr_pm_id
+                else {"cred__pmcur_id": odb.cred.pmcur_id}
+            )
+            if not (fiat := await models.Fiat.get_or_none(**fltr).prefetch_related("cred__pmcur__pm")):
+                raise ValueError(odb, "No Fiat")
+        fee = round(odb.amount * (fiat.cred.pmcur.pm.fee or 0) * 0.0001)
         # k = int(im_seller) * 2 - 1  # im_seller: 1, im_buyer: -1
-        if order_db.status == OrderStatus.created:
+        if odb.status == OrderStatus.created:
             if im_seller:
-                ass.free -= order_db.quantity
-                ass.freeze += order_db.quantity
+                ass.free -= odb.quantity
+                ass.freeze += odb.quantity
             else:  # я покупатель
-                fiat.amount -= order_db.amount + fee
-        elif order_db.status == OrderStatus.completed:
+                fiat.amount -= odb.amount + fee
+        elif odb.status == OrderStatus.completed:
             if im_seller:
-                fiat.amount += order_db.amount
+                fiat.amount += odb.amount
             else:  # я покупатель
-                ass.free += order_db.quantity
-        elif order_db.status == OrderStatus.canceled:
+                ass.free += odb.quantity
+        elif odb.status == OrderStatus.canceled:
             if im_seller:
-                ass.free += order_db.quantity
-                ass.freeze -= order_db.quantity
+                ass.free += odb.quantity
+                ass.freeze -= odb.quantity
             else:  # я покупатель
-                fiat.amount += order_db.amount + fee
+                fiat.amount += odb.amount + fee
         else:
-            logging.exception(order_db.id, f"STATUS: {order_db.status.name}")
+            logging.exception(odb.id, f"STATUS: {odb.status.name}")
         await ass.save(update_fields=["free", "freeze"])
         await fiat.save(update_fields=["amount"])
-        logging.info(f"Order #{order_db.id} {order_db.status.name}. Fiat: {fiat.amount}, Asset: {ass.free}")
+        logging.info(f"Order #{odb.id} {odb.status.name}. Fiat: {fiat.amount}, Asset: {ass.free}")
 
-    async def send_payment(self, order_db: models.Order, dest):
+    async def send_payment(self, order_db: models.Order):
         if order_db.status != OrderStatus.created:
             return
         fmt_am = round(order_db.amount * 10**-2, 2)
         pma, cur = await self.get_pma_by_pmex(order_db)
         async with in_transaction():
             # отмечаем ордер на бирже "оплачен"
-            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.agent_client.actor.ex)
-            credex = await models.CredEx.get(cred=order_db.cred, ex=self.agent_client.actor.ex)
-            self.agent_client.api.mark_as_paid(
+            pmex = await models.PmEx.get(pm_id=order_db.cred.pmcur.pm_id, ex=self.actor.ex)
+            credex = await models.CredEx.get(cred=order_db.cred, ex=self.actor.ex)
+            self.api.mark_as_paid(
                 orderId=str(order_db.exid),
                 paymentType=pmex.exid,  # pmex.exid
                 paymentId=str(credex.exid),  # credex.exid
@@ -335,43 +361,43 @@ class InAgentClient(BaseInAgentClient):
             # проверяем не отправляли ли мы уже перевод по этому ордеру
             if t := await models.Transfer.get_or_none(order=order_db, amount=order_db.amount):
                 await pma.bot.send(
-                    f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {dest} #{t.pmid}!",
-                    self.agent_client.actor.person.user.username_id,
+                    f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!",
+                    self.actor.person.user.username_id,
+                )
+                raise Exception(
+                    f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {order_db.cred.detail} #{t.pmid}!"
                 )
-                raise Exception(f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {dest} #{t.pmid}!")
 
             # ставим в бд статус "оплачен"
             order_db.status = OrderStatus.paid
             order_db.payed_at = datetime.now(timezone.utc)
             await order_db.save()
-            # отправляем деньги
-            tid, img, rest_amount = await pma.send(dest=dest, amount=fmt_am, cur=cur)
             # создаем перевод в бд
-            t, _ = await models.Transfer.update_or_create({"order": order_db, "amount": order_db.amount}, pmid=tid)
+            t = models.Transfer(order=order_db, amount=order_db.amount, updated_at=now())
+            # отправляем деньги
+            tid, img = await pma.send(t)
+            t.pmid = tid
+            await t.save()
             await self.send_receipt(str(order_db.exid), tid)  # отправляем продавцу чек
             logging.info(f"Order {order_db.exid} PAID at {datetime.now()}: {fmt_am}!")
 
     async def send_receipt(self, oexid: str, tid: int) -> tuple[PmAgentClient | None, models.CredEx] | None:
         try:
-            if res := self.agent_client.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
+            if res := self.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
                 await sleep(0.5)
-                self.agent_client.api.send_chat_message(
-                    orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex
-                )
+                self.api.send_chat_message(orderId=oexid, contentType="pic", message=res["url"], msgUuid=uuid4().hex)
         except Exception as e:
             logging.error(e)
         await sleep(0.5)
-        self.agent_client.api.send_chat_message(
-            orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex
-        )
+        self.api.send_chat_message(orderId=oexid, contentType="str", message=f"#{tid}", msgUuid=uuid4().hex)
 
     async def get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient | None, models.CredEx] | None:
         cdxs = await models.CredEx.filter(
-            ex=self.agent_client.ex_client.ex,
+            ex=self.ex_client.ex,
             exid__in=[ptl.id for ptl in order.paymentTermList],
-            cred__person=self.agent_client.actor.person,
+            cred__person=self.actor.person,
         ).prefetch_related("cred__pmcur__cur")
-        pmas = [pma for cdx in cdxs if (pma := self.pmacs.get(cdx.cred.pmcur.pm_id))]
+        pmas = [pma for cdx in cdxs if (pma := self.pm_clients.get(cdx.cred.pmcur.pm_id))]
         if not len(pmas):
             # raise ValueError(order.paymentTermList, f"No pm_agents for {order.paymentTermList[0].paymentType}")
             return None
@@ -381,7 +407,7 @@ class InAgentClient(BaseInAgentClient):
             return pmas[0], cdxs[0]
 
     async def get_pma_by_pmex(self, order_db: models.Order) -> tuple[PmAgentClient, str]:
-        pma = self.pmacs.get(order_db.cred.pmcur.pm_id)
+        pma = self.pm_clients.get(order_db.cred.pmcur.pm_id)
         if pma:
             return pma, order_db.cred.pmcur.cur.ticker
         logging.error(f"No pm_agents for {order_db.cred.pmcur.pm_id}")
@@ -396,34 +422,43 @@ async def main():
     from x_model import init_db
     from xync_client.loader import TORM
 
-    _ = await init_db(TORM, True)
+    cn = await init_db(TORM, True)
     logging.basicConfig(level=logging.INFO)
 
-    actor = (
-        await models.Actor.filter(
-            ex_id=4,
-            agent__auth__isnull=False,
-            person__user__status=UserStatus.ACTIVE,
-            person__user__pm_agents__isnull=False,
+    agent = (
+        await models.Agent.filter(
+            actor__ex_id=4,
+            status__in=[3],
+            auth__isnull=False,
+            actor__person__user__status=UserStatus.ACTIVE,
+            actor__person__user__pm_agents__pm_id=366,
+            actor__person_id=1,
         )
-        .prefetch_related("ex", "agent", "person__user__pm_agents__user", "person__user__pm_agents__pm")
+        .prefetch_related("actor__ex", "actor__person__user__gmail")
         .first()
     )
+    pm_agents = await models.PmAgent.filter(
+        active=True,
+        auth__isnull=False,
+        user__status=UserStatus.ACTIVE,
+    ).prefetch_related("pm", "user__gmail")
+
+    bbot = XyncBot(PAY_TOKEN, cn)
 
     async with FileClient(NET_TOKEN) as b:
         b: FileClient
-        cl: InAgentClient = actor.in_client(b)
+        cl = InAgentClient(agent, b, bbot)
         # await cl.agent_client.export_my_ads()
         # payeer_cl = Client(actor.person.user.username_id)
-        for pma in actor.person.user.pm_agents:
-            pcl = pma.client()
-            cl.pmacs[pma.pm_id] = await pcl.start(await async_playwright().start(), False)
+        for pma in pm_agents:
+            pcl: PmAgentClient = pma.client(bbot)
+            cl.pm_clients[pma.pm_id] = await pcl.start(await async_playwright().start(), False)
         try:
             _ = await cl.start_listen()
         except Exception as e:
-            await b.send("😱Bybit InAgent CRASHED!!!😱", actor.person.user.username_id)
-            await b.send(e.__repr__(), actor.person.user.username_id)
-        await cl.agent_client.close()
+            await b.send("😱Bybit InAgent CRASHED!!!😱", agent.actor.person.user.username_id)
+            await b.send(f"```\n{''.join(traceback.format_exception(e))}\n```", agent.actor.person.user.username_id)
+        await cl.close()
 
 
 if __name__ == "__main__":