FastComments SDK Java

Donnez à votre agent de codage le contexte FastComments dont il a besoin - widgets, configuration, SSO sécurisé, l'API REST et les SDK :

npx skills add fastcomments/skills

Fonctionne avec Claude Code, Codex, Cursor, Copilot, Gemini et tout autre agent pris en charge par le skills CLI.

Maven

Ajoutez le dépôt Repsy au POM de votre projet :

<repositories>
    <repository>
        <id>repsy</id>
        <name>FastComments Maven Repository on Repsy</name>
        <url>https://repo.repsy.io/mvn/winrid/fastcomments</url>
    </repository>
</repositories>

Ensuite, ajoutez les dépendances dont vous avez besoin :

<dependencies>
    <!-- Client API -->
    <dependency>
        <groupId>com.fastcomments</groupId>
        <artifactId>client</artifactId>
        <version>3.0.1</version>
    </dependency>
    
    <!-- Bibliothèque principale (inclut SSO) -->
    <dependency>
        <groupId>com.fastcomments</groupId>
        <artifactId>core</artifactId>
        <version>3.0.1</version>
    </dependency>
    
    <!-- Bibliothèque PubSub (pour les événements en direct) -->
    <dependency>
        <groupId>com.fastcomments</groupId>
        <artifactId>pubsub</artifactId>
        <version>3.0.1</version>
    </dependency>
</dependencies>

Gradle

Ajoutez le dépôt Repsy à votre fichier build.gradle :

repositories {
    mavenCentral()
    maven {
        url "https://repo.repsy.io/mvn/winrid/fastcomments"
    }
}

dependencies {
    // Client API
    implementation "com.fastcomments:client:3.0.1"
    
    // Bibliothèque principale (inclut SSO)
    implementation "com.fastcomments:core:3.0.1"
    
    // Bibliothèque PubSub (pour les événements en direct)
    implementation "com.fastcomments:pubsub:3.0.1"
}

Contenu de la bibliothèque

Cette bibliothèque contient trois modules. Le client API généré, la bibliothèque Java principale qui contient des utilitaires écrits à la main pour faciliter l'utilisation de l'API, et le module pubsub qui est une bibliothèque pour s'abonner aux flux de changements.

• API Client Library Docs
• Core Library Docs, Including SSO Examples
• PubSub Library Docs

API publiques vs sécurisées

Pour le client API, il existe trois classes, DefaultApi, PublicApi et ModerationApi. Le DefaultApi contient des méthodes qui nécessitent votre clé API, et le PublicApi contient des méthodes qui peuvent être appelées directement depuis un navigateur/appareil mobile/etc. sans authentification.

Le ModerationApi fournit une suite étendue d'API de modération en temps réel et rapides. Chaque méthode du ModerationApi accepte un paramètre sso et peut s'authentifier via SSO ou un cookie de session FastComments.com.

Utilisation des API authentifiées (DefaultApi)

Important : Vous devez définir votre clé API sur ApiClient avant d'effectuer des requêtes authentifiées. Si vous ne le faites pas, les requêtes échoueront avec une erreur 401.

import com.fastcomments.invoker.ApiClient;
import com.fastcomments.invoker.ApiException;
import com.fastcomments.api.DefaultApi;
import com.fastcomments.model.*;

public class Example {
    public static void main(String[] args) {
        // Créez et configurez le client API
        ApiClient apiClient = new ApiClient();

        // OBLIGATOIRE : Définissez votre clé API (obtenez-la depuis votre tableau de bord FastComments)
        apiClient.setApiKey("YOUR_API_KEY_HERE");

        // Créez l'instance API avec le client configuré
        DefaultApi api = new DefaultApi(apiClient);

        // Vous pouvez maintenant effectuer des appels API authentifiés
        try {
            // Exemple : Ajouter un utilisateur SSO
            CreateAPISSOUserData userData = new CreateAPISSOUserData();
            userData.setId("user-123");
            userData.setEmail("user@example.com");
            userData.setDisplayName("John Doe");

            AddSSOUserAPIResponse response = api.addSSOUser("YOUR_TENANT_ID", userData)
                .execute();
            System.out.println("User created: " + response);

        } catch (ApiException e) {
            System.err.println("Error: " + e.getResponseBody());
            // Erreurs courantes :
            // - 401 : la clé API est manquante ou invalide
            // - 400 : la validation de la requête a échoué
        }
    }
}

Utilisation des API publiques (PublicApi)

Les points de terminaison publics ne requièrent pas d'authentification :

import com.fastcomments.api.PublicApi;
import com.fastcomments.invoker.ApiException;

PublicApi publicApi = new PublicApi();

try {
    var response = publicApi.getCommentsPublic("YOUR_TENANT_ID", "page-url-id")
        .execute();
    System.out.println(response);
} catch (ApiException e) {
    e.printStackTrace();
}

Utilisation des API de modération (ModerationApi)

L'API ModerationApi alimente le tableau de bord du modérateur. Chaque méthode accepte un paramètre sso identifiant le modérateur authentifié via SSO pour le compte duquel la requête est effectuée :

import com.fastcomments.api.ModerationApi;
import com.fastcomments.invoker.ApiException;
import com.fastcomments.model.*;

ModerationApi moderationApi = new ModerationApi();

try {
    // Lister les commentaires en attente de modération
    ModerationAPIGetCommentsResponse response = moderationApi.getApiComments()
        .sso("YOUR_SSO_TOKEN")
        .execute();
    System.out.println(response);
} catch (ApiException e) {
    e.printStackTrace();
}

Problèmes courants

1. 401 "missing-api-key" erreur : Assurez-vous d'appeler apiClient.setApiKey("YOUR_KEY") avant de créer l'instance DefaultApi.
2. Classe d'API incorrecte : Utilisez DefaultApi pour les requêtes authentifiées côté serveur, PublicApi pour les requêtes côté client / publiques.
3. Clé API nulle : Le SDK ignorera silencieusement l'authentification si la clé API est nulle, ce qui conduira à des erreurs 401.

Identifiants de diffusion

Vous verrez qu'il faut passer un broadcastId dans certains appels d'API. Lorsque vous recevez des événements, vous récupérerez cet ID, ce qui vous permettra d'ignorer l'événement si vous prévoyez d'appliquer de manière optimiste des modifications côté client (ce que vous voudrez probablement faire car cela offre la meilleure expérience). Passez un UUID ici. L'ID doit être suffisamment unique pour ne pas se produire deux fois dans une session de navigateur.