def cards(deck_type: Optional[str] = None) -> str:
tournament_only = validate_deck_type(
deck_type, [DeckType.ALL, DeckType.TOURNAMENT]) == DeckType.TOURNAMENT
query = request.args.get('fq')
if query is None:
query = ''
all_cards = cs.load_cards(season_id=get_season_id(),
tournament_only=tournament_only)
view = Cards(all_cards, query=query, tournament_only=tournament_only)
return view.page()
def person(mtgo_username: Optional[str] = None,
person_id: Optional[int] = None) -> str:
p = load_person(mtgo_username, person_id, season_id=get_season_id())
person_cards = cs.load_cards(person_id=p.id, season_id=get_season_id())
person_archetypes = archs.load_archetypes_deckless(
person_id=p.id, season_id=get_season_id())
all_archetypes = archs.load_archetypes_deckless(season_id=get_season_id())
trailblazer_cards = cs.trailblazer_cards(p.id)
unique_cards = cs.unique_cards_played(p.id)
your_cards = {'unique': unique_cards, 'trailblazer': trailblazer_cards}
seasons_active = ps.seasons_active(p.id)
view = Person(p, person_cards, person_archetypes, all_archetypes,
your_cards, seasons_active, get_season_id())
return view.page()
def person(person_id: str) -> str:
p = ps.load_person_by_id_or_mtgo_username(person_id,
season_id=get_season_id())
person_cards = cs.load_cards(person_id=p.id, season_id=get_season_id())
person_archetypes = archs.load_archetypes_deckless(
person_id=p.id, season_id=get_season_id())
all_archetypes = archs.load_archetypes_deckless(season_id=get_season_id())
trailblazer_cards = cs.trailblazer_cards(p.id)
unique_cards = cs.unique_cards_played(p.id)
your_cards = {'unique': unique_cards, 'trailblazer': trailblazer_cards}
person_matchups = archs.load_matchups(person_id=p.id,
season_id=get_season_id())
view = Person(p, person_cards, person_archetypes, all_archetypes,
person_matchups, your_cards, get_season_id())
return view.page()
def cards2_api() -> Response:
"""
Grab a slice of results from a 0-indexed resultset of cards.
Input:
{
'deckType': <'league'|'tournament'|'all'>,
'page': <int>,
'pageSize': <int>,
'personId': <int?>,
'sortBy': <str>,
'sortOrder': <'ASC'|'DESC'>,
'seasonId': <int|'all'>,
'q': <str>
}
Output:
{
'page': <int>,
'objects': [<card>],
'total': <int>
}
"""
order_by = query.cards_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}'
person_id = request.args.get('personId') or None
tournament_only = request.args.get('deckType') == 'tournament'
season_id = seasons.season_id(str(request.args.get('seasonId')), None)
q = request.args.get('q', '').strip()
additional_where = query.card_search_where(q) if q else 'TRUE'
cs = card.load_cards(additional_where=additional_where,
order_by=order_by,
limit=limit,
person_id=person_id,
tournament_only=tournament_only,
season_id=season_id)
prepare_cards(cs, tournament_only=tournament_only)
total = card.load_cards_count(additional_where=additional_where,
person_id=person_id,
season_id=season_id)
r = {'page': page, 'total': total, 'objects': cs}
resp = return_json(r, camelize=True)
resp.set_cookie('page_size', str(page_size))
return resp
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 person(person_id: str) -> str:
p = ps.load_person_by_id_or_mtgo_username(person_id,
season_id=get_season_id())
person_cards = cs.load_cards(person_id=p.id, season_id=get_season_id())
view = Person(p, person_cards, get_season_id())
return view.page()
def home() -> str:
view = Home(ns.all_news(max_items=10), ds.latest_decks(),
cs.load_cards(season_id=get_season_id()), ms.stats())
return view.page()
def cards_tournament() -> str:
view = Cards(cs.load_cards(season_id=get_season_id()),
tournament_only=True)
return view.page()
def cards() -> str:
view = Cards(cs.load_cards(season_id=get_season_id()))
return view.page()
def person(person_id):
p = ps.load_person(person_id, season_id=get_season_id())
person_cards = cs.load_cards(person_id=p.id, season_id=get_season_id())
only_played_cards = []
view = Person(p, person_cards, only_played_cards)
return view.page()
def cards_api() -> Response:
blob = {'cards': cs.load_cards()}
return return_json(blob)
def test_load_cards_season() -> None:
perf.test(lambda: card.load_cards(season_id=1), 0.5)
def cards_api():
return return_json(cs.load_cards())
