aboutsummaryrefslogtreecommitdiff
path: root/webmentions_ssg/views/received.py
diff options
context:
space:
mode:
Diffstat (limited to 'webmentions_ssg/views/received.py')
-rw-r--r--webmentions_ssg/views/received.py391
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,
+ )
+ )