¿Quieres crear una aplicación y conseguir muchos usuarios?

Todos lo hacemos y, si eres principiante, debes tener en cuenta las siguientes funciones de registro de correo electrónico.

1. Dirección de correo electrónico válida con una contraseña segura
2. Prevención de robots
3. Registro de doble suscripción

Un sistema sólido de registro de correo electrónico es esencial para aplicaciones web, boletines informativos, descargas gratuitas, invitaciones a grupos privados y generación de leads. No dependamos del uso de servicios de terceros como Auth0, Facebook o Google para tener acceso a su aplicación. ¡Mantén tuyos los datos de tu aplicación!

Para comenzar, debes tener algo de experiencia en Python porque usaremos el marco Flask con una base de datos MySQL. Esto será más divertido que usar Wordpress, el CMS más popular. Tendría que pagar por algún complemento de Wordpress para tener la misma capacidad que una extensión gratuita de Flask. He compilado previamente sobre ambos y prefiero Python Flask para aplicaciones web, aunque Wordpress es muy capaz de crear aplicaciones web.

Cada fragmento de código se explicará e incluirá algunos comentarios en el código. En caso de que no haya creado un registro de usuario o no conozca el funcionamiento interno, le describiré los detalles. Aquí hay un resumen de las características que implementaremos como se indica en el primer párrafo:

1. Se puede verificar una dirección de correo electrónico válida analizando la cadena de entrada del usuario usando una expresión regular o una extensión Flask. No permitiremos hacks de tipo texto aleatorio ni inyección SQL.

2. La prevención de bots se puede realizar con un campo oculto que no se muestra al usuario, pero que normalmente los bots que rastrean en busca de formularios de registro vulnerables lo completan automáticamente.

3. El método de doble suscripción requiere que el destinatario le dé permiso para enviarle un correo electrónico al recibir un enlace de validación en su bandeja de entrada. Esto se utiliza principalmente para evitar que otra persona utilice su dirección de correo electrónico. Esto también evita que los usuarios de prueba que simplemente se registran y abandonen sus cuentas.

¡Vamos a codificarlo!

Crear un directorio de trabajo:

mkdir signup
cd signup

Cree su entorno Python usando python3 -m venv signup o conda create -n signup python3. Prefiero conda.

Crea una tabla MySQL para almacenar tus usuarios. El campo validado es para el doble 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
);

Instalar dependencias:
pip flask flask-mail seguro SQLAlchemy Flask-WTF Flask-SQLAlchemy mysql-connector-python

Alternativamente, puede incluir lo mismo en un archivo requisitos.txt y ejecutar pip install -r requisitos.txt

Cree el archivo app.py con las siguientes dependencias:

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

Ingrese los datos de configuración de su propio servidor usando estas líneas:

# 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 última instancia, deberías tener tu información de configuración en un archivo .env.

La siguiente sección utiliza la estructura ORM de SQLAlchemy para consultar la base de datos por usted. Tenga en cuenta que el nombre de la clase debe coincidir con el nombre de la tabla de su base de datos de lo contrario obtendrá un error. El db.model representa la configuración de su tabla que incluye el nombre de la columna, su tipo, longitud, clave y valor nulo:

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 aún no ha creado manualmente la tabla de la base de datos MySQL, puede hacerlo con este código de Flask directamente después del bloque de código de usuario de clase:

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

Para abreviar este tutorial, omitiremos la página de índice o lo que le gustaría llamar la página de inicio de su aplicación y solo mostraremos la página de registro usando la función decoradora de Python para la ruta de la página:

@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')

Antes de agregar el formulario de registro html, completemos el backend agregando la ruta para validar la función de doble suscripción. Esta ruta utiliza la variable s que creamos anteriormente que genera el token secreto urgente. Consulte los documentos para obtener más detalles
La edad máxima son los segundos antes de que caduque el enlace, por lo que en este caso, el usuario tiene 20 minutos para confirmar su dirección de correo electrónico.

@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!
'

Ahora, para la omnipresente declaración principal que le dice a Python que ejecute el script si el archivo se ejecuta directamente (a diferencia de un módulo importado):

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

Antes de completar este código de back-end, todavía necesitamos el html de front-end para la entrada del usuario. Haremos esto con la plantilla Jinja incorporada de Flask. Cree un archivo llamado templates/signup.html cuyo nombre debería coincidir con la ruta que creó anteriormente en app.py. De forma predeterminada, Jinja usa el directorio /templates para los archivos html. Puedes cambiar esta configuración, pero para este tutorial usaremos el directorio /templates de la aplicación.

    
Sign Up
    

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

Su código debería funcionar a partir de este punto cuando ejecute el comando flask con la depuración habilitada. Esto le permitirá ver cualquier error en la línea de comando y en la ventana del navegador:

flask --app app.py --debug run