def userSongs(): token = request.headers.get('Authorization') req = requests.get('https://dev-c-4o8wnx.auth0.com/userinfo', headers={'Authorization': token}).content userInfo = json.loads(req) userId = User.query.filter_by(email=userInfo['email']).first().id userInfo = User.query.options(db.joinedload( 'songs'), db.joinedload('favorites')).get(userId) return userInfo.to_dict(), 200
def get_sets(): # gets decodes userinfo out of token using auth0 api token = request.headers.get('Authorization') req = requests.get('https://codelet-app.auth0.com/userinfo', headers={ 'Authorization': token }).content userInfo = json.loads(req) userId = User.query.filter_by(email=userInfo['email']).first().id userInfo = User.query.options( db.joinedload('sets').joinedload('votes'), db.joinedload('favorites')).get(userId) return userInfo.to_dict(), 200
def view_turn(game_id, round_id, turn_id): game = Game.query.get(game_id) game_round = Round.query.get(round_id) turn = Turn.query.options(db.joinedload(Turn.player)).get(turn_id) if turn.completed_at: return redirect( url_for('salad_bowl.view_round', game_id=game_id, round_id=round_id)) seconds_remaining = int( (turn.expected_complete_at - datetime.utcnow()).total_seconds()) word = None if turn.player_id == g.current_player.id: if request.args.get('currentWord'): word = SaladBowlWord.query.get(int(request.args['currentWord'])) else: unguessed_words_q = SaladBowlWord.query unguessed_words_q = unguessed_words_q.join( GuessedWord, db.and_(GuessedWord.round_id == round_id, GuessedWord.word_id == SaladBowlWord.id), isouter=True) unguessed_words_q = unguessed_words_q.filter( SaladBowlWord.game_id == game_id) unguessed_words_q = unguessed_words_q.filter( GuessedWord.round_id.is_(None)) word = random.choice(unguessed_words_q.all()) from app.actions.salad_bowl.turn import EndTurnForm, WordGuessedForm return render_template( 'salad_bowl/view_turn.html', game=game, game_round=game_round, turn=turn, seconds_remaining=seconds_remaining, word=word, end_turn_form=EndTurnForm() if word else None, word_guessed_form=WordGuessedForm(word_id=word.id) if word else None)
def start_game(game_id): form = StartGameForm() if form.validate_on_submit( ): # make sure game is open, stuff like that, user is logged in, user isnt already in game game = Game.query.options(db.joinedload(Game.teams)).get(game_id) game.started_at = datetime.utcnow() turn_order = list(range(len(game.teams))) shuffle(turn_order) for i, team in enumerate(game.teams): team.turn_order = turn_order[i] db.session.commit() return True, redirect(url_for('.view_game', game_id=game_id)) return False, render_template('salad_bowl/actions/start_game.html', form=form, action_url=url_for('salad_bowl.start_game', game_id=game_id))
def home(): sort = request.args.get('sort', 'total') total_value_calc = db.func.coalesce( db.func.sum(BankerCurrency.amount * Currency.value), 0) sorted_standings_q = db.session.query( Banker, total_value_calc.label('total_value')).outerjoin( BankerCurrency, BankerCurrency.banker_id == Banker.id).outerjoin( Currency, Currency.id == BankerCurrency.currency_id).options( db.joinedload(Banker.currencies)).group_by(Banker.id) if sort == 'total': sorted_standings_q = sorted_standings_q.order_by( db.desc(total_value_calc), Banker.id) else: sort_by_currency_id = int(sort) sorting_subq = db.session.query( Banker.id.label('banker_id'), db.func.coalesce(BankerCurrency.amount, 0).label('sorted_column_amount')).outerjoin( BankerCurrency, db.and_( BankerCurrency.banker_id == Banker.id, BankerCurrency.currency_id == sort_by_currency_id)).subquery() sorted_standings_q = sorted_standings_q.join( sorting_subq, sorting_subq.c.banker_id == Banker.id).order_by( db.desc(db.func.max(sorting_subq.c.sorted_column_amount)), Banker.id) sorted_standings = sorted_standings_q.limit(20).all() return render_template('ct_conomy/home.html', sorted_standings=sorted_standings)
def word_guessed(game_id, round_id, turn_id): form = WordGuessedForm() if form.validate_on_submit(): current_players_team_id_q = db.session.query(PlayerTeam.team_id) current_players_team_id_q = current_players_team_id_q.join(Team) current_players_team_id = current_players_team_id_q.filter(Team.game_id == game_id, PlayerTeam.player_id == g.current_player.id).scalar() guessed_word = GuessedWord( word_id=form.word_id.data, round_id=round_id, team_id=current_players_team_id, player_id=g.current_player.id) db.session.add(guessed_word) db.session.flush() unguessed_words_q = SaladBowlWord.query unguessed_words_q = unguessed_words_q.join(GuessedWord, db.and_( GuessedWord.round_id == round_id, GuessedWord.word_id == SaladBowlWord.id), isouter=True) unguessed_words_q = unguessed_words_q.filter(SaladBowlWord.game_id == game_id) unguessed_words_q = unguessed_words_q.filter(GuessedWord.round_id.is_(None)) if unguessed_words_q.count() == 0: turn = Turn.query.get(turn_id) turn.completed_at = datetime.utcnow() game_round = Round.query.get(round_id) game_round.completed_at = datetime.utcnow() db.session.flush() game = Game.query.options(db.joinedload(Game.rounds)).get(game_id) if all(round.completed_at for round in game.rounds): game.completed_at = datetime.utcnow() db.session.commit() return False, redirect(url_for('salad_bowl.view_turn', game_id=game_id, round_id=round_id, turn_id=turn_id))
def view_game(game_id): if not g.current_player: # BUild this into a decorator abort(404) player_game = PlayerGame.query.filter( PlayerGame.player_id == g.current_player.id, PlayerGame.game_id == game_id).one_or_none() if not player_game: abort(404) game_q = Game.query game_q = game_q.options(db.joinedload(Game.teams).joinedload(Team.players)) game_q = game_q.options(db.joinedload(Game.rounds)) game = game_q.get(game_id) game_rounds = sorted(game.rounds, key=lambda x: x.round_number) for game_round in game_rounds: if game_round.started_at and not game_round.completed_at: return redirect( url_for('salad_bowl.view_round', game_id=game_id, round_id=game_round.id)) next_round = None for game_round in game_rounds: if not game_round.started_at: next_round = game_round break player_id_to_team = None submitted_words_by_player_id = None team_id_to_round_number_to_word_count = None num_completed_rounds = 0 if next_round and next_round.round_number == 1: words = SaladBowlWord.query.filter( SaladBowlWord.game_id == game_id).all() submitted_words_by_player_id = {} for word in words: submitted_words_by_player_id[word.writer_id] = True if game.started_at: if not submitted_words_by_player_id.get(g.current_player.id): return redirect( url_for('salad_bowl.add_words', game_id=game_id)) player_id_to_team = {} for team in game.teams: for player in team.players: player_id_to_team[player.id] = team else: word_count_q = db.session.query(GuessedWord.team_id, Round.round_number, db.func.count(GuessedWord.round_id)) word_count_q = word_count_q.join(Round) word_count_q = word_count_q.join(SaladBowlWord) word_count_q = word_count_q.group_by(Round.round_number, GuessedWord.team_id) word_count_q = word_count_q.filter(SaladBowlWord.game_id == game_id) team_id_to_round_number_to_word_count = defaultdict( lambda: defaultdict(int)) for team_id, round_number, word_count in word_count_q.all(): num_completed_rounds = max(num_completed_rounds, round_number) team_id_to_round_number_to_word_count[team_id][ round_number] = word_count can_start_next_round = False if next_round: if next_round.round_number == 1: if all( submitted_words_by_player_id.get(player.id) for player in game.players): can_start_next_round = True else: can_start_next_round = True can_start_next_round = can_start_next_round and game.owner_player_id == g.current_player.id return render_template( 'salad_bowl/view_game.html', game=game, teams=game.teams, player_id_to_team=player_id_to_team, submitted_words_by_player_id=submitted_words_by_player_id, team_id_to_round_number_to_word_count= team_id_to_round_number_to_word_count, num_completed_rounds=num_completed_rounds, next_round=next_round, can_start_next_round=can_start_next_round)
def view_round(game_id, round_id): game = Game.query.options(db.joinedload(Game.teams)).get(game_id) game_round = Round.query.options(db.joinedload(Round.turns)).get(round_id) if game_round.completed_at: return redirect(url_for('salad_bowl.view_game', game_id=game_id)) for turn in game_round.turns: if turn.started_at and not turn.completed_at: return redirect( url_for('salad_bowl.view_turn', game_id=game_id, round_id=round_id, turn_id=turn.id)) turn_length = game_round.seconds_per_turn seconds_remaining = turn_length if not game_round.turns: # we are starting a new round if game_round.round_number == 1: # start of game, pick first team next_team = next( (team for team in game.teams if team.turn_order == 0)) else: # see who was going at the end of the previous round previous_turn_q = Turn.query previous_turn_q = previous_turn_q.join(Round) previous_turn_q = previous_turn_q.filter( Round.game_id == game_id, Round.round_number == game_round.round_number - 1) previous_turn_q = previous_turn_q.order_by(db.desc( Turn.started_at)) previous_turn = previous_turn_q.first() next_team = next((team for team in game.teams if team.id == previous_turn.team_id)) seconds_remaining = turn_length - int( (previous_turn.expected_complete_at - previous_turn.completed_at).total_seconds()) else: # weve already had teams go this round previous_turn = None turn_order_index = None for turn in sorted(game_round.turns, key=lambda x: x.started_at): previous_turn = turn for team in game.teams: if team.id == previous_turn.team_id: turn_order_index = (team.turn_order + 1) % len(game.teams) next_team = next((team for team in game.teams if team.turn_order == turn_order_index)) current_players_team_id_q = db.session.query(PlayerTeam.team_id) current_players_team_id_q = current_players_team_id_q.join(Team) current_players_team_id = current_players_team_id_q.filter( Team.game_id == game_id, PlayerTeam.player_id == g.current_player.id).scalar() can_start_next_turn = next_team.id == current_players_team_id unguessed_words_q = SaladBowlWord.query unguessed_words_q = unguessed_words_q.join( GuessedWord, db.and_(GuessedWord.round_id == round_id, GuessedWord.word_id == SaladBowlWord.id), isouter=True) unguessed_words_q = unguessed_words_q.filter( SaladBowlWord.game_id == game_id) unguessed_words_q = unguessed_words_q.filter( GuessedWord.round_id.is_(None)) unguessed_word_count = unguessed_words_q.count() return render_template('salad_bowl/view_round.html', game=game, game_round=game_round, next_team=next_team, seconds_remaining=seconds_remaining, unguessed_word_count=unguessed_word_count, can_start_next_turn=can_start_next_turn)
def category_sets(category_id): category_info = Category.query.options( db.joinedload('sets')).get(category_id) return category_info.to_dict_sets(), 200
def get_and_normalize_all_data_for_user(current_user): """ Get all a user's data to set-up their frontend store, including chronicles, tales, threads, choices, characters, etc., then normalize into dictionaries. """ # Query all a user's chronicles user = User.query.options( db.joinedload(User.pcs), db.joinedload(User.assets), db.joinedload(User.meters), db.joinedload(User.statuses), db.joinedload(User.entities), \ # .joinedload(Entity.assets), \ # db.joinedload(User.entities) \ # .joinedload(Entity.meters), \ # db.joinedload(User.entities) \ # .joinedload(Entity.statuses), \ # db.joinedload(User.entities) \ # .joinedload(Entity.slots), \ db.joinedload(User.chronicles) \ .joinedload(Chronicle.tales) \ .joinedload(Tale.threads) \ .joinedload(Thread.asset_effects), \ db.joinedload(User.chronicles) \ .joinedload(Chronicle.tales) \ .joinedload(Tale.threads) \ .joinedload(Thread.choices) \ .joinedload(Choice.asset_locks) \ ).get(current_user.id) # Normalize data before returning pcs = {pc.id: pc.to_dict() for pc in user.pcs} assets = {a.id: a.to_dict() for a in user.assets} statuses = {s.id: s.to_dict() for s in user.statuses} meters = {m.id: m.to_dict() for m in user.meters} entities = {e.id: e.to_dict() for e in user.entities} chronicles = {c.id: c.to_dict() for c in user.chronicles} tales = {} threads = {} choices = {} for chronicle in user.chronicles: for tale in chronicle.tales: tales[tale.id] = tale.to_dict() for thread in tale.threads: threads[thread.id] = thread.to_dict() for choice in thread.choices: choices[choice.id] = choice.to_dict() user = normalize_user_data( user=current_user, pcs=pcs, chronicles=chronicles, tales=tales, threads=threads, choices=choices, entities=entities, assets=assets, statuses=statuses, meters=meters, ) print("\n\nUSER, CHRONICLES, TALES, THREADS, CHOICES") # pprint(user) # pprint(chronicles) # pprint(tales) # pprint(threads) # pprint(choices) return user, pcs, chronicles, tales, threads, choices, entities, assets, statuses, meters