SDK Java FastComments

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>

Then add the dependencies you need:

<dependencies>
    <!-- API Client -->
    <dependency>
        <groupId>com.fastcomments</groupId>
        <artifactId>client</artifactId>
        <version>2.0.0</version>
    </dependency>
    
    <!-- Core Library (includes SSO) -->
    <dependency>
        <groupId>com.fastcomments</groupId>
        <artifactId>core</artifactId>
        <version>2.0.0</version>
    </dependency>
    
    <!-- PubSub Library (for live events) -->
    <dependency>
        <groupId>com.fastcomments</groupId>
        <artifactId>pubsub</artifactId>
        <version>2.0.0</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 {
    // API Client
    implementation "com.fastcomments:client:2.0.0"
    
    // Core Library (includes SSO)
    implementation "com.fastcomments:core:2.0.0"
    
    // PubSub Library (for live events)
    implementation "com.fastcomments:pubsub:2.0.0"
}

Library Contents

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

• Docs de la bibliothèque client API
• Docs de la bibliothèque Core, y compris des exemples SSO
• Docs de la bibliothèque PubSub

Public vs Secured APIs

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

La ModerationApi alimente le tableau de bord des modérateurs. Elle contient des méthodes pour la modération des commentaires (liste, comptage, recherche, journaux et export), les actions de modération (supprimer/restaurer, signaler, définir le statut revue/spam/approbation, votes, et rouvrir/fermer un fil), les bannissements (interdire de commenter, annuler une interdiction, résumés pré-interdiction, statut et préférences de bannissement, et nombre d'utilisateurs bannis), et les badges & la confiance (attribuer/supprimer un badge, badges manuels, obtenir/définir le facteur de confiance, et profil interne de l'utilisateur). Chaque méthode de la ModerationApi accepte un paramètre sso afin que l'appel puisse être effectué au nom d'un modérateur authentifié via SSO.

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.