mirror of
https://github.com/Ahrimdon/detailed-cod-tracker.git
synced 2024-11-03 16:46:44 -05:00
731 lines
27 KiB
Python
731 lines
27 KiB
Python
__version__ = "2.0.1"
|
|
|
|
# Imports
|
|
import asyncio
|
|
import enum
|
|
import json
|
|
import uuid
|
|
from abc import abstractmethod
|
|
from datetime import datetime
|
|
from urllib.parse import quote
|
|
|
|
import aiohttp
|
|
import requests
|
|
from aiohttp import ClientResponseError
|
|
|
|
|
|
# Enums
|
|
|
|
class platforms(enum.Enum):
|
|
All = 'all'
|
|
Activision = 'acti'
|
|
Battlenet = 'battle'
|
|
PSN = 'psn'
|
|
Steam = 'steam'
|
|
Uno = 'uno'
|
|
XBOX = 'xbl'
|
|
|
|
|
|
class games(enum.Enum):
|
|
ColdWar = 'cw'
|
|
ModernWarfare = 'mw'
|
|
ModernWarfare2 = 'mw2'
|
|
Vanguard = 'vg'
|
|
Warzone = 'wz'
|
|
Warzone2 = 'wz2'
|
|
|
|
|
|
class friendActions(enum.Enum):
|
|
Invite = "invite"
|
|
Uninvite = "uninvite"
|
|
Remove = "remove"
|
|
Block = "block"
|
|
Unblock = "unblock"
|
|
|
|
|
|
class API:
|
|
"""
|
|
Call Of Duty API Wrapper
|
|
|
|
Developed by Todo Lodo & Engineer152
|
|
|
|
Contributors
|
|
- Werseter
|
|
|
|
Source Code: https://github.com/TodoLodo/cod-python-api
|
|
"""
|
|
def __init__(self):
|
|
# sub classes
|
|
self.Warzone = self.__WZ()
|
|
self.ModernWarfare = self.__MW()
|
|
self.Warzone2 = self.__WZ2()
|
|
self.ModernWarfare2 = self.__MW2()
|
|
self.ColdWar = self.__CW()
|
|
self.Vanguard = self.__VG()
|
|
self.Shop = self.__SHOP()
|
|
self.Me = self.__USER()
|
|
self.Misc = self.__ALT()
|
|
|
|
async def loginAsync(self, sso_token: str) -> None:
|
|
await API._Common.loginAsync(sso_token)
|
|
|
|
# Login
|
|
def login(self, ssoToken: str):
|
|
API._Common.login(ssoToken)
|
|
|
|
class _Common:
|
|
requestHeaders = {
|
|
"content-type": "application/json",
|
|
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
|
|
"AppleWebKit/537.36 (KHTML, like Gecko) "
|
|
"Chrome/74.0.3729.169 "
|
|
"Safari/537.36",
|
|
"Accept": "application/json",
|
|
"Connection": "Keep-Alive"
|
|
}
|
|
cookies = {"new_SiteId": "cod", "ACT_SSO_LOCALE": "en_US", "country": "US",
|
|
"ACT_SSO_COOKIE_EXPIRY": "1645556143194"}
|
|
cachedMappings = None
|
|
|
|
fakeXSRF = str(uuid.uuid4())
|
|
baseUrl: str = "https://my.callofduty.com/api/papi-client"
|
|
loggedIn: bool = False
|
|
|
|
# endPoints
|
|
|
|
# game platform lookupType gamertag type
|
|
fullDataUrl = "/stats/cod/v1/title/%s/platform/%s/%s/%s/profile/type/%s"
|
|
# game platform lookupType gamertag type start end [?limit=n or '']
|
|
combatHistoryUrl = "/crm/cod/v2/title/%s/platform/%s/%s/%s/matches/%s/start/%d/end/%d/details"
|
|
# game platform lookupType gamertag type start end
|
|
breakdownUrl = "/crm/cod/v2/title/%s/platform/%s/%s/%s/matches/%s/start/%d/end/%d"
|
|
# game platform lookupType gamertag
|
|
seasonLootUrl = "/loot/title/%s/platform/%s/%s/%s/status/en"
|
|
# game platform
|
|
mapListUrl = "/ce/v1/title/%s/platform/%s/gameType/mp/communityMapData/availability"
|
|
# game platform type matchId
|
|
matchInfoUrl = "/crm/cod/v2/title/%s/platform/%s/fullMatch/%s/%d/en"
|
|
|
|
@staticmethod
|
|
async def loginAsync(sso_token: str) -> None:
|
|
API._Common.cookies["ACT_SSO_COOKIE"] = sso_token
|
|
API._Common.baseSsoToken = sso_token
|
|
r = await API._Common.__Request(f"{API._Common.baseUrl}/crm/cod/v2/identities/{sso_token}")
|
|
if r['status'] == 'success':
|
|
API._Common.loggedIn = True
|
|
else:
|
|
raise InvalidToken(sso_token)
|
|
|
|
@staticmethod
|
|
def login(sso_token: str) -> None:
|
|
API._Common.cookies["ACT_SSO_COOKIE"] = sso_token
|
|
API._Common.baseSsoToken = sso_token
|
|
|
|
r = requests.get(f"{API._Common.baseUrl}/crm/cod/v2/identities/{sso_token}",
|
|
headers=API._Common.requestHeaders, cookies=API._Common.cookies)
|
|
|
|
if r.json()['status'] == 'success':
|
|
API._Common.loggedIn = True
|
|
API._Common.cookies.update(r.cookies)
|
|
else:
|
|
raise InvalidToken(sso_token)
|
|
|
|
@staticmethod
|
|
def sso_token() -> str:
|
|
return API._Common.cookies["ACT_SSO_COOKIE"]
|
|
|
|
# Requests
|
|
|
|
@staticmethod
|
|
async def __Request(url):
|
|
async with aiohttp.client.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=True),
|
|
timeout=aiohttp.ClientTimeout(total=30)) as session:
|
|
try:
|
|
async with session.get(url, cookies=API._Common.cookies,
|
|
headers=API._Common.requestHeaders) as resp:
|
|
try:
|
|
resp.raise_for_status()
|
|
except ClientResponseError as err:
|
|
return {'status': 'error', 'data': {'type': type(err), 'message': err.message}}
|
|
else:
|
|
API._Common.cookies.update({c.key: c.value for c in session.cookie_jar})
|
|
return await resp.json()
|
|
except asyncio.TimeoutError as err:
|
|
return {'status': 'error', 'data': {'type': type(err), 'message': str(err)}}
|
|
|
|
async def __sendRequest(self, url: str):
|
|
if self.loggedIn:
|
|
response = await API._Common.__Request(f"{self.baseUrl}{url}")
|
|
if response['status'] == 'success':
|
|
response['data'] = await self.__perform_mapping(response['data'])
|
|
return response
|
|
else:
|
|
raise NotLoggedIn
|
|
|
|
# client name url formatter
|
|
def __cleanClientName(self, gamertag):
|
|
return quote(gamertag.encode("utf-8"))
|
|
|
|
# helper
|
|
def __helper(self, platform, gamertag):
|
|
lookUpType = "gamer"
|
|
if platform == platforms.Uno:
|
|
lookUpType = "id"
|
|
if platform == platforms.Activision:
|
|
platform = platforms.Uno
|
|
if platform not in [platforms.Activision, platforms.Battlenet, platforms.Uno, platforms.All, platforms.PSN,
|
|
platforms.XBOX]:
|
|
raise InvalidPlatform(platform)
|
|
else:
|
|
gamertag = self.__cleanClientName(gamertag)
|
|
return lookUpType, gamertag, platform
|
|
|
|
async def __get_mappings(self):
|
|
if API._Common.cachedMappings is None:
|
|
API._Common.cachedMappings = (
|
|
await API._Common.__Request('https://engineer152.github.io/wz-data/weapon-ids.json'),
|
|
await API._Common.__Request('https://engineer152.github.io/wz-data/game-modes.json'),
|
|
await API._Common.__Request('https://engineer152.github.io/wz-data/perks.json'))
|
|
return API._Common.cachedMappings
|
|
|
|
# mapping
|
|
async def __perform_mapping(self, data):
|
|
guns, modes, perks = await self.__get_mappings()
|
|
if not isinstance(data, list) or 'matches' not in data:
|
|
return data
|
|
try:
|
|
for match in data['matches']:
|
|
# time stamps
|
|
try:
|
|
match['utcStartDateTime'] = datetime.fromtimestamp(
|
|
match['utcStartSeconds']).strftime("%A, %B %d, %Y, %I:%M:%S")
|
|
match['utcEndDateTime'] = datetime.fromtimestamp(
|
|
match['utcEndSeconds']).strftime("%A, %B %d, %Y, %I:%M:%S")
|
|
except KeyError:
|
|
pass
|
|
|
|
# loadouts list
|
|
for loadout in match['player']['loadouts']:
|
|
# weapons
|
|
if loadout['primaryWeapon']['label'] is None:
|
|
try:
|
|
loadout['primaryWeapon']['label'] = guns[loadout['primaryWeapon']['name']]
|
|
except KeyError:
|
|
pass
|
|
if loadout['secondaryWeapon']['label'] is None:
|
|
try:
|
|
loadout['secondaryWeapon']['label'] = guns[loadout['secondaryWeapon']['name']]
|
|
except KeyError:
|
|
pass
|
|
|
|
# perks list
|
|
for perk in loadout['perks']:
|
|
if perk['label'] is None:
|
|
try:
|
|
perk['label'] = perks[perk['name']]
|
|
except KeyError:
|
|
pass
|
|
|
|
# extra perks list
|
|
for perk in loadout['extraPerks']:
|
|
if perk['label'] is None:
|
|
try:
|
|
perk['label'] = perks[perk['name']]
|
|
except KeyError:
|
|
pass
|
|
|
|
# loadout list
|
|
for loadout in match['player']['loadout']:
|
|
if loadout['primaryWeapon']['label'] is None:
|
|
try:
|
|
loadout['primaryWeapon']['label'] = guns[loadout['primaryWeapon']['name']]
|
|
except KeyError:
|
|
pass
|
|
if loadout['secondaryWeapon']['label'] is None:
|
|
try:
|
|
loadout['secondaryWeapon']['label'] = guns[loadout['secondaryWeapon']['name']]
|
|
except KeyError:
|
|
pass
|
|
|
|
# perks list
|
|
for perk in loadout['perks']:
|
|
if perk['label'] is None:
|
|
try:
|
|
perk['label'] = perks[perk['name']]
|
|
except KeyError:
|
|
pass
|
|
|
|
# extra perks list
|
|
for perk in loadout['extraPerks']:
|
|
if perk['label'] is None:
|
|
try:
|
|
perk['label'] = perks[perk['name']]
|
|
except KeyError:
|
|
pass
|
|
except KeyError:
|
|
pass
|
|
|
|
# return mapped or unmapped data
|
|
return data
|
|
|
|
# API Requests
|
|
async def _fullDataReq(self, game, platform, gamertag, type):
|
|
lookUpType, gamertag, platform = self.__helper(platform, gamertag)
|
|
return await self.__sendRequest(self.fullDataUrl % (game, platform.value, lookUpType, gamertag, type))
|
|
|
|
async def _combatHistoryReq(self, game, platform, gamertag, type, start, end):
|
|
lookUpType, gamertag, platform = self.__helper(platform, gamertag)
|
|
return await self.__sendRequest(
|
|
self.combatHistoryUrl % (game, platform.value, lookUpType, gamertag, type, start, end))
|
|
|
|
async def _breakdownReq(self, game, platform, gamertag, type, start, end):
|
|
lookUpType, gamertag, platform = self.__helper(platform, gamertag)
|
|
return await self.__sendRequest(
|
|
self.breakdownUrl % (game, platform.value, lookUpType, gamertag, type, start, end))
|
|
|
|
async def _seasonLootReq(self, game, platform, gamertag):
|
|
lookUpType, gamertag, platform = self.__helper(platform, gamertag)
|
|
return await self.__sendRequest(self.seasonLootUrl % (game, platform.value, lookUpType, gamertag))
|
|
|
|
async def _mapListReq(self, game, platform):
|
|
return await self.__sendRequest(self.mapListUrl % (game, platform.value))
|
|
|
|
async def _matchInfoReq(self, game, platform, type, matchId):
|
|
return await self.__sendRequest(self.matchInfoUrl % (game, platform.value, type, matchId))
|
|
|
|
class __GameDataCommons(_Common):
|
|
"""
|
|
Methods
|
|
=======
|
|
Sync
|
|
----
|
|
fullData(platform:platforms, gamertag:str)
|
|
returns player's game data of type dict
|
|
|
|
combatHistory(platform:platforms, gamertag:str)
|
|
returns player's combat history of type dict
|
|
|
|
combatHistoryWithDate(platform:platforms, gamertag:str, start:int, end:int)
|
|
returns player's combat history within the specified timeline of type dict
|
|
|
|
breakdown(platform:platforms, gamertag:str)
|
|
returns player's combat history breakdown of type dict
|
|
|
|
breakdownWithDate(platform:platforms, gamertag:str, start:int, end:int)
|
|
returns player's combat history breakdown within the specified timeline of type dict
|
|
|
|
seasonLoot(platform:platforms, gamertag:str)
|
|
returns player's season loot
|
|
|
|
mapList(platform:platforms)
|
|
returns available maps and available modes for each
|
|
|
|
matchInfo(platform:platforms, matchId:int)
|
|
returns details match details of type dict
|
|
|
|
Async
|
|
----
|
|
fullDataAsync(platform:platforms, gamertag:str)
|
|
returns player's game data of type dict
|
|
|
|
combatHistoryAsync(platform:platforms, gamertag:str)
|
|
returns player's combat history of type dict
|
|
|
|
combatHistoryWithDateAsync(platform:platforms, gamertag:str, start:int, end:int)
|
|
returns player's combat history within the specified timeline of type dict
|
|
|
|
breakdownAsync(platform:platforms, gamertag:str)
|
|
returns player's combat history breakdown of type dict
|
|
|
|
breakdownWithDateAsync(platform:platforms, gamertag:str, start:int, end:int)
|
|
returns player's combat history breakdown within the specified timeline of type dict
|
|
|
|
seasonLootAsync(platform:platforms, gamertag:str)
|
|
returns player's season loot
|
|
|
|
mapListAsync(platform:platforms)
|
|
returns available maps and available modes for each
|
|
|
|
matchInfoAsync(platform:platforms, matchId:int)
|
|
returns details match details of type dict
|
|
"""
|
|
|
|
def __init_subclass__(cls, **kwargs):
|
|
cls.__doc__ = cls.__doc__ + super(cls, cls).__doc__
|
|
|
|
@property
|
|
@abstractmethod
|
|
def _game(self) -> str:
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
@abstractmethod
|
|
def _type(self) -> str:
|
|
raise NotImplementedError
|
|
|
|
async def fullDataAsync(self, platform: platforms, gamertag: str):
|
|
data = await self._fullDataReq(self._game, platform, gamertag, self._type)
|
|
return data
|
|
|
|
def fullData(self, platform: platforms, gamertag: str):
|
|
return asyncio.run(self.fullDataAsync(platform, gamertag))
|
|
|
|
async def combatHistoryAsync(self, platform: platforms, gamertag: str):
|
|
data = await self._combatHistoryReq(self._game, platform, gamertag, self._type, 0, 0)
|
|
return data
|
|
|
|
def combatHistory(self, platform: platforms, gamertag: str):
|
|
return asyncio.run(self.combatHistoryAsync(platform, gamertag))
|
|
|
|
async def combatHistoryWithDateAsync(self, platform, gamertag: str, start: int, end: int):
|
|
data = await self._combatHistoryReq(self._game, platform, gamertag, self._type, start, end)
|
|
return data
|
|
|
|
def combatHistoryWithDate(self, platform, gamertag: str, start: int, end: int):
|
|
return asyncio.run(self.combatHistoryWithDateAsync(platform, gamertag, start, end))
|
|
|
|
async def breakdownAsync(self, platform, gamertag: str):
|
|
data = await self._breakdownReq(self._game, platform, gamertag, self._type, 0, 0)
|
|
return data
|
|
|
|
def breakdown(self, platform, gamertag: str):
|
|
return asyncio.run(self.breakdownAsync(platform, gamertag))
|
|
|
|
async def breakdownWithDateAsync(self, platform, gamertag: str, start: int, end: int):
|
|
data = await self._breakdownReq(self._game, platform, gamertag, self._type, start, end)
|
|
return data
|
|
|
|
def breakdownWithDate(self, platform, gamertag: str, start: int, end: int):
|
|
return asyncio.run(self.breakdownWithDateAsync(platform, gamertag, start, end))
|
|
|
|
async def matchInfoAsync(self, platform, matchId: int):
|
|
data = await self._matchInfoReq(self._game, platform, self._type, matchId)
|
|
return data
|
|
|
|
def matchInfo(self, platform, matchId: int):
|
|
return asyncio.run(self.matchInfoAsync(platform, matchId))
|
|
|
|
async def seasonLootAsync(self, platform, gamertag):
|
|
data = await self._seasonLootReq(self._game, platform, gamertag)
|
|
return data
|
|
|
|
def seasonLoot(self, platform, gamertag):
|
|
return asyncio.run(self.seasonLootAsync(platform, gamertag))
|
|
|
|
async def mapListAsync(self, platform):
|
|
data = await self._mapListReq(self._game, platform)
|
|
return data
|
|
|
|
def mapList(self, platform):
|
|
return asyncio.run(self.mapListAsync(platform))
|
|
# WZ
|
|
|
|
class __WZ(__GameDataCommons):
|
|
"""
|
|
Warzone class: A class to get players warzone stats, warzone combat history and specific warzone match details
|
|
classCategory: game
|
|
gameId/gameTitle: mw or wz
|
|
gameType: wz
|
|
|
|
"""
|
|
|
|
@property
|
|
def _game(self) -> str:
|
|
return "mw"
|
|
|
|
@property
|
|
def _type(self) -> str:
|
|
return "wz"
|
|
|
|
async def seasonLootAsync(self, platform, gamertag):
|
|
raise InvalidEndpoint
|
|
|
|
async def mapListAsync(self, platform):
|
|
raise InvalidEndpoint
|
|
|
|
# WZ2
|
|
|
|
class __WZ2(__GameDataCommons):
|
|
"""
|
|
Warzone 2 class: A class to get players warzone 2 stats, warzone 2 combat history and specific warzone 2 match details
|
|
classCategory: game
|
|
gameId/gameTitle: mw or wz
|
|
gameType: wz2
|
|
|
|
"""
|
|
|
|
@property
|
|
def _game(self) -> str:
|
|
return "mw2"
|
|
|
|
@property
|
|
def _type(self) -> str:
|
|
return "wz2"
|
|
|
|
async def seasonLootAsync(self, platform, gamertag):
|
|
raise InvalidEndpoint
|
|
|
|
async def mapListAsync(self, platform):
|
|
raise InvalidEndpoint
|
|
|
|
# MW
|
|
|
|
class __MW(__GameDataCommons):
|
|
"""
|
|
ModernWarfare class: A class to get players modernwarfare stats, modernwarfare combat history, a player's modernwarfare season loot, modernwarfare map list and specific modernwarfare match details
|
|
classCategory: game
|
|
gameId/gameTitle: mw
|
|
gameType: mp
|
|
|
|
"""
|
|
|
|
@property
|
|
def _game(self) -> str:
|
|
return "mw"
|
|
|
|
@property
|
|
def _type(self) -> str:
|
|
return "mp"
|
|
|
|
# CW
|
|
|
|
class __CW(__GameDataCommons):
|
|
"""
|
|
ColdWar class: A class to get players coldwar stats, coldwar combat history, a player's coldwar season loot, coldwar map list and specific coldwar match details
|
|
classCategory: game
|
|
gameId/gameTitle: cw
|
|
gameType: mp
|
|
|
|
"""
|
|
@property
|
|
def _game(self) -> str:
|
|
return "cw"
|
|
|
|
@property
|
|
def _type(self) -> str:
|
|
return "mp"
|
|
|
|
# VG
|
|
|
|
class __VG(__GameDataCommons):
|
|
"""
|
|
Vanguard class: A class to get players vanguard stats, vanguard combat history, a player's vanguard season loot, vanguard map list and specific vanguard match details
|
|
classCategory: game
|
|
gameId/gameTitle: vg
|
|
gameType: pm
|
|
|
|
"""
|
|
|
|
@property
|
|
def _game(self) -> str:
|
|
return "vg"
|
|
|
|
@property
|
|
def _type(self) -> str:
|
|
return "mp"
|
|
|
|
# MW2
|
|
|
|
class __MW2(__GameDataCommons):
|
|
"""
|
|
ModernWarfare 2 class: A class to get players modernwarfare 2 stats, modernwarfare 2 combat history, a player's modernwarfare 2 season loot, modernwarfare 2 map list and specific modernwarfare 2 match details
|
|
classCategory: game
|
|
gameId/gameTitle: mw
|
|
gameType: mp
|
|
|
|
"""
|
|
|
|
@property
|
|
def _game(self) -> str:
|
|
return "mw2"
|
|
|
|
@property
|
|
def _type(self) -> str:
|
|
return "mp"
|
|
|
|
# USER
|
|
class __USER(_Common):
|
|
def info(self):
|
|
if self.loggedIn:
|
|
# Assuming 'user_info.json' is the file you've downloaded with the information
|
|
file_path = 'userInfo.json'
|
|
# Load the JSON content from the local file
|
|
with open(file_path, 'r') as file:
|
|
rawData = json.load(file)
|
|
try:
|
|
userInfo = rawData['userInfo'] # Accessing the nested 'userInfo' dictionary
|
|
identities = rawData.get('identities', []) # Accessing the 'identities' if it exists or default to empty list
|
|
|
|
data = {'userName': userInfo['userName'], 'identities': []} # Getting 'userName' from the nested dictionary
|
|
for i in identities: # Loop through each identity in the 'identities' list
|
|
data['identities'].append({
|
|
'platform': i['provider'],
|
|
'gamertag': i['username'],
|
|
'accountID': i['accountID'] # Assuming 'accountID' exists; otherwise, you might need a default value
|
|
})
|
|
return data
|
|
|
|
except KeyError as e:
|
|
# Handle the case where the expected key is not found in the dictionary
|
|
print(f"Error: A required field is missing in the data. Details: {str(e)}")
|
|
# Re-raise the exception or handle it as required
|
|
raise
|
|
|
|
else:
|
|
raise NotLoggedIn
|
|
|
|
def __priv(self):
|
|
d = self.info()
|
|
return d['identities'][0]['platform'], quote(d['identities'][0]['gamertag'].encode("utf-8"))
|
|
|
|
async def friendFeedAsync(self):
|
|
p, g = self.__priv()
|
|
data = await self._Common__sendRequest(
|
|
f"/userfeed/v1/friendFeed/platform/{p}/gamer/{g}/friendFeedEvents/en")
|
|
return data
|
|
|
|
def friendFeed(self):
|
|
return asyncio.run(self.friendFeedAsync())
|
|
|
|
async def eventFeedAsync(self):
|
|
data = await self._Common__sendRequest(f"/userfeed/v1/friendFeed/rendered/en/{self.sso_token()}")
|
|
return data
|
|
|
|
def eventFeed(self):
|
|
return asyncio.run(self.eventFeedAsync())
|
|
|
|
async def loggedInIdentitiesAsync(self):
|
|
data = await self._Common__sendRequest(f"/crm/cod/v2/identities/{self.sso_token()}")
|
|
return data
|
|
|
|
def loggedInIdentities(self):
|
|
return asyncio.run(self.loggedInIdentitiesAsync())
|
|
|
|
async def codPointsAsync(self):
|
|
p, g = self.__priv()
|
|
data = await self._Common__sendRequest(f"/inventory/v1/title/mw/platform/{p}/gamer/{g}/currency")
|
|
return data
|
|
|
|
def codPoints(self):
|
|
return asyncio.run(self.codPointsAsync())
|
|
|
|
async def connectedAccountsAsync(self):
|
|
p, g = self.__priv()
|
|
data = await self._Common__sendRequest(f"/crm/cod/v2/accounts/platform/{p}/gamer/{g}")
|
|
return data
|
|
|
|
def connectedAccounts(self):
|
|
return asyncio.run(self.connectedAccountsAsync())
|
|
|
|
async def settingsAsync(self):
|
|
p, g = self.__priv()
|
|
data = await self._Common__sendRequest(f"/preferences/v1/platform/{p}/gamer/{g}/list")
|
|
return data
|
|
|
|
def settings(self):
|
|
return asyncio.run(self.settingsAsync())
|
|
|
|
# SHOP
|
|
class __SHOP(_Common):
|
|
"""
|
|
Shop class: A class to get bundle details and battle pass loot
|
|
classCategory: other
|
|
|
|
Methods
|
|
=======
|
|
Sync
|
|
----
|
|
purchasableItems(game: games)
|
|
returns purchasable items for a specific gameId/gameTitle
|
|
|
|
bundleInformation(game: games, bundleId: int)
|
|
returns bundle details for the specific gameId/gameTitle and bundleId
|
|
|
|
battlePassLoot(game: games, platform: platforms, season: int)
|
|
returns battle pass loot for specific game and season on given platform
|
|
|
|
Async
|
|
----
|
|
purchasableItemsAsync(game: games)
|
|
returns purchasable items for a specific gameId/gameTitle
|
|
|
|
bundleInformationAsync(game: games, bundleId: int)
|
|
returns bundle details for the specific gameId/gameTitle and bundleId
|
|
|
|
battlePassLootAsync(game: games, platform: platforms, season: int)
|
|
returns battle pass loot for specific game and season on given platform
|
|
"""
|
|
|
|
async def purchasableItemsAsync(self, game: games):
|
|
data = await self._Common__sendRequest(f"/inventory/v1/title/{game.value}/platform/uno/purchasable/public/en")
|
|
return data
|
|
|
|
def purchasableItems(self, game: games):
|
|
return asyncio.run(self.purchasableItemsAsync(game))
|
|
|
|
async def bundleInformationAsync(self, game: games, bundleId: int):
|
|
data = await self._Common__sendRequest(f"/inventory/v1/title/{game.value}/bundle/{bundleId}/en")
|
|
return data
|
|
|
|
def bundleInformation(self, game: games, bundleId: int):
|
|
return asyncio.run(self.bundleInformationAsync(game, bundleId))
|
|
|
|
async def battlePassLootAsync(self, game: games, platform: platforms, season: int):
|
|
data = await self._Common__sendRequest(
|
|
f"/loot/title/{game.value}/platform/{platform.value}/list/loot_season_{season}/en")
|
|
return data
|
|
|
|
def battlePassLoot(self, game: games, platform: platforms, season: int):
|
|
return asyncio.run(self.battlePassLootAsync(game, platform, season))
|
|
|
|
# ALT
|
|
class __ALT(_Common):
|
|
|
|
async def searchAsync(self, platform, gamertag: str):
|
|
lookUpType, gamertag, platform = self._Common__helper(platform, gamertag)
|
|
data = await self._Common__sendRequest(f"/crm/cod/v2/platform/{platform.value}/username/{gamertag}/search")
|
|
return data
|
|
|
|
def search(self, platform, gamertag: str):
|
|
return asyncio.run(self.searchAsync(platform, gamertag))
|
|
|
|
|
|
# Exceptions
|
|
|
|
class NotLoggedIn(Exception):
|
|
def __str__(self):
|
|
return "Not logged in!"
|
|
|
|
|
|
class InvalidToken(Exception):
|
|
def __init__(self, token):
|
|
self.token = token
|
|
|
|
def __str__(self):
|
|
return f"Token is invalid, token: {self.token}"
|
|
|
|
|
|
class InvalidPlatform(Exception):
|
|
def __init__(self, platform: platforms):
|
|
self.message: str
|
|
if platform == platforms.Steam:
|
|
self.message = "Steam cannot be used till further updates."
|
|
else:
|
|
self.message = "Invalid platform, use platform class!"
|
|
|
|
|
|
super().__init__(self.message)
|
|
|
|
def __str__(self):
|
|
return self.message
|
|
|
|
|
|
class InvalidEndpoint(Exception):
|
|
def __str__(self):
|
|
return "This endpoint is not available for selected title"
|
|
|
|
|
|
class StatusError(Exception):
|
|
def __str__(self):
|
|
return "Status Error, Check if your sso token is valid or try again later."
|