Ajouter des commentaires à votre application Django

• Python 3.10+
• Django 4.2, 5.0, 5.1 ou 5.2
• Un ID de locataire FastComments (utilisez demo pour l'essayer sans compte)
• Un secret d'API est requis uniquement pour le SSO sécurisé

Installez à partir d’un tag de version (ce projet est distribué via des tags git, pas PyPI) :

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

Pour un accès REST côté serveur (les aides admin() / public_api()), ajoutez l’extra api, qui inclut le client généré du SDK :

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

Ajoutez l’application à INSTALLED_APPS :

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

Configurez votre tenant dans settings.py :

import os

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

Déposez le widget dans n'importe quel modèle :

{% load fastcomments %}

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

Pour transmettre l'utilisateur connecté au widget automatiquement, les balises lisent le utilisateur actuel depuis la requête. Assurez‑vous que votre projet possède les deux (elles sont activées par défaut dans un projet Django standard) :

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

Sans une requête dans le contexte du modèle, les widgets s'affichent pour un visiteur anonyme. Vous pouvez toujours passer un utilisateur explicitement : {% fastcomments user=some_user %}.

Chaque widget possède sa propre balise. Toutes acceptent les arguments mot‑clé **extra, qui sont fusionnés dans la configuration du widget tels quels (utilisez des clés en camelCase) pour tout ce qui n’est pas couvert par les arguments nommés ci‑dessous.

Les arguments nommés correspondent aux clés de configuration camelCase du widget :

Exemples :

{% 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 %}

{# Le chat collaboratif se branche à un élément existant sur la page #}
<article id="post-body">...</article>
{% fastcomments_collab_chat target="#post-body" %}

{# Comptes en masse : placez des marqueurs, puis un chargeur en masse les remplit tous #}
{% 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 and choose a mode in settings.py. Secure SSO signs the user server-side with HMAC‑SHA256 using your API secret and is recommended.

FASTCOMMENTS = {
    "TENANT_ID": os.environ["FASTCOMMENTS_TENANT_ID"],
    "API_KEY": os.environ["FASTCOMMENTS_API_KEY"],   # your API secret; signs Secure SSO
    "SSO": {
        "ENABLED": True,
        "MODE": "secure",                            # "secure" | "simple"
        # Map FastComments fields to your user model. Values may be an attribute
        # name, a dotted path ("profile.avatar_url"), a callable(user), or 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, or dotted path
        "IS_MODERATOR": None,
        "GROUP_IDS": None,                           # callable(user) -> list, or dotted path
    },
}

Choisissez délibérément le id SSO. Le id FastComments est le pointeur permanent de l'historique des commentaires d'un utilisateur. Le USER_MAP par défaut le mappe à votre clé primaire Django pour une commodité sans configuration, mais les PK entiers séquentiels sont énumérables et difficiles à modifier plus tard (modifier le id d'un utilisateur divise son historique en un nouveau compte). Pour tout ce qui dépasse une démo, mappez le id à une valeur stable et opaque choisie à l'avance (un UUID ou un identifiant public dédié), et ne mettez jamais de données privées dedans. L'application d'exemple utilise un id basé sur le nom d'utilisateur pour cette raison.

SSO is injected automatically into {% fastcomments %}, {% fastcomments_live_chat %}, {% fastcomments_collab_chat %}, {% fastcomments_image_chat %} and {% fastcomments_user_activity %} for the current user.

Login/logout URLs shown to signed-out visitors default to reverse("login") / reverse("logout"); override them with SSO["LOGIN_URL"] / SSO["LOGOUT_URL"].

Mappage personnalisé

Two higher-precedence options beat USER_MAP:

• A method on your user model (the Pythonic analog of an interface):

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

• A global mapper, a dotted path to callable(user) -> dict:

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

Precedence is USER_MAPPER > to_fastcomments_user_data() > USER_MAP.

Avec l'extra [api] installé, appelez l'API REST de FastComments via le SDK, pré‑configuré avec votre clé API et votre région :

from fastcomments_django import admin, public_api, get_manager

admin().get_comments("YOUR_TENANT_ID", ...)     # authenticated (DefaultApi)
public_api().get_comments_public(...)            # public (PublicApi)

# Generate an SSO token for API calls or client hand-off:
token = get_manager().sso().token_for(request.user)

Définissez REGION pour acheminer les widgets et l'API vers l'UE :

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

Surcharge fastcomments/widget.html en plaçant votre propre copie plus tôt dans le
chemin de recherche des modèles (un projet templates/fastcomments/widget.html). C’est
l’équivalent Django du vendor:publish --tag=fastcomments-views de Laravel.

Une démonstration exécutable se trouve dans example/ : une application à rail latéral + scène principale avec une page par widget et une page de connexion répertoriant des utilisateurs de démonstration pré‑alimentés.
Connectez‑vous avec l’un d’eux et les widgets de commentaire et de chat en direct authentifient cette identité via Secure SSO. Depuis ce répertoire :

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

Sans secret d’API, cela revient au locataire public demo (anonyme).
example/browser_smoke.py est un test e2e Playwright qui charge la page dans un vrai navigateur et publie un commentaire en tant qu’utilisateur Secure‑SSO.