flask-formula10/formula10.py

from typing import List

from flask import Flask, render_template, request, redirect
from flask_sqlalchemy import SQLAlchemy
from model import *
from database_utils import reload_static_data, reload_dynamic_data, export_dynamic_data

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///formula10.db"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db.init_app(app)


# TODO
# General
# - Move guessed place to leftmost column and display actual finishing position of driver instead
# - Show coming race in table, to give better feedback once a user has locked in a guess
# - Only allow guess entering in user-specific page
# - Remove whitespace from usernames

# - Sortable list to enter full race results (need 7 positions to calculate points) => remove from race page
# - Make the season card grid left-aligned? So e.g. 2 cards are not spread over the whole screen with large gaps?
# - Choose "place to guess" late before the race?
# - Timer until season picks lock + next race timer
# - A lot of validation (esp. in the model), each input should be checked...

# Statistics page
# - Auto calculate points
# - Generate static diagram using chart.js + templating the js (yikes)

# Rules page


@app.route("/")
def index():
    return redirect("/race")


@app.route("/saveall")
def savedynamic():
    export_dynamic_data()
    return redirect("/")


@app.route("/loadall")
def load():
    reload_static_data(db)
    reload_dynamic_data(db)
    return redirect("/")


@app.route("/loadstatic")
def reloadstatic():
    reload_static_data(db)
    return redirect("/")


@app.route("/loaddynamic")
def reloaddynamic():
    reload_dynamic_data(db)
    return redirect("/")


@app.route("/race")
def guessraceresult():
    return redirect("/race/Everyone")


@app.route("/race/<username>")
def guessuserraceresults(username):
    users: List[User] = User.query.all()
    activeuser: User | None = User.query.filter_by(name=username).first()  # "Everyone" should yield None
    raceresults: List[RaceResult] = RaceResult.query.all()[::-1]
    drivers: List[Driver] = Driver.query.all()

    # Select User
    # chosenusers = users
    # if username != "Everyone":
    #     chosenusers = [user for user in users if user.name == username]

    guesses = dict()
    for guess in RaceGuess.query.all():
        if guess.race_id not in guesses:
            guesses[guess.race_id] = dict()

        guesses[guess.race_id][guess.user_id] = guess

    # nextid = raceresults[0].race_id + 1 if len(raceresults) > 0 else 1
    # nextrace: Race = Race.query.filter_by(id=nextid).first()

    return render_template("race.jinja",
                           users=users,
                           drivers=drivers,
                           raceresults=raceresults,
                           guesses=guesses,
                           activeuser=activeuser)


@app.route("/guessrace/<raceid>/<username>", methods=["POST"])
def guessrace(raceid, username):
    pxx = request.form.get("pxxselect")
    dnf = request.form.get("dnfselect")

    if pxx is None or dnf is None:
        return redirect("/race")

    if RaceResult.query.filter_by(race_id=raceid).first() is not None:
        print("Error: Can't guess race result if the race result is already known!")
        return redirect("/race")

    raceguess: RaceGuess | None = RaceGuess.query.filter_by(user_id=username, race_id=raceid).first()

    if raceguess is None:
        raceguess = RaceGuess()
        raceguess.user_id = username
        raceguess.race_id = raceid
        db.session.add(raceguess)

    raceguess.pxx_id = pxx
    raceguess.dnf_id = dnf
    db.session.commit()

    return redirect("/race")


# @app.route("/enterresult/<raceid>", methods=["POST"])
# def enterresult(raceid):
#     pxx = request.form.get("pxxselect")
#     dnf = request.form.get("dnfselect")
#
#     if pxx is None or dnf is None:
#         return redirect("/race")
#
#     raceresult: RaceResult | None = RaceResult.query.filter_by(race_id=raceid).first()
#
#     if raceresult is not None:
#         print("RaceResult already exists!")
#         return redirect("/race")
#
#     raceresult = RaceResult()
#     raceresult.race_id = raceid
#     raceresult.pxx_id = pxx
#     raceresult.dnf_id = dnf
#     db.session.add(raceresult)
#     db.session.commit()
#
#     return redirect("/race")


@app.route("/season")
def guessseasonresults():
    return redirect("/season/Everyone")


@app.route("/season/<username>")
def guessuserseasonresults(username):
    users: List[User] = User.query.all()
    activeuser: User | None = User.query.filter_by(name=username).first()
    teams: List[Team] = Team.query.all()
    drivers: List[Driver] = Driver.query.all()

    # Remove NONE driver
    drivers = [driver for driver in drivers if driver.name != "NONE"]

    guesses = dict()
    guess: SeasonGuess
    for guess in SeasonGuess.query.all():
        guesses[guess.user_id] = guess

    driverpairs = dict()
    team: Team
    for team in teams:
        driverpairs[team.name] = []
    driver: Driver
    for driver in drivers:
        driverpairs[driver.team.name] += [driver]

    return render_template("season.jinja",
                           users=users,
                           teams=teams,
                           drivers=drivers,
                           driverpairs=driverpairs,
                           guesses=guesses,
                           activeuser=activeuser)


@app.route("/guessseason/<username>", methods=["POST"])
def guessseason(username):
    guesses = [
        request.form.get("hottakeselect"),
        request.form.get("p2select"),
        request.form.get("overtakeselect"),
        request.form.get("dnfselect"),
        request.form.get("gainedselect"),
        request.form.get("lostselect")
    ]
    teamwinnerguesses = [
        request.form.get(f"teamwinner-{team.name}") for team in Team.query.all()
    ]
    podiumdriverguesses = request.form.getlist("podiumdrivers")

    if any(guess is None for guess in guesses + teamwinnerguesses):
        print("Error: /guessseason could not obtain request data!")
        return redirect("/season")

    seasonguess: SeasonGuess | None = SeasonGuess.query.filter_by(user_id=username).first()
    teamwinners: TeamWinners | None = seasonguess.team_winners if seasonguess is not None else None
    podiumdrivers: PodiumDrivers | None = seasonguess.podium_drivers if seasonguess is not None else None

    if teamwinners is None:
        teamwinners = TeamWinners()
        db.session.add(teamwinners)

    teamwinners.winner_ids = teamwinnerguesses
    teamwinners.user_id = username
    db.session.commit()

    if podiumdrivers is None:
        podiumdrivers = PodiumDrivers()
        db.session.add(podiumdrivers)

    podiumdrivers.podium_ids = podiumdriverguesses
    podiumdrivers.user_id = username
    db.session.commit()

    # Refresh teamwinners + podiumdrivers to obtain IDs
    teamwinners = TeamWinners.query.filter_by(user_id=username).first()
    podiumdrivers = PodiumDrivers.query.filter_by(user_id=username).first()

    if seasonguess is None:
        seasonguess = SeasonGuess()
        seasonguess.user_id = username
        db.session.add(seasonguess)

    seasonguess.hot_take = guesses[0]
    seasonguess.p2_constructor_id = guesses[1]
    seasonguess.most_overtakes_id = guesses[2]
    seasonguess.most_dnfs_id = guesses[3]
    seasonguess.most_gained_id = guesses[4]
    seasonguess.most_lost_id = guesses[5]
    seasonguess.team_winners_id = teamwinners.id
    seasonguess.podium_drivers_id = podiumdrivers.id
    db.session.commit()

    return redirect("/season")


@app.route("/enter")
def enterraceresult():
    return render_template("enter.jinja")


@app.route("/users")
def manageusers():
    users = User.query.all()

    return render_template("users.jinja",
                           users=users)


@app.route("/adduser", methods=["POST"])
def adduser():
    username = request.form.get("select-add-user").strip()

    if len(User.query.filter_by(name=username).all()) > 0:
        print(f"Not adding user {username}: Already exists!")
        return redirect("/users")

    user = User()
    user.name = username
    db.session.add(user)
    db.session.commit()

    return redirect("/users")


@app.route("/deleteuser", methods=["POST"])
def deleteuser():
    username = request.form.get("select-delete-user")

    if username == "Select User":
        return redirect("/users")

    print(f"Deleting user {username}...")

    User.query.filter_by(name=username).delete()
    db.session.commit()

    return redirect("/users")


if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0")