Vous souhaitez donc créer une application et attirer de nombreux utilisateurs ?

Nous le faisons tous et si vous êtes débutant, vous devez prendre en compte les fonctionnalités d'inscription par e-mail suivantes.

1. Adresse e-mail valide avec un mot de passe fort
2. Prévention des robots
3. Inscription double opt-in

Un système d'inscription par e-mail solide est essentiel pour les applications Web, les newsletters, les téléchargements gratuits, les invitations à des groupes privés et la génération de leads. Ne comptons pas sur l'utilisation de services tiers tels que Auth0, Facebook ou Google pour accéder à votre application. Gardez les données de votre application pour vous !

Pour commencer, vous devez avoir une certaine expérience en Python car nous allons utiliser le framework Flask avec une base de données MySQL. Cela va être plus amusant que d'utiliser Wordpress, le CMS le plus populaire. Vous devrez payer pour un plugin Wordpress pour avoir les mêmes fonctionnalités qu'une extension Flask gratuite. J'ai déjà construit sur les deux et je préfère Python Flask pour les applications Web, même si Wordpress est très capable de créer des applications Web.

Chaque extrait de code sera expliqué et inclura quelques commentaires dans le code. Si vous n'avez pas créé d'enregistrement d'utilisateur ou si vous ne connaissez pas le fonctionnement interne, je décrirai les détails pour vous. Voici un résumé des fonctionnalités que nous mettrons en œuvre comme indiqué dans le premier paragraphe :

1. Une adresse e-mail valide peut être vérifiée en analysant la chaîne d'entrée de l'utilisateur à l'aide d'une expression régulière ou d'une extension Flask. Nous n'autoriserons pas les hacks de type texte aléatoire ni injection SQL.

La

2. La prévention des robots peut être effectuée avec un champ masqué qui n'est pas affiché à l'utilisateur mais qui est généralement rempli automatiquement par les robots qui explorent les formulaires d'inscription vulnérables.

3. La méthode de double opt-in nécessite que le destinataire vous autorise à lui envoyer un e-mail en recevant un lien de validation dans sa boîte de réception. Ceci est principalement utilisé pour empêcher quelqu'un d'autre d'utiliser votre adresse e-mail. Cela empêche également les utilisateurs de test qui se contentent de s'inscrire et d'abandonner leur compte.

Codons-le !

Créer un répertoire de travail :

mkdir signup
cd signup

Créez votre environnement Python en utilisant python3 -m venv signup ou conda create -n signup python3. Je préfère conda.

Créez une table MySQL pour stocker vos utilisateurs. Le champ validé est pour le double opt-in :

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    email VARCHAR(120) NOT NULL UNIQUE,
    password VARCHAR(120) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    validated BOOLEAN DEFAULT FALSE
);

Installer les dépendances :
pip flask flask-mail sécurisé SQLAlchemy Flask-WTF Flask-SQLAlchemy mysql-connector-python

Alternativement, vous pouvez avoir la même chose répertoriée dans un fichier exigences.txt et exécuter pip install -r exigences.txt

Créez le fichier app.py avec les dépendances suivantes :

from flask import Flask, render_template, request, url_for, redirect, flash
from flask_mail import Mail, Message
from datetime import datetime
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.sql import func
from itsdangerous import URLSafeTimedSerializer, SignatureExpired
from werkzeug.security import generate_password_hash, check_password_hash
import secrets

Saisissez vos propres données de configuration de serveur en utilisant ces lignes :

# Flask configurations
secret = secrets.token_urlsafe(32)
app.secret_key = secret
app.config['SECRET_KEY'] = secret # auto-generated secret key

# SQLAlchemy configurations
SQLALCHEMY_DATABASE_URI = 'mysql mysqlconnector://admin:user@localhost/tablename'

# Email configurations
app.config['MAIL_SERVER'] = 'smtp.example.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USERNAME'] = '[email protected]'
app.config['MAIL_PASSWORD'] = 'your_password'
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USE_SSL'] = False

db = SQLAlchemy(app)
mail = Mail(app)
s = URLSafeTimedSerializer(app.config['SECRET_KEY']) #set secret to the serliazer

En fin de compte, vous devriez avoir vos informations de configuration dans un fichier .env.

La section suivante utilise la structure ORM de SQLAlchemy pour interroger la base de données pour vous. Notez que le nom de la classe doit correspondre au nom de votre table de base de données, sinon vous obtiendrez une erreur. Le db.model représente les paramètres de votre table qui incluent le nom de la colonne, son type, sa longueur, sa clé et sa valeur nulle :

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(120), nullable=False)
    created_at = db.Column(db.DateTime, server_default=db.func.now())
    validated = db.Column(db.Boolean, default=False)

Si vous n'avez pas déjà créé manuellement la table de la base de données MySQL, vous pouvez le faire avec ce code Flask directement après le bloc de code utilisateur de la classe :

# Create the database table
with app.app_context():
    db.create_all()

Par souci de concision de ce didacticiel, nous ignorons la page d'index ou ce que vous voudriez appeler la page d'accueil de votre application et affichons simplement la page d'inscription à l'aide de la fonction de décoration de Python pour l'itinéraire de la page :

@app.route('/')
def index():
    return '
Homepage
'

@app.route('/signup', methods=['GET', 'POST'])
def signup():
    if request.method == 'POST':
        # Hidden field validation to prevent bot submission
        hidden_field = request.form.get('hidden_field')
        if hidden_field:
            return redirect(url_for('index'))  # Bot detected, ignore submission

        email = request.form['email']
        password = request.form['password']
        hashed_password = generate_password_hash(password, method='sha256')

        # Insert user into the database
        new_user = User(email=email, password=hashed_password)
        db.session.add(new_user)
        db.session.commit()

        # Send confirmation email
        token = s.dumps(email, salt='email-confirm')
        msg = Message('Confirm your Email', sender='[email protected]', recipients=[email])
        link = url_for('confirm_email', token=token, _external=True)
        msg.body = f'Your link is {link}'
        mail.send(msg)
        flash('A confirmation email has been sent to your email address.', 'success')
        return redirect(url_for('index'))
    return render_template('signup.html')

Avant d'ajouter le formulaire d'inscription html, complétons le backend en ajoutant la route de validation de la fonctionnalité de double opt-in. Cette route utilise la variable s que nous avons créée précédemment qui génère le jeton secret sensible au temps. Consultez la documentation pour plus de détails
L'âge maximum correspond aux secondes précédant l'expiration du lien. Dans ce cas, l'utilisateur dispose de 20 minutes pour confirmer son adresse e-mail.

@app.route('/confirm_email/')
def confirm_email(token):
    try:
        email = s.loads(token, salt='email-confirm', max_age=1200)  # Token expires after 1 hour
    except SignatureExpired:
        return '
The token is expired!
'

    # Update field in database
    user = User.query.filter_by(email=email).first_or_404()
    user.validated = True
    db.session.commit()

    return '
Email address confirmed!
'

Maintenant, l'instruction principale omniprésente qui indique à Python d'exécuter le script si le fichier est exécuté directement (par opposition à un module importé) :

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

Avant de terminer ce code back-end, nous avons toujours besoin du code HTML front-end pour la saisie de l'utilisateur. Nous allons le faire avec le modèle Jinja intégré de Flask. Créez un fichier nommé templates/signup.html dont le nom doit correspondre à l'itinéraire que vous avez créé précédemment dans app.py. Par défaut, Jinja utilise le répertoire /templates pour les fichiers html. Vous pouvez modifier ce paramètre mais pour ce tutoriel, nous allons utiliser le répertoire /templates de l'application.

    
Sign Up
    

{% for category, message in messages %}
• {{ message }}
{% endfor %}

Votre code devrait fonctionner à partir de ce point lorsque vous exécutez la commande flask avec le débogage activé. Cela vous permettra de voir les erreurs éventuelles dans la ligne de commande ainsi que dans la fenêtre du navigateur :

flask --app app.py --debug run