xync-client 0.0.141__py3-none-any.whl → 0.0.156.dev18__py3-none-any.whl

xync_client/Gmail/__init__.py

@@ -1,113 +1,134 @@
-from playwright.async_api import Page, Playwright
-from pyro_client.client.file import FileClient
-from pyro_client.client.user import UserClient
+import logging
+import pickle
+import re
+from base64 import urlsafe_b64decode
+from datetime import datetime
+
+from google.auth.transport.requests import Request
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import Resource, build
+from requests import get
 from xync_schema.models import User, Gmail
 
-from xync_client.loader import NET_TOKEN
+from xync_client.Abc.HasAbotUid import HasAbotUid
+from xync_client.loader import TORM
+
+# Область доступа
+SCOPES = ["https://www.googleapis.com/auth/gmail.readonly"]
+
+
+class GmClient(HasAbotUid):
+    service: Resource
+
+    def __init__(self, user: User):
+        """Авторизация и создание сервиса Gmail API"""
+        creds = None
+        # Файл token.pickle хранит токены доступа пользователя
+        if user.gmail.token:
+            creds = pickle.loads(user.gmail.token)
+
+        # Если нет валидных credentials, запрашиваем авторизацию
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_config(user.gmail.auth, SCOPES)
+                creds = flow.run_local_server(port=0)
 
+            # Сохраняем credentials для следующего запуска
+            user.gmail.token = pickle.dumps(creds)
 
-class GmClient:
-    uid: int
-    user: User
-    page: Page
-    bot: UserClient = None
-    HOME = "https://mail.google.com/mail/u/0/"
+        self.service = build("gmail", "v1", credentials=creds)
+        self.uid = user.username_id
 
-    def __init__(self, uid: int):
-        self.uid = uid
+    def _get_last_email(self, sender_email, subject_keyword=None):
+        """
+        Получить последнее письмо от определенного отправителя
 
-    async def start(self, pw: Playwright, headed: bool = False):
-        self.user = await User.get(username_id=self.uid).prefetch_related("gmail")
-        if not self.user.gmail:
-            self.user.gmail = await Gmail.create(
-                login=input(f"{self.user.last_name} gmail login:"), password=input("password:")
+        Args:
+            sender_email: email отправителя (например, 'example@gmail.com')
+            subject_keyword: ключевое слово в теме (опционально)
+        """
+
+        def _get_email_body(payload):
+            """Извлечь текст письма из payload"""
+            if "body" in payload and "data" in payload["body"]:
+                return urlsafe_b64decode(payload["body"]["data"]).decode("utf-8")
+            return ""
+
+        # Формируем поисковый запрос
+        query = f"from:{sender_email}"
+        if subject_keyword:
+            query += f" subject:{subject_keyword}"
+
+        # Ищем письма с этим запросом
+        results = (
+            self.service.users()
+            .messages()
+            .list(
+                userId="me",
+                q=query,
+                maxResults=1,  # Только последнее письмо
             )
-        browser = await pw.chromium.launch(
-            channel="chrome",
-            headless=not headed,
-            args=[
-                "--disable-blink-features=AutomationControlled",
-                "--no-sandbox",
-                "--disable-web-security",
-                "--disable-infobars",
-                "--disable-extensions",
-                "--start-maximized",
-            ],
+            .execute()
         )
-        context = await browser.new_context(storage_state=self.user.gmail.auth, locale="en")
-        self.page = await context.new_page()
-        # go home
-        await self.page.goto(self.HOME, timeout=62000)
-        if not self.page.url.startswith(self.HOME):
-            if await (  # ваще с 0 заходим
-                sgn_btn := self.page.locator(
-                    'header a[href^="https://accounts.google.com/AccountChooser/signinchooser"]:visible',
-                    has_text="sign",
-                )
-            ).count():
-                await sgn_btn.click()
-            if self.page.url.startswith("https://accounts.google.com/v3/signin/accountchooser"):  # надо выбрать акк
-                await self.page.locator("li").first.click()
-            # если предлагает залогиниться
-            elif await self.page.locator("h1#headingText", has_text="Sign In").count():
-                await self.page.fill("input[type=email]", self.user.gmail.login)
-                await self.page.locator("button", has_text="Next").click()
-            # осталось ввести пороль:
-            await self.page.fill("input[type=password]", self.user.gmail.password)
-            await self.page.locator("#passwordNext").click()
-            await self.page.wait_for_timeout(3000)
-            if self.page.url.startswith("https://accounts.google.com/v3/signin/challenge/dp"):
-                await self.load_bot()
-                await self.bot.receive("Аппрувни гмейл, у тебя 1.5 минуты", photo=await self.page.screenshot())
-        await self.page.wait_for_url(lambda u: u.startswith(self.HOME), timeout=90 * 1000)  # убеждаемся что мы в почте
-        self.user.gmail.auth = await self.page.context.storage_state()
-        await self.user.gmail.save()
-
-    async def mail_confirm(self):
-        lang = await self.page.get_attribute("html", "lang")
-        labs = {
-            "ru": "Оповещения",
-            "en-US": "Updates",
-        }
-        tab = self.page.get_by_role("heading").get_by_label(labs[lang]).last
-        await tab.click()
-        rows = self.page.locator("tbody>>nth=4 >> tr")
-        row = rows.get_by_text("Volet.com").and_(rows.get_by_text("Please Confirm Withdrawal"))
-        if not await row.count():
-            await self.bot.receive("А нет запросов от волета", photo=await self.page.screenshot())
-
-        await row.click()
-        await self.page.wait_for_load_state()
-        btn = self.page.locator('a[href^="https://account.volet.com/verify/"]', has_text="confirm").first
-        await btn.click()
-
-    async def load_bot(self):
-        if not self.bot:
-            bot = FileClient(NET_TOKEN)
-            self.bot = UserClient(self.uid, bot)
-        if not self.bot.is_connected:
-            await self.bot.start()
-
-    async def stop(self):
-        if self.bot and self.bot.is_connected:  # todo: do not stop if
-            await self.bot.stop(False)
-        await self.page.context.close()
-        await self.page.context.browser.close()
+
+        if not (messages := results.get("messages", [])):
+            logging.warning("Письма не найдены")
+            return None
+
+        # Получаем полную информацию о письме
+        message_id = messages[0]["id"]
+        message = self.service.users().messages().get(userId="me", id=message_id, format="full").execute()
+
+        # Извлекаем заголовки
+        headers = message["payload"]["headers"]
+        subject = next((h["value"] for h in headers if h["name"] == "Subject"), "Нет темы")
+        from_email = next((h["value"] for h in headers if h["name"] == "From"), "Неизвестно")
+        date = next((h["value"] for h in headers if h["name"] == "Date"), "Неизвестно")
+
+        # Извлекаем текст письма
+        body = _get_email_body(message["payload"])
+
+        return {"id": message_id, "subject": subject, "from": from_email, "date": date, "body": body}
+
+    async def volet_confirm(self, amount: float, dt: datetime):
+        if email := self._get_last_email("noreply@volet.com", "Please Confirm Withdrawal"):  # "Volet.com"
+            date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
+            if match := re.search(r"Amount: <b>([\d.]+) [A-Z]{3}</b>", email["body"]):
+                amt = float(match.group(1))
+            if match := re.search(r"https://account\.volet\.com/verify/([a-f0-9-]+)", email["body"]):
+                token = match.group(1)
+
+        if email and amount == amt and date > dt and token:
+            get(f"https://account.volet.com/verify/{token}")
+            return True
+
+        await self.receive("А нет запросов от волета")
+        return False
+
+    async def bybit_code(self, dt: datetime) -> str | None:
+        if email := self._get_last_email("Bybit", "[Bybit]Security Code for Your Bybit Account"):
+            date = datetime.strptime(email["date"].split(",")[1].split(" +")[0], "%d %b %Y %H:%M:%S")
+            if match := re.search(r'<span style="font-size:28pt;color:#ff9c2e">(\d{6})</span>', email["body"]):
+                code = match.group(1)
+
+        if email and date > dt and code:
+            get(f"https://account.volet.com/verify/{code}")
+            return code
+
+        await self.receive("А нет запросов от волета")
+        return None
 
 
 async def _test():
     from x_model import init_db
-    from xync_schema import TORM
-
-    _ = await init_db(TORM, True)
-    uid = 193017646
-    gmc = GmClient(uid)
-    try:
-        await gmc.start(True)
-    except TimeoutError as te:
-        raise te
-    finally:
-        await gmc.stop()
+
+    _ = await init_db(TORM)
+
+    gm = await Gmail.get(id=1).prefetch_related("user__username")
+    gmc = GmClient(gm)
+    await gmc.volet_confirm(amount=90, dt=datetime.now())
 
 
 if __name__ == "__main__":

xync_client/Htx/agent.py

@@ -1,18 +1,29 @@
+import re
 from json import dumps
+from time import time
+from urllib.parse import quote
 
+from aiohttp import ClientResponse
+from pyro_client.client.file import FileClient
+from x_client import df_hdrs
 from x_client.aiohttp import Client
+from xync_bot import XyncBot
+
+from xync_client.Abc.xtype import AdUpd, GetAds
+from xync_client.Htx.etype.order import OrderItem, OrderFull
+from xync_client.loader import NET_TOKEN, PAY_TOKEN, TORM
+
 from xync_schema.enums import AdStatus, PmType, OrderStatus
-from xync_schema.models import Pm, Coin, Cur, Ad, Order
 from xync_schema import models
 from xync_client.Abc.Agent import BaseAgentClient
-from xync_client.Htx.etype import test
+from xync_client.Htx.etype import test, ad
 
 import logging
 
 url_ads_req = "https://otc-cf.huobi.com/v1/data/trade-market"
 url_ads_web = "https://www.huobi.com/en-us/fiat-crypto/trade/"
 url_my_ads = "https://otc-api.trygofast.com/v1/data/trade-list?pageSize=50"
-url_my_ad = "https://www.huobi.com/-/x/otc/v1/otc/trade/"  # + id
+url_my_ad = "/-/x/otc/v1/otc/trade/"  # + id
 url_my_bals = "https://www.huobi.com/-/x/otc/v1/capital/balance"
 url_paccs = "https://www.huobi.com/-/x/otc/v1/user/receipt-account"
 
@@ -22,9 +33,19 @@ class Public(Client):
 
 
 class AgentClient(BaseAgentClient):
-    headers = {
-        "portal": "web",
-    }
+    headers = {"portal": "web"} | df_hdrs
+
+    async def login(self):
+        t = int(time() * 1000)
+        resp = await self._get("/-/x/uc/uc/open/ticket/get", {"t": t})
+        if resp.get("data") is None:
+            ...
+        if ticket := resp["data"].get("ticket"):
+            resp = await self._post("/-/x/otc/v1/user/login", form_data={"ticket": ticket, "type": "WEB"})
+            if resp["success"]:
+                self.agent.auth["headers"]["Token"] = resp["data"]
+                await self.agent.save(update_fields=["auth"])
+                self.session.headers["Token"] = resp["data"]
 
     async def creds(self) -> list[test.CredEpyd]:
         resp = await self._get("/-/x/otc/v1/user/receipt-account")
@@ -46,7 +67,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_new(self, cred: models.Cred) -> models.CredEx:
         pmcur = await cred.pmcur
-        exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        exid = str(await models.PmEx.get(pm_id=pmcur.pmex_exid, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -71,7 +92,7 @@ class AgentClient(BaseAgentClient):
 
     async def cred_upd(self, cred: models.Cred, exid: int) -> models.CredEx:
         pmcur = await cred.pmcur
-        _exid = str(await models.PmEx.get(pm_id=pmcur.pm_id, ex=self.ex_client.ex).values_list("exid", flat=True))
+        _exid = str(await models.PmEx.get(pm_id=pmcur.pmex_exid, ex=self.ex_client.ex).values_list("exid", flat=True))
         field_map = {
             "payee": "name",
             "bank": "extra",
@@ -95,14 +116,40 @@ class AgentClient(BaseAgentClient):
 
     # 0
     async def get_orders(
-        self, stauts: OrderStatus = OrderStatus.created, coin: Coin = None, cur: Cur = None, is_sell: bool = None
-    ) -> list[Order]:
-        pass
+        self,
+        stauts: OrderStatus = OrderStatus.created,
+        coin: models.Coin = None,
+        cur: models.Cur = None,
+        is_sell: bool = None,
+    ) -> list[OrderItem]:
+        resp = await self._get("/-/x/otc/v1/trade/order/process", {"needTradeCount": "true"})
+        if resp["success"]:
+            return [OrderItem(**o) for o in resp["data"]]
+        return []
+
+    async def get_order(self, oid: int) -> OrderFull | None:
+        resp = await self._get("/-/x/otc/v1/trade/order", {"orderId": oid})
+        if resp["success"]:
+            o = OrderFull(**resp["data"])
+            return o
+        return None
+
+    async def recv(self, order: OrderItem):
+        if order.orderStatus:
+            ...
+        else:
+            ...
+
+    async def start_listen(self):
+        """Фоновая задача для ловли входящих ордеров"""
+        while True:
+            [await self.recv(o) for o in await self.get_orders()]
+            await sleep(9)
 
     async def order_request(self, ad_id: int, amount: float) -> dict:
         pass
 
-    async def my_fiats(self, cur: Cur = None) -> list[dict]:
+    async def my_fiats(self, cur: models.Cur = None) -> list[dict]:
         pass
 
     # async def fiat_new(self, fiat: FiatNew) -> Fiat.pyd():
@@ -124,30 +171,94 @@ class AgentClient(BaseAgentClient):
 
     async def ad_new(
         self,
-        coin: Coin,
-        cur: Cur,
+        coin: models.Coin,
+        cur: models.Cur,
         is_sell: bool,
-        pms: list[Pm],
+        pms: list[models.Pm],
         price: float,
         is_float: bool = True,
         min_fiat: int = None,
         details: str = None,
         autoreply: str = None,
         status: AdStatus = AdStatus.active,
-    ) -> Ad:
+    ) -> models.Ad:
         pass
 
-    async def ad_upd(
-        self,
-        pms: [Pm] = None,
-        price: float = None,
-        is_float: bool = None,
-        min_fiat: int = None,
-        details: str = None,
-        autoreply: str = None,
-        status: AdStatus = None,
-    ) -> bool:
-        pass
+    async def x2e_req_ad_upd(self, xreq: AdUpd) -> ad.AdsUpd:
+        creds = [
+            ad.TradeRule(
+                content="Payment method-%s",
+                contentCode="PAY",
+                hint="Please enter",
+                inputType=0,
+                inputValue=cx.cred.detail,
+                sort=1,
+                title="【Payment related】",
+                titleValue=(await models.PmEx.get(pm_id=cx.cred.pmcur.pm_id, ex=self.ex_client.ex)).name,
+            )
+            for cx in xreq.credexs
+        ]
+        trade_rules = ad.TradeRulesV2(
+            [
+                *creds,
+                ad.TradeRule(
+                    content="",
+                    contentCode="MERCHANT",
+                    hint="Please enter",
+                    inputType=0,
+                    inputValue="",
+                    sort=4,
+                    title="【Merchant Tips】",
+                ),
+            ]
+        ).model_dump_json(exclude_none=True)
+        coin_id, coin_scale = await self.ex_client.x2e_coin(xreq.coin_id)
+        cur_id, cur_scale, minimum = await self.ex_client.x2e_cur(xreq.cur_id)
+        return ad.AdsUpd(
+            id=xreq.id,
+            tradeType=int(xreq.is_sell),
+            coinId=int(coin_id),
+            currency=int(cur_id),
+            minTradeLimit=minimum,
+            maxTradeLimit=round(xreq.amount - 10**-cur_scale, cur_scale),
+            tradeCount=round(xreq.quantity or xreq.amount / xreq.price, coin_scale),
+            password=self.agent.auth["pass"],
+            payTerm=15,
+            premium=0.00,
+            isFixed="on",
+            fixedPrice=round(xreq.price, cur_scale),
+            isAutoReply="off",
+            takerAcceptOrder=0,
+            isPayCode="off",
+            receiveAccounts=",".join([str(cx.exid) for cx in xreq.credexs]),
+            deviation=0,
+            isTakerLimit="on",
+            takerIsMerchant="on",
+            takerRealLevel="off",
+            takerIsPhoneBind="off",
+            takerIsPayment="on",
+            blockType=1,
+            session=1,
+            chargeType=False,
+            apiVersion=4,
+            channel="web",
+            tradeRulesV2=quote(trade_rules),
+        )
+
+    async def _ad_upd(self, req: ad.AdsUpd, hdrs: dict[str, str] = None) -> dict:
+        res = await self._post(self.url_my_ad + str(req.id), form_data=req.model_dump(exclude_none=True), hdrs=hdrs)
+        if res["code"] == 200:
+            return res["data"]
+        elif res["code"] == 605:
+            hdrs = {"x-dialog-trace-id": res["extend"]["traceId"]}
+            return await self._ad_upd(req, hdrs)
+        elif res["code"] == 1010:
+            if (match := re.search(r"Available amount ([\d.]+)", res["message"])) and (qty := match.group(1)):
+                req.tradeCount = float(qty)
+                return await self._ad_upd(req, hdrs)
+        elif res["code"] == 401:
+            raise Exception(res)
+        raise BaseException(res)
 
     async def ad_del(self) -> bool:
         pass
@@ -182,32 +293,94 @@ class AgentClient(BaseAgentClient):
     base_url = ""
     middle_url = ""
 
-    htok: str = "Ev5lFfAvxDU2MA9BJ-Mc4U6zZG3Wb6qsp3Tx2fz6GIoY-uOP2m0-gvjE57ad1qDF"
-
     url_ads_req = "https://otc-cf.huobi.com/v1/data/trade-market"
     url_my_ads = "https://otc-api.trygofast.com/v1/data/trade-list?pageSize=50"
-    url_my_ad = "https://www.huobi.com/-/x/otc/v1/otc/trade/"  # + id
+    url_my_ad = "/-/x/otc/v1/otc/trade/"  # + id
     url_my_bals = "https://www.huobi.com/-/x/otc/v1/capital/balance"
     url_paccs = "https://www.huobi.com/-/x/otc/v1/user/receipt-account"
 
+    async def _proc(self, resp: ClientResponse, bp: dict | str = None) -> dict | str:
+        if (await resp.json()).get("code") == 401:
+            await self.login()
+            return await self.METHS[resp.method](self, resp.url.path, bp)
+        return await super()._proc(resp, bp)
+
 
 async def _test():
     from x_model import init_db
-    from xync_schema import TORM
 
-    _ = await init_db(TORM, True)
-    actor = (
-        await models.Actor.filter(ex_id=15, agent__isnull=False).prefetch_related("ex", "agent", "person__user").first()
+    cn = await init_db(TORM, True)
+    ex = await models.Ex[9]
+    filebot = FileClient(NET_TOKEN)
+    ecl = ex.client(filebot)
+    agent = (
+        await models.Agent.filter(actor__ex=ex, auth__isnull=False)
+        .prefetch_related(
+            "actor__ex",
+            "actor__person__user__gmail",
+            "actor__my_ads__my_ad__race",
+            "actor__my_ads__pair_side__pair__cur",
+            "actor__my_ads__pms",
+        )
+        .first()
     )
-    cl: AgentClient = actor.client()
-    cred = await models.Cred[89]
-    _ = await cl.cred_new(cred)
-    _creds = await cl.creds()
+    cl: AgentClient = agent.client(ecl, filebot, XyncBot(PAY_TOKEN, cn))
+    # cred = await models.Cred[89]
+    # _ = await cl.cred_new(cred)
+    # _creds = await cl.creds()
     # _ = await cl.cred_del(16984748)
-    await cl.close()
+
+    while True:
+        breq = GetAds(coin_id=1, cur_id=1, is_sell=False, pm_ids=[366])
+        sreq = GetAds(coin_id=1, cur_id=1, is_sell=True, pm_ids=[366])
+        breq_upd = AdUpd(id=1185713, price=87.01, **{**breq.model_dump(), "amount": 100000.01})
+        sreq_upd = AdUpd(id=1188929, price=98.99, **{**sreq.model_dump(), "amount": 200000.01})
+
+        bads: list[ad.Resp] = await cl.ex_client.ads(breq)
+        sads: list[ad.Resp] = await cl.ex_client.ads(sreq)
+        bceil = 101.11
+        sceil = 151
+        bads = [a for a in bads if a.price < bceil and a.tradeCount > 10 and (a.maxTradeLimit - a.minTradeLimit > 800)]
+        sads = [a for a in sads if a.price > sceil and a.tradeCount > 10 and (a.maxTradeLimit - a.minTradeLimit > 800)]
+
+        if len(bads) > 1:
+            if bads[0].uid == cl.actor.exid:
+                if round(bads[0].price - bads[1].price, 2) > 0.01:
+                    breq_upd.price = bads[1].price + 0.01
+                    await cl.ad_upd(breq_upd)
+                    print(end="!", flush=True)
+            elif bads[0].price < bceil:
+                breq_upd.price = bads[0].price + 0.01
+                await cl.ad_upd(breq_upd)
+                print(end="!", flush=True)
+
+        if len(sads) > 1:
+            if sads[0].uid == cl.actor.exid:
+                if round(sads[1].price - sads[0].price, 2) > 0.01:
+                    sreq_upd.price = sads[1].price - 0.01
+                    await cl.ad_upd(sreq_upd)
+                    print(end="!", flush=True)
+            elif sads[0].price > sceil:
+                sreq_upd.price = sads[0].price - 0.01
+                await cl.ad_upd(sreq_upd)
+                print(end="!", flush=True)
+
+        if (pos := await cl.get_orders()) and (po := pos.pop(0)):
+            if po.side:  # is_sell
+                po.amount  # check
+            else:  # buy
+                order: OrderFull = await cl.get_order(po.orderId)
+                if ps := [pm.bankNumber for pm in order.paymentMethod if pm.bankType in [24]]:
+                    if match := re.search(r"^[PpРр]\d{7,10}\b", ps[0]):
+                        match.group()
+
+        print(end=".", flush=True)
+        await sleep(9)
+
+    await cl.stop()
 
 
 if __name__ == "__main__":
-    from asyncio import run
+    from asyncio import run, sleep
 
     run(_test())