def adjust_elo(winning_deck_id: int, losing_deck_id: int) -> None:
if not losing_deck_id:
return # Intentional draws do not affect Elo.
winner = guarantee.exactly_one(person.load_people('p.id IN (SELECT person_id FROM deck WHERE id = {winning_deck_id})'.format(winning_deck_id=sqlescape(winning_deck_id))))
loser = guarantee.exactly_one(person.load_people('p.id IN (SELECT person_id FROM deck WHERE id = {losing_deck_id})'.format(losing_deck_id=sqlescape(losing_deck_id))))
adj = adjustment(winner.elo or STARTING_ELO, loser.elo or STARTING_ELO)
sql = 'UPDATE person SET elo = IFNULL(elo, {starting_elo}) + %s WHERE id = %s'.format(starting_elo=sqlescape(STARTING_ELO))
db().execute(sql, [adj, winner.id])
db().execute(sql, [-adj, loser.id])
def run() -> None:
sql = """
SELECT
GROUP_CONCAT(d.person_id) AS people,
GROUP_CONCAT(dm.games) AS games
FROM
`match` AS m
INNER JOIN
deck_match AS dm ON dm.match_id = m.id
INNER JOIN
deck AS d ON dm.deck_id = d.id
GROUP BY
m.id
ORDER BY
m.date,
`round`
"""
matches = db().select(sql)
for m in matches:
match(m)
current = person.load_people()
people_by_id = {p.id: p for p in current}
sql = 'UPDATE person SET elo = %s WHERE id = %s'
for person_id, new_elo in sorted(PEOPLE.items(), key=lambda x: -x[1]):
p = people_by_id[int(person_id)]
if p.elo != new_elo:
logger.warning('{id} currently has Elo of {current_elo} and we are setting it to {new_elo}'.format(id=p.id, current_elo=p.elo, new_elo=new_elo))
db().execute(sql, [new_elo, p.id])
def people() -> List[Dict[str, str]]:
urls = []
for p in person.load_people():
urls.append({
'name': p.name,
'type': 'Person',
'url': url_for('person', mtgo_username=p.name)
})
return urls
def matchups() -> str:
hero, enemy = {}, {}
for k, v in request.args.items():
if k.startswith('hero_'):
k = k.replace('hero_', '')
hero[k] = v
else:
k = k.replace('enemy_', '')
enemy[k] = v
season_id = request.args.get('season_id')
results = mus.matchup(hero, enemy,
season_id=season_id) if request.args else {}
matchup_archetypes = archs.load_archetypes_deckless()
matchup_archetypes.sort(key=lambda a: a.name)
matchup_people = list(ps.load_people(where='p.mtgo_username IS NOT NULL'))
matchup_people.sort(key=lambda p: p.name)
matchup_cards = cs.load_cards()
matchup_cards.sort(key=lambda c: c.name)
view = Matchups(hero, enemy, season_id, matchup_archetypes, matchup_people,
matchup_cards, results)
return view.page()
def people_api() -> Response:
"""
Grab a slice of results from a 0-indexed resultset of people.
Input:
{
'page': <int>,
'pageSize': <int>,
'sortBy': <str>,
'sortOrder': <'ASC'|'DESC'>,
'seasonId': <int|'all'>,
'q': <str>
}
Output:
{
'page': <int>,
'objects': [<person>],
'total': <int>
}
"""
order_by = query.people_order_by(request.args.get('sortBy'),
request.args.get('sortOrder'))
page_size = int(request.args.get('pageSize', DEFAULT_LIVE_TABLE_PAGE_SIZE))
page = int(request.args.get('page', 0))
start = page * page_size
limit = f'LIMIT {start}, {page_size}'
season_id = seasons.season_id(str(request.args.get('seasonId')), None)
q = request.args.get('q', '').strip()
where = query.text_match_where(query.person_query(), q) if q else 'TRUE'
people = ps.load_people(where=where,
order_by=order_by,
limit=limit,
season_id=season_id)
prepare_people(people)
total = ps.load_people_count(where=where, season_id=season_id)
r = {'page': page, 'total': total, 'objects': people}
resp = return_json(r, camelize=True)
resp.set_cookie('page_size', str(page_size))
return resp
def edit_aliases() -> str:
aliases = ps.load_aliases()
all_people = ps.load_people(order_by_name=True)
view = EditAliases(aliases, all_people)
return view.page()
def unlink(num_affected_people: Optional[int] = None,
errors: List[str] = None) -> str:
all_people = ps.load_people(order_by_name=True)
view = Unlink(all_people, num_affected_people, errors)
return view.page()
def player_notes() -> str:
notes = ps.load_notes()
all_people = ps.load_people(order_by_name=True)
view = PlayerNotes(notes, all_people)
return view.page()
def people() -> str:
view = People(ps.load_people(season_id=get_season_id()))
return view.page()
def player_notes():
notes = ps.load_notes()
all_people = ps.load_people(order_by='p.mtgo_username')
view = PlayerNotes(notes, all_people)
return view.page()
def people():
view = People(ps.load_people())
return view.page()
def unlink(num_affected_people=None):
all_people = ps.load_people(order_by='p.mtgo_username')
view = Unlink(all_people, num_affected_people)
return view.page()
def edit_aliases() -> str:
aliases = ps.load_aliases()
all_people = ps.load_people(order_by='p.mtgo_username')
view = EditAliases(aliases, all_people)
return view.page()
