Merge pull request #2 from PogoDigitalism/pre_stable_1

PogoDigitalism · web-flow · commit adb8cc63dc59 · 2024-02-20T19:49:02.000+01:00
Pre stable 1
diff --git a/src/handler.py b/src/handler.py
@@ -8,18 +8,18 @@
 from data import DataManager
 from utils import SyncInAsync
 from win_comms import ToastManager
-from http_comms import HttpManager
+from http_comms import HttpManager, InboundData
 from threading import Thread
 
 INBOUND_COOLDOWN = 5
-TOAST_DISPLAY_TIME = 6
+TOAST_DISPLAY_TIME = 5
 
 class Handler:
     def __init__(self) -> None:
         Log.warning("------------- BOOT -------------")
 
 
-        self._toast_queue = list()
+        self._toast_queue: list[InboundData] = list()
         # DATA INITIALIZATION
         self.data_manager = DataManager()
 
@@ -62,8 +62,12 @@ async def _handle_toast(self):
 
         while True:
             if self._toast_queue:
-                inbound = self._toast_queue[0]          
-                self.toast_manager.create_toast(message=f"{inbound.username} | Trade inbound", title=f"{inbound.username} | Trade inbound")
+                inbound = self._toast_queue[0]
+
+                message = f"you: {inbound.give_value} value & {inbound.give_robux} Robux\n{inbound.username}: {inbound.receive_value} value & {inbound.receive_robux} Robux"
+                title = f"{inbound.username} | Trade Inbound"
+
+                self.toast_manager.create_toast(message=message, title=title)
                 del self._toast_queue[0]
 
                 await asyncio.sleep(TOAST_DISPLAY_TIME)
@@ -72,7 +76,11 @@ async def _handle_toast(self):
             await asyncio.sleep(0.01) # have to add this to not block the event loop
 
     async def check_inbounds(self):
-        self._loop.create_task(self._handle_toast())
+        self._loop.create_task(self.http_manager.refresh_valuelist()) # initialize Rolimons valuelist refresher
+        self._loop.create_task(self._handle_toast()) # initialize Toast (queue) handler 
+
+        await asyncio.sleep(2) # add a start-up little delay for the tasks.
+
         while True:
             inbound_data = await self.http_manager.check_inbound_trades()
             self._toast_queue.extend(inbound_data)
diff --git a/src/http_comms/__init__.py b/src/http_comms/__init__.py
@@ -1,3 +1,3 @@
 from .http_manager import *
 
-__all__ = ('HttpManager')
+__all__ = ('HttpManager','InboundData')
diff --git a/src/http_comms/http_manager.py b/src/http_comms/http_manager.py
@@ -1,7 +1,8 @@
 import asyncio
 import typing
-import time
+import sys
 import json
+import time
 import urllib.request as request
 import urllib.parse as parse
 import urllib.response as response
@@ -11,30 +12,39 @@
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 
+from win_comms import ToastManager
 from data import DataManager
-from utils import SyncInAsync
+from utils import SyncInAsync, parse_query_params
 from log_comms import Log
 
 Success: typing.TypeAlias = bool
 
 TRADE_URL = "https://trades.roblox.com/v1/trades/inbound?cursor=&limit=25&sortOrder=Desc"
+TRADE_INFO_URL = f"https://trades.roblox.com/v1/trades/$id$"
+
 XCSRF_URL = "https://auth.roblox.com/v2/logout"
+VALUE_LIST_URL = "https://api.rolimons.com/items/v1/itemdetails"
+
 XCSRF_REFRESH_TIME = 25*60
+ROLIVALUES_REFRESH_TIME = 1.5*60
 
 @dataclass
 class InboundData:
     username: str
     user_id: int
 
-    offer_items: list[int] = None
-    request_items: list[int] = None
+    give_value: int = None
+    receive_value: int = None
 
-    offer_robux: int = None
-    request_robux: int = None
+    give_items: list[int] = None
+    receive_items: list[int] = None
+
+    give_robux: int = None
+    receive_robux: int = None
 
 
 class HttpManager:
-    def __init__(self) -> None:
+    def __init__(self):
         self._loop = asyncio.get_event_loop()
         self.sync_in_async = SyncInAsync(POOL=ThreadPoolExecutor())
 
@@ -44,9 +54,10 @@ def __init__(self) -> None:
 
         self._opener = request.build_opener(request.HTTPCookieProcessor(self._jar))
 
+        self._value_list = dict()
         self._xcsrf = None # created in __init__ and not initialize_session due to cookie validation
 
-    def initialize_session(self):
+    def initialize_session(self) -> None:
         self._refresh_task = self._loop.create_task(self._refresh_xcsrf())
         self._cached_inbound_id_list: list[int] = list()
 
@@ -72,7 +83,7 @@ def _get_xcsrf(self) -> Success:
                 case _:
                     return False
 
-    async def _refresh_xcsrf(self):
+    async def _refresh_xcsrf(self) -> None:
         while True:
             if not self._xcsrf: # to avoid too many calls if a validation has been done recently.
                 result = await self.sync_in_async.Call(self._get_xcsrf)
@@ -83,7 +94,80 @@ async def _refresh_xcsrf(self):
             await asyncio.sleep(XCSRF_REFRESH_TIME)
             self._xcsrf = None
 
-    def _get_inbound_trades(self):
+    def _get_value_list(self) -> Success:
+        request_struct = request.Request(url=VALUE_LIST_URL, method="GET")
+
+        try:
+            resp = Log.wrap_http(self._opener.open, request_struct=request_struct, success_codes=[])
+        except error.HTTPError as resp:
+            match resp.code:
+                case _:
+                    return False
+        else:
+            response_content = resp.read()
+            json_response = json.loads(response_content.decode('utf-8'))
+
+            if json_response["success"]:
+                self._value_list = json_response["items"]
+                return True
+            else:
+                return False
+
+    async def refresh_valuelist(self):
+        while True:
+            success = await self.sync_in_async.Call(self._get_value_list)
+
+            await asyncio.sleep(ROLIVALUES_REFRESH_TIME)
+
+    def _items_to_value(self, trade_info: dict) -> tuple[int , int] | tuple[str, str]:
+        if self._value_list:
+            give_list = trade_info["offers"][0]["userAssets"]
+            receive_list = trade_info["offers"][1]["userAssets"]
+
+            give_value = 0
+            for asset_data in give_list:
+                asset_value = self._value_list[str(asset_data["assetId"])][4]
+                give_value += asset_value
+
+            receive_value = 0
+            for asset_data in receive_list:
+                asset_value = self._value_list[str(asset_data["assetId"])][4]
+                receive_value += asset_value
+
+            return (give_value, receive_value)
+        else:
+            return ("-", "-")
+
+    def _get_trade_info(self, id: int) -> dict | bool:
+        parsed_url = parse_query_params(TRADE_INFO_URL, {"id": id})
+
+        request_struct = request.Request(url=parsed_url, method="GET")
+        request_struct.add_header("Cookie", f".ROBLOSECURITY={self._cookie_str}")
+        request_struct.add_header("x-csrf-token", self._xcsrf)
+        request_struct.add_header("content-type", "application/json")
+
+        try:
+            resp = Log.wrap_http(self._opener.open, request_struct=request_struct, success_codes=[200, 201])
+        except error.HTTPError as resp:
+            match resp.code:
+                case 403:
+                    self._get_xcsrf()
+
+                case 401:
+                    toast = ToastManager.spawn_toast("Cookie has been invalided. Please restart your app.", "Cookie invalidated", 5)
+                    sys.exit()
+
+                case _:
+                    ...
+
+            return False
+        else:
+            response_content = resp.read()
+            json_response = json.loads(response_content.decode('utf-8'))
+
+            return json_response
+
+    def _get_inbound_trades(self) -> dict | bool:
         request_struct = request.Request(url=TRADE_URL, method="GET")
         request_struct.add_header("Cookie", f".ROBLOSECURITY={self._cookie_str}")
         request_struct.add_header("x-csrf-token", self._xcsrf)
@@ -96,6 +180,10 @@ def _get_inbound_trades(self):
                 case 403:
                     self._get_xcsrf()
 
+                case 401:
+                    toast = ToastManager.spawn_toast("Cookie has been invalided. Please restart your app.", "Cookie invalidated", 5)
+                    sys.exit()
+
                 case _:
                     ...
 
@@ -109,32 +197,80 @@ def _get_inbound_trades(self):
     async def check_inbound_trades(self) -> list[InboundData] | None:
         inbound_data_list: list[InboundData] = list()
         inbound_trades_list = await self.sync_in_async.Call(self._get_inbound_trades)
+        if not inbound_trades_list:
+            return inbound_data_list
 
         new_inbounds_list = []
 
-        inbound_id_list = [inbound["id"] for inbound in inbound_trades_list["data"]]
-        if self._cached_inbound_id_list and any(new_inbounds := [inbound for inbound in inbound_trades_list["data"] if not inbound["id"] in self._cached_inbound_id_list]):
-            new_inbounds_list = [inbound['id'] for inbound in new_inbounds]
-            Log.info(f"New inbounds detected: {new_inbounds_list}")
-
-            for inbound in new_inbounds:
-                inbound_data = InboundData(username=inbound["user"]["name"],
-                                           user_id=inbound["user"]["id"])
-                inbound_data_list.append(inbound_data)
-
-        self._cached_inbound_id_list.extend(new_inbounds_list) if self._cached_inbound_id_list else self._cached_inbound_id_list.extend(inbound_id_list)
+        # inbound_id_list = [inbound["id"] for inbound in inbound_trades_list["data"]]
+        # if self._cached_inbound_id_list and any(new_inbounds := [inbound for inbound in inbound_trades_list["data"] if not inbound["id"] in self._cached_inbound_id_list]):
+        #     new_inbounds_list = [inbound['id'] for inbound in new_inbounds]
+
+        #     Log.info(f"New inbounds detected: {new_inbounds_list}")
+
+        #     for inbound in new_inbounds:
+        #         inbound_trade_info = await self.sync_in_async.Call(self._get_trade_info, id=inbound["id"])
+        #         if inbound_trade_info:
+        #             give_value, receive_value = self._items_to_value(trade_info=inbound_trade_info)
+
+        #             inbound_data = InboundData(
+        #                                     username=inbound["user"]["name"],
+        #                                     user_id=inbound["user"]["id"],
+
+        #                                     give_items=inbound_trade_info["offers"][0]["userAssets"],
+        #                                     give_value=give_value,
+        #                                     give_robux=inbound_trade_info["offers"][0]["robux"],
+                                            
+        #                                     receive_items=inbound_trade_info["offers"][1]["userAssets"],
+        #                                     receive_value=receive_value,
+        #                                     receive_robux=inbound_trade_info["offers"][1]["robux"],
+        #                                     )          
+        #         else:
+        #             inbound_data = InboundData(
+        #                                     username=inbound["user"]["name"],
+        #                                     user_id=inbound["user"]["id"],
+
+        #                                     give_items=[],
+        #                                     give_value="-",
+        #                                     give_robux="-",
+                                            
+        #                                     receive_items=[],
+        #                                     receive_value="-",
+        #                                     receive_robux="-",
+        #                                     )                   
+        #         inbound_data_list.append(inbound_data)
+
+        # self._cached_inbound_id_list.extend(new_inbounds_list) if self._cached_inbound_id_list else self._cached_inbound_id_list.extend(inbound_id_list)
 
         ## for testing purposes
-        # for inbound in inbound_trades_list["data"]:
-        #     inbound_data = InboundData(username=inbound["user"]["name"],
-        #                                 user_id=inbound["user"]["id"])
-        #     inbound_data_list.append(inbound_data)
+        for inbound in inbound_trades_list["data"][:1]:
+            inbound_trade_info = await self.sync_in_async.Call(self._get_trade_info, id=inbound["id"])
+            if inbound_trade_info:
+                give_value, receive_value = self._items_to_value(trade_info=inbound_trade_info)
+
+                inbound_data = InboundData(
+                                        username=inbound["user"]["name"],
+                                        user_id=inbound["user"]["id"],
+
+                                        give_items=inbound_trade_info["offers"][0]["userAssets"],
+                                        give_value=give_value,
+                                        give_robux=inbound_trade_info["offers"][0]["robux"],
+                                        
+                                        receive_items=inbound_trade_info["offers"][1]["userAssets"],
+                                        receive_value=receive_value,
+                                        receive_robux=inbound_trade_info["offers"][1]["robux"],
+                                        )          
+                inbound_data_list.append(inbound_data)
 
         return inbound_data_list
 
-    def quit_session(self):
+    def quit_session(self) -> None:
         self._opener.close()
         self._refresh_task.cancel()
 
-    def validate_cookie(self):
+    def validate_cookie(self) -> bool:
         return self._get_xcsrf()
+
+    @property
+    def value_list(self):
+        return self._value_list
diff --git a/src/log_comms/log.py b/src/log_comms/log.py
@@ -112,14 +112,14 @@ def wrap_http(func: typing.Callable, request_struct , success_codes: list[int],
         try:
             resp = func(request_struct, *args, **kwargs)
 
-            Log.info(f"Opened URL: {resp.url} with code {resp.code}")
+            Log.info(f"Opened URL: {request_struct.get_method()} {resp.url} with code {resp.code}")
 
             return resp
         except error.HTTPError as resp:
             if resp.code not in success_codes:
-                Log.critical(f"HTTPError at {func.__name__}: [{resp.code}] | {resp.read()}")
+                Log.critical(f"HTTPError for {request_struct.get_method()} {resp.url}: [{resp.code}] | {resp.read()}")
             else:
-                Log.info(f"Opened URL: {resp.url} with code {resp.code}")
+                Log.info(f"Opened URL: {request_struct.get_method()} {resp.url} with code {resp.code}")
             raise resp
 
     @staticmethod
diff --git a/src/utils/__init__.py b/src/utils/__init__.py
@@ -1,4 +1,5 @@
 from .encoders import *
 from .syncinasync import *
+from .url_parser import *
 
-__all__ = ('SyncInAsync')
+__all__ = ('SyncInAsync', 'parse_query_params')
diff --git a/src/utils/url_parser.py b/src/utils/url_parser.py
@@ -0,0 +1,5 @@
+def parse_query_params(url: str, params: dict[str, str | int | float]):
+    for name, value in params.items():
+        url = url.replace(f"${name}$", str(value))
+
+    return url
diff --git a/src/win_comms/toast_manager.py b/src/win_comms/toast_manager.py

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`from .http_manager import *`
`2`	`2`
`3`		`-__all__ = ('HttpManager')`
	`3`	`+__all__ = ('HttpManager','InboundData')`