7797504062

Committed 11 Sep 2024 11:07AM UTC coverage: 89.921% (-0.5%) from 90.41%

Build Type

push

coveralls-python

Committed by memphis-tools

Commit Message

Merge branch 'development' into 'master'

Run Details

702 of 775 branches covered (90.58%)

Branch coverage included in aggregate %.

4 of 27 new or added lines in 2 files covered. (14.81%)

1 existing line in 1 file now uncovered.

1921 of 2142 relevant lines covered (89.68%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.63

/app/packages/flask_app/project/__init__.py

""" The Flask app definition.Notice we do not use the app factory pattern """

import os
import requests
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail
from flask import (
    Flask,
    url_for,
    render_template,
    flash,
    redirect,
    request,
)

from flask_bootstrap import Bootstrap
from flask_login import (
    LoginManager,
    login_user,
    logout_user,
    current_user,
)
from flask_wtf import CSRFProtect
from sqlalchemy.orm import joinedload
from werkzeug.security import generate_password_hash, check_password_hash

try:
    import handle_passwords
    import log_events
    import settings
    from database.commands import session_commands
    from database.models.models import Book, User, BookCategory
except ModuleNotFoundError:
    from app.packages import handle_passwords, log_events, settings
    from app.packages.database.commands import session_commands
    from app.packages.database.models.models import Book, User, BookCategory
from .user_routes_blueprint import user_routes_blueprint
from .stat_routes_blueprint import stat_routes_blueprint
from .book_routes_blueprint import book_routes_blueprint
from .book_category_routes_blueprint import book_category_routes_blueprint
from .comment_routes_blueprint import comment_routes_blueprint
from .quote_routes_blueprint import quote_routes_blueprint
from .shared_functions_and_decorators import get_random_books_ids
from . import forms


app = Flask(
    __name__,
    template_folder="templates",
    instance_path=settings.INSTANCE_PATH,
)
app.config.from_pyfile("config.py")
app.register_blueprint(book_routes_blueprint)
app.register_blueprint(user_routes_blueprint)
app.register_blueprint(stat_routes_blueprint)
app.register_blueprint(book_category_routes_blueprint)
app.register_blueprint(comment_routes_blueprint)
app.register_blueprint(quote_routes_blueprint)

bootstrap = Bootstrap(app)
csrf = CSRFProtect(app)
login_manager = LoginManager(app)
login_manager.init_app(app)
login_manager.login_view = "/"
login_manager.session_protection = "strong"
WTF_CSRF_SECRET_KEY = os.getenv("SECRET_KEY")
MAX_BOOKS_ON_INDEX_PAGE = 3


@login_manager.user_loader
def load_user(user_id):
    """
    Description: a default user_loader which enable the flask_login usage.
    """
    session = session_commands.get_a_database_session()
    loaded = session.get(User, user_id)
    session.close()
    return loaded


@login_manager.unauthorized_handler
def unauthorized():
    """
    Description: disable access to protected uri.
    """
    flash("Vous devez d'abord vous connecter", "error")
    return redirect(url_for("login"))


@app.errorhandler(413)
def too_large(e):
    """
    Description: custom error message when uploaded image size is too big.
    """
    return f"Taille fichier excède la limite prévue {e}", 413


@app.template_filter()
def format_datetime(value):
    """
    Description: a custom filter for date to be used in templates
    """
    # to use for an english output (import calendar)
    # formated_date = f"{calendar.month_name[int(value.strftime('%m'))]} {value.strftime('%d')} {value.strftime('%Y')}"
    formated_date = (
        f"{value.strftime('%d')}/{value.strftime('%m')}/{value.strftime('%Y')}"
    )
    return formated_date


@app.template_filter()
def format_user(user_id):
    """
    Description: a custom filter for username to be used in templates
    """
    session = session_commands.get_a_database_session()
    user = session.get(User, user_id)
    session.close()
    if current_user.is_authenticated:
        if current_user.id == user.id:
            return "vous"
    return user


@app.template_filter()
def format_book_category(book_id):
    """
    Description: a custom filter for book category to be used in templates
    """
    session = session_commands.get_a_database_session()
    category = session.get(BookCategory, book_id)
    session.close()
    return category


@app.route("/")
@app.route("/home/")
def index():
    """
    Description: the index /home, Flask route.
    """
    session = session_commands.get_a_database_session()
    ids_list = [id[0] for id in session.query(Book.id).all()]
    if len(ids_list) >= MAX_BOOKS_ON_INDEX_PAGE:
        random_ids = get_random_books_ids(ids_list, MAX_BOOKS_ON_INDEX_PAGE)
    else:
        random_ids = get_random_books_ids(ids_list, len(ids_list))
    first_books = (
        session.query(Book)
        .filter(Book.id.in_(random_ids))
        .options(joinedload(Book.book_comments))
        .options(joinedload(Book.starred))
        .all()
    )
    session.close()
    return render_template(
        "index.html", books=first_books, is_authenticated=current_user.is_authenticated
    )


@app.route("/contact/", methods=["GET", "POST"])
def contact():
    """
    Description: the contact Flask route.
    """
    form = forms.ContactForm()
    if form.validate_on_submit():
        # Retrieve hCaptcha response token from the form data
        hcaptcha_response = request.form.get('h-captcha-response')
        if not hcaptcha_response:
            flash("Veuillez valider le captcha.", "error")
            return render_template("contact.html", form=form)

        # hCaptcha verification
        hcaptcha_secret_key = app.config["HCAPTCHA_SITE_SECRET"]
        verify_url = app.config["HCAPTCHA_VERIFY_URL"]
        payload = {
            "secret": hcaptcha_secret_key,
            "response": hcaptcha_response
        }

        # Make POST request to hCaptcha API
        response = requests.post(verify_url, data=payload)
        response_json = response.json()

        if not response_json.get('success'):
            flash("Echec vérification hCaptcha, essayez de nouveau.", "error")
            return render_template(
                "contact.html",
                form=form,
                is_authenticated=current_user.is_authenticated,
            )
        username = form.name.data
        email = form.email.data
        message = form.message.data

        message = Mail(
            from_email="no-reply@dummy-ops.dev",
            to_emails=f"{os.getenv('ADMIN_EMAIL')}",
            subject="Dummy-ops contact",
            html_content=f"{username} with email {email} sent this message: {message}"
        )

        SENDGRID_API_KEY = os.getenv("SENDGRID_API_KEY")
        try:
            sg = SendGridAPIClient(os.getenv("SENDGRID_API_KEY"))
            sg.send(message)
            return render_template(
                "mail_sent.html",
                name=username,
                is_authenticated=current_user.is_authenticated,
            )
        except Exception as e:
            logs_context = {"username": f"{username}", "email": f"{email}"}
            log_events.log_event(
                f"[+] Flask - Echec envoi email: {e}", logs_context
            )
            print(f"DEBUG EMAIL NOT SENT SIR: {e}")
            return render_template(
                "mail_not_sent.html",
                name=username,
                is_authenticated=current_user.is_authenticated,
            )
    return render_template(
        "contact.html", form=form, is_authenticated=current_user.is_authenticated
    )


@app.route("/login/", methods=["GET", "POST"])
def login():
    """
    Description: the login Flask route.
    Ensure the email is well formed (in database).
    """
    session = session_commands.get_a_database_session()
    form = forms.LoginForm()
    if form.validate_on_submit():
        # Retrieve hCaptcha response token from the form data
        hcaptcha_response = request.form.get('h-captcha-response')
        if not hcaptcha_response:
            flash("Veuillez valider le captcha.", "error")
            return render_template("login.html", form=form)

        # hCaptcha verification
        hcaptcha_secret_key = app.config["HCAPTCHA_SITE_SECRET"]
        verify_url = app.config["HCAPTCHA_VERIFY_URL"]
        payload = {
            "secret": hcaptcha_secret_key,
            "response": hcaptcha_response
        }

        # Make POST request to hCaptcha API
        response = requests.post(verify_url, data=payload)
        response_json = response.json()

        if not response_json.get('success'):
            flash("Echec vérification hCaptcha, essayez de nouveau.", "error")
            session.close()
            return render_template(
                "login.html",
                form=form,
                is_authenticated=current_user.is_authenticated,
            )
        email = str(form.email.data).lower()
        username = str(form.login.data).lower()
        password = form.password.data
        user = session.query(User).filter_by(username=username).first()
        if not user or user.email != email:
            logs_context = {"username": f"{username}", "email": f"{email}"}
            log_events.log_event(
                "[+] Flask - Echec connexion à application.", logs_context
            )
            flash("Identifiants invalides", "error")
            session.close()
            return redirect(url_for("index"))

        if check_password_hash(user.hashed_password, password):
            login_user(user)
            flash(f"Vous nous avez manqué {user} 🫶")
            logs_context = {"username": f"{username}"}
            log_events.log_event("[+] Flask - Connexion à application.", logs_context)
            session.close()
            return redirect(url_for("index"))

        logs_context = {"username": f"{username}", "email": f"{email}"}
        log_events.log_event(
            "[+] Flask - Echec connexion à application. Mot de passe invalide.",
            logs_context,
        )
        flash("Mot de passe invalide", "error")
        session.close()
    return render_template(
        "login.html", form=form, is_authenticated=current_user.is_authenticated
    )


@app.route("/logout/")
def logout():
    """
    Description: the logout Flask route.
    """
    logout_user()
    flash("Vous n'êtes plus connecté 👋")
    return redirect(url_for("index"))


@app.route("/register/", methods=["GET", "POST"])
def register():
    """
    Description: the register Flask route.
    """
    session = session_commands.get_a_database_session()
    form = forms.RegisterForm()
    if form.validate_on_submit():
        # Retrieve hCaptcha response token from the form data
        hcaptcha_response = request.form.get('h-captcha-response')
        if not hcaptcha_response:
            flash("Veuillez valider le captcha.", "error")
            return render_template("register.html", form=form)

        # hCaptcha verification
        hcaptcha_secret_key = app.config["HCAPTCHA_SITE_SECRET"]
        verify_url = app.config["HCAPTCHA_VERIFY_URL"]
        payload = {
            "secret": hcaptcha_secret_key,
            "response": hcaptcha_response
        }

        # Make POST request to hCaptcha API
        response = requests.post(verify_url, data=payload)
        response_json = response.json()

        if not response_json.get('success'):
            flash("Echec vérification hCaptcha, essayez de nouveau.", "error")
            session.close()
            return render_template(
                "register.html",
                form=form,
                is_authenticated=current_user.is_authenticated,
            )

        if not handle_passwords.check_password(form.password.data):
            flash("Mot de passe trop simple, essayez de nouveau.", "error")
            session.close()
            return render_template(
                "register.html",
                form=form,
                is_authenticated=current_user.is_authenticated,
            )
        username = str(form.login.data).lower()
        hashed_password = generate_password_hash(
            form.password.data, "pbkdf2:sha256", salt_length=8
        )
        email = str(form.email.data).lower()
        user = session.query(User).filter_by(username=username).first()
        user_email = session.query(User).filter_by(email=email).first()

        if user_email:
            flash("Email existe deja en base", "error")
        elif form.password.data != form.password_check.data:
            flash("Mots de passe ne correspondent pas", "error")
        else:
            if not user:
                new_user = User(
                    username=username, hashed_password=hashed_password, email=email
                )
                session.add(new_user)
                session.commit()
                flash(f"Bienvenue {username} vous pouvez vous connecter", "info")
                logs_context = {"username": f"{username}", "email": f"{email}"}
                log_events.log_event(
                    "[+] Flask - Création compte utilisateur.", logs_context
                )
                session.close()
                return render_template(
                    "register.html",
                    form=form,
                    is_authenticated=current_user.is_authenticated,
                )
            username = str(form.login.data).lower()
            hashed_password = generate_password_hash(
                form.password.data, "pbkdf2:sha256", salt_length=8
            )
            email = str(form.email.data).lower()
            user = session.query(User).filter_by(username=username).first()
            user_email = session.query(User).filter_by(email=email).first()

            if user_email:
                flash("Email existe deja en base", "error")
            elif form.password.data != form.password_check.data:
                flash("Mots de passe ne correspondent pas", "error")
            else:
                if not user:
                    new_user = User(
                        username=username, hashed_password=hashed_password, email=email
                    )
                    session.add(new_user)
                    session.commit()
                    flash(f"Bienvenue {username} vous pouvez vous connecter", "info")
                    logs_context = {"username": f"{username}", "email": f"{email}"}
                    log_events.log_event(
                        "[+] Flask - Création compte utilisateur.", logs_context
                    )
                    session.close()
                    return redirect(url_for("login"))
                flash("Nom utilisateur existe deja, veuillez le modifier", "error")
    session.close()
    return render_template(
        "register.html", form=form, is_authenticated=current_user.is_authenticated
    )


@app.route("/ops/")
def ops():
    """
    Description: the ops Flask route.
    """
    return render_template("ops.html", is_authenticated=current_user.is_authenticated)


@app.route("/moocs/")
def moocs():
    """
    Description: the moocs Flask route.
    """
    return render_template("moocs.html", is_authenticated=current_user.is_authenticated)

1	""" The Flask app definition.Notice we do not use the app factory pattern """
2
3	import os	1✔
4	import requests	1✔
5	from sendgrid import SendGridAPIClient	1✔
6	from sendgrid.helpers.mail import Mail	1✔
7	from flask import (	1✔
8	Flask,
9	url_for,
10	render_template,
11	flash,
12	redirect,
13	request,
14	)
15
16	from flask_bootstrap import Bootstrap	1✔
17	from flask_login import (	1✔
18	LoginManager,
19	login_user,
20	logout_user,
21	current_user,
22	)
23	from flask_wtf import CSRFProtect	1✔
24	from sqlalchemy.orm import joinedload	1✔
25	from werkzeug.security import generate_password_hash, check_password_hash	1✔
26
27	try:	1✔
28	import handle_passwords	1✔
29	import log_events	×
30	import settings	×
31	from database.commands import session_commands	×
32	from database.models.models import Book, User, BookCategory	×
33	except ModuleNotFoundError:	1✔
34	from app.packages import handle_passwords, log_events, settings	1✔
35	from app.packages.database.commands import session_commands	1✔
36	from app.packages.database.models.models import Book, User, BookCategory	1✔
37	from .user_routes_blueprint import user_routes_blueprint	1✔
38	from .stat_routes_blueprint import stat_routes_blueprint	1✔
39	from .book_routes_blueprint import book_routes_blueprint	1✔
40	from .book_category_routes_blueprint import book_category_routes_blueprint	1✔
41	from .comment_routes_blueprint import comment_routes_blueprint	1✔
42	from .quote_routes_blueprint import quote_routes_blueprint	1✔
43	from .shared_functions_and_decorators import get_random_books_ids	1✔
44	from . import forms	1✔
45
46
47	app = Flask(	1✔
48	__name__,
49	template_folder="templates",
50	instance_path=settings.INSTANCE_PATH,
51	)
52	app.config.from_pyfile("config.py")	1✔
53	app.register_blueprint(book_routes_blueprint)	1✔
54	app.register_blueprint(user_routes_blueprint)	1✔
55	app.register_blueprint(stat_routes_blueprint)	1✔
56	app.register_blueprint(book_category_routes_blueprint)	1✔
57	app.register_blueprint(comment_routes_blueprint)	1✔
58	app.register_blueprint(quote_routes_blueprint)	1✔
59
60	bootstrap = Bootstrap(app)	1✔
61	csrf = CSRFProtect(app)	1✔
62	login_manager = LoginManager(app)	1✔
63	login_manager.init_app(app)	1✔
64	login_manager.login_view = "/"	1✔
65	login_manager.session_protection = "strong"	1✔
66	WTF_CSRF_SECRET_KEY = os.getenv("SECRET_KEY")	1✔
67	MAX_BOOKS_ON_INDEX_PAGE = 3	1✔
68
69
70	@login_manager.user_loader	1✔
71	def load_user(user_id):	1✔
72	"""
73	Description: a default user_loader which enable the flask_login usage.
74	"""
75	session = session_commands.get_a_database_session()	1✔
76	loaded = session.get(User, user_id)	1✔
77	session.close()	1✔
78	return loaded	1✔
79
80
81	@login_manager.unauthorized_handler	1✔
82	def unauthorized():	1✔
83	"""
84	Description: disable access to protected uri.
85	"""
86	flash("Vous devez d'abord vous connecter", "error")	1✔
87	return redirect(url_for("login"))	1✔
88
89
90	@app.errorhandler(413)	1✔
91	def too_large(e):	1✔
92	"""
93	Description: custom error message when uploaded image size is too big.
94	"""
95	return f"Taille fichier excède la limite prévue {e}", 413	1✔
96
97
98	@app.template_filter()	1✔
99	def format_datetime(value):	1✔
100	"""
101	Description: a custom filter for date to be used in templates
102	"""
103	# to use for an english output (import calendar)
104	# formated_date = f"{calendar.month_name[int(value.strftime('%m'))]} {value.strftime('%d')} {value.strftime('%Y')}"
105	formated_date = (	1✔
106	f"{value.strftime('%d')}/{value.strftime('%m')}/{value.strftime('%Y')}"
107	)
108	return formated_date	1✔
109
110
111	@app.template_filter()	1✔
112	def format_user(user_id):	1✔
113	"""
114	Description: a custom filter for username to be used in templates
115	"""
116	session = session_commands.get_a_database_session()	1✔
117	user = session.get(User, user_id)	1✔
118	session.close()	1✔
119	if current_user.is_authenticated:	1✔
120	if current_user.id == user.id:	1✔
121	return "vous"	1✔
122	return user	1✔
123
124
125	@app.template_filter()	1✔
126	def format_book_category(book_id):	1✔
127	"""
128	Description: a custom filter for book category to be used in templates
129	"""
130	session = session_commands.get_a_database_session()	1✔
131	category = session.get(BookCategory, book_id)	1✔
132	session.close()	1✔
133	return category	1✔
134
135
136	@app.route("/")	1✔
137	@app.route("/home/")	1✔
138	def index():	1✔
139	"""
140	Description: the index /home, Flask route.
141	"""
142	session = session_commands.get_a_database_session()	1✔
143	ids_list = [id[0] for id in session.query(Book.id).all()]	1✔
144	if len(ids_list) >= MAX_BOOKS_ON_INDEX_PAGE:	1!
145	random_ids = get_random_books_ids(ids_list, MAX_BOOKS_ON_INDEX_PAGE)	1✔
146	else:
147	random_ids = get_random_books_ids(ids_list, len(ids_list))	×
148	first_books = (	1✔
149	session.query(Book)
150	.filter(Book.id.in_(random_ids))
151	.options(joinedload(Book.book_comments))
152	.options(joinedload(Book.starred))
153	.all()
154	)
155	session.close()	1✔
156	return render_template(	1✔
157	"index.html", books=first_books, is_authenticated=current_user.is_authenticated
158	)
159
160
161	@app.route("/contact/", methods=["GET", "POST"])	1✔
162	def contact():	1✔
163	"""
164	Description: the contact Flask route.
165	"""
166	form = forms.ContactForm()	1✔
167	if form.validate_on_submit():	1!
168	# Retrieve hCaptcha response token from the form data
NEW 169	hcaptcha_response = request.form.get('h-captcha-response')	×
NEW 170	if not hcaptcha_response:	×
NEW 171	flash("Veuillez valider le captcha.", "error")	×
NEW 172	return render_template("contact.html", form=form)	×
173
174	# hCaptcha verification
NEW 175	hcaptcha_secret_key = app.config["HCAPTCHA_SITE_SECRET"]	×
NEW 176	verify_url = app.config["HCAPTCHA_VERIFY_URL"]	×
NEW 177	payload = {	×
178	"secret": hcaptcha_secret_key,
179	"response": hcaptcha_response
180	}
181
182	# Make POST request to hCaptcha API
NEW 183	response = requests.post(verify_url, data=payload)	×
NEW 184	response_json = response.json()	×
185
NEW 186	if not response_json.get('success'):	×
NEW 187	flash("Echec vérification hCaptcha, essayez de nouveau.", "error")	×
NEW 188	return render_template(	×
189	"contact.html",
190	form=form,
191	is_authenticated=current_user.is_authenticated,
192	)
NEW 193	username = form.name.data	×
194	email = form.email.data	×
195	message = form.message.data	×
196
NEW 197	message = Mail(	×
198	from_email="no-reply@dummy-ops.dev",
199	to_emails=f"{os.getenv('ADMIN_EMAIL')}",
200	subject="Dummy-ops contact",
201	html_content=f"{username} with email {email} sent this message: {message}"
202	)
203
NEW 204	SENDGRID_API_KEY = os.getenv("SENDGRID_API_KEY")	×
NEW 205	try:	×
NEW 206	sg = SendGridAPIClient(os.getenv("SENDGRID_API_KEY"))	×
NEW 207	sg.send(message)	×
UNCOV 208	return render_template(	×
209	"mail_sent.html",
210	name=username,
211	is_authenticated=current_user.is_authenticated,
212	)
NEW 213	except Exception as e:	×
NEW 214	logs_context = {"username": f"{username}", "email": f"{email}"}	×
NEW 215	log_events.log_event(	×
216	f"[+] Flask - Echec envoi email: {e}", logs_context
217	)
NEW 218	print(f"DEBUG EMAIL NOT SENT SIR: {e}")	×
NEW 219	return render_template(	×
220	"mail_not_sent.html",
221	name=username,
222	is_authenticated=current_user.is_authenticated,
223	)
224	return render_template(	1✔
225	"contact.html", form=form, is_authenticated=current_user.is_authenticated
226	)
227
228
229	@app.route("/login/", methods=["GET", "POST"])	1✔
230	def login():	1✔
231	"""
232	Description: the login Flask route.
233	Ensure the email is well formed (in database).
234	"""
235	session = session_commands.get_a_database_session()	1✔
236	form = forms.LoginForm()	1✔
237	if form.validate_on_submit():	1✔
238	# Retrieve hCaptcha response token from the form data
239	hcaptcha_response = request.form.get('h-captcha-response')	1✔
240	if not hcaptcha_response:	1!
241	flash("Veuillez valider le captcha.", "error")	×
242	return render_template("login.html", form=form)	×
243
244	# hCaptcha verification
245	hcaptcha_secret_key = app.config["HCAPTCHA_SITE_SECRET"]	1✔
246	verify_url = app.config["HCAPTCHA_VERIFY_URL"]	1✔
247	payload = {	1✔
248	"secret": hcaptcha_secret_key,
249	"response": hcaptcha_response
250	}
251
252	# Make POST request to hCaptcha API
253	response = requests.post(verify_url, data=payload)	1✔
254	response_json = response.json()	1✔
255
256	if not response_json.get('success'):	1!
257	flash("Echec vérification hCaptcha, essayez de nouveau.", "error")	×
258	session.close()	×
259	return render_template(	×
260	"login.html",
261	form=form,
262	is_authenticated=current_user.is_authenticated,
263	)
264	email = str(form.email.data).lower()	1✔
265	username = str(form.login.data).lower()	1✔
266	password = form.password.data	1✔
267	user = session.query(User).filter_by(username=username).first()	1✔
268	if not user or user.email != email:	1✔
269	logs_context = {"username": f"{username}", "email": f"{email}"}	1✔
270	log_events.log_event(	1✔
271	"[+] Flask - Echec connexion à application.", logs_context
272	)
273	flash("Identifiants invalides", "error")	1✔
274	session.close()	1✔
275	return redirect(url_for("index"))	1✔
276
277	if check_password_hash(user.hashed_password, password):	1✔
278	login_user(user)	1✔
279	flash(f"Vous nous avez manqué {user} 🫶")	1✔
280	logs_context = {"username": f"{username}"}	1✔
281	log_events.log_event("[+] Flask - Connexion à application.", logs_context)	1✔
282	session.close()	1✔
283	return redirect(url_for("index"))	1✔
284
285	logs_context = {"username": f"{username}", "email": f"{email}"}	1✔
286	log_events.log_event(	1✔
287	"[+] Flask - Echec connexion à application. Mot de passe invalide.",
288	logs_context,
289	)
290	flash("Mot de passe invalide", "error")	1✔
291	session.close()	1✔
292	return render_template(	1✔
293	"login.html", form=form, is_authenticated=current_user.is_authenticated
294	)
295
296
297	@app.route("/logout/")	1✔
298	def logout():	1✔
299	"""
300	Description: the logout Flask route.
301	"""
302	logout_user()	1✔
303	flash("Vous n'êtes plus connecté 👋")	1✔
304	return redirect(url_for("index"))	1✔
305
306
307	@app.route("/register/", methods=["GET", "POST"])	1✔
308	def register():	1✔
309	"""
310	Description: the register Flask route.
311	"""
312	session = session_commands.get_a_database_session()	1✔
313	form = forms.RegisterForm()	1✔
314	if form.validate_on_submit():	1✔
315	# Retrieve hCaptcha response token from the form data
316	hcaptcha_response = request.form.get('h-captcha-response')	1✔
317	if not hcaptcha_response:	1!
318	flash("Veuillez valider le captcha.", "error")	×
319	return render_template("register.html", form=form)	×
320
321	# hCaptcha verification
322	hcaptcha_secret_key = app.config["HCAPTCHA_SITE_SECRET"]	1✔
323	verify_url = app.config["HCAPTCHA_VERIFY_URL"]	1✔
324	payload = {	1✔
325	"secret": hcaptcha_secret_key,
326	"response": hcaptcha_response
327	}
328
329	# Make POST request to hCaptcha API
330	response = requests.post(verify_url, data=payload)	1✔
331	response_json = response.json()	1✔
332
333	if not response_json.get('success'):	1!
334	flash("Echec vérification hCaptcha, essayez de nouveau.", "error")	×
335	session.close()	×
336	return render_template(	×
337	"register.html",
338	form=form,
339	is_authenticated=current_user.is_authenticated,
340	)
341
342	if not handle_passwords.check_password(form.password.data):	1!
343	flash("Mot de passe trop simple, essayez de nouveau.", "error")	×
344	session.close()	×
345	return render_template(	×
346	"register.html",
347	form=form,
348	is_authenticated=current_user.is_authenticated,
349	)
350	username = str(form.login.data).lower()	1✔
351	hashed_password = generate_password_hash(	1✔
352	form.password.data, "pbkdf2:sha256", salt_length=8
353	)
354	email = str(form.email.data).lower()	1✔
355	user = session.query(User).filter_by(username=username).first()	1✔
356	user_email = session.query(User).filter_by(email=email).first()	1✔
357
358	if user_email:	1✔
359	flash("Email existe deja en base", "error")	1✔
360	elif form.password.data != form.password_check.data:	1✔
361	flash("Mots de passe ne correspondent pas", "error")	1✔
362	else:
363	if not user:	1✔
364	new_user = User(	1✔
365	username=username, hashed_password=hashed_password, email=email
366	)
367	session.add(new_user)	1✔
368	session.commit()	1✔
369	flash(f"Bienvenue {username} vous pouvez vous connecter", "info")	1✔
370	logs_context = {"username": f"{username}", "email": f"{email}"}	1✔
371	log_events.log_event(	1✔
372	"[+] Flask - Création compte utilisateur.", logs_context
373	)
374	session.close()	1✔
375	return render_template(	1✔
376	"register.html",
377	form=form,
378	is_authenticated=current_user.is_authenticated,
379	)
380	username = str(form.login.data).lower()	1✔
381	hashed_password = generate_password_hash(	1✔
382	form.password.data, "pbkdf2:sha256", salt_length=8
383	)
384	email = str(form.email.data).lower()	1✔
385	user = session.query(User).filter_by(username=username).first()	1✔
386	user_email = session.query(User).filter_by(email=email).first()	1✔
387
388	if user_email:	1!
389	flash("Email existe deja en base", "error")	×
390	elif form.password.data != form.password_check.data:	1!
391	flash("Mots de passe ne correspondent pas", "error")	×
392	else:
393	if not user:	1!
394	new_user = User(	×
395	username=username, hashed_password=hashed_password, email=email
396	)
397	session.add(new_user)	×
398	session.commit()	×
399	flash(f"Bienvenue {username} vous pouvez vous connecter", "info")	×
400	logs_context = {"username": f"{username}", "email": f"{email}"}	×
401	log_events.log_event(	×
402	"[+] Flask - Création compte utilisateur.", logs_context
403	)
404	session.close()	×
405	return redirect(url_for("login"))	×
406	flash("Nom utilisateur existe deja, veuillez le modifier", "error")	1✔
407	session.close()	1✔
408	return render_template(	1✔
409	"register.html", form=form, is_authenticated=current_user.is_authenticated
410	)
411
412
413	@app.route("/ops/")	1✔
414	def ops():	1✔
415	"""
416	Description: the ops Flask route.
417	"""
418	return render_template("ops.html", is_authenticated=current_user.is_authenticated)	1✔
419
420
421	@app.route("/moocs/")	1✔
422	def moocs():	1✔
423	"""
424	Description: the moocs Flask route.
425	"""
426	return render_template("moocs.html", is_authenticated=current_user.is_authenticated)	1✔

memphis-tools / dummy_fastapi_flask_blog_app / 7797504062

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous