FastComments SDK Java

Maven

Aggiungi il repository Repsy al POM del tuo progetto:

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

Quindi aggiungi le dipendenze necessarie:

<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

Aggiungi il repository Repsy al file 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"
}

Contenuti della libreria

Questa libreria contiene tre moduli. Il client API generato, la libreria Java core che contiene utilità scritte a mano per rendere più semplice il lavoro con l'API, e il modulo pubsub che è una libreria per iscriversi ai feed di cambiamento.

• Documentazione libreria client API
• Documentazione libreria core, inclusi esempi SSO
• Documentazione libreria PubSub

API Pubbliche vs Protette

Per il client API, ci sono tre classi, DefaultApi, PublicApi, e ModerationApi. La DefaultApi contiene metodi che richiedono la tua API key, e PublicApi contiene metodi che possono essere eseguiti direttamente da un browser/dispositivo mobile/etc senza autenticazione.

La ModerationApi alimenta la dashboard dei moderatori. Contiene metodi per la moderazione dei commenti (elenco, conteggio, ricerca, log e esportazione), azioni di moderazione (rimuovere/ripristinare, segnala, impostare lo stato di revisione/spam/approvazione, voti e riaprire/chiudere il thread), ban (vietare di commentare, annullare un ban, riepiloghi pre-ban, stato e preferenze del ban, e conteggi utenti bannati), e badge & fiducia (assegnare/rimuovere un badge, badge manuali, ottenere/impostare il fattore di fiducia, e profilo interno utente). Ogni metodo di ModerationApi accetta un parametro sso in modo che la chiamata possa essere eseguita per conto di un moderatore autenticato tramite SSO.

Utilizzo delle API Autenticate (DefaultApi)

Importante: Devi impostare la tua API key su ApiClient prima di effettuare richieste autenticate. Se non lo fai, le richieste falliranno con un errore 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) {
        // Crea e configura il client API
        ApiClient apiClient = new ApiClient();

        // OBBLIGATORIO: Imposta la tua API key (prendila dalla dashboard di FastComments)
        apiClient.setApiKey("YOUR_API_KEY_HERE");

        // Crea l'istanza API con il client configurato
        DefaultApi api = new DefaultApi(apiClient);

        // Ora puoi effettuare chiamate API autenticate
        try {
            // Esempio: Aggiungi un utente 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());
            // Errori comuni:
            // - 401: Mancante o invalida API key
            // - 400: La validazione della richiesta è fallita
        }
    }
}

Utilizzo delle API Pubbliche (PublicApi)

Gli endpoint pubblici non richiedono autenticazione:

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();
}

Utilizzo delle API di Moderazione (ModerationApi)

La ModerationApi gestisce la dashboard dei moderatori. Ogni metodo accetta un parametro sso che identifica il moderatore autenticato via SSO per conto del quale viene effettuata la richiesta:

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

ModerationApi moderationApi = new ModerationApi();

try {
    // Elenca i commenti in attesa di moderazione
    ModerationAPIGetCommentsResponse response = moderationApi.getApiComments()
        .sso("YOUR_SSO_TOKEN")
        .execute();
    System.out.println(response);
} catch (ApiException e) {
    e.printStackTrace();
}

Problemi comuni

1. 401 "missing-api-key" error: Assicurati di chiamare apiClient.setApiKey("YOUR_KEY") prima di creare l'istanza DefaultApi.
2. Classe API errata: Usa DefaultApi per richieste autenticate lato server, PublicApi per richieste client-side/pubbliche.
3. Null API key: L'SDK salterà silenziosamente l'autenticazione se la API key è null, causando errori 401.

ID di broadcast

Vedrai che dovrai passare un broadcastId in alcune chiamate API. Quando riceverai eventi, ti verrà restituito questo ID, così saprai di ignorare l'evento se prevedi di applicare le modifiche in modo ottimistico sul client (probabilmente vorrai farlo, perché offre la migliore esperienza). Passa un UUID qui. L'ID dovrebbe essere sufficientemente unico da non ripetersi due volte durante una sessione del browser.