main.py

"""
Fichier main du site VideoFlex
Amouroux Paul
Jaunet Mathieu
"""
from datetime import datetime

from passlib.context import CryptContext

from validate_email_address import validate_email

from flask import (
    Flask,
    render_template,
    redirect,
    url_for,
    request,
    session
)

import db

from utils.py_utilities import (
    get_fin_abo,
    verif_cli_pro,
    error_list
)

app = Flask(__name__)
app.secret_key = "VideoFlex_is_better_than_Netflix"

@app.route("/")
def retour():
    """
    Fonction de la page `/`
    """
    return redirect(url_for("lobby"))



@app.route("/register", methods=["GET", "POST"])
def register():
    """
    Fonction de la page `/register`
    Appelle une première en methode `GET`,
    puis boucle en methode `POST`
    """
    # Configuration de la bibliotheque
    password_ctx = CryptContext(schemes=['bcrypt'])

    # Appelle de la page en methode `POST`
    if request.method == "POST":
        user_info = {
            "name": request.form["user_name"],
            "first_name": request.form["user_first_name"],
            "lieu": request.form["user_lieu"],
            "mail": request.form["user_mail"],
            "pass": request.form["user_pass"],
            "pass_verif": request.form["user_pass_verif"],
            "type_abon": request.form["type_abon"],
            "dure_abon": request.form["dure_abon"]
        }
        code_error = 0

        # Verification de la validite du nom  du prenom
        if user_info["name"] == "" or user_info["first_name"] == "":
            code_error = 1

        # Verification de la validite de l'adresse
        elif user_info["lieu"] == "":
            code_error = 2

        # Verification de la validite de l'adresse e-mail
        elif not validate_email(user_info["mail"]):
            code_error = 3

        # Verification du mot de passe correctement tappe
        elif user_info["pass"] != user_info["pass_verif"]:
            code_error = 4

        # Verification de la longueur du mot de passe (>= 6)
        elif len(user_info["pass"]) < 6:
            code_error = 5

        else:
            # Verification de l'adresse e-mail non utilise
            with db.connect() as conn:
                with conn.cursor() as cur:
                    cur.execute(
                        "SELECT idcli FROM clients WHERE courriel= %s",
                        (user_info["mail"], )
                    )
                    result_mail = cur.fetchone()
                    if result_mail is not None:
                        code_error = 6
                    else:
                        cur.execute(
                            "INSERT INTO clients VALUES (DEFAULT, %s, %s, %s, %s, %s, %s, %s)",
                            (user_info["mail"],
                             user_info["name"],
                             user_info["first_name"],
                             user_info["lieu"],
                             password_ctx.hash(user_info["pass"]),
                             get_fin_abo(user_info["dure_abon"]),
                             user_info["type_abon"])
                        )

        if code_error != 0:
            print(code_error)
            return render_template("register.html", error_list=error_list, error=code_error)
        return render_template("register_validate.html")

    return render_template("register.html", error=0)



@app.route("/connect", methods=["GET", "POST"])
def connect():
    """
    Fonction de la page `/connect`
    Appelle une première en methode `GET`,
    puis boucle en methode `POST`
    """
    # Configuration de la bibliotheque
    password_ctx = CryptContext(schemes=['bcrypt'])

    # Appelle de la page en methode `POST`
    if request.method == "POST":
        user_mail = request.form["user_mail"]
        user_pass = request.form["user_pass"]

        # Recuperation du mot de passe hashe
        with db.connect() as conn:
            with conn.cursor() as cur:
                cur.execute("SELECT idcli, mdp FROM clients WHERE courriel = %s", (user_mail, ))
                result_pass = cur.fetchone()

        # Si le compte n'existe pas ou que le mot de passe est incorrecte
        if result_pass is None or not password_ctx.verify(str(user_pass), result_pass[1]):
            return render_template("connect.html", error=1)

        # Si tout est correct
        session["id_client"] = result_pass[0]
        return redirect(url_for("lobby"))


    # Appelle de la page en methode `GET`
    return render_template("connect.html")



@app.route("/disconnect")
def disconnect():
    """
    Fonction de la page `/disconnect`
    """
    # Teste si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Si tout est correcte
    session.pop("id_client", None)
    session.pop("id_profil", None)

    return render_template("disconnect.html")



@app.route("/profil", methods=["GET", "POST"])
def profil():
    """
    Fonction de la page `/profil`
    """
    # Teste si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Si tout est correcte
    idcli = session["id_client"]
    idpro = session["id_profil"] if "id_profil" in session else -1
    with db.connect() as conn:
        with conn.cursor() as cur:
            cur.execute("SELECT idpro, pseudo FROM profil WHERE idcli = %s", (idcli, ))
            result_profil = cur.fetchall()

        with conn.cursor() as cur:
            cur.execute("SELECT nom, prenom, courriel FROM clients WHERE idcli = %s", (idcli, ))
            result_client = cur.fetchone()

    # Appelle en methode `POST`
    if request.method == "POST":
        session["id_profil"] = request.form["profil_choose"]
        return redirect(url_for("lobby"))

    print(idpro, result_profil[0].idpro)
    return render_template(
        "profil.html",
        list_profil=result_profil,
        nb_pro=len(result_profil),
        idpro=int(idpro),
        client=result_client
    )



@app.route("/create_profil", methods=["GET", "POST"])
def create_profil():
    """
    Fonction de la page `/create_profil`
    """
    # Test si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Si tout est correcte
    if request.method == "POST":
        error = 0
        id_client = session["id_client"]
        new_pro = request.form["new_pro"]
        with db.connect() as conn:
            with conn.cursor() as cur:
                cur.execute(f"SELECT * FROM profil WHERE idcli={id_client} AND pseudo='{new_pro}'")
                result_profil = cur.fetchone()

        # Teste des differents teste
        if new_pro == "":
            error = 8
        elif len(new_pro) > 25:
            error = 7
        elif result_profil is not None:
            error = 9

        # Si il y a une erreur
        if error != 0:
            return render_template("profil_create.html", error=error)

        # Si tout est bon
        with db.connect() as conn:
            with conn.cursor() as cur:
                cur.execute(
                    "INSERT INTO profil VALUES (DEFAULT, %s, %s)",
                    (
                        new_pro,
                        id_client,
                    )
                )
        return redirect(url_for("lobby"))

    # Appelle en methode `GET`
    return render_template("profil_create.html", error=0)



@app.route("/lobby")
def lobby():
    """
    Fonction de la page `/lobby`
    """
    # Test si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Test la presence et si l'id du profil est lie a l'id du client
    if "id_profil" not in session or not verif_cli_pro(session["id_client"], session["id_profil"]):
        return redirect(url_for("profil"))

    # Si tout est correcte
    with db.connect() as conn:
        with conn.cursor() as cur:
            cur.execute(
                "SELECT idfilm, nom, picture FROM film ORDER BY nom, anprod LIMIT 10"
                )
            result_film = cur.fetchall()

        with conn.cursor() as cur:
            cur.execute(
                "SELECT idsaison, nom, picture FROM saison ORDER BY nom, numsaison LIMIT 10"
                )
            result_saison = cur.fetchall()

        with conn.cursor() as cur:
            cur.execute(
                "SELECT idfilm, nom, picture FROM moynotefilm NATURAL JOIN film LIMIT 10"
                )
            result_best_film = cur.fetchall()

        with conn.cursor() as cur:
            cur.execute(
                "SELECT idsaison, nom, picture FROM moynotesaison NATURAL JOIN saison LIMIT 10"
                )
            result_best_saison = cur.fetchall()

    return render_template(
        "lobby.html",
        lst_f=result_film,
        lst_s=result_saison,
        lst_bf=result_best_film,
        lst_bs=result_best_saison
    )



@app.route("/search", methods=["GET", "POST"])
def search():
    """
    Fonction de la page `/search`
    """
    # Test si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Test la presence et si l'id du profil est lie a l'id du client
    if "id_profil" not in session or not verif_cli_pro(session["id_client"], session["id_profil"]):
        return redirect(url_for("profil"))

    dico_result = {}
    # Appelle en methode POST
    if request.method == "POST":
        research = request.form["research"]
        type_search = request.form["type_search"]
        with db.connect() as conn:
            if "film" in type_search:
                with conn.cursor() as cur:
                    cur.execute(
                        f"SELECT idfilm, nom, picture FROM film WHERE nom LIKE '%{research}%'"
                        )
                    result_film = cur.fetchall()
                    if result_film != []:
                        dico_result["film"] = result_film
            if "serie" in type_search:
                with conn.cursor() as cur:
                    cur.execute(
                        f"SELECT idsaison, nom, picture FROM saison WHERE nom LIKE '%{research}%'"
                    )
                    result_serie = cur.fetchall()
                    if result_serie != []:
                        dico_result["serie"] = result_serie
    print(dico_result)


    # Si tout est correcte
    return render_template("search.html", dico_result=dico_result)



@app.route("/film/<id_film>", methods=["GET", "POST"])
def watch_film(id_film):
    """
    Fonction de la page `/film`
    Avec comme valeur rajoute `id_film`
    """
    # Test si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Test la presence et si l'id du profil est lie a l'id du client
    if "id_profil" not in session or not verif_cli_pro(session["id_client"], session["id_profil"]):
        return redirect(url_for("profil"))

    # Si tout est correcte
    with db.connect() as conn:
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT idfilm, nom, anprod, duree, video FROM film WHERE idfilm = {id_film}"
            )
            result_film = cur.fetchone()

        # Appelle en methode POST
        if request.method == "POST" and request.form["note"] != '':
            note = request.form["note"]
            id_pro = session["id_profil"]
            with conn.cursor() as cur:
                cur.execute(
                    f"SELECT * FROM notefilm WHERE idpro={id_pro} AND idfilm={id_film}"
                )
                result_test = cur.fetchone()

            with conn.cursor() as cur:
                # Si il n'a pas deja note
                if result_test is None:
                    cur.execute(
                        f"INSERT INTO notefilm VALUES ({id_pro}, {id_film}, {note})"
                    )
                # Si c'est le cas
                else:
                    cur.execute(
                        "UPDATE notefilm SET note=%s WHERE idpro=%s AND idfilm=%s",
                        (
                            note,
                            id_pro,
                            id_film,
                        )
                    )

        # Recupere la liste des acteurs
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT nom, prenom FROM gens NATURAL JOIN jouefilm WHERE idfilm = {id_film}"
            )
            liste_act = cur.fetchall()

        # Recupere la liste des realisateurs
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT nom, prenom FROM gens NATURAL JOIN realfilm WHERE idfilm = {id_film}"
            )
            real = cur.fetchall()

        # Recupere la moyenne du film
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT moyenne FROM moynotefilm WHERE idfilm={id_film}"
            )
            result_note = cur.fetchone()
            result_note = float(result_note.moyenne) if result_note is not None else -1

        # Recupere le nombre de visionnage du film
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT * FROM nbvuefilm WHERE idfilm={id_film}"
            )
            result_nbvu = cur.fetchone()
            result_nbvu = int(result_nbvu.toto) if result_nbvu is not None else -1

        # Recupere le nombre de visionnage du film au dela de 95%
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT * FROM nbvuefilm95 WHERE idfilm={id_film}"
            )
            result_nbv9 = cur.fetchone()
            result_nbv9 = int(result_nbv9.more95) if result_nbv9 is not None else -1


    return render_template(
        "watch_film.html",
        film=result_film,
        acteurs=liste_act,
        real=real,
        vue=[result_nbvu, result_nbv9],
        note=result_note
    )



@app.route("/serie/<id_serie>", methods=["GET", "POST"])
def list_episode(id_serie):
    """
    Fonction de la page `/serie`
    Avec comme valeur rajoute `id_serie`
    """
    # Test si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Test la presence et si l'id du profil est lie a l'id du client
    if "id_profil" not in session or not verif_cli_pro(session["id_client"], session["id_profil"]):
        return redirect(url_for("profil"))

    # Si tout est correcte
    # Appelle en methode POST
    if request.method == "POST" and request.form["note"] != '':
        # Pour noter la serie
        print(session["id_profil"], id_serie, request.form["note"])
        id_pro = session["id_profil"]
        note = request.form["note"]

        # Verifie si elle est deja notee
        with db.connect() as conn:
            with conn.cursor() as cur:
                cur.execute(
                    f"SELECT * FROM notesaison WHERE idpro={id_pro} AND idsaison={id_serie}"
                )
                result_test = cur.fetchone()
            with conn.cursor() as cur:
                # Si c'est pas le cas
                if result_test is None:
                    cur.execute(
                        f"INSERT INTO notesaison VALUES ({id_pro}, {id_serie}, {note})"
                    )
                # Si c'est le cas
                else:
                    cur.execute(
                        "UPDATE notesaison SET note=%s WHERE idpro=%s AND idsaison=%s",
                        (note, id_pro, id_serie, )
                    )

    with db.connect() as conn:
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT * FROM episode WHERE idsaison = {id_serie}"
                )
            result_episode = cur.fetchall()

        # Recupere la liste des realisateur
        with conn.cursor() as cur:
            cur.execute(
                f"select nom, prenom from gens natural join realsaison where idsaison = {id_serie}"
                )
            real = cur.fetchall()

        # Recupere la liste des acteurs
        with conn.cursor() as cur:
            cur.execute(
                f"select nom, prenom from gens natural join jouesaison where idsaison = {id_serie}"
                )
            acteurs = cur.fetchall()

        # Recupere la moyenne de la série
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT moyenne FROM moynotesaison WHERE idsaison={id_serie}"
            )
            result_note = cur.fetchone()
            result_note = float(result_note.moyenne) if result_note is not None else -1

        # Recupere le nombre de visionnage de la série
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT * FROM nbvueserie WHERE idsaison={id_serie}"
            )
            result_nbvu = cur.fetchone()
            result_nbvu = int(result_nbvu.toto) if result_nbvu is not None else -1

        # Recupere le nombre de visionnage de la série au dela de 95%
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT * FROM nbvueserie95 WHERE idsaison={id_serie}"
            )
            result_nbv9 = cur.fetchone()
            result_nbv9 = int(result_nbv9.more95) if result_nbv9 is not None else -1

    # Si il n'y a aucun épisode
    if result_episode == []:
        return redirect(url_for("lobby"))

    return render_template(
        "list_serie.html",
        lst_serie=result_episode,
        acteurs=acteurs,
        real=real,
        vue=[result_nbvu, result_nbv9],
        note=result_note
    )



@app.route("/serie/<id_s>/<id_ep>", methods={"GET", "POST"})
def watch_serie(id_s, id_ep):
    """
    Fonction de la page `/serie`
    Avec comme valeur rajoute `id_serie` et `id_episode`
    """
    # Test si l'id du client n'est pas present
    if "id_client" not in session:
        return redirect(url_for("connect"))

    # Test la presence et si l'id du profil est lie a l'id du client
    if "id_profil" not in session or not verif_cli_pro(session["id_client"], session["id_profil"]):
        return redirect(url_for("profil"))
    id_pro = session["id_profil"]

    # Si tout est correcte
    with db.connect() as conn:
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT idsaison, numsaison, nom, video FROM saison WHERE idsaison = {id_s}"
            )
            result_saison = cur.fetchone()
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT * FROM episode WHERE idsaison={id_s} AND idep={id_ep}"
            )
            result_episode = cur.fetchone()

        # Verifie la presence d'un episode anterieur
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT idep FROM episode WHERE idsaison={id_s} AND idep={int(id_ep) - 1}"
            )
            result_ante = cur.fetchone()
        # Verifie la presence d'un episode posterieur
        with conn.cursor() as cur:
            cur.execute(
                f"SELECT idep FROM episode WHERE idsaison={id_s} AND idep={int(id_ep) + 1}"
            )
            result_post = cur.fetchone()

    if result_episode == []:
        return redirect(url_for("lobby"))

    # Appelle en méthode `POST`
    if request.method == "POST":
        watch_time = request.form["watchtime"]
        date_now = f"{datetime.now().year}-{datetime.now().month}-{datetime.now().day}"

        # Verifie si il y a deja un WatchTime aujourd'hui
        with db.connect() as conn:
            with conn.cursor() as cur:
                cur.execute(
                    f"SELECT * FROM voirep WHERE idpro={id_pro} AND idep={id_ep}"
                )
                result_test = cur.fetchone()
            with conn.cursor() as cur:
                # Si c'est pas le cas
                if result_test is None:
                    cur.execute(
                        f"INSERT INTO voirep VALUES ({id_pro}, {id_ep}, {watch_time}, '{date_now}')"
                    )
                # Si c'est le cas
                else:
                    cur.execute(
                        "UPDATE voirep SET duree=%s, datevis=%s WHERE idpro=%s AND idep=%s",
                        (watch_time, date_now, id_pro, id_ep, )
                    )

    return render_template(
        "watch_ep.html",
        saison=result_saison,
        episode=result_episode,
        ep_ante=result_ante if result_ante is not None else -1,
        ep_post=result_post if result_post is not None else -1
    )



if __name__ == '__main__':
    app.run()