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

xync_client/Bybit/InAgent.py

@@ -1,23 +1,28 @@
 import json
 import logging
 import re
-from datetime import datetime, timezone
+import traceback
+from datetime import datetime, timezone, timedelta
 from uuid import uuid4
 
 import websockets
-from asyncio import run
+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_schema.models import CredEx
+from xync_bot import XyncBot
+from xync_client.Bybit.ex import ExClient
 
 from xync_client.Abc.PmAgent import PmAgentClient
 from xync_schema import models
 from xync_schema.enums import UserStatus, OrderStatus
 
-from xync_client.Pms.Payeer import Client
 from xync_client.Bybit.etype.order import (
     StatusChange,
     CountDown,
@@ -27,18 +32,21 @@ from xync_client.Bybit.etype.order import (
     OrderFull,
     StatusApi,
 )
-from xync_client.loader import 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
@@ -74,76 +82,126 @@ 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"]:
                                 case "STATUS_CHANGE":
-                                    upd = StatusChange.model_validate(data["data"])
-                                    order = self.agent_client.api.get_order_details(orderId=upd.id)
+                                    try:
+                                        upd = StatusChange.model_validate(data["data"])
+                                    except ValidationError as e:
+                                        logging.error(e)
+                                        logging.error(data["data"])
+                                    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}")
-                                            if upd.side == 1:  # я покупатель - ждем мою оплату
-                                                dest = order.paymentTermList[0].accountNo
-                                                if not re.match(r"^P\d{8,10}$", dest):
+                                            # сразу уменьшаем доступный остаток монеты/валюты
+                                            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):
                                                     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(
                                                         f"Order {order.id} created at {order.createDate}, not paid yet"
                                                     )
                                                     continue
-                                                t, is_new = await models.Transfer.update_or_create(
-                                                    dict(
-                                                        amount=int(float(order.amount) * 100),
-                                                        accepted_at=datetime.now(timezone.utc),
-                                                    ),
-                                                    order=order_db,
-                                                    pmid=tid,
-                                                )
-                                                if not is_new:
+                                                try:
+                                                    t, is_new = await models.Transfer.update_or_create(
+                                                        dict(
+                                                            amount=int(float(order.amount) * 100),
+                                                            order=order_db,
+                                                        ),
+                                                        pmid=tid,
+                                                    )
+                                                except IntegrityError as e:
+                                                    logging.error(tid)
+                                                    logging.error(order)
+                                                    logging.exception(e)
+
+                                                if not is_new:  # если по этому платежу уже отпущен другая продажа
                                                     continue
-                                                await order_db.fetch_related("ad__pair_side__pair")
-                                                async with in_transaction():
-                                                    # добавляем остаток монеты
-                                                    ass = await models.Asset.get(
-                                                        addr__coin_id=order_db.ad.pair_side.pair.coin_id,
-                                                        addr__actor=self.agent_client.actor,
+
+                                                # если висят незавершенные продажи с такой же суммой
+                                                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 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
                                                     )
-                                                    ass.free -= int(order_db.amount / order_db.ad.price)
-                                                    await ass.save(update_fields=["free"])
-                                                    # обновляем остаток валюты
-                                                    fiat = await models.Fiat.get(cred_id=order_db.cred_id)
-                                                    fiat.amount += order_db.amount
-                                                    await fiat.save(update_fields=["amount"])
-                                                    # отправляем деньги
-                                                    self.agent_client.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()}"
+                                                ]
+                                                curex = await models.CurEx.get(
+                                                    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(minutes=15),
+                                                )
+                                                if pos or pos_db:
+                                                    await self.ex_client.bot.send(
+                                                        f"[Duplicate amount!]"
+                                                        f"(https://www.bybit.com/ru-RU/p2p/orderList/{order.id})",
+                                                        self.actor.person.user.username_id,
                                                     )
+                                                    logging.warning("Duplicate amount!")
+                                                    continue
+
+                                                # !!! ОТПРАВЛЯЕМ ДЕНЬГИ !!!
+                                                self.api.release_assets(orderId=upd.id)
+                                                logging.info(
+                                                    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
                                             # await order_db.update_from_dict({"status": OrderStatus.canceled}).save()
                                             # logging.info(f"Order {order.id} canceled at {datetime.now()}")
+
+                                        case StatusApi.wait_for_seller:
+                                            if order_db.status == OrderStatus.paid:
+                                                continue
+                                            await order_db.update_from_dict(
+                                                {
+                                                    "status": OrderStatus.paid,
+                                                    "payed_at": datetime.fromtimestamp(
+                                                        float(order.transferDate) / 1000
+                                                    ),
+                                                }
+                                            ).save()
+                                            logging.info(f"Order {order.id} payed at {order_db.payed_at}")
+
                                         case StatusApi.appealed:
                                             # todo: appealed by WHO? щас наугад стоит by_seller
                                             await order_db.update_from_dict(
@@ -155,9 +213,12 @@ class InAgentClient(BaseInAgentClient):
                                                 }
                                             ).save()
                                             logging.info(f"Order {order.id} appealed at {order_db.appealed_at}")
+
                                         case StatusApi.canceled:
                                             await order_db.update_from_dict({"status": OrderStatus.canceled}).save()
                                             logging.info(f"Order {order.id} canceled at {datetime.now()}")
+                                            await self.money_upd(order_db)
+
                                         case StatusApi.completed:
                                             await order_db.update_from_dict(
                                                 {
@@ -167,19 +228,8 @@ class InAgentClient(BaseInAgentClient):
                                                     ),
                                                 }
                                             ).save()
-                                            logging.info(f"Order {order.id} completed at {order_db.confirmed_at}")
-                                        case StatusApi.wait_for_seller:
-                                            if order_db.status == OrderStatus.paid:
-                                                continue
-                                            await order_db.update_from_dict(
-                                                {
-                                                    "status": OrderStatus.paid,
-                                                    "payed_at": datetime.fromtimestamp(
-                                                        float(order.transferDate) / 1000
-                                                    ),
-                                                }
-                                            ).save()
-                                            logging.info(f"Order {order.id} payed at {order_db.payed_at}")
+                                            await self.money_upd(order_db)
+
                                         case _:
                                             logging.warning(f"Order {order.id} UNKNOWN STATUS {datetime.now()}")
                                 case "COUNT_DOWN":
@@ -191,30 +241,33 @@ 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 not in ("sys", "alarm"):
+                                        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),
                                                 },
-                                                sent_at=datetime.fromtimestamp(float(upd.createDate) / 1000),
                                                 txt=upd.message,
                                                 order=order_db,
                                             )
                                             if not upd.message:
                                                 ...
-                                            if im_buyer and re.match(r"^P\d{8,10}$", upd.message):
-                                                await self.send_payment(order_db, upd.message)
+                                            if im_buyer and (g := re.match(r"^[PpРр]\d{7,10}\b", upd.message)):
+                                                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":
@@ -244,59 +297,107 @@ class InAgentClient(BaseInAgentClient):
                     if not upd:
                         logging.warning(data, "NOT PROCESSED UPDATE")
 
-    async def send_payment(self, order_db: models.Order, dest):
-        if order_db.status not in (OrderStatus.created, OrderStatus.requested):
+    async def money_upd(self, odb: models.Order):
+        # обновляем остаток монеты
+        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)
+        # обновляем остаток валюты
+        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 odb.status == OrderStatus.created:
+            if im_seller:
+                ass.free -= odb.quantity
+                ass.freeze += odb.quantity
+            else:  # я покупатель
+                fiat.amount -= odb.amount + fee
+        elif odb.status == OrderStatus.completed:
+            if im_seller:
+                fiat.amount += odb.amount
+            else:  # я покупатель
+                ass.free += odb.quantity
+        elif odb.status == OrderStatus.canceled:
+            if im_seller:
+                ass.free += odb.quantity
+                ass.freeze -= odb.quantity
+            else:  # я покупатель
+                fiat.amount += odb.amount + fee
+        else:
+            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 #{odb.id} {odb.status.name}. Fiat: {fiat.amount}, Asset: {ass.free}")
+
+    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
             )
             # проверяем не отправляли ли мы уже перевод по этому ордеру
             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}!")
-                raise Exception(f"Order# {order_db.exid}: Double send {fmt_am}{cur} to {dest} #{t.pmid}!")
+                await pma.bot.send(
+                    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}!"
+                )
 
             # ставим в бд статус "оплачен"
             order_db.status = OrderStatus.paid
             order_db.payed_at = datetime.now(timezone.utc)
             await order_db.save()
-            # добавляем остаток монеты
-            ass = await models.Asset.get(
-                addr__coin_id=order_db.ad.pair_side.pair.coin_id, addr__actor=self.agent_client.actor
-            )
-            ass.free += int(order_db.amount / order_db.ad.price)
-            await ass.save(update_fields=["free"])
-            # отправляем деньги
-            tid, img, rest_amount = await pma.send(dest=dest, amount=fmt_am, cur=cur)
             # создаем перевод в бд
-            t, _ = await models.Transfer.update_or_create(
-                {"amount": order_db.amount},
-                order=order_db,
-                pmid=tid,
-            )
-            # обновляем остаток валюты
-            await models.Fiat.update_or_create({"amount": rest_amount * 100}, cred_id=order_db.cred_id)
-            # отправляем продавцу чек
-            if res := self.agent_client.api.upload_chat_file(upload_file=f"tmp/{dest}.png").get("result"):
-                self.agent_client.api.send_chat_message(
-                    orderId=str(order_db.exid), contentType="pic", message=res["url"], msgUuid=uuid4().hex
-                )
+            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 get_pma_by_cdex(self, order: OrderFull) -> tuple[PmAgentClient | None, CredEx] | None:
+    async def send_receipt(self, oexid: str, tid: int) -> tuple[PmAgentClient | None, models.CredEx] | None:
+        try:
+            if res := self.api.upload_chat_file(upload_file=f"tmp/{tid}.png").get("result"):
+                await sleep(0.5)
+                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.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
@@ -306,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}")
@@ -321,29 +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")
+        .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")
 
-    async with FileClient(TOKEN) as b:
-        cl: InAgentClient = actor.in_client(b)
-        # await cl.agent_client.export_my_ads()
-        payeer_cl = Client(actor.person.user.username_id)
-        for pma in actor.person.user.pm_agents:
-            cl.pmacs[pma.pm_id] = await payeer_cl.start(await async_playwright().start(), True)
+    bbot = XyncBot(PAY_TOKEN, cn)
 
-        _ = await cl.start_listen()
-        await cl.agent_client.close()
+    async with FileClient(NET_TOKEN) as b:
+        b: FileClient
+        cl = InAgentClient(agent, b, bbot)
+        # await cl.agent_client.export_my_ads()
+        # payeer_cl = Client(actor.person.user.username_id)
+        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!!!😱", 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__":