def tournaments_join(tournament_id):
tournament = Tournament.query.get(tournament_id)
user = User.query.get(current_user.id)
tournament.players.append(user)
if len(tournament.players) == tournament.playerCount:
value = 0
while value != tournament.playerCount:
playersInRound = []
game = Game(tournament.name)
game.playerCount = 4
game.done = False
game.account_id = current_user.id
playerCountValue = 0
while playerCountValue != 4:
randomPlayer = random.choice(tournament.players)
if randomPlayer not in playersInRound and randomPlayer not in game.players:
game.players.append(randomPlayer)
playersInRound.append(randomPlayer)
playerCountValue += 1
tournament.games.append(game)
db.session().add(game)
value += 1
db.session().add(tournament)
db.session().commit()
return redirect(url_for("tournaments_index"))
def index():
unreviewed_games = []
if current_user.is_authenticated:
unreviewed_games = Game.find_all_unreviewed_games(current_user.id)
top_games = Game.find_top_five_games()
general_details = Game.find_general_details()
return render_template("index.html", unreviewed_games = unreviewed_games, general_details = general_details, top_games = top_games)
def games_create():
form = GameForm(request.form)
if not form.validate():
return render_template('games/new.html', form=form)
new_game = Game(form.name.data)
new_game.bgg = form.bgg.data
db.session().add(new_game)
db.session().commit()
return redirect(url_for('games_index'))
def games_create():
game_form = GameForm(request.form)
genre_form = GenreSelectionForm(request.form)
if not (game_form.validate() and genre_form.validate()):
return render_template("/games/new.html",
game_form=game_form,
genre_form=genre_form)
game = Game(game_form.name.data, game_form.developer.data,
game_form.description.data, game_form.year.data)
db.session.add(game)
db.session.commit()
game.add_genres(genre_form.genre_ids.data)
return redirect(url_for("games_index"))
def games_index(page_number=1, sort_column=0, sort_direction="ASC"):
columns = [
"Game.id", "Game.name", "Game.developer", "Game.year",
"COUNT(Review.points)", "AVG(Review.points)"
]
possible_sort_column = request.args.get("sort_column")
possible_sort_direction = request.args.get("sort_direction")
if possible_sort_column:
sort_column = possible_sort_column
if possible_sort_direction:
sort_direction = possible_sort_direction
sort_column = parse_to_int(sort_column)
page_number = parse_to_int(page_number)
if page_number is None or sort_column is None or sort_direction not in [
"ASC", "DESC"
]:
return render_template("error.html",
error="Yrität antaa vääränlaisia parametreja")
games_info = Game.find_all_info(page_number=page_number,
order_column=columns[sort_column],
order_direction=sort_direction)
base_url = "/games/page"
return render_template("games/list.html",
games_info=games_info,
title="Kaikki pelit",
page_number=page_number,
last_page=len(games_info) < GAME_RESULTS_PER_PAGE,
base_url=base_url,
sort_column=sort_column,
sort_direction=sort_direction)
def games_create():
error = None
form = GameForm()
if form.validate_on_submit():
try:
g = Game(date=form.date.data,
opponent=form.opponent.data,
our_goals=form.our_goals.data,
opponent_goals=form.opponent_goals.data)
g.team_id = current_user.team_id
db.session.add(g)
db.session.commit()
flash("game added")
except Exception as e:
error = e
# siirrytään pelin tilastojen syöttämiseen
return redirect(url_for("stats_add", game_id=g.id))
return render_template("/games/new.html", form=form, error=error)
def games_createOrUpdate():
if ('create' in request.form):
form = GameForm(request.form)
if not form.validate():
return render_template("games/new.html", form=form)
name = form.name.data
tag = form.tag.data
year, month, day = map(int, form.publication.data.split('-'))
publication = datetime.date(year, month, day)
game = Game(name, tag, publication)
db.session().add(game)
db.session().commit()
elif ('edit' in request.form):
form = GameEditForm(request.form)
if not form.validate():
return render_template("games/edit.html", form=form)
oldName = form.oldName.data
game = Game.query.filter_by(name=oldName).first()
year, month, day = map(int, form.publication.data.split('-'))
publication = datetime.date(year, month, day)
game.name = form.name.data
game.tag = form.tag.data
game.flag = False
game.publication = publication
db.session().commit()
return redirect(url_for("games_index"))
def tag_games(tag_id, page_number=1, sort_column=0, sort_direction="ASC"):
tag = Tag.query.filter(Tag.id == tag_id).first()
if not tag:
return render_template("error.html", error="Tagia ei ole olemassa")
columns = [
"Game.id", "Game.name", "Game.developer", "Game.year",
"COUNT(Review.points)", "AVG(Review.points)"
]
possible_sort_column = request.args.get("sort_column")
possible_sort_direction = request.args.get("sort_direction")
if possible_sort_column:
sort_column = possible_sort_column
if possible_sort_direction:
sort_direction = possible_sort_direction
sort_column = parse_to_int(sort_column)
page_number = parse_to_int(page_number)
if not (page_number is not None and sort_column is not None
and sort_direction in ["ASC", "DESC"]):
return render_template("error.html",
error="Yrität antaa vääränlaisia parametreja")
games_info = Game.find_all_info({"tags": [int(tag_id)]},
page_number=page_number,
order_column=columns[sort_column],
order_direction=sort_direction)
base_url = "/tags/" + tag_id + "/games/page"
return render_template("games/list.html",
games_info=games_info,
base_url=base_url,
page_number=page_number,
last_page=len(games_info) < GAME_RESULTS_PER_PAGE,
title="Tag: " + tag.name,
sort_column=sort_column,
sort_direction=sort_direction)
def genres_view(genre_id, page_number=1, sort_column=0, sort_direction="ASC"):
genre = Genre.query.filter_by(id=genre_id).first()
if genre is None:
return render_template("error.html", error="Genreä ei ole olemassa")
columns = [
"Game.id", "Game.name", "Game.developer", "Game.year",
"COUNT(Review.points)", "AVG(Review.points)"
]
possible_sort_column = request.args.get("sort_column")
possible_sort_direction = request.args.get("sort_direction")
if possible_sort_column:
sort_column = possible_sort_column
if possible_sort_direction:
sort_direction = possible_sort_direction
sort_column = parse_to_int(sort_column)
page_number = parse_to_int(page_number)
if page_number is None or sort_column is None or sort_direction not in [
"ASC", "DESC"
]:
return render_template("error.html",
error="Yrität antaa vääränlaisia parametreja")
games_info = Game.find_all_info({"genres": [genre.id]},
page_number=page_number,
order_column=columns[sort_column],
order_direction=sort_direction)
base_url = "/genres/" + str(genre_id) + "/page"
return render_template("games/list.html",
games_info=games_info,
title=("Genre: " + genre.name),
page_number=page_number,
last_page=len(games_info) < GAME_RESULTS_PER_PAGE,
base_url=base_url,
sort_column=sort_column,
sort_direction=sort_direction)
def search(page_number=1):
if request.method == "GET":
form = SearchForm()
if current_user.is_authenticated:
form.set_tags_info(current_user)
return render_template("search/search.html", form=form)
form = SearchForm(request.form)
# uuden formin luomisen jälkeen tagivaihtoehdot on uudelleenasetettava, tai saadaan virhe kun tämä lomake yritetään näyttää sivulla
if current_user.is_authenticated:
form.set_tags_info(current_user)
else:
form.tags.choices = []
if not form.validate():
tag_values = form.tags.data
if current_user.is_authenticated:
form.set_tags_info(current_user)
form.tags.data = tag_values
return render_template("search/search.html", form=form)
search_parameters = {}
if form.name.data != "":
search_parameters["name"] = form.name.data
if form.min_year.data is not None:
search_parameters["min_year"] = form.min_year.data
if form.max_year.data is not None:
search_parameters["max_year"] = form.max_year.data
if form.developer.data != "":
search_parameters["developer"] = form.developer.data
if form.genres.data:
search_parameters["genres"] = tuple(form.genres.data)
if form.tags.data:
search_parameters["tags"] = tuple(form.tags.data)
if form.min_average.data is not None:
search_parameters[
"min_average"] = form.min_average.data if os.environ.get(
"HEROKU") else float(form.min_average.data)
if form.max_average.data is not None:
search_parameters[
"max_average"] = form.max_average.data if os.environ.get(
"HEROKU") else float(form.max_average.data)
if form.min_count.data is not None:
search_parameters["min_count"] = form.min_count.data
if form.max_count.data is not None:
search_parameters["max_count"] = form.max_count.data
games_info = Game.find_all_info(search_parameters,
page_number=int(page_number))
return render_template("search/search.html",
form=form,
games_info=games_info,
page_number=int(page_number),
scroll="result_table",
last_page=len(games_info) < GAME_RESULTS_PER_PAGE)
def index():
game = Game.find_highest_rated()
return render_template('index.html', game=game)