def viewscores(userid: UserID) -> Response:
frontend = DDRFrontend(g.data, g.config, g.cache)
info = frontend.get_latest_player_info([userid]).get(userid)
if info is None:
abort(404)
scores = frontend.get_scores(userid, limit=100)
if len(scores) > 10:
scores = frontend.round_to_ten(scores)
return render_react(
'{}\'s DDR Scores'.format(info['name']),
'ddr/scores.react.js',
{
'attempts': scores,
'songs': frontend.get_all_songs(),
'players': {},
'versions': {version: name for (game, version, name) in frontend.all_games()},
'shownames': False,
'shownewrecords': True,
},
{
'refresh': url_for('ddr_pages.listscores', userid=userid),
'player': url_for('ddr_pages.viewplayer', userid=-1),
'individual_score': url_for('ddr_pages.viewtopscores', musicid=-1),
},
)
def viewrecords(userid: UserID) -> Response:
frontend = PopnMusicFrontend(g.data, g.config, g.cache)
info = frontend.get_latest_player_info([userid]).get(userid)
if info is None:
abort(404)
versions = {
version: name
for (game, version, name) in frontend.all_games()
}
versions[0] = 'CS and Licenses'
return render_react(
'{}\'s Pop\'n Music Records'.format(info['name']),
'popn/records.react.js',
{
'records': frontend.get_records(userid),
'songs': frontend.get_all_songs(),
'players': {},
'versions': versions,
'shownames': False,
'showpersonalsort': True,
'filterempty': True,
},
{
'refresh': url_for('popn_pages.listrecords', userid=userid),
'player': url_for('popn_pages.viewplayer', userid=-1),
'individual_score': url_for('popn_pages.viewtopscores',
musicid=-1),
},
)
def viewrivals() -> Response:
frontend = PopnMusicFrontend(g.data, g.config, g.cache)
rivals, playerinfo = frontend.get_rivals(g.userID)
# There is no support for Rivals in Tune Street.
if VersionConstants.POPN_MUSIC_TUNE_STREET in rivals:
del rivals[VersionConstants.POPN_MUSIC_TUNE_STREET]
return render_react(
'Pop\'n Music Rivals',
'popn/rivals.react.js',
{
'userid': str(g.userID),
'rivals': rivals,
'max_active_rivals': frontend.max_active_rivals,
'players': playerinfo,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
},
{
'refresh': url_for('popn_pages.listrivals'),
'search': url_for('popn_pages.searchrivals'),
'player': url_for('popn_pages.viewplayer', userid=-1),
'addrival': url_for('popn_pages.addrival'),
'removerival': url_for('popn_pages.removerival'),
},
)
def viewuser(userid: int) -> Response:
user = g.data.local.user.get_user(userid)
def __format_card(card: str) -> str:
try:
return CardCipher.encode(card)
except CardCipherException:
return '????????????????'
cards = [__format_card(card) for card in g.data.local.user.get_cards(userid)]
arcades = g.data.local.machine.get_all_arcades()
return render_react(
'User',
'admin/user.react.js',
{
'user': {
'email': user.email,
'username': user.username,
},
'cards': cards,
'arcades': {arcade.id: arcade.name for arcade in arcades},
'balances': {arcade.id: g.data.local.user.get_balance(userid, arcade.id) for arcade in arcades},
'events': [format_event(event) for event in g.data.local.network.get_events(userid=userid, event='paseli_transaction')],
},
{
'refresh': url_for('admin_pages.listuser', userid=userid),
'removeusercard': url_for('admin_pages.removeusercard', userid=userid),
'addusercard': url_for('admin_pages.addusercard', userid=userid),
'updatebalance': url_for('admin_pages.updatebalance', userid=userid),
'updateusername': url_for('admin_pages.updateusername', userid=userid),
'updateemail': url_for('admin_pages.updateemail', userid=userid),
'updatepin': url_for('admin_pages.updatepin', userid=userid),
'updatepassword': url_for('admin_pages.updatepassword', userid=userid),
},
)
def viewscores(userid: UserID) -> Response:
frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
info = frontend.get_latest_player_info([userid]).get(userid)
if info is None:
abort(404)
scores = frontend.get_scores(userid, limit=100)
if len(scores) > 10:
scores = frontend.round_to_ten(scores)
return render_react(
f'{info["name"]}\'s SDVX Scores',
'sdvx/scores.react.js',
{
'attempts': scores,
'songs': frontend.get_all_songs(),
'players': {},
'shownames': False,
'shownewrecords': True,
},
{
'refresh': url_for('sdvx_pages.listscores', userid=userid),
'player': url_for('sdvx_pages.viewplayer', userid=-1),
'individual_score': url_for('sdvx_pages.viewtopscores', musicid=-1),
},
)
def viewrivals() -> Response:
frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
rivals, playerinfo = frontend.get_rivals(g.userID)
# There were no rivals in SDVX 1 or 2.
if VersionConstants.SDVX_BOOTH in rivals:
del rivals[VersionConstants.SDVX_BOOTH]
if VersionConstants.SDVX_INFINITE_INFECTION in rivals:
del rivals[VersionConstants.SDVX_INFINITE_INFECTION]
return render_react(
'SDVX Rivals',
'sdvx/rivals.react.js',
{
'userid': str(g.userID),
'rivals': rivals,
'players': playerinfo,
'versions': {version: name for (game, version, name) in frontend.all_games()},
},
{
'refresh': url_for('sdvx_pages.listrivals'),
'search': url_for('sdvx_pages.searchrivals'),
'player': url_for('sdvx_pages.viewplayer', userid=-1),
'addrival': url_for('sdvx_pages.addrival'),
'removerival': url_for('sdvx_pages.removerival'),
},
)
def viewsettings() -> Response:
frontend = IIDXFrontend(g.data, g.config, g.cache)
userid = g.userID
djinfo = frontend.get_all_player_info([userid])[userid]
if not djinfo:
abort(404)
versions = sorted(
[version for (game, version, name) in frontend.all_games()],
reverse=True,
)
return render_react(
'IIDX Game Settings',
'iidx/settings.react.js',
{
'player': djinfo,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
'qpros': frontend.get_all_items(versions),
},
{
'updateqpro': url_for('iidx_pages.updateqpro'),
'updateflags': url_for('iidx_pages.updateflags'),
'updatesettings': url_for('iidx_pages.updatesettings'),
'updatename': url_for('iidx_pages.updatename'),
'updateprefecture': url_for('iidx_pages.updateprefecture'),
'leavearcade': url_for('iidx_pages.leavearcade'),
},
)
def viewnetworkrecords() -> Response:
frontend = MusecaFrontend(g.data, g.config, g.cache)
network_records = frontend.get_network_records()
versions = {
version: name
for (game, version, name) in frontend.all_games()
}
versions[0] = 'CS and Licenses'
return render_react(
'Global MÚSECA Records',
'museca/records.react.js',
{
'records': network_records['records'],
'songs': frontend.get_all_songs(),
'players': network_records['players'],
'versions': versions,
'shownames': True,
'showpersonalsort': False,
'filterempty': False,
},
{
'refresh': url_for('museca_pages.listnetworkrecords'),
'player': url_for('museca_pages.viewplayer', userid=-1),
'individual_score': url_for('museca_pages.viewtopscores',
musicid=-1),
},
)
def viewevents() -> Response:
iidx = IIDXFrontend(g.data, g.config, g.cache)
jubeat = JubeatFrontend(g.data, g.config, g.cache)
pnm = PopnMusicFrontend(g.data, g.config, g.cache)
return render_react(
'Events',
'admin/events.react.js',
{
'events': [format_event(event) for event in g.data.local.network.get_events(limit=100)],
'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
'arcades': {arcade.id: arcade.name for arcade in g.data.local.machine.get_all_arcades()},
'iidxsongs': iidx.get_all_songs(),
'jubeatsongs': jubeat.get_all_songs(),
'pnmsongs': pnm.get_all_songs(),
'iidxversions': {version: name for (game, version, name) in iidx.all_games()},
'jubeatversions': {version: name for (game, version, name) in jubeat.all_games()},
'pnmversions': {version: name for (game, version, name) in pnm.all_games()},
},
{
'refresh': url_for('admin_pages.listevents', since=-1),
'backfill': url_for('admin_pages.backfillevents', until=-1),
'viewuser': url_for('admin_pages.viewuser', userid=-1),
'jubeatsong': url_for('jubeat_pages.viewtopscores', musicid=-1) if g.config.get('support', {}).get(GameConstants.JUBEAT, False) else None,
'iidxsong': url_for('iidx_pages.viewtopscores', musicid=-1) if g.config.get('support', {}).get(GameConstants.IIDX, False) else None,
'pnmsong': url_for('popn_pages.viewtopscores', musicid=-1) if g.config.get('support', {}).get(GameConstants.POPN_MUSIC, False) else None,
},
)
def viewplayer(userid: UserID) -> Response:
frontend = IIDXFrontend(g.data, g.config, g.cache)
djinfo = frontend.get_all_player_info([userid])[userid]
if not djinfo:
abort(404)
latest_version = sorted(djinfo.keys(), reverse=True)[0]
for version in djinfo:
sp_rival = g.data.local.user.get_link(GameConstants.IIDX, version,
g.userID, 'sp_rival', userid)
dp_rival = g.data.local.user.get_link(GameConstants.IIDX, version,
g.userID, 'dp_rival', userid)
djinfo[version]['sp_rival'] = sp_rival is not None
djinfo[version]['dp_rival'] = dp_rival is not None
return render_react(
f'dj {djinfo[latest_version]["name"]}\'s IIDX Profile',
'iidx/player.react.js',
{
'playerid': userid,
'own_profile': userid == g.userID,
'player': djinfo,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
},
{
'refresh': url_for('iidx_pages.listplayer', userid=userid),
'records': url_for('iidx_pages.viewrecords', userid=userid),
'scores': url_for('iidx_pages.viewscores', userid=userid),
'addrival': url_for('iidx_pages.addrival'),
'removerival': url_for('iidx_pages.removerival'),
},
)
def viewnetworkrecords() -> Response:
frontend = IIDXFrontend(g.data, g.config, g.cache)
network_records = frontend.get_network_records()
return render_react(
'Global IIDX Records',
'iidx/records.react.js',
{
'records': network_records['records'],
'songs': frontend.get_all_songs(),
'players': network_records['players'],
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
'showdjnames': True,
'showpersonalsort': False,
'filterempty': False,
},
{
'refresh': url_for('iidx_pages.listnetworkrecords'),
'player': url_for('iidx_pages.viewplayer', userid=-1),
'individual_score': url_for('iidx_pages.viewtopscores',
musicid=-1),
},
)
def viewsettings() -> Response:
frontend = JubeatFrontend(g.data, g.config, g.cache)
userid = g.userID
info = frontend.get_all_player_info([userid])[userid]
versions = sorted(
[version for (game, version, name) in frontend.all_games()],
reverse=True,
)
if not info:
abort(404)
all_emblems = frontend.get_all_items(versions)
return render_react(
'Jubeat Game Settings',
'jubeat/settings.react.js',
{
'player': info,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
'emblems': all_emblems,
},
{
'updatename': url_for('jubeat_pages.updatename'),
'updateemblem': url_for('jubeat_pages.updateemblem')
},
)
def showjubility(userid: UserID) -> Response:
frontend = JubeatFrontend(g.data, g.config, g.cache)
info = frontend.get_all_player_info([userid])[userid]
if not info:
abort(404)
latest_version = sorted(info.keys(), reverse=True)[0]
return render_react(
f'{info[latest_version]["name"]}\'s Jubility Breakdown',
'jubeat/jubility.react.js',
{
'playerid': userid,
'player': info,
'songs': frontend.get_all_songs(),
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
},
{
'refresh': url_for('jubeat_pages.listplayer', userid=userid),
'individual_score': url_for('jubeat_pages.viewtopscores',
musicid=-1),
'profile': url_for('jubeat_pages.viewplayer', userid=userid),
},
)
def viewplayer(userid: UserID) -> Response:
frontend = JubeatFrontend(g.data, g.config, g.cache)
info = frontend.get_all_player_info([userid])[userid]
if not info:
abort(404)
latest_version = sorted(info.keys(), reverse=True)[0]
return render_react(
f'{info[latest_version]["name"]}\'s Jubeat Profile',
'jubeat/player.react.js',
{
'playerid': userid,
'own_profile': userid == g.userID,
'player': info,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
},
{
'refresh': url_for('jubeat_pages.listplayer', userid=userid),
'records': url_for('jubeat_pages.viewrecords', userid=userid),
'scores': url_for('jubeat_pages.viewscores', userid=userid),
'jubility': url_for('jubeat_pages.showjubility', userid=userid)
},
)
def viewsettings() -> Response:
frontend = DDRFrontend(g.data, g.config, g.cache)
userid = g.userID
info = frontend.get_all_player_info([userid])[userid]
if not info:
abort(404)
return render_react(
'DDR Game Settings',
'ddr/settings.react.js',
{
'player': info,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
},
{
'updatename': url_for('ddr_pages.updatename'),
'updateweight': url_for('ddr_pages.updateweight'),
'updateearlylate': url_for('ddr_pages.updateearlylate'),
'updatebackgroundcombo':
url_for('ddr_pages.updatebackgroundcombo'),
'updatesettings': url_for('ddr_pages.updatesettings'),
},
)
def viewrivals() -> Response:
frontend = ReflecBeatFrontend(g.data, g.config, g.cache)
rivals, playerinfo = frontend.get_rivals(g.userID)
# Reflec Beat 1 has no rivals support
for no_rivals_support in NO_RIVAL_SUPPORT:
if no_rivals_support in rivals:
del rivals[no_rivals_support]
return render_react(
'Reflec Beat Rivals',
'reflec/rivals.react.js',
{
'userid': str(g.userID),
'rivals': rivals,
'players': playerinfo,
'versions': {version: name for (game, version, name) in frontend.all_games() if version not in NO_RIVAL_SUPPORT},
},
{
'refresh': url_for('reflec_pages.listrivals'),
'search': url_for('reflec_pages.searchrivals'),
'player': url_for('reflec_pages.viewplayer', userid=-1),
'addrival': url_for('reflec_pages.addrival'),
'removerival': url_for('reflec_pages.removerival'),
},
)
def viewrivals() -> Response:
frontend = DDRFrontend(g.data, g.config, g.cache)
rivals, info = frontend.get_rivals(g.userID)
return render_react(
'DDR Rivals',
'ddr/rivals.react.js',
{
'userid': str(g.userID),
'rivals': rivals,
'max_active_rivals': frontend.max_active_rivals,
'players': info,
'versions':
{version: name
for (game, version, name) in frontend.all_games()},
},
{
'refresh': url_for('ddr_pages.listrivals'),
'search': url_for('ddr_pages.searchrivals'),
'player': url_for('ddr_pages.viewplayer', userid=-1),
'addrival': url_for('ddr_pages.addrival'),
'removerival': url_for('ddr_pages.removerival'),
'setactiverival': url_for('ddr_pages.setactiverival'),
'setinactiverival': url_for('ddr_pages.setinactiverival'),
},
)
def viewnetworkscores() -> Response:
# Only load the last 100 results for the initial fetch, so we can render faster
frontend = MusecaFrontend(g.data, g.config, g.cache)
network_scores = frontend.get_network_scores(limit=100)
if len(network_scores['attempts']) > 10:
network_scores['attempts'] = frontend.round_to_ten(
network_scores['attempts'])
return render_react(
'Global MÚSECA Scores',
'museca/scores.react.js',
{
'attempts': network_scores['attempts'],
'songs': frontend.get_all_songs(),
'players': network_scores['players'],
'shownames': True,
'shownewrecords': False,
},
{
'refresh': url_for('museca_pages.listnetworkscores'),
'player': url_for('museca_pages.viewplayer', userid=-1),
'individual_score': url_for('museca_pages.viewtopscores',
musicid=-1),
},
)
def viewarcade(arcadeid: int) -> Response:
# Cast the ID for type safety.
arcadeid = ArcadeID(arcadeid)
arcade = g.data.local.machine.get_arcade(arcadeid)
if g.userID not in arcade.owners:
abort(403)
machines = [
format_machine(machine) for machine in g.data.local.machine.get_all_machines(arcade.id)
]
return render_react(
arcade.name,
'arcade/arcade.react.js',
{
'arcade': format_arcade(arcade),
'machines': machines,
'game_settings': get_game_settings(arcade),
'balances': {balance[0]: balance[1] for balance in g.data.local.machine.get_balances(arcadeid)},
'users': {user.id: user.username for user in g.data.local.user.get_all_users()},
'events': [format_event(event) for event in g.data.local.network.get_events(arcadeid=arcadeid, event='paseli_transaction')],
'enforcing': g.config['server']['enforce_pcbid'],
},
{
'refresh': url_for('arcade_pages.listarcade', arcadeid=arcadeid),
'viewuser': url_for('admin_pages.viewuser', userid=-1),
'paseli_enabled': url_for('arcade_pages.updatearcade', arcadeid=arcadeid, attribute='paseli_enabled'),
'paseli_infinite': url_for('arcade_pages.updatearcade', arcadeid=arcadeid, attribute='paseli_infinite'),
'mask_services_url': url_for('arcade_pages.updatearcade', arcadeid=arcadeid, attribute='mask_services_url'),
'update_settings': url_for('arcade_pages.updatesettings', arcadeid=arcadeid),
'add_balance': url_for('arcade_pages.addbalance', arcadeid=arcadeid),
'update_balance': url_for('arcade_pages.updatebalance', arcadeid=arcadeid),
'update_pin': url_for('arcade_pages.updatepin', arcadeid=arcadeid),
},
)
def viewrecords(userid: UserID) -> Response:
frontend = SoundVoltexFrontend(g.data, g.config, g.cache)
info = frontend.get_latest_player_info([userid]).get(userid)
if info is None:
abort(404)
versions = {version: name for (game, version, name) in frontend.all_games()}
return render_react(
f'{info["name"]}\'s SDVX Records',
'sdvx/records.react.js',
{
'records': frontend.get_records(userid),
'songs': frontend.get_all_songs(),
'players': {},
'versions': versions,
'shownames': False,
'showpersonalsort': True,
'filterempty': True,
},
{
'refresh': url_for('sdvx_pages.listrecords', userid=userid),
'player': url_for('sdvx_pages.viewplayer', userid=-1),
'individual_score': url_for('sdvx_pages.viewtopscores', musicid=-1),
},
)
def viewmachines() -> Response:
games: Dict[str, Dict[int, str]] = {}
for (game, version, name) in Base.all_games():
if game not in games:
games[game] = {}
games[game][version] = name
return render_react(
'Machines',
'admin/machines.react.js',
{
'machines': [format_machine(machine) for machine in g.data.local.machine.get_all_machines()],
'arcades': {arcade.id: arcade.name for arcade in g.data.local.machine.get_all_arcades()},
'series': {
GameConstants.BISHI_BASHI: 'BishiBashi',
GameConstants.DDR: 'DDR',
GameConstants.IIDX: 'IIDX',
GameConstants.JUBEAT: 'Jubeat',
GameConstants.MUSECA: 'MÚSECA',
GameConstants.POPN_MUSIC: 'Pop\'n Music',
GameConstants.REFLEC_BEAT: 'Reflec Beat',
GameConstants.SDVX: 'SDVX',
},
'games': games,
'enforcing': g.config['server']['enforce_pcbid'],
},
{
'generatepcbid': url_for('admin_pages.generatepcbid'),
'addpcbid': url_for('admin_pages.addpcbid'),
'updatepcbid': url_for('admin_pages.updatepcbid'),
'removepcbid': url_for('admin_pages.removepcbid'),
},
)
def viewhome() -> Response:
return render_react(
g.config.get('name', 'e-AMUSEMENT Network'), 'home.react.js', {
'news': [
format_news(news)
for news in g.data.local.network.get_all_news()
],
})
def viewplayers() -> Response:
frontend = IIDXFrontend(g.data, g.config, g.cache)
return render_react(
'All IIDX Players',
'iidx/allplayers.react.js',
{'players': frontend.get_all_players()},
{
'refresh': url_for('iidx_pages.listplayers'),
'player': url_for('iidx_pages.viewplayer', userid=-1),
},
)
def viewplayers() -> Response:
frontend = PopnMusicFrontend(g.data, g.config, g.cache)
return render_react(
'All Pop\'n Music Players',
'popn/allplayers.react.js',
{'players': frontend.get_all_players()},
{
'refresh': url_for('popn_pages.listplayers'),
'player': url_for('popn_pages.viewplayer', userid=-1),
},
)
def viewplayers() -> Response:
frontend = MusecaFrontend(g.data, g.config, g.cache)
return render_react(
'All MÚSECA Players',
'museca/allplayers.react.js',
{'players': frontend.get_all_players()},
{
'refresh': url_for('museca_pages.listplayers'),
'player': url_for('museca_pages.viewplayer', userid=-1),
},
)
def viewplayers() -> Response:
frontend = BishiBashiFrontend(g.data, g.config, g.cache)
return render_react(
'All BishiBashi Players',
'bishi/allplayers.react.js',
{'players': frontend.get_all_players()},
{
'refresh': url_for('bishi_pages.listplayers'),
'player': url_for('bishi_pages.viewplayer', userid=-1),
},
)
def viewtopscores(musicid: int) -> Response:
# We just want to find the latest mix that this song exists in
frontend = JubeatFrontend(g.data, g.config, g.cache)
versions = sorted(
[version for (game, version, name) in frontend.all_games()],
reverse=True,
)
name = None
artist = None
genre = None
difficulties = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
found = [False, False, False, False, False, False]
for version in versions:
for omniadd in [10000, 0]:
for chart in [0, 1, 2, 3, 4, 5]:
details = g.data.local.music.get_song(GameConstants.JUBEAT,
version + omniadd,
musicid, chart)
if details is not None:
found[chart] = True
print(version + omniadd)
name = details.name
artist = details.artist
genre = details.genre
difficulties[chart] = details.data.get_float(
'difficulty', 13)
if False not in found:
break
if False not in found:
break
if name is None:
# Not a real song!
abort(404)
top_scores = frontend.get_top_scores(musicid)
return render_react(
f'Top Jubeat Scores for {artist} - {name}',
'jubeat/topscores.react.js',
{
'name': name,
'artist': artist,
'genre': genre,
'difficulties': difficulties,
'players': top_scores['players'],
'topscores': top_scores['topscores'],
},
{
'refresh': url_for('jubeat_pages.listtopscores', musicid=musicid),
'player': url_for('jubeat_pages.viewplayer', userid=-1),
},
)
def viewusers() -> Response:
return render_react(
'Users',
'admin/users.react.js',
{
'users': [format_user(user) for user in g.data.local.user.get_all_users()],
},
{
'searchusers': url_for('admin_pages.searchusers'),
'viewuser': url_for('admin_pages.viewuser', userid=-1),
},
)
def viewnews() -> Response:
return render_react(
'News',
'admin/news.react.js',
{
'news': [format_news(news) for news in g.data.local.network.get_all_news()],
},
{
'removenews': url_for('admin_pages.removenews'),
'addnews': url_for('admin_pages.addnews'),
'updatenews': url_for('admin_pages.updatenews'),
},
)
def viewtopscores(musicid: int) -> Response:
# We just want to find the latest mix that this song exists in
frontend = PopnMusicFrontend(g.data, g.config, g.cache)
versions = sorted(
[version for (game, version, name) in frontend.all_games()],
reverse=True,
)
name = None
artist = None
genre = None
difficulties = [0, 0, 0, 0]
for version in versions:
for omniadd in [0, 10000]:
for chart in [0, 1, 2, 3]:
details = g.data.local.music.get_song(GameConstants.POPN_MUSIC,
version + omniadd,
musicid, chart)
if details is not None:
if name is None:
name = details.name
if artist is None:
artist = details.artist
if genre is None:
genre = details.genre
if difficulties[chart] == 0:
difficulties[chart] = details.data.get_int(
'difficulty')
if name is None:
# Not a real song!
abort(404)
top_scores = frontend.get_top_scores(musicid)
return render_react(
f'Top Pop\'n Music Scores for {artist} - {name}',
'popn/topscores.react.js',
{
'name': name,
'artist': artist,
'genre': genre,
'difficulties': difficulties,
'players': top_scores['players'],
'topscores': top_scores['topscores'],
},
{
'refresh': url_for('popn_pages.listtopscores', musicid=musicid),
'player': url_for('popn_pages.viewplayer', userid=-1),
},
)
