Chapitre 11 - Session utilisateurs et insertions SQL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapitre 10 - Session utilisations et Insertions SQL\n",
    "===\n",
    "\n",
    "## Bibliographie\n",
    "\n",
    "- [Formulaires avec WTForms](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-iii-web-forms)\n",
    "- [How NOT to Store Passwords](https://www.youtube.com/watch?v=8ZtInClXe1Q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube-nocookie.com/embed/8ZtInClXe1Q\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import HTML\n",
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube-nocookie.com/embed/8ZtInClXe1Q\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Créer des comptes\n",
    "\n",
    "La création de comptes est une des tâches les plus courantes dans le cadre d'un développement d'application. C'est aussi une des plus dangereuses : vous êtes responsables de la sécurité de vos utilisateurs et de leurs données. On apprendra donc ici à sécuriser un maximum nos données sensibles.\n",
    "\n",
    "### Gérer des mots de passe\n",
    "\n",
    "Pour enregistrer un mot de passe, on va *à minima* encrypter ce mot de passe. On utilise d'ailleurs à mauvais escient ce terme car ce que l'on va calculer réellement est un hash. Contrairement au cryptage, le hash n'est pas réversible. Si quelque chose est hashé en \"qqewretet\", la seule manière de trouver l'original est de \"brute-forcer\" ce dernier, c'est-à-dire de générer tous les mots de passe possibles (ce qui est, disons-le, plutôt difficile).\n",
    "\n",
    "L'autre manière de casser un Hash, c'est d'avoir la malchance d'avoir l'algorithme de hashage de cassé. On en trouve trois actuellement recommandés (*cf.* *[\n",
    "About Secure Password Hashing](http://security.blogoverflow.com/2013/09/about-secure-password-hashing/)*).\n",
    "\n",
    "Pour Flask, Werkzeug (un outil qui permet à Flask de fonctionner) fournit deux fonctions : `generate_password_hash` et `check_password_hash`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Constante de sécurité\n",
    "\n",
    "Pour notre application, nous allons intégrer un nouveau module pour stocker nos constantes. Cela permettra de gérer les configurations générales plus proprement : créons donc `gazetteer/constantes.py` où nous stockons un \"secret\" qui permettra à Flask d'effectuer des transactions sécurisées :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat cours-flask/exemple16/gazetteer/constantes.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le sel devant être unique et non devinable, on rajoute un avertissement au cas où la personne mettant ce site en fonctionnement n'avait pas connaissance de ce changement de configuration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Méthode propre\n",
    "\n",
    "On va maintenant créer une fonction pour vérifier une connexion. Rappel de notre classe `User`:\n",
    "\n",
    "```python\n",
    "class User(db.Model):\n",
    "    user_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)\n",
    "    user_nom = db.Column(db.Text, nullable=False)\n",
    "    user_login = db.Column(db.String(45), nullable=False, unique=True)\n",
    "    user_email = db.Column(db.Text, nullable=False)\n",
    "    user_password = db.Column(db.String(100), nullable=False)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour vérifier la validité de l'identification de l'utilisateur, on va retrouver l'utilisateur, comparer le hash généré du mot de passe avec celui enregistré :\n",
    "\n",
    "```python\n",
    "def identification(login, motdepasse):\n",
    "    \"\"\" Identifie un utilisateur. Si cela fonctionne, renvoie les données de l'utilisateur.\n",
    "    \n",
    "    :param login: Login de l'utilisateur\n",
    "    :param motdepasse: Mot de passe envoyé par l'utilisateur\n",
    "    :returns: Si réussite, données de l'utilisateur. Sinon None\n",
    "    :rtype: User or None\n",
    "    \"\"\"\n",
    "    utilisateur = User.query.filter(User.user_login == login).first()\n",
    "    if utilisateur and check_password_hash(utilisateur.user_password, motdepasse):\n",
    "        return utilisateur\n",
    "    return None\n",
    "```\n",
    "\n",
    "Pour que cette fonction soit facile à retrouver, on va l'enregistrer sous la responsabilité de la classe `User` :\n",
    "\n",
    "```python\n",
    "class User(db.Model):\n",
    "    user_id = db.Column(db.Integer, unique=True, nullable=False, primary_key=True, autoincrement=True)\n",
    "    user_nom = db.Column(db.Text, nullable=False)\n",
    "    user_login = db.Column(db.String(45), nullable=False, unique=True)\n",
    "    user_email = db.Column(db.Text, nullable=False)\n",
    "    user_password = db.Column(db.String(64), nullable=False)\n",
    "    \n",
    "    @staticmethod\n",
    "    def identification(login, motdepasse):\n",
    "        \"\"\" Identifie un utilisateur. Si cela fonctionne, renvoie les données de l'utilisateur.\n",
    "\n",
    "        :param login: Login de l'utilisateur\n",
    "        :param motdepasse: Mot de passe envoyé par l'utilisateur\n",
    "        :returns: Si réussite, données de l'utilisateur. Sinon None\n",
    "        :rtype: User or None\n",
    "        \"\"\"\n",
    "        utilisateur = User.query.filter(User.user_login == login).first()\n",
    "        if utilisateur and check_password_hash(utilisateur.user_password, motdepasse):\n",
    "            return utilisateur\n",
    "        return None\n",
    "```\n",
    "\n",
    "On précède notre fonction de `@staticmethod` pour mettre d'appeler cette fonction ainsi :\n",
    "\n",
    "```python\n",
    "utilisateur = User.identification(login, motdepasse)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Premier insert\n",
    "\n",
    "On va maintenant effectuer notre premier insert ! Et oui, il va falloir créer des comptes. Pour créer un compte, il nous faudra aussi une fonction de création de comptes.\n",
    "\n",
    "Pour créer un enregistrement ou une mise à jour, SQL et SQLAlchemy fonctionnent par session de changement, un peu comme git : on crée un ensemble de modifications, on les stocke pour l'envoi (`db.session.add(lachoseaenvoyer)`) et on envoie à MySQL (`db.session.commit()`). Prenez le temps de bien lire le contenu qui suit :\n",
    "\n",
    "```python\n",
    "class User(db.model):\n",
    "    # ...\n",
    "    @staticmethod\n",
    "    def creer(login, email, nom, motdepasse):\n",
    "        \"\"\" Crée un compte utilisateur-rice. Retourne un tuple (booléen, User ou liste).\n",
    "        Si il y a une erreur, la fonction renvoie False suivi d'une liste d'erreur\n",
    "        Sinon, elle renvoie True suivi de la donnée enregistrée\n",
    "\n",
    "        :param login: Login de l'utilisateur-rice\n",
    "        :param email: Email de l'utilisateur-rice\n",
    "        :param nom: Nom de l'utilisateur-rice\n",
    "        :param motdepasse: Mot de passe de l'utilisateur-rice (Minimum 6 caractères)\n",
    "\n",
    "        \"\"\"\n",
    "        erreurs = []\n",
    "        if not login:\n",
    "            erreurs.append(\"Le login fourni est vide\")\n",
    "        if not email:\n",
    "            erreurs.append(\"L'email fourni est vide\")\n",
    "        if not nom:\n",
    "            erreurs.append(\"Le nom fourni est vide\")\n",
    "        if not motdepasse or len(motdepasse) < 6:\n",
    "            erreurs.append(\"Le mot de passe fourni est vide ou trop court\")\n",
    "\n",
    "        # On vérifie que personne n'a utilisé cet email ou ce login\n",
    "        uniques = User.query.filter(\n",
    "            db.or_(User.user_email == email, User.user_login == login)\n",
    "        ).count()\n",
    "        if uniques > 0:\n",
    "            erreurs.append(\"L'email ou le login sont déjà inscrits dans notre base de données\")\n",
    "\n",
    "        # Si on a au moins une erreur\n",
    "        if len(erreurs) > 0:\n",
    "            return False, erreurs\n",
    "\n",
    "        # On crée un utilisateur\n",
    "        utilisateur = User(\n",
    "            user_nom=nom,\n",
    "            user_login=login,\n",
    "            user_email=email,\n",
    "            user_password=generate_password_hash(motdepasse)\n",
    "        )\n",
    "\n",
    "        try:\n",
    "            # On l'ajoute au transport vers la base de données\n",
    "            db.session.add(utilisateur)\n",
    "            # On envoie le paquet\n",
    "            db.session.commit()\n",
    "\n",
    "            # On renvoie l'utilisateur\n",
    "            return True, utilisateur\n",
    "        except Exception as erreur:\n",
    "            return False, [str(erreur)]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formulaire d'inscription\n",
    "\n",
    "On ajoute ensuite la route pour s'inscrire (ainsi qu'un lien dans le menu !) :\n",
    "\n",
    "```python\n",
    "from flask import flash, redirect, request\n",
    "\n",
    "\n",
    "@app.route(\"/register\", methods=[\"GET\", \"POST\"])\n",
    "def inscription():\n",
    "    \"\"\" Route gérant les inscriptions\n",
    "    \"\"\"\n",
    "    # Si on est en POST, cela veut dire que le formulaire a été envoyé\n",
    "    if request.method == \"POST\":\n",
    "        statut, donnees = User.creer(\n",
    "            login=request.form.get(\"login\", None),\n",
    "            email=request.form.get(\"email\", None),\n",
    "            nom=request.form.get(\"nom\", None),\n",
    "            motdepasse=request.form.get(\"motdepasse\", None)\n",
    "        )\n",
    "        if statut is True:\n",
    "            flash(\"Enregistrement effectué. Identifiez-vous maintenant\", \"success\")\n",
    "            return redirect(\"/\")\n",
    "        else:\n",
    "            flash(\"Les erreurs suivantes ont été rencontrées : \" + \",\".join(donnees), \"error\")\n",
    "            return render_template(\"pages/inscription.html\")\n",
    "    else:\n",
    "        return render_template(\"pages/inscription.html\")\n",
    "```\n",
    "\n",
    "#### On remarque: \n",
    "\n",
    "- Dans @app.route, on a ajouté `methods=[\"GET\", \"POST\"]` : cela signifie que la page est disponible à la fois pour GET et POST\n",
    "- On peut vérifier la méthode utilisée en vérifiant la valeur de `request.method`\n",
    "- On peut utiliser la fonction `flask.flash` pour afficher des messages d'erreurs (Regardez le `container.html` qui a été modifié pour afficher celles-ci). Les erreurs peuvent être accompagnées de catégorie.\n",
    "- On peut rediriger vers une url précise via `flask.redirect`\n",
    "- On a préféré séparer la logique de la connexion (dans modeles/utilisateur.py) plutôt que dans les routes. La route `inscription` ne sert qu'à appeler les différentes fonctions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Se connecter\n",
    "\n",
    "Pour gérer les utilisateurs, Flask possède un plugin `flask-login` que nous allons installer :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install flask-login"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration\n",
    "\n",
    "Flask-Login s'installe de la même manière que Flask SQLAlchemy :\n",
    "\n",
    "```python\n",
    "from flask_login import LoginManager\n",
    "app = Flask(...)\n",
    "# ...\n",
    "login = LoginManager(app)\n",
    "```\n",
    "\n",
    "On ajoute donc ces lignes à notre `app.py`.\n",
    "\n",
    "Une fois cela fait, on va configurer notre objet SQLAlchemy User pour qu'il puisse être compris par Flask Login, il va falloir rajouter quatre fonctions :\n",
    "- `is_authenticated` : une propriété, elle retournera True si l'utilisateur-rice est connecté-e, False sinon\n",
    "- `is_active` : une propriété, elle retournera True si l'utilisateur-rice est actif-ve, False sinon. \n",
    "    - Le caractère actif des membres de notre site n'est pas utilisé, pourtant, il faudra remplir cette case. On renverra donc True\n",
    "- `is_anonymous` : une propriété qui retournera False pour les utilisateur-rices non anonymes.\n",
    "- `get_id(identifier)` : une fonction qui retournera l'utilisateur pour l'ID donné\n",
    "\n",
    "**Mais** les choses sont bien faites, Flask Login propose un outil pour ne pas avoir à coder cela soit même : `flask_login.UserMixin` :\n",
    "\n",
    "```python\n",
    "from werkzeug.security import generate_password_hash, check_password_hash\n",
    "from flask_login import UserMixin\n",
    "\n",
    "from .. app import db\n",
    "\n",
    "class User(UserMixin, db.Model):\n",
    "    # ...\n",
    "```\n",
    "\n",
    "**Explications** : en ajoutant `UserMixin` à `db.Model`, on donne à python l'information que User est à la fois un `UserMixin` et un `db.Model`\n",
    "\n",
    "**Malheureusement**, le `get_id` par défaut de UserMixin n'est pas complètement compatible avec notre `User`, car il a besoin d'une propriété `.id` pour que `get_id()` fonctionne. On va donc écrire par-dessus:\n",
    "\n",
    "```python\n",
    "class User(UserMixin, db.Model):\n",
    "    # ...\n",
    "    def get_id(self):\n",
    "        \"\"\" Retourne l'id de l'objet actuellement utilisé \n",
    "        \n",
    "        :returns: ID de l'utilisateur\n",
    "        :rtype: int\n",
    "        \"\"\"\n",
    "        return self.user_id\n",
    "```\n",
    "\n",
    "Ici, `self` prend la valeur de l'utilisateur courant. Par exemple :\n",
    "\n",
    "```python\n",
    "Laurel = User(user_id=1)\n",
    "Hardy = User(user_id=2)\n",
    "\n",
    "print(Laurel.get_id())\n",
    ">>> 1\n",
    "print(Hardy.get_id())\n",
    ">>> 2\n",
    "```\n",
    "\n",
    "Il va quand même falloir définir nous-mêmes une fonction qui permettra de récupérer un utilisateur en fonction de son identifiant (toujours dans `utilisateur.py`) :\n",
    "\n",
    "```python\n",
    "from app import login\n",
    "\n",
    "# ...\n",
    "@login.user_loader\n",
    "def trouver_utilisateur_via_id(id):\n",
    "    return User.query.get(int(id))\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formulaire de connexion\n",
    "\n",
    "On ajoutera donc un nouveau formulaire à notre application ainsi qu'un nouveau menu dans le container principal :\n",
    "\n",
    "```html\n",
    "{% extends \"conteneur.html\" %}\n",
    "\n",
    "{% block titre %}| Connexion{%endblock%}\n",
    "\n",
    "{% block corps %}\n",
    "\n",
    "<h1>Inscription</h1>\n",
    "<form class=\"form\" method=\"POST\" action=\"{{url_for(\"connexion\")}}\">\n",
    "  <div class=\"form-group row\">\n",
    "    <label for=\"register-login\" class=\"col-sm-2 col-form-label\">Login</label>\n",
    "    <div class=\"col-sm-10\">\n",
    "      <input type=\"text\" class=\"form-control\" id=\"register-login\" name=\"login\" placeholder=\"Nom d'utilisateur pour se connecter\">\n",
    "    </div>\n",
    "  </div>\n",
    "  <div class=\"form-group row\">\n",
    "    <label for=\"register-password\" class=\"col-sm-2 col-form-label\">Password</label>\n",
    "    <div class=\"col-sm-10\">\n",
    "      <input type=\"password\" class=\"form-control\" id=\"register-password\" placeholder=\"Mot de passe\" name=\"motdepasse\">\n",
    "    </div>\n",
    "  </div>\n",
    "  <div>\n",
    "    <button type=\"submit\" class=\"btn btn-primary\">Connexion</button>\n",
    "    <a href=\"{{url_for(\"inscription\")}}\" class=\"btn btn-secondary\">Inscription</a>\n",
    "  </div>\n",
    "</form>\n",
    "{% endblock %}\n",
    "```\n",
    "\n",
    "et la route qui correspondra \n",
    "\n",
    "```python\n",
    "from flask_login import login_user, current_user\n",
    "from .app import login\n",
    "\n",
    "\n",
    "@app.route(\"/connexion\", methods=[\"POST\", \"GET\"])\n",
    "def connexion():\n",
    "    \"\"\" Route gérant les connexions\n",
    "    \"\"\"\n",
    "    if current_user.is_authenticated is True:\n",
    "        flash(\"Vous êtes déjà connecté-e\", \"info\")\n",
    "        return redirect(\"/\")\n",
    "    # Si on est en POST, cela veut dire que le formulaire a été envoyé\n",
    "    if request.method == \"POST\":\n",
    "        utilisateur = User.identification(\n",
    "            login=request.form.get(\"login\", None),\n",
    "            motdepasse=request.form.get(\"motdepasse\", None)\n",
    "        )\n",
    "        if utilisateur:\n",
    "            flash(\"Connexion effectuée\", \"success\")\n",
    "            login_user(utilisateur)\n",
    "            return redirect(\"/\")\n",
    "        else:\n",
    "            flash(\"Les identifiants n'ont pas été reconnus\", \"error\")\n",
    "\n",
    "    return render_template(\"pages/connexion.html\")\n",
    "        \n",
    "login.login_view = 'connexion'\n",
    "```\n",
    "\n",
    "##### On remarquera\n",
    "- Pour obtenir l'utilisateur courant, on appelle `flask_login.current_user`\n",
    "- Pour valider l'authentification, on passer à la fonction `flask_login.login_user` la variable comportant l'utilisateur\n",
    "- On marque la route définie comme celle de connexion\n",
    "\n",
    "### Deconnexion\n",
    "\n",
    "La route de déconnexion est aussi assez simple : on va juste utiliser la fonction `flask_login.logout_user` :\n",
    "\n",
    "```python\n",
    "from flask_login import logout_user, current_user\n",
    "\n",
    "@app.route(\"/deconnexion\", methods=[\"POST\", \"GET\"])\n",
    "def deconnexion():\n",
    "    if current_user.is_authenticated is True:\n",
    "        logout_user()\n",
    "    flash(\"Vous êtes déconnecté-e\", \"info\")\n",
    "    return redirect(\"/\")\n",
    "```\n",
    "\n",
    "### Afficher l'utilisateur courant dans les templates\n",
    "\n",
    "Pour afficher l'utilisateur courant dans les templates, on utilise de même la variable `{{ current_user }}`: \n",
    "\n",
    "```html\n",
    "<ul class=\"navbar-nav mr-auto\">\n",
    "    {% if not current_user.is_authenticated %}\n",
    "      <li class=\"nav-item\">\n",
    "        <a class=\"nav-link\" href=\"{{url_for(\"inscription\")}}\">Inscription</a>\n",
    "      </li>\n",
    "      <li class=\"nav-item\">\n",
    "        <a class=\"nav-link\" href=\"{{url_for(\"connexion\")}}\">Connexion</a>\n",
    "      </li>\n",
    "    {% else %}\n",
    "      <li class=\"nav-item\">\n",
    "        <a class=\"nav-link\" href=\"{{url_for(\"deconnexion\")}}\">Déconnexion ({{current_user.user_nom}})</a>\n",
    "      </li>\n",
    "    {% endif %}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exemple 16\n",
    "\n",
    "On ouvrira un terminal, s'assurera d'être dans un environnement virtuel et on tapera depuis le dossier source\n",
    "\n",
    "```sh\n",
    "cd cours-flask/exemple16\n",
    "python run.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice\n",
    "\n",
    "Écrire une page pour créer un nouveau lieu seulement quand on est connecté. Pour limiter la capacité à accéder à une page, on précède la route de `flask_login.login_required` :\n",
    "\n",
    "```python\n",
    "from flask_login import login_required\n",
    "\n",
    "@login_required\n",
    "def route()\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}