def put_league(self, item: LeagueListDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
item["platformId"] = platform
# Get league to update it later if it exists
league = self._session().query(SQLLeague) \
.filter_by(platformId=platform) \
.filter_by(leagueId=item["leagueId"]).first()
if not league:
# League isn't present yet. Just insert it
self._put(SQLLeague(**item))
return
# Map new entries by summoner id for easier lookup later on
map_by_id = {int(value["playerOrTeamId"]): {**value, "playerOrTeamId": int(value["playerOrTeamId"])} for value
in item["entries"]}
# Iterate over existing entries
for i in reversed(range(len(league.entries))):
entry = league.entries[i]
if entry.playerOrTeamId in map_by_id:
# Entry is still present, just update it
entry.__init__(**map_by_id[entry.playerOrTeamId])
# Delete it from the map, so it doesn't get added twice later
del map_by_id[entry.playerOrTeamId]
else:
# Entry isn't present anymore, remove it
del league.entries[i]
# append remaining entries
for value in map_by_id.values():
league.entries.append(SQLLeaguePosition(**value))
league.updated()
self._session().merge(league)
def put_realms(self,
item: RealmDto,
context: PipelineContext = None) -> None:
key = "{clsname}.{platform}".format(clsname=RealmDto.__name__,
platform=Region(
item["region"]).platform.value)
self._put(key, item)
def put_champion_mastery_list(self, item: ChampionMasteryListDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
summoner = item["summonerId"]
for cm in item["masteries"]:
cm["platformId"] = platform
cm["summonerId"] = summoner
self._put_many(item["masteries"], SQLChampionMastery)
def put_champion_mastery_list(self, item: ChampionMasteryListDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
summoner_id = item["summonerId"]
key = "{clsname}.{platform}.{summoner_id}".format(clsname=ChampionMasteryListDto.__name__,
platform=platform,
summoner_id=summoner_id)
self._put(key, item)
def put_status(self,
item: ShardStatusDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}".format(clsname=ShardStatusDto.__name__,
platform=platform)
self._put(key, item)
def put_rune_list(self, item: RuneListDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{version}.{locale}".format(clsname=RuneListDto.__name__,
platform=platform,
version=item["version"],
locale=item["locale"])
self._put(key, item)
def put_champion_status_list(self,
item: ChampionListDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
for champ in item["champions"]:
champ["platform"] = platform
self._put_many(item["champions"], SQLChampionStatus)
def put_profile_icons(self, item: ProfileIconDataDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{version}.{locale}".format(clsname=ProfileIconDataDto.__name__,
platform=platform,
version=item["version"],
locale=item["locale"])
self._put(key, item)
def put_language_strings(self, item: LanguageStringsDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{version}.{locale}".format(clsname=LanguageStringsDto.__name__,
platform=platform,
version=item["version"],
locale=item["locale"])
self._put(key, item)
def put_featured_games(self,
item: FeaturedGamesDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}".format(clsname=FeaturedGamesDto.__name__,
platform=platform)
self._put(key, item)
def put_language(self,
item: LanguagesDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}".format(clsname=LanguagesDto.__name__,
platform=platform)
self._put(key, item)
def put_champion_status_list(self,
item: ChampionRotationDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}".format(clsname="ChampionRotationDto",
platform=platform)
self._put(key, item)
def put_timeline(self,
item: TimelineDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{id}".format(clsname=TimelineDto.__name__,
platform=platform,
id=item["matchId"])
self._put(key, item)
def put_summoner_spell_list(self, item: SummonerSpellListDto, context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
included_data = "|".join(sorted(item["includedData"]))
key = "{clsname}.{platform}.{version}.{locale}.{included_data}".format(clsname=SummonerSpellListDto.__name__,
platform=platform,
version=item["version"],
locale=item["locale"],
included_data=included_data)
self._put(key, item)
def put_league_positions(self,
item: LeaguePositionsDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{id}".format(
clsname=LeaguePositionsDto.__name__,
platform=platform,
id=item["summonerId"])
self._put(key, item)
def put_master_league(self,
item: MasterLeagueListDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{queue}".format(
clsname=MasterLeagueListDto.__name__,
platform=platform,
queue=item["queue"])
self._put(key, item)
def put_current_game(self,
item: CurrentGameInfoDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
key = "{clsname}.{platform}.{id}".format(
clsname=CurrentGameInfoDto.__name__,
platform=platform,
id=item["summonerId"])
self._put(key, item)
def put_champion_status_list(self,
item: ChampionListDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
free_to_play = item["freeToPlay"]
key = "{clsname}.{platform}.{free_to_play}".format(
clsname="ChampionStatusListDto",
platform=platform,
free_to_play=free_to_play)
self._put(key, item)
def to_dto(self):
dto = super().to_dto()
locales = set()
locales.add(Region(dto["slug"].upper()).default_locale)
for service in dto["services"]:
for incident in service["incidents"]:
for update in incident["updates"]:
for translation in update["translations"]:
locales.add(translation["locale"])
dto["locales"] = list(locales)
return dto
def put_summoner(self,
item: SummonerDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
pairs = {}
for id_type in ["name", "accountId", "id", "puuid"]:
key = "{clsname}.{platform}.{value}".format(
clsname=SummonerDto.__name__,
platform=platform,
value=item[id_type])
pairs[key] = item
self._put_many(pairs, SummonerDto)
def put_summoner(self,
item: SummonerDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
name = item["name"].replace(" ", "").lower()
name = name.encode("utf-8")
key = "{clsname}.{platform}.{id}.{account_id}.{name}".format(
clsname=SummonerDto.__name__,
platform=platform,
id=item["id"],
account_id=item["accountId"],
name=name)
self._put(key, item)
def put_champion_list(self,
item: ChampionListDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
included_data = "|".join(sorted(item["includedData"]))
key = "{clsname}.{platform}.{version}.{locale}.{included_data}.{data_by_id}".format(
clsname=ChampionListDto.__name__,
platform=platform,
version=item["version"],
locale=item["locale"],
included_data=included_data,
data_by_id=item["dataById"])
self._put(key, item)
def put_league_positions(self,
session,
item: LeaguePositionsDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
item["platformId"] = platform
old_positions = []
query = session.query(SQLLeaguePosition) \
.filter_by(platformId=platform) \
.filter_by(playerOrTeamId=item["summonerId"])
if query.count() > 0:
# There are already positions stored for that summoner
old_positions = query.all()
map_by_id = {
position["leagueId"]: position
for position in item["positions"]
}
for i in range(len(old_positions)):
if old_positions[i].leagueId in map_by_id:
# The given position is already present. update it
old_positions[i].__init__(
**map_by_id[old_positions[i].leagueId])
# Remove from map to prevent inserting it twice later on
del map_by_id[old_positions[i].leagueId]
session.merge(old_positions[i])
else:
# The given position is no longer present. remove it
session.delete(old_positions[i])
for pos in map_by_id.values():
# Create league, so it does get created in the database if it doesn't exist
league = SQLLeague(platformId=platform,
leagueId=pos["leagueId"],
name=pos["leagueName"],
tier=pos["tier"],
queue=pos["queueType"])
position = SQLLeaguePosition(**pos, league=league)
# This will not call SQlLeague.updated() to make sure we don't mess up the expiration of the hole league
position.updated()
session.merge(position)
self._put(
SQLLeaguePositions(summonerId=item["summonerId"],
platformId=platform,
positions=[]))
def put_timeline(self,
item: TimelineDto,
context: PipelineContext = None) -> None:
platform = Region(item["region"]).platform.value
item["platformId"] = platform
self._put(SQLTimeline(**item))
def put_summoner(self,
item: SummonerDto,
context: PipelineContext = None) -> None:
if not "platform" in item:
item["platform"] = Region(item["region"]).platform.value
self._put(SQLSummoner(**item))