7095579900

Committed 13 Jun 2024 06:34PM UTC coverage: 93.541%. Remained the same

Build Type

push

coveralls-python

Committed by memphis-tools

Commit Message

Merge branch 'development' into 'master'

Run Details

689 of 754 branches covered (91.38%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 3 files covered. (100.0%)

9 existing lines in 2 files now uncovered.

1802 of 1909 relevant lines covered (94.39%)

0.94 hits per line

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

86.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)
                flash("[+] Flask - Ajout livre.", "info")
                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,
    )


def get_book_by_id(book_id):
    """
    Description: retrieve a book by its ID.
    """
    session = session_commands.get_a_database_session()
    query = (
        session.query(Book)
        .filter(Book.id == book_id)
        .options(joinedload(Book.book_comments))
        .options(joinedload(Book.starred))
        .first()
    )
    session.close()
    return query


@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 = get_book_by_id(book_id)
    if not a_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()
        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)
            flash("[+] Flask - Mise à jour livre.", "info")
            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!
102	new_comment = Comment(	×
103	text=form.comment_text.data, author_id=current_user.id, book_id=a_book.id
104	)
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()	×
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")	×
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!
175	flash("Type image non accepté", "error")	×
176	return redirect(url_for("index"))	×
177	if os.getenv("SCOPE") == "production":	1!
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	flash("[+] Flask - Ajout livre.", "info")	1✔
195	session.close()	1✔
196	return redirect(url_for("book_routes_blueprint.books"))	1✔
197	else:
198	flash(book_is_valid, "error")	1✔
199	session.close()	1✔
200	return render_template(	1✔
201	"add_book.html",
202	form=form,
203	is_authenticated=current_user.is_authenticated,
204	)
205	session.close()	1✔
206	return render_template(	1✔
207	"add_book.html", form=form, is_authenticated=current_user.is_authenticated
208	)
209
210
211	@book_routes_blueprint.route("/book/<int:book_id>/delete/", methods=["GET", "POST"])	1✔
212	@login_required	1✔
213	def delete_book(book_id):	1✔
214	"""
215	Description: the delete book Flask route.
216	"""
217	session = session_commands.get_a_database_session()	1✔
218	form = forms.DeleteInstanceForm()	1✔
219	book_to_delete = session.get(Book, book_id)	1✔
220	if current_user.id != book_to_delete.user_id and current_user.role != "admin":	1✔
221	logs_context = {	1✔
222	"current_user": f"{current_user.username}",
223	"book_title": book_to_delete.title,
224	}
225	log_events.log_event("[+] Flask - Suppression livre refusée.", logs_context)	1✔
226	flash("Seul l'utilisateur ayant publié le livre peut le supprimer", "error")	1✔
227	session.close()	1✔
228	return abort(403)	1✔
229	if form.validate_on_submit():	1✔
230	book_picture_name = book_to_delete.book_picture_name	1✔
231	session.delete(book_to_delete)	1✔
232	os.remove(f"{settings.INSTANCE_PATH}staticfiles/img/{book_picture_name}")	1✔
233	logs_context = {	1✔
234	"current_user": f"{current_user.username}",
235	"book_title": book_to_delete.title,
236	}
237	log_events.log_event("[+] Flask - Suppression livre.", logs_context)	1✔
238	session.commit()	1✔
239	session.close()	1✔
240	return redirect(url_for("book_routes_blueprint.books"))	1✔
241	session.close()	1✔
242	return render_template(	1✔
243	"delete_book.html",
244	form=form,
245	book_to_delete=book_to_delete,
246	is_authenticated=current_user.is_authenticated,
247	)
248
249
250	def get_book_by_id(book_id):	1✔
251	"""
252	Description: retrieve a book by its ID.
253	"""
254	session = session_commands.get_a_database_session()	1✔
255	query = (	1✔
256	session.query(Book)
257	.filter(Book.id == book_id)
258	.options(joinedload(Book.book_comments))
259	.options(joinedload(Book.starred))
260	.first()
261	)
262	session.close()	1✔
263	return query	1✔
264
265
266	@book_routes_blueprint.route("/book/<int:book_id>/update/", methods=["GET", "POST"])	1✔
267	@login_required	1✔
268	def update_book(book_id):	1✔
269	"""
270	Description: the update book Flask route.
271	"""
272	session = session_commands.get_a_database_session()	1✔
273	a_book = get_book_by_id(book_id)	1✔
274	if not a_book:	1✔
275	flash("Livre non trouvé", "error")	1✔
276	session.close()	1✔
277	return redirect(url_for("book_routes_blueprint.books"))	1✔
278
279	if current_user.id != a_book.user_id and current_user.role != "admin":	1✔
280	session.close()	1✔
281	return abort(403)	1✔
282	book_picture_filename = a_book.book_picture_name	1✔
283	books_categories_query = session.query(BookCategory).all()	1✔
284	books_categories = [(i.id, i.title) for i in books_categories_query]	1✔
285	edit_form = forms.UpdateBookForm(	1✔
286	books_categories=books_categories,
287	book=a_book,
288	)
289	if edit_form.validate_on_submit():	1✔
290	form = request.form.to_dict()	1✔
291	if "title" in form:	1!
292	title = form["title"]	1✔
293	else:
UNCOV 294	title = a_book.title	×
295	if "summary" in form:	1✔
296	summary = form["summary"]	1✔
297	else:
298	summary = a_book.summary	1✔
299	if "content" in form:	1✔
300	content = form["content"]	1✔
301	else:
302	content = a_book.content	1✔
303	if "author" in form:	1✔
304	author = form["author"]	1✔
305	else:
306	author = a_book.author	1✔
307	if "year_of_publication" in form:	1✔
308	year_of_publication = int(form["year_of_publication"])	1✔
309	else:
310	year_of_publication = a_book.year_of_publication	1✔
311	if "categories" in form:	1!
312	category_id_from_form = int(form["categories"])	1✔
313	try:	1✔
314	category_id = (	1✔
315	session.query(BookCategory)
316	.filter(BookCategory.id == category_id_from_form)
317	.first()
318	.id
319	)
320	except Exception:	×
321	flash("Saisie invalide, categorie livre non prevue.", "error")	×
UNCOV 322	return render_template(	×
323	"update_book.html",
324	form=edit_form,
325	is_authenticated=current_user.is_authenticated,
326	)
327	try:	1✔
328	book_picture = edit_form["photo"]	1✔
329	uploaded_file = request.files["photo"]	1✔
330	except Exception:	1✔
331	book_picture = None	1✔
332	if book_picture is not None:	1✔
333	filename = secure_filename(uploaded_file.filename)	1✔
334	else:
335	filename = book_picture_filename	1✔
336	publication_date = a_book.publication_date	1✔
337	updated_book = Book(	1✔
338	title=title,
339	summary=summary,
340	content=content,
341	author=author,
342	category=category_id,
343	year_of_publication=year_of_publication,
344	book_picture_name=filename,
345	publication_date=publication_date,
346	user_id=a_book.user_id,
347	)
348	if book_picture_filename != filename:	1✔
349	if filename != "":	1!
350	file_ext = os.path.splitext(filename)[1]	1✔
351	if file_ext not in settings.UPLOAD_EXTENSIONS:	1!
UNCOV 352	return "Image invalide", 400	×
353	if os.getenv("SCOPE") == "production":	1!
UNCOV 354	uploaded_file.save(	×
355	os.path.join(
356	settings.INSTANCE_PATH, "staticfiles/img", filename
357	)
358	)
359	try:	×
UNCOV 360	os.remove(	×
361	f"{settings.INSTANCE_PATH}staticfiles/img/{book_picture_filename}"
362	)
363	except FileNotFoundError:	×
UNCOV 364	pass	×
365	else:
366	updated_book.book_picture_name = "dummy_blank_book.png"	1✔
367	else:
UNCOV 368	updated_book.book_picture_name = book_picture_filename	×
369	session.query(Book).where(Book.id == book_id).update(	1✔
370	updated_book.get_json_for_update()
371	)
372	book_is_valid = check_book_fields(updated_book)	1✔
373	if book_is_valid is True:	1!
374	session.commit()	1✔
375	session.close()	1✔
376	logs_context = {	1✔
377	"current_user": f"{current_user.username}",
378	"book_title": updated_book.title,
379	}
380	log_events.log_event("[+] Flask - Mise à jour livre.", logs_context)	1✔
381	flash("[+] Flask - Mise à jour livre.", "info")	1✔
382	return redirect(url_for("book_routes_blueprint.book", book_id=book_id))	1✔
383
384	flash("Erreur avec image illustration", "error")	×
385	session.close()	×
UNCOV 386	return render_template(	×
387	"update_book.html",
388	form=edit_form,
389	is_authenticated=current_user.is_authenticated,
390	)
391	return render_template(	1✔
392	"update_book.html",
393	form=edit_form,
394	book=a_book,
395	is_authenticated=current_user.is_authenticated,
396	)

memphis-tools / dummy_fastapi_flask_blog_app / 7095579900

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