Agregar comentarios a tu aplicación Django

• Python 3.10+
• Django 4.2, 5.0, 5.1, o 5.2
• Un ID de arrendatario de FastComments (use demo para probarlo sin una cuenta)
• Se requiere un secreto API solo para SSO seguro

Instale desde una etiqueta de lanzamiento (este proyecto se distribuye mediante etiquetas git, no PyPI):

pip install "git+https://github.com/fastcomments/fastcomments-django.git@v0.1.0"

Para el acceso REST del lado del servidor (los asistentes admin() / public_api()), añada el extra api, que incorpora el cliente generado por el SDK:

pip install "fastcomments-django[api] @ git+https://github.com/fastcomments/fastcomments-django.git@v0.1.0"

Agregue la aplicación a INSTALLED_APPS:

INSTALLED_APPS = [
    # ...
    "fastcomments_django",
]

Configure su inquilino en settings.py:

import os

FASTCOMMENTS = {
    "TENANT_ID": os.environ.get("FASTCOMMENTS_TENANT_ID", "demo"),
}

Coloque el widget en cualquier plantilla:

{% load fastcomments %}

{% fastcomments url_id="my-page" %}

Para pasar el usuario conectado al widget automáticamente, las etiquetas leen el
usuario actual de la solicitud. Asegúrate de que tu proyecto tenga ambos (están
activados por defecto en un proyecto Django estándar):

• django.template.context_processors.request in TEMPLATES["OPTIONS"]["context_processors"]
• django.contrib.auth.middleware.AuthenticationMiddleware in MIDDLEWARE

Sin una solicitud en el contexto de la plantilla, los widgets se renderizan para un
visitante anónimo. Siempre puedes pasar un usuario explícitamente: {% fastcomments user=some_user %}.

Cada widget tiene su propia etiqueta. Todos aceptan argumentos de palabra clave **extra, los cuales se fusionan en la configuración del widget tal cual (use claves camelCase) para cualquier cosa que no esté cubierta por los argumentos nombrados a continuación.

Los argumentos nombrados se asignan a las claves camelCase de la configuración del widget:

Ejemplos:

{% load fastcomments %}

{% fastcomments url_id="my-page" locale="en_us" default_sort_direction="MR" %}

{% fastcomments_live_chat url_id="room-1" %}

Comments: {% fastcomments_comment_count url_id="my-page" number_only=True %}

{# El chat colaborativo se adjunta a un elemento existente en la página #}
<article id="post-body">...</article>
{% fastcomments_collab_chat target="#post-body" %}

{# Recuentos masivos: coloque marcadores, luego un cargador masivo los completa todos #}
{% for post in posts %}
    <a href="\{{ post.url }}">\{{ post.title }}</a>
    {% fastcomments_count_marker url_id=post.url_id %}
{% endfor %}
{% fastcomments_comment_count_bulk %}

Enable SSO y elige un modo en settings.py. Secure SSO firma al usuario del lado del servidor con HMAC‑SHA256 usando tu secreto de API y se recomienda.

FASTCOMMENTS = {
    "TENANT_ID": os.environ["FASTCOMMENTS_TENANT_ID"],
    "API_KEY": os.environ["FASTCOMMENTS_API_KEY"],   # tu secreto de API; firma Secure SSO
    "SSO": {
        "ENABLED": True,
        "MODE": "secure",                            # "secure" | "simple"
        # Mapea los campos de FastComments a tu modelo de usuario. Los valores pueden ser un atributo
        # nombre, una ruta con puntos ("profile.avatar_url"), una callable(user), o None.
        "USER_MAP": {
            "id": "id",
            "email": "email",
            "username": "username",
            "avatar": None,
            "display_name": None,
            "website_url": None,
        },
        "IS_ADMIN": lambda user: user.is_staff,      # callable(user) -> bool, o ruta con puntos
        "IS_MODERATOR": None,
        "GROUP_IDS": None,                           # callable(user) -> list, o ruta con puntos
    },
}

Elige el id de SSO deliberadamente. El id de FastComments es el identificador permanente del historial de comentarios de un usuario. El USER_MAP predeterminado lo asigna a la clave primaria de Django para mayor comodidad sin configuración, pero las PKs enteras secuenciales son enumerables y difíciles de cambiar más tarde (cambiar el id de un usuario divide su historial en una nueva cuenta). Para cualquier caso más allá de una demostración, asigna id a un valor estable y opaco elegido de antemano (un UUID o un ID público dedicado), y nunca pongas datos privados allí. La aplicación de ejemplo usa un id basado en el nombre de usuario por esta razón.

SSO se inyecta automáticamente en {% fastcomments %}, {% fastcomments_live_chat %}, {% fastcomments_collab_chat %}, {% fastcomments_image_chat %} y {% fastcomments_user_activity %} para el usuario actual.

Las URL de login/logout mostradas a los visitantes sin sesión predeterminadamente son reverse("login") / reverse("logout"); sobrescríbelas con SSO["LOGIN_URL"] / SSO["LOGOUT_URL"].

Mapeo personalizado

Dos opciones de mayor precedencia sobrescriben USER_MAP:

• Un método en tu modelo de usuario (el análogo Pythonic de una interfaz):

  class User(AbstractUser):
      def to_fastcomments_user_data(self):
          return {"id": self.pk, "email": self.email, "username": self.get_username()}

• Un mapper global, una ruta con puntos a callable(user) -> dict:

  FASTCOMMENTS = {"SSO": {"USER_MAPPER": "myapp.sso.map_user"}}

La precedencia es USER_MAPPER > to_fastcomments_user_data() > USER_MAP.

Con el extra [api] instalado, llama a la API REST de FastComments a través del SDK, preconfigurado con tu clave API y región:

from fastcomments_django import admin, public_api, get_manager

admin().get_comments("YOUR_TENANT_ID", ...)     # autenticado (DefaultApi)
public_api().get_comments_public(...)            # público (PublicApi)

# Genera un token SSO para llamadas API o entrega al cliente:
token = get_manager().sso().token_for(request.user)

Establezca REGION para dirigir los widgets y la API a la UE:

FASTCOMMENTS = {"TENANT_ID": "...", "REGION": "eu"}

Sobrescriba fastcomments/widget.html colocando su propia copia antes en la ruta de búsqueda de plantillas (un proyecto templates/fastcomments/widget.html). Esto es el análogo de Django a vendor:publish --tag=fastcomments-views de Laravel.

Una demostración ejecutable se encuentra en example/: una aplicación de carril izquierdo + escenario principal con una página por widget y una página de inicio de sesión que enumera usuarios de demostración pre-semilla.
Inicia sesión con cualquiera de ellos y los widgets de comentarios y chat en vivo autentican esa identidad a través de Secure SSO. Desde ese directorio:

python manage.py migrate
# Use your own tenant to see Secure SSO in action (an API secret enables it):
FASTCOMMENTS_TENANT_ID=... FASTCOMMENTS_API_KEY=... python manage.py runserver

Sin una clave API vuelve al inquilino público demo (anónimo).
example/browser_smoke.py es una prueba e2e de Playwright que carga la página en un navegador real y publica un comentario como el usuario Secure-SSO.