385 lines
14 KiB
Python
385 lines
14 KiB
Python
# vim: set fileencoding=utf-8
|
|
import copy
|
|
from abc import ABC
|
|
from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, cast
|
|
|
|
from flask_caching import Cache
|
|
|
|
from bemani.common import GameConstants, Profile, ValidatedDict, ID
|
|
from bemani.data import Data, Config, Score, Attempt, Link, Song, UserID, RemoteUser
|
|
|
|
|
|
class FrontendBase(ABC):
|
|
|
|
"""
|
|
All subclasses should override this attribute with the string
|
|
the game series uses in the DB.
|
|
"""
|
|
|
|
game: GameConstants
|
|
|
|
"""
|
|
If a subclass wishes to constrain music searches to a particular
|
|
version, this should be set. If this is left blank, music operations
|
|
such as records and attempts will pull from all versions of the game.
|
|
"""
|
|
version: Optional[int] = None
|
|
|
|
"""
|
|
List of valid chart integers. Should be overridden by the game.
|
|
"""
|
|
valid_charts: List[int] = []
|
|
|
|
"""
|
|
List of valid rival type strings. Should be overridden by the game.
|
|
"""
|
|
valid_rival_types: List[str] = []
|
|
|
|
def __init__(self, data: Data, config: Config, cache: Cache) -> None:
|
|
self.data = data
|
|
self.config = config
|
|
self.cache = cache
|
|
|
|
def make_index(self, songid: int, chart: int) -> str:
|
|
return f"{songid}-{chart}"
|
|
|
|
def get_duplicate_id(self, musicid: int, chart: int) -> Optional[Tuple[int, int]]:
|
|
return None
|
|
|
|
def format_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
|
|
return {
|
|
"userid": str(userid),
|
|
"songid": score.id,
|
|
"chart": score.chart,
|
|
"plays": score.plays,
|
|
"points": score.points,
|
|
}
|
|
|
|
def format_top_score(self, userid: UserID, score: Score) -> Dict[str, Any]:
|
|
return self.format_score(userid, score)
|
|
|
|
def format_attempt(self, userid: UserID, attempt: Attempt) -> Dict[str, Any]:
|
|
return {
|
|
"userid": str(userid),
|
|
"songid": attempt.id,
|
|
"chart": attempt.chart,
|
|
"timestamp": attempt.timestamp,
|
|
"raised": attempt.new_record,
|
|
"points": attempt.points,
|
|
}
|
|
|
|
def format_rival(self, link: Link, profile: Profile) -> Dict[str, Any]:
|
|
return {
|
|
"type": link.type,
|
|
"userid": str(link.other_userid),
|
|
"remote": RemoteUser.is_remote(link.other_userid),
|
|
}
|
|
|
|
def format_profile(
|
|
self, profile: Profile, playstats: ValidatedDict
|
|
) -> Dict[str, Any]:
|
|
return {
|
|
"name": profile.get_str("name"),
|
|
"extid": ID.format_extid(profile.extid),
|
|
"first_play_time": playstats.get_int("first_play_timestamp"),
|
|
"last_play_time": playstats.get_int("last_play_timestamp"),
|
|
}
|
|
|
|
def format_song(self, song: Song) -> Dict[str, Any]:
|
|
return {
|
|
"name": song.name,
|
|
"artist": song.artist,
|
|
"genre": song.genre,
|
|
}
|
|
|
|
def merge_song(self, existing: Dict[str, Any], new: Song) -> Dict[str, Any]:
|
|
return existing
|
|
|
|
def round_to_ten(self, elems: List[Any]) -> List[Any]:
|
|
num = len(elems)
|
|
if num % 10 == 0:
|
|
return elems
|
|
else:
|
|
return elems[: -(num % 10)]
|
|
|
|
def all_games(self) -> Iterator[Tuple[GameConstants, int, str]]:
|
|
"""
|
|
Override this to return an interator based on a game series factory.
|
|
"""
|
|
|
|
def get_all_songs(self, force_db_load: bool = False) -> Dict[int, Dict[str, Any]]:
|
|
if not force_db_load:
|
|
cached_songs = self.cache.get(f"{self.game.value}.sorted_songs")
|
|
if cached_songs is not None:
|
|
# Not sure why mypy insists that this is a str instead of Any.
|
|
return cast(Dict[int, Dict[str, Any]], cached_songs)
|
|
|
|
# Find all songs in the game, process notecounts and difficulties
|
|
songs: Dict[int, Dict[str, Any]] = {}
|
|
for song in self.data.local.music.get_all_songs(self.game, self.version):
|
|
if song.chart not in self.valid_charts:
|
|
# No beginner chart support
|
|
continue
|
|
if song.id not in songs:
|
|
songs[song.id] = self.format_song(song)
|
|
else:
|
|
songs[song.id] = self.merge_song(songs[song.id], song)
|
|
|
|
self.cache.set(f"{self.game.value}.sorted_songs", songs, timeout=600)
|
|
return songs
|
|
|
|
def get_all_player_info(
|
|
self,
|
|
userids: List[UserID],
|
|
limit: Optional[int] = None,
|
|
allow_remote: bool = False,
|
|
) -> Dict[UserID, Dict[int, Dict[str, Any]]]:
|
|
info: Dict[UserID, Dict[int, Dict[str, Any]]] = {}
|
|
playstats: Dict[UserID, ValidatedDict] = {}
|
|
|
|
# Find all versions of the users' profiles, sorted newest to oldest.
|
|
versions = sorted(
|
|
[version for (game, version, name) in self.all_games()], reverse=True
|
|
)
|
|
for userid in userids:
|
|
info[userid] = {}
|
|
userlimit = limit
|
|
for version in versions:
|
|
if allow_remote:
|
|
profile = self.data.remote.user.get_profile(
|
|
self.game, version, userid
|
|
)
|
|
else:
|
|
profile = self.data.local.user.get_profile(
|
|
self.game, version, userid
|
|
)
|
|
if profile is not None:
|
|
if userid not in playstats:
|
|
stats = self.data.local.game.get_settings(self.game, userid)
|
|
if stats is None:
|
|
stats = ValidatedDict()
|
|
playstats[userid] = stats
|
|
info[userid][version] = self.format_profile(
|
|
profile, playstats[userid]
|
|
)
|
|
info[userid][version]["remote"] = RemoteUser.is_remote(userid)
|
|
# Exit out if we've hit the limit
|
|
if userlimit is not None:
|
|
userlimit = userlimit - 1
|
|
if userlimit == 0:
|
|
break
|
|
|
|
return info
|
|
|
|
def get_latest_player_info(
|
|
self, userids: List[UserID]
|
|
) -> Dict[UserID, Dict[str, Any]]:
|
|
# Grab the latest profile for each user
|
|
all_info = self.get_all_player_info(userids, 1)
|
|
info = {}
|
|
|
|
for userid in userids:
|
|
for version in all_info[userid]:
|
|
info[userid] = all_info[userid][version]
|
|
break
|
|
|
|
return info
|
|
|
|
def get_all_players(self) -> Dict[UserID, Dict[str, Any]]:
|
|
userids: Set[UserID] = set()
|
|
|
|
versions = [version for (game, version, name) in self.all_games()]
|
|
for version in versions:
|
|
userids.update(self.data.local.user.get_all_players(self.game, version))
|
|
|
|
return self.get_latest_player_info(list(userids))
|
|
|
|
def get_network_scores(self, limit: Optional[int] = None) -> Dict[str, Any]:
|
|
userids: List[UserID] = []
|
|
|
|
# Find all attempts across all games
|
|
attempts = [
|
|
attempt
|
|
for attempt in self.data.local.music.get_all_attempts(
|
|
game=self.game, version=self.version, limit=limit
|
|
)
|
|
if attempt[0] is not None
|
|
]
|
|
for attempt in attempts:
|
|
if attempt[0] not in userids:
|
|
userids.append(attempt[0])
|
|
|
|
return {
|
|
"attempts": sorted(
|
|
[self.format_attempt(attempt[0], attempt[1]) for attempt in attempts],
|
|
reverse=True,
|
|
key=lambda attempt: (
|
|
attempt["timestamp"],
|
|
attempt["songid"],
|
|
attempt["chart"],
|
|
),
|
|
),
|
|
"players": self.get_latest_player_info(userids),
|
|
}
|
|
|
|
def get_network_records(self) -> Dict[str, Any]:
|
|
records: Dict[str, Tuple[UserID, Score]] = {}
|
|
userids: List[UserID] = []
|
|
|
|
# Find all high-scores across all games
|
|
highscores = self.data.local.music.get_all_records(
|
|
game=self.game, version=self.version
|
|
)
|
|
for score in highscores:
|
|
index = self.make_index(score[1].id, score[1].chart)
|
|
if index not in records:
|
|
records[index] = score
|
|
if score[0] not in userids:
|
|
userids.append(score[0])
|
|
# Also take care of duplicate IDs (revivals, omnimix, etc)
|
|
alternate = self.get_duplicate_id(score[1].id, score[1].chart)
|
|
if alternate is not None:
|
|
altid, altchart = alternate
|
|
index = self.make_index(altid, altchart)
|
|
if index not in records:
|
|
newscore = copy.deepcopy(score)
|
|
newscore[1].id = altid
|
|
newscore[1].chart = altchart
|
|
records[index] = newscore
|
|
|
|
return {
|
|
"records": [
|
|
self.format_score(records[index][0], records[index][1])
|
|
for index in records
|
|
],
|
|
"players": self.get_latest_player_info(userids),
|
|
}
|
|
|
|
def get_scores(
|
|
self, userid: UserID, limit: Optional[int] = None
|
|
) -> List[Dict[str, Any]]:
|
|
# Find all attempts across all games
|
|
attempts = [
|
|
attempt
|
|
for attempt in self.data.local.music.get_all_attempts(
|
|
game=self.game, version=self.version, userid=userid, limit=limit
|
|
)
|
|
if attempt[0] is not None
|
|
]
|
|
|
|
return sorted(
|
|
[self.format_attempt(None, attempt[1]) for attempt in attempts],
|
|
reverse=True,
|
|
key=lambda attempt: (
|
|
attempt["timestamp"],
|
|
attempt["songid"],
|
|
attempt["chart"],
|
|
),
|
|
)
|
|
|
|
def get_records(self, userid: UserID) -> List[Dict[str, Any]]:
|
|
records: Dict[str, Tuple[UserID, Score]] = {}
|
|
|
|
# Find all high-scores across all games
|
|
highscores = self.data.local.music.get_all_scores(
|
|
game=self.game, version=self.version, userid=userid
|
|
)
|
|
for score in highscores:
|
|
index = self.make_index(score[1].id, score[1].chart)
|
|
if index not in records:
|
|
records[index] = score
|
|
else:
|
|
current_score = records[index][1].points
|
|
current_plays = records[index][1].plays
|
|
new_score = score[1].points
|
|
new_plays = score[1].plays
|
|
if new_score > current_score:
|
|
records[index] = score
|
|
records[index][1].plays += current_plays
|
|
else:
|
|
records[index][1].plays += new_plays
|
|
|
|
# Copy over records to duplicate IDs, such as revivals
|
|
indexes = [index for index in records]
|
|
for index in indexes:
|
|
alternate = self.get_duplicate_id(
|
|
records[index][1].id, records[index][1].chart
|
|
)
|
|
if alternate is not None:
|
|
altid, altchart = alternate
|
|
newindex = self.make_index(altid, altchart)
|
|
if newindex not in records:
|
|
newscore = copy.deepcopy(score)
|
|
newscore[1].id = altid
|
|
newscore[1].chart = altchart
|
|
records[newindex] = newscore
|
|
|
|
return [self.format_score(None, records[index][1]) for index in records]
|
|
|
|
def get_top_scores(self, musicid: int) -> Dict[str, Any]:
|
|
scores = self.data.local.music.get_all_scores(
|
|
game=self.game, version=self.version, songid=musicid
|
|
)
|
|
userids: List[UserID] = []
|
|
for score in scores:
|
|
if score[1].chart not in self.valid_charts:
|
|
# No beginner chart support
|
|
continue
|
|
if score[0] not in userids:
|
|
userids.append(score[0])
|
|
|
|
for score in scores:
|
|
# See if this is a legacy ID
|
|
if score[1].id != musicid:
|
|
alternative = self.get_duplicate_id(score[1].id, score[1].chart)
|
|
if alternative is None:
|
|
continue
|
|
|
|
oldid, oldchart = alternative
|
|
if oldid == musicid:
|
|
score[1].id = oldid
|
|
score[1].chart = oldchart
|
|
|
|
return {
|
|
"topscores": [
|
|
self.format_top_score(score[0], score[1])
|
|
for score in scores
|
|
if score[1].chart in self.valid_charts
|
|
],
|
|
"players": self.get_latest_player_info(userids),
|
|
}
|
|
|
|
def get_rivals(
|
|
self, userid: UserID
|
|
) -> Tuple[
|
|
Dict[int, List[Dict[str, Any]]], Dict[UserID, Dict[int, Dict[str, Any]]]
|
|
]:
|
|
rivals = {}
|
|
userids = set()
|
|
versions = [version for (game, version, name) in self.all_games()]
|
|
profiles = {}
|
|
for version in versions:
|
|
profile = self.data.local.user.get_profile(self.game, version, userid)
|
|
if profile is None:
|
|
# No profile for this version, so no rivals either.
|
|
continue
|
|
profiles[version] = profile
|
|
rivals[version] = [
|
|
link
|
|
for link in self.data.local.user.get_links(self.game, version, userid)
|
|
if link.type in self.valid_rival_types
|
|
]
|
|
for rival in rivals[version]:
|
|
userids.add(rival.other_userid)
|
|
|
|
return (
|
|
{
|
|
version: [
|
|
self.format_rival(rival, profiles[version])
|
|
for rival in rivals[version]
|
|
]
|
|
for version in rivals
|
|
},
|
|
self.get_all_player_info(list(userids), allow_remote=True),
|
|
)
|