diff options
Diffstat (limited to 'webmentions_ssg/views/received.py')
| -rw-r--r-- | webmentions_ssg/views/received.py | 391 |
1 files changed, 391 insertions, 0 deletions
diff --git a/webmentions_ssg/views/received.py b/webmentions_ssg/views/received.py new file mode 100644 index 0000000..7d633ab --- /dev/null +++ b/webmentions_ssg/views/received.py @@ -0,0 +1,391 @@ +# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me> +# +# SPDX-License-Identifier: BSD-3-Clause + +"""Authenticated views for received Webmentions.""" + +import uuid +from datetime import UTC, date, datetime, time +from http import HTTPStatus +from typing import TypedDict, cast + +import sqlalchemy as sa +from flask import abort, current_app, flash, redirect, render_template, request, url_for +from flask.typing import ResponseReturnValue +from flask_login import login_required + +from ..db_helpers import rows_affected +from ..extensions import db +from ..forms.admin import ConfirmActionForm +from ..forms.received import ( + RECEIVED_STATUS_CHOICES, + ReceivedWebmentionFilterForm, + default_received_page_size, +) +from ..models.received import ReceivedWebmention, ReceivedWebmentionStatus +from ..moderation_policy import domain_from_url +from ..tasks.verification import verify_webmention +from .blueprint import webmentions_bp +from .moderation import block_domains + +RECEIVED_STATUS_FILTERS = { + "pending": (ReceivedWebmentionStatus.RECEIVED,), + "verifying": (ReceivedWebmentionStatus.VERIFYING,), + "verified": (ReceivedWebmentionStatus.VERIFIED,), + "declined": ( + ReceivedWebmentionStatus.FAILED, + ReceivedWebmentionStatus.SOURCE_REMOVED, + ), +} + + +class ReceivedFilterArgs(TypedDict, total=False): + """Validated received-list query parameters; keys match GET form fields.""" + + status: str + q: str + date_from: str + date_to: str + sort: str + order: str + per_page: str + + +def received_filter_form() -> ReceivedWebmentionFilterForm: + """Validate query-string filters without requiring CSRF on the GET form.""" + form = ReceivedWebmentionFilterForm(formdata=request.args, meta={"csrf": False}) + if not form.validate(): + abort(HTTPStatus.BAD_REQUEST) + form.q.data = (form.q.data or "").strip() + return form + + +def received_filter_args(form: ReceivedWebmentionFilterForm) -> ReceivedFilterArgs: + """Serialize non-default form fields registered in ``ReceivedFilterArgs``.""" + values: dict[str, str] = {} + for name in ReceivedFilterArgs.__annotations__: + field = form[name] + value = field.data + default = field.default() if callable(field.default) else field.default + if value is None or value == "" or value == default: + continue + values[name] = value.isoformat() if isinstance(value, date) else str(value) + # TypedDict keys are dynamic because this function iterates its annotations. + return cast(ReceivedFilterArgs, values) + + +@webmentions_bp.route("/received") +@login_required +def received_list() -> ResponseReturnValue: + """Display received Webmentions. + + :returns: Rendered page containing the paginated received Webmentions. + """ + filters = received_filter_args(received_filter_form()) + + query = sa.select(ReceivedWebmention) + + if status := filters.get("status"): + query = query.where( + ReceivedWebmention.status.in_(RECEIVED_STATUS_FILTERS[status]) + ) + + if text := filters.get("q"): + query = query.where( + sa.or_( + ReceivedWebmention.source.icontains(text, autoescape=True), + ReceivedWebmention.target.icontains(text, autoescape=True), + ) + ) + + if start := filters.get("date_from"): + query = query.where( + ReceivedWebmention.updated_at + >= datetime.combine(date.fromisoformat(start), time.min, UTC) + ) + + if end := filters.get("date_to"): + query = query.where( + ReceivedWebmention.updated_at + <= datetime.combine(date.fromisoformat(end), time.max, UTC) + ) + + # Keep both declined lifecycle states together when sorting by status. + # UUID is a unique tie-breaker for stable pagination. + status_rank = sa.case( + (ReceivedWebmention.status == ReceivedWebmentionStatus.RECEIVED, 0), + (ReceivedWebmention.status == ReceivedWebmentionStatus.VERIFYING, 1), + (ReceivedWebmention.status == ReceivedWebmentionStatus.VERIFIED, 2), + else_=3, + ) + sort_columns = { + "received": ReceivedWebmention.uuid, + "updated": ReceivedWebmention.updated_at, + "status": status_rank, + "source": ReceivedWebmention.source, + "target": ReceivedWebmention.target, + } + + sort_key = filters.get("sort", "received") + sort_order = filters.get("order", "desc") + + column = sort_columns[sort_key] + ordering = column.asc() if sort_order == "asc" else column.desc() + + query = query.order_by(ordering) + + if sort_key != "received": + query = query.order_by(ReceivedWebmention.uuid.desc()) + + page_size = int(filters.get("per_page", default_received_page_size())) + webmentions = db.paginate( + query, + per_page=page_size, + max_per_page=current_app.config["RECEIVED_MAX_PAGE_SIZE"], + ) + + sort_urls = {} + for key in sort_columns: + if key == sort_key: + next_order = "asc" if sort_order == "desc" else "desc" + else: + next_order = "asc" if key in ("status", "source", "target") else "desc" + + sort_filters: ReceivedFilterArgs = {**filters, "sort": key, "order": next_order} + sort_urls[key] = url_for("webmentions.received_list", **sort_filters) + + return render_template( + "received.html", + title="Received Webmentions", + webmentions=webmentions, + filters=filters, + sort_key=sort_key, + sort_order=sort_order, + status_choices=RECEIVED_STATUS_CHOICES, + page_size=page_size, + sort_urls=sort_urls, + max_received_page_size=current_app.config["RECEIVED_MAX_PAGE_SIZE"], + action_form=ConfirmActionForm(), + ) + + +@webmentions_bp.post("/received/<uuid:webmention_uuid>/delete") +@login_required +def delete_received_webmention(webmention_uuid: uuid.UUID) -> ResponseReturnValue: + """Delete a received Webmention. + + :param webmention_uuid: UUID of the Webmention to delete. + :returns: Redirect response to the received Webmentions view. + """ + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + webmention = db.get_or_404(ReceivedWebmention, webmention_uuid) + + db.session.delete(webmention) + db.session.commit() + + flash(f"Webmention {webmention.uuid} deleted.", "success") + + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) + + +@webmentions_bp.post("/received/<uuid:webmention_uuid>/reverify") +@login_required +def reverify_received_webmention(webmention_uuid: uuid.UUID) -> ResponseReturnValue: + """Queue a received Webmention for reverification. + + The Webmention status is reset before a new verification task is queued. + + :param webmention_uuid: UUID of the Webmention to reverify. + :returns: Redirect response to the received Webmentions view. + """ + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + webmention = db.get_or_404(ReceivedWebmention, webmention_uuid) + + webmention.reopen_verification() + + db.session.commit() + + verify_webmention(webmention_uuid) + + flash(f"Webmention {webmention.uuid} queued for reverification.", "success") + + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) + + +def selected_received_webmentions() -> list[ReceivedWebmention]: + """Load a valid, nonempty selection of rows from the current list page. + + Reject malformed, duplicated, oversized, or stale selections rather than + silently performing only part of a requested bulk action. + """ + submitted = request.form.getlist("webmention_uuids") + if not submitted or len(submitted) > current_app.config["RECEIVED_MAX_PAGE_SIZE"]: + abort(HTTPStatus.BAD_REQUEST) + + try: + identifiers = {uuid.UUID(value) for value in submitted} + except ValueError, AttributeError, TypeError: + abort(HTTPStatus.BAD_REQUEST) + + if len(identifiers) != len(submitted): + abort(HTTPStatus.BAD_REQUEST) + + webmentions = list( + db.session.scalars( + sa.select(ReceivedWebmention).where( + ReceivedWebmention.uuid.in_(identifiers) + ) + ) + ) + if len(webmentions) != len(identifiers): + abort(HTTPStatus.NOT_FOUND) + + return webmentions + + +@webmentions_bp.post("/received/bulk/reverify") +@login_required +def reverify_selected_received_webmentions() -> ResponseReturnValue: + """Reopen and queue each selected received Webmention for verification.""" + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + webmentions = selected_received_webmentions() + + identifiers = [webmention.uuid for webmention in webmentions] + for webmention in webmentions: + webmention.reopen_verification() + db.session.commit() + + for identifier in identifiers: + verify_webmention(identifier) + + flash(f"{len(webmentions)} Webmentions queued for reverification.", "success") + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) + + +@webmentions_bp.post("/received/bulk/delete") +@login_required +def delete_selected_received_webmentions() -> ResponseReturnValue: + """Permanently delete only the selected received Webmentions.""" + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + webmentions = selected_received_webmentions() + + for webmention in webmentions: + db.session.delete(webmention) + db.session.commit() + + flash(f"{len(webmentions)} Webmentions deleted.", "success") + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) + + +@webmentions_bp.post("/received/declined/delete") +@login_required +def delete_all_declined_received_webmentions() -> ResponseReturnValue: + """Delete every declined received Webmention, regardless of age or filters.""" + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + result = db.session.execute( + sa.delete(ReceivedWebmention).where( + ReceivedWebmention.status.in_(RECEIVED_STATUS_FILTERS["declined"]) + ) + ) + db.session.commit() + + count = rows_affected(result) + flash(f"{count} declined Webmentions deleted.", "success") + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) + + +@webmentions_bp.post("/received/bulk/block-sources") +@login_required +def block_selected_received_sources() -> ResponseReturnValue: + """Block the unique source domains of selected received Webmentions.""" + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + webmentions = selected_received_webmentions() + domains = {domain_from_url(webmention.source) for webmention in webmentions} + if None in domains: + # Fail the entire selection instead of silently skipping a source. + abort(HTTPStatus.BAD_REQUEST) + + added = block_domains(cast(set[str], domains)) + flash( + f"{added} source domains newly blocked from {len(webmentions)} selected Webmentions.", + "success", + ) + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) + + +@webmentions_bp.post("/received/<uuid:webmention_uuid>/block-source") +@login_required +def block_received_source(webmention_uuid: uuid.UUID) -> ResponseReturnValue: + """Add a received Webmention's source hostname to the blocklist.""" + if not ConfirmActionForm().validate_on_submit(): + abort(HTTPStatus.BAD_REQUEST) + + filters = received_filter_args(received_filter_form()) + webmention = db.get_or_404(ReceivedWebmention, webmention_uuid) + if (domain := domain_from_url(webmention.source)) is None: + abort(HTTPStatus.BAD_REQUEST) + + block_domains({domain}) + + flash(f"Source domain {domain} blocked.", "success") + return redirect( + url_for( + "webmentions.received_list", + page=request.args.get("page", 1, type=int), + **filters, + ) + ) |
