6994028358

Committed 01 Jun 2024 12:19AM UTC coverage: 88.256%. Remained the same

Build Type

push

coveralls-python

Committed by memphis-tools

Commit Message

Merge branch 'development' into 'master'

Run Details

790 of 884 branches covered (89.37%)

Branch coverage included in aggregate %.

8 of 9 new or added lines in 1 file covered. (88.89%)

21 existing lines in 1 file now uncovered.

1660 of 1892 relevant lines covered (87.74%)

0.88 hits per line

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

83.14

/app/packages/flask_app/project/book_routes_blueprint.py

""" The Book blueprint routes """

import os
from flask import (
    Blueprint,
    url_for,
    render_template,
    flash,
    abort,
    redirect,
    request,
)
from flask_login import (
    current_user,
    login_required,
)
from sqlalchemy.orm import joinedload
from werkzeug.utils import secure_filename

from app.packages import log_events, settings
from app.packages.database.commands import session_commands
from app.packages.database.models.models import (
    Book,
    BookCategory,
    Comment,
    Starred,
)
from . import forms
from .shared_functions_and_decorators import (
    return_pagination,
    return_random_quote,
    check_book_fields,
)


book_routes_blueprint = Blueprint("book_routes_blueprint", __name__)


@book_routes_blueprint.route("/books/")
def books():
    """
    Description: the books Flask route.
    """
    session = session_commands.get_a_database_session()
    all_books = (
        session.query(Book)
        .order_by(Book.id)
        .options(joinedload(Book.book_comments))
        .options(joinedload(Book.starred))
        .all()
    )
    session.close()
    total_books = len(all_books)
    items, page, per_page, total_pages = return_pagination(all_books)
    random_quote = return_random_quote()
    return render_template(
        "books.html",
        random_quote=random_quote,
        books=items,
        page=page,
        total_books=total_books,
        per_page=per_page,
        total_pages=total_pages,
        is_authenticated=current_user.is_authenticated,
    )


@book_routes_blueprint.route("/book/<int:book_id>/", methods=["GET", "POST"])
@login_required
def book(book_id):
    """
    Description: the book Flask route.
    """
    session = session_commands.get_a_database_session()
    delete_book_form = forms.DeleteInstanceForm()
    form = forms.CommentForm()
    a_book = (
        session.query(Book)
        .filter(Book.id == book_id)
        .options(joinedload(Book.book_comments))
        .options(joinedload(Book.starred))
        .first()
    )

    comments = session.query(Comment).filter_by(book_id=a_book.id).all()

    user_starred_books_id_list = (
        session.query(Starred)
        .filter(Starred.user_id == current_user.id)
        .with_entities(Starred.book_id)
        .all()
    )

    logs_context = {
        "current_user": f"{current_user.username}",
        "book_id": book_id,
        "book_title": a_book.title,
    }
    log_events.log_event("[+] Flask - Consultation livre.", logs_context)

    if form.validate_on_submit():
        new_comment = Comment(
            text=form.comment_text.data, author_id=current_user.id, book_id=a_book.id
        )
        logs_context = {
            "current_user": f"{current_user.username}",
            "book_title": a_book.title,
        }
        log_events.log_event("[+] Flask - Ajout commentaire.", logs_context)
        session.add(new_comment)
        session.commit()
        session.close()
        return redirect(url_for("book_routes_blueprint.books"))

    session.close()
    return render_template(
        "book.html",
        book=a_book,
        user_starred_books_id_list=user_starred_books_id_list,
        form=form,
        delete_book_form=delete_book_form,
        comments=comments,
        is_authenticated=current_user.is_authenticated,
    )


@book_routes_blueprint.route("/books/add/", methods=["GET", "POST"])
@login_required
def add_book():
    """
    Description: the add book Flask route.
    """
    session = session_commands.get_a_database_session()
    books_categories_query = session.query(BookCategory).all()
    books_categories = [(i.id, i.title) for i in books_categories_query]
    form = forms.BookForm(books_categories=books_categories)
    if form.validate_on_submit():
        title = form.title.data
        summary = form.summary.data
        content = form.content.data
        author = form.author.data
        category_id_from_form = int(form.categories.data[0])
        try:
            category_id = (
                session.query(BookCategory)
                .filter(BookCategory.id == category_id_from_form)
                .first()
                .id
            )
        except Exception:
            flash("Saisie invalide, categorie livre non prevue.", "error")
            return render_template(
                "add_book.html",
                form=form,
                is_authenticated=current_user.is_authenticated,
            )
        year_of_publication = form.year_of_publication.data
        book_picture = form.photo.data
        filename = secure_filename(book_picture.filename)
        new_book = Book(
            title=title,
            summary=summary,
            content=content,
            author=author,
            category=category_id,
            year_of_publication=year_of_publication,
            book_picture_name=filename,
            user_id=current_user.get_id(),
        )
        book_is_valid = check_book_fields(new_book)
        if book_is_valid is True:
            if filename != "":
                file_ext = os.path.splitext(filename)[1]
                if file_ext not in settings.UPLOAD_EXTENSIONS:
                    flash("Type image non accepté", "error")
                    return redirect(url_for("index"))
                if os.getenv("SCOPE") == "production":
                    book_picture.save(
                        os.path.join(
                            settings.INSTANCE_PATH, "staticfiles/img", filename
                        )
                    )
                else:
                    new_book.book_picture_name = "dummy_blank_book.png"
                session.add(new_book)
                session.commit()
                session.refresh(new_book)
                session.commit()
                logs_context = {
                    "current_user": f"{current_user.username}",
                    "book_title": new_book.title,
                }
                log_events.log_event("[+] Flask - Ajout livre.", logs_context)
                session.close()
                return redirect(url_for("book_routes_blueprint.books"))
        else:
            flash(book_is_valid, "error")
            session.close()
            return render_template(
                "add_book.html",
                form=form,
                is_authenticated=current_user.is_authenticated,
            )
    session.close()
    return render_template(
        "add_book.html", form=form, is_authenticated=current_user.is_authenticated
    )


@book_routes_blueprint.route("/book/<int:book_id>/delete/", methods=["GET", "POST"])
@login_required
def delete_book(book_id):
    """
    Description: the delete book Flask route.
    """
    session = session_commands.get_a_database_session()
    form = forms.DeleteInstanceForm()
    book_to_delete = session.get(Book, book_id)
    if current_user.id != book_to_delete.user_id and current_user.role != "admin":
        logs_context = {
            "current_user": f"{current_user.username}",
            "book_title": book_to_delete.title,
        }
        log_events.log_event("[+] Flask - Suppression livre refusée.", logs_context)
        flash("Seul l'utilisateur ayant publié le livre peut le supprimer", "error")
        session.close()
        return abort(403)
    if form.validate_on_submit():
        book_picture_name = book_to_delete.book_picture_name
        session.delete(book_to_delete)
        os.remove(f"{settings.INSTANCE_PATH}staticfiles/img/{book_picture_name}")
        logs_context = {
            "current_user": f"{current_user.username}",
            "book_title": book_to_delete.title,
        }
        log_events.log_event("[+] Flask - Suppression livre.", logs_context)
        session.commit()
        session.close()
        return redirect(url_for("book_routes_blueprint.books"))
    session.close()
    return render_template(
        "delete_book.html",
        form=form,
        book_to_delete=book_to_delete,
        is_authenticated=current_user.is_authenticated,
    )


@book_routes_blueprint.route("/book/<int:book_id>/update/", methods=["GET", "POST"])
@login_required
def update_book(book_id):
    """
    Description: the update book Flask route.
    """
    session = session_commands.get_a_database_session()
    a_book = (
        session.query(Book)
        .filter(Book.id.in_([book_id]))
        .options(joinedload(Book.book_comments))
        .options(joinedload(Book.starred))
        .first()
    )
    if not book:
        flash("Livre non trouvé", "error")
        session.close()
        return redirect(url_for("book_routes_blueprint.books"))

    if current_user.id != a_book.user_id and current_user.role != "admin":
        session.close()
        return abort(403)
    book_picture_filename = a_book.book_picture_name
    books_categories_query = session.query(BookCategory).all()
    books_categories = [(i.id, i.title) for i in books_categories_query]
    edit_form = forms.UpdateBookForm(
        books_categories=books_categories,
        book=a_book,
    )
    if edit_form.validate_on_submit():
        form = request.form.to_dict()
        form_file = request.files.to_dict
        if "title" in form:
            title = form["title"]
        else:
            title = a_book.title
        if "summary" in form:
            summary = form["summary"]
        else:
            summary = a_book.summary
        if "content" in form:
            content = form["content"]
        else:
            content = a_book.content
        if "author" in form:
            author = form["author"]
        else:
            author = a_book.author
        if "year_of_publication" in form:
            year_of_publication = int(form["year_of_publication"])
        else:
            year_of_publication = a_book.year_of_publication
        if "categories" in form:
            category_id_from_form = int(form["categories"])
            try:
                category_id = (
                    session.query(BookCategory)
                    .filter(BookCategory.id == category_id_from_form)
                    .first()
                    .id
                )
            except Exception:
                flash("Saisie invalide, categorie livre non prevue.", "error")
                return render_template(
                    "update_book.html",
                    form=edit_form,
                    is_authenticated=current_user.is_authenticated,
                )
        try:
            book_picture = edit_form["photo"]
            uploaded_file = request.files["photo"]
        except Exception:
            book_picture = None
        if book_picture is not None:
            filename = secure_filename(uploaded_file.filename)
        else:
            filename = book_picture_filename
        publication_date = a_book.publication_date
        updated_book = Book(
            title=title,
            summary=summary,
            content=content,
            author=author,
            category=category_id,
            year_of_publication=year_of_publication,
            book_picture_name=filename,
            publication_date=publication_date,
            user_id=a_book.user_id,
        )
        if book_picture_filename != filename:
            if filename != "":
                file_ext = os.path.splitext(filename)[1]
                if file_ext not in settings.UPLOAD_EXTENSIONS:
                    return "Image invalide", 400
                if os.getenv("SCOPE") == "production":
                    uploaded_file.save(
                        os.path.join(
                            settings.INSTANCE_PATH, "staticfiles/img", filename
                        )
                    )
                    try:
                        os.remove(
                            f"{settings.INSTANCE_PATH}staticfiles/img/{book_picture_filename}"
                        )
                    except FileNotFoundError:
                        pass
                else:
                    updated_book.book_picture_name = "dummy_blank_book.png"
            else:
                updated_book.book_picture_name = book_picture_filename
        session.query(Book).where(Book.id == book_id).update(
            updated_book.get_json_for_update()
        )
        book_is_valid = check_book_fields(updated_book)
        if book_is_valid is True:
            session.commit()
            session.close()
            logs_context = {
                "current_user": f"{current_user.username}",
                "book_title": updated_book.title,
            }
            log_events.log_event("[+] Flask - Mise à jour livre.", logs_context)
            return redirect(url_for("book_routes_blueprint.book", book_id=book_id))

        flash("Erreur avec image illustration", "error")
        session.close()
        return render_template(
            "update_book.html",
            form=edit_form,
            is_authenticated=current_user.is_authenticated,
        )
    return render_template(
        "update_book.html",
        form=edit_form,
        book=a_book,
        is_authenticated=current_user.is_authenticated,
    )

1	""" The Book blueprint routes """
2
3	import os	1✔
4	from flask import (	1✔
5	Blueprint,
6	url_for,
7	render_template,
8	flash,
9	abort,
10	redirect,
11	request,
12	)
13	from flask_login import (	1✔
14	current_user,
15	login_required,
16	)
17	from sqlalchemy.orm import joinedload	1✔
18	from werkzeug.utils import secure_filename	1✔
19
20	from app.packages import log_events, settings	1✔
21	from app.packages.database.commands import session_commands	1✔
22	from app.packages.database.models.models import (	1✔
23	Book,
24	BookCategory,
25	Comment,
26	Starred,
27	)
28	from . import forms	1✔
29	from .shared_functions_and_decorators import (	1✔
30	return_pagination,
31	return_random_quote,
32	check_book_fields,
33	)
34
35
36	book_routes_blueprint = Blueprint("book_routes_blueprint", __name__)	1✔
37
38
39	@book_routes_blueprint.route("/books/")	1✔
40	def books():	1✔
41	"""
42	Description: the books Flask route.
43	"""
44	session = session_commands.get_a_database_session()	1✔
45	all_books = (	1✔
46	session.query(Book)
47	.order_by(Book.id)
48	.options(joinedload(Book.book_comments))
49	.options(joinedload(Book.starred))
50	.all()
51	)
52	session.close()	1✔
53	total_books = len(all_books)	1✔
54	items, page, per_page, total_pages = return_pagination(all_books)	1✔
55	random_quote = return_random_quote()	1✔
56	return render_template(	1✔
57	"books.html",
58	random_quote=random_quote,
59	books=items,
60	page=page,
61	total_books=total_books,
62	per_page=per_page,
63	total_pages=total_pages,
64	is_authenticated=current_user.is_authenticated,
65	)
66
67
68	@book_routes_blueprint.route("/book/<int:book_id>/", methods=["GET", "POST"])	1✔
69	@login_required	1✔
70	def book(book_id):	1✔
71	"""
72	Description: the book Flask route.
73	"""
74	session = session_commands.get_a_database_session()	1✔
75	delete_book_form = forms.DeleteInstanceForm()	1✔
76	form = forms.CommentForm()	1✔
77	a_book = (	1✔
78	session.query(Book)
79	.filter(Book.id == book_id)
80	.options(joinedload(Book.book_comments))
81	.options(joinedload(Book.starred))
82	.first()
83	)
84
85	comments = session.query(Comment).filter_by(book_id=a_book.id).all()	1✔
86
87	user_starred_books_id_list = (	1✔
88	session.query(Starred)
89	.filter(Starred.user_id == current_user.id)
90	.with_entities(Starred.book_id)
91	.all()
92	)
93
94	logs_context = {	1✔
95	"current_user": f"{current_user.username}",
96	"book_id": book_id,
97	"book_title": a_book.title,
98	}
99	log_events.log_event("[+] Flask - Consultation livre.", logs_context)	1✔
100
101	if form.validate_on_submit():	1!
UNCOV 102	new_comment = Comment(	×
103	text=form.comment_text.data, author_id=current_user.id, book_id=a_book.id
104	)
UNCOV 105	logs_context = {	×
106	"current_user": f"{current_user.username}",
107	"book_title": a_book.title,
108	}
109	log_events.log_event("[+] Flask - Ajout commentaire.", logs_context)	×
110	session.add(new_comment)	×
111	session.commit()	×
112	session.close()	×
UNCOV 113	return redirect(url_for("book_routes_blueprint.books"))	×
114
115	session.close()	1✔
116	return render_template(	1✔
117	"book.html",
118	book=a_book,
119	user_starred_books_id_list=user_starred_books_id_list,
120	form=form,
121	delete_book_form=delete_book_form,
122	comments=comments,
123	is_authenticated=current_user.is_authenticated,
124	)
125
126
127	@book_routes_blueprint.route("/books/add/", methods=["GET", "POST"])	1✔
128	@login_required	1✔
129	def add_book():	1✔
130	"""
131	Description: the add book Flask route.
132	"""
133	session = session_commands.get_a_database_session()	1✔
134	books_categories_query = session.query(BookCategory).all()	1✔
135	books_categories = [(i.id, i.title) for i in books_categories_query]	1✔
136	form = forms.BookForm(books_categories=books_categories)	1✔
137	if form.validate_on_submit():	1✔
138	title = form.title.data	1✔
139	summary = form.summary.data	1✔
140	content = form.content.data	1✔
141	author = form.author.data	1✔
142	category_id_from_form = int(form.categories.data[0])	1✔
143	try:	1✔
144	category_id = (	1✔
145	session.query(BookCategory)
146	.filter(BookCategory.id == category_id_from_form)
147	.first()
148	.id
149	)
150	except Exception:	×
151	flash("Saisie invalide, categorie livre non prevue.", "error")	×
UNCOV 152	return render_template(	×
153	"add_book.html",
154	form=form,
155	is_authenticated=current_user.is_authenticated,
156	)
157	year_of_publication = form.year_of_publication.data	1✔
158	book_picture = form.photo.data	1✔
159	filename = secure_filename(book_picture.filename)	1✔
160	new_book = Book(	1✔
161	title=title,
162	summary=summary,
163	content=content,
164	author=author,
165	category=category_id,
166	year_of_publication=year_of_publication,
167	book_picture_name=filename,
168	user_id=current_user.get_id(),
169	)
170	book_is_valid = check_book_fields(new_book)	1✔
171	if book_is_valid is True:	1✔
172	if filename != "":	1!
173	file_ext = os.path.splitext(filename)[1]	1✔
174	if file_ext not in settings.UPLOAD_EXTENSIONS:	1!
UNCOV 175	flash("Type image non accepté", "error")	×
176	return redirect(url_for("index"))	×
177	if os.getenv("SCOPE") == "production":	1!
UNCOV 178	book_picture.save(	×
179	os.path.join(
180	settings.INSTANCE_PATH, "staticfiles/img", filename
181	)
182	)
183	else:
184	new_book.book_picture_name = "dummy_blank_book.png"	1✔
185	session.add(new_book)	1✔
186	session.commit()	1✔
187	session.refresh(new_book)	1✔
188	session.commit()	1✔
189	logs_context = {	1✔
190	"current_user": f"{current_user.username}",
191	"book_title": new_book.title,
192	}
193	log_events.log_event("[+] Flask - Ajout livre.", logs_context)	1✔
194	session.close()	1✔
195	return redirect(url_for("book_routes_blueprint.books"))	1✔
196	else:
197	flash(book_is_valid, "error")	1✔
198	session.close()	1✔
199	return render_template(	1✔
200	"add_book.html",
201	form=form,
202	is_authenticated=current_user.is_authenticated,
203	)
204	session.close()	1✔
205	return render_template(	1✔
206	"add_book.html", form=form, is_authenticated=current_user.is_authenticated
207	)
208
209
210	@book_routes_blueprint.route("/book/<int:book_id>/delete/", methods=["GET", "POST"])	1✔
211	@login_required	1✔
212	def delete_book(book_id):	1✔
213	"""
214	Description: the delete book Flask route.
215	"""
216	session = session_commands.get_a_database_session()	1✔
217	form = forms.DeleteInstanceForm()	1✔
218	book_to_delete = session.get(Book, book_id)	1✔
219	if current_user.id != book_to_delete.user_id and current_user.role != "admin":	1✔
220	logs_context = {	1✔
221	"current_user": f"{current_user.username}",
222	"book_title": book_to_delete.title,
223	}
224	log_events.log_event("[+] Flask - Suppression livre refusée.", logs_context)	1✔
225	flash("Seul l'utilisateur ayant publié le livre peut le supprimer", "error")	1✔
226	session.close()	1✔
227	return abort(403)	1✔
228	if form.validate_on_submit():	1!
229	book_picture_name = book_to_delete.book_picture_name	1✔
230	session.delete(book_to_delete)	1✔
231	os.remove(f"{settings.INSTANCE_PATH}staticfiles/img/{book_picture_name}")	1✔
232	logs_context = {	1✔
233	"current_user": f"{current_user.username}",
234	"book_title": book_to_delete.title,
235	}
236	log_events.log_event("[+] Flask - Suppression livre.", logs_context)	1✔
237	session.commit()	1✔
238	session.close()	1✔
239	return redirect(url_for("book_routes_blueprint.books"))	1✔
UNCOV 240	session.close()	×
UNCOV 241	return render_template(	×
242	"delete_book.html",
243	form=form,
244	book_to_delete=book_to_delete,
245	is_authenticated=current_user.is_authenticated,
246	)
247
248
249	@book_routes_blueprint.route("/book/<int:book_id>/update/", methods=["GET", "POST"])	1✔
250	@login_required	1✔
251	def update_book(book_id):	1✔
252	"""
253	Description: the update book Flask route.
254	"""
255	session = session_commands.get_a_database_session()	1✔
256	a_book = (	1✔
257	session.query(Book)
258	.filter(Book.id.in_([book_id]))
259	.options(joinedload(Book.book_comments))
260	.options(joinedload(Book.starred))
261	.first()
262	)
263	if not book:	1!
UNCOV 264	flash("Livre non trouvé", "error")	×
UNCOV 265	session.close()	×
UNCOV 266	return redirect(url_for("book_routes_blueprint.books"))	×
267
268	if current_user.id != a_book.user_id and current_user.role != "admin":	1✔
269	session.close()	1✔
270	return abort(403)	1✔
271	book_picture_filename = a_book.book_picture_name	1✔
272	books_categories_query = session.query(BookCategory).all()	1✔
273	books_categories = [(i.id, i.title) for i in books_categories_query]	1✔
274	edit_form = forms.UpdateBookForm(	1✔
275	books_categories=books_categories,
276	book=a_book,
277	)
278	if edit_form.validate_on_submit():	1✔
279	form = request.form.to_dict()	1✔
280	form_file = request.files.to_dict	1✔
281	if "title" in form:	1!
282	title = form["title"]	1✔
283	else:
NEW 284	title = a_book.title	×
285	if "summary" in form:	1✔
286	summary = form["summary"]	1✔
287	else:
288	summary = a_book.summary	1✔
289	if "content" in form:	1✔
290	content = form["content"]	1✔
291	else:
292	content = a_book.content	1✔
293	if "author" in form:	1✔
294	author = form["author"]	1✔
295	else:
296	author = a_book.author	1✔
297	if "year_of_publication" in form:	1✔
298	year_of_publication = int(form["year_of_publication"])	1✔
299	else:
300	year_of_publication = a_book.year_of_publication	1✔
301	if "categories" in form:	1!
302	category_id_from_form = int(form["categories"])	1✔
303	try:	1✔
304	category_id = (	1✔
305	session.query(BookCategory)
306	.filter(BookCategory.id == category_id_from_form)
307	.first()
308	.id
309	)
UNCOV 310	except Exception:	×
UNCOV 311	flash("Saisie invalide, categorie livre non prevue.", "error")	×
UNCOV 312	return render_template(	×
313	"update_book.html",
314	form=edit_form,
315	is_authenticated=current_user.is_authenticated,
316	)
317	try:	1✔
318	book_picture = edit_form["photo"]	1✔
319	uploaded_file = request.files["photo"]	1✔
320	except Exception:	1✔
321	book_picture = None	1✔
322	if book_picture is not None:	1✔
323	filename = secure_filename(uploaded_file.filename)	1✔
324	else:
325	filename = book_picture_filename	1✔
326	publication_date = a_book.publication_date	1✔
327	updated_book = Book(	1✔
328	title=title,
329	summary=summary,
330	content=content,
331	author=author,
332	category=category_id,
333	year_of_publication=year_of_publication,
334	book_picture_name=filename,
335	publication_date=publication_date,
336	user_id=a_book.user_id,
337	)
338	if book_picture_filename != filename:	1✔
339	if filename != "":	1!
340	file_ext = os.path.splitext(filename)[1]	1✔
341	if file_ext not in settings.UPLOAD_EXTENSIONS:	1!
UNCOV 342	return "Image invalide", 400	×
343	if os.getenv("SCOPE") == "production":	1!
UNCOV 344	uploaded_file.save(	×
345	os.path.join(
346	settings.INSTANCE_PATH, "staticfiles/img", filename
347	)
348	)
349	try:	×
350	os.remove(	×
351	f"{settings.INSTANCE_PATH}staticfiles/img/{book_picture_filename}"
352	)
UNCOV 353	except FileNotFoundError:	×
354	pass	×
355	else:
356	updated_book.book_picture_name = "dummy_blank_book.png"	1✔
357	else:
UNCOV 358	updated_book.book_picture_name = book_picture_filename	×
359	session.query(Book).where(Book.id == book_id).update(	1✔
360	updated_book.get_json_for_update()
361	)
362	book_is_valid = check_book_fields(updated_book)	1✔
363	if book_is_valid is True:	1!
364	session.commit()	1✔
365	session.close()	1✔
366	logs_context = {	1✔
367	"current_user": f"{current_user.username}",
368	"book_title": updated_book.title,
369	}
370	log_events.log_event("[+] Flask - Mise à jour livre.", logs_context)	1✔
371	return redirect(url_for("book_routes_blueprint.book", book_id=book_id))	1✔
372
UNCOV 373	flash("Erreur avec image illustration", "error")	×
UNCOV 374	session.close()	×
UNCOV 375	return render_template(	×
376	"update_book.html",
377	form=edit_form,
378	is_authenticated=current_user.is_authenticated,
379	)
380	return render_template(	1✔
381	"update_book.html",
382	form=edit_form,
383	book=a_book,
384	is_authenticated=current_user.is_authenticated,
385	)

memphis-tools / dummy_fastapi_flask_blog_app / 6994028358

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