API-ji za komentarisanje uživo

FastComments API

FastComments pruža API za interakciju sa mnogim resursima. Izgradite integracije sa našom platformom, ili čak izradite sopstvene klijente!

U ovoj dokumentaciji ćete pronaći sve podržane resurse API‑ja dokumentovane sa njihovim tipovima zahteva i odgovora.

Za Enterprise korisnike, sav pristup API‑ju se beleži u revizijskom dnevniku.

Generisani SDK‑ovi

FastComments sada generiše API specifikaciju iz našeg koda (još nije kompletna, ali uključuje mnoge API‑e).

Takođe sada imamo SDK‑ove za popularne jezike:

Autentifikacija

API se autentifikuje prosleđivanjem vašeg api ključa kao X-API-KEY zaglavlja ili API_KEY parametra upita. Takođe će vam biti potreban tenantId za pozivanje API‑ja. Može se preuzeti sa iste stranice kao i vaš api ključ.

Napomena o bezbednosti

Ove rute su namenjene pozivanju sa servera. NE pozivajte ih iz pregledača. To će otkriti vaš API ključ – što omogućava potpun pristup vašem nalogu bilo kome ko može da vidi izvorni kod stranice!

Opcija autentifikacije 1 – Zaglavlja

Header: X-API-KEY
Header: X-TENANT-ID

Opcija autentifikacije 2 – Parametri upita

Query Param: API_KEY
Query Param: tenantId

Opcija autentifikacije 3 – OAuth Bearer token

Header: Authorization: Bearer fcat_...

Third‑party aplikacije kao što su Zapier i klijenti MCP servera dobijaju token putem OAuth‑a umesto API ključa. Taj token funkcioniše na svakom krajnjem punktu ovde. Tenant je impliciran tokenom, pa je tenantId opcionalan, ali mora da se podudara sa tokenom ako je naveden. GET zahtevi zahtevaju read opseg, a svi ostali metodi zahtevaju write opseg. Ceo tok, uključujući registraciju klijenta, PKCE, osvežavanje i opoziv, dokumentovan je pod OAuth Authorization. Otkrivanje počinje na https://fastcomments.com/.well-known/oauth-authorization-server.

Čitanje sopstvenih upisa

FastComments pruža Active‑Active dostupnost. Zahtevi iz vašeg data‑centra se usmeravaju na najbližu tačku prisustva u odnosu na vas. Ovo je automatsko i obično možete primetiti semantiku čitanja‑posle‑pisanja. Ako želite da budete sigurni da čitate sopstvene upise, možete fiksirati svoje zahteve na određenu regiju koristeći tu regiju kao API host (iako to obično nije potrebno za većinu integracija):

gdc-oregon.fastcomments.com
gdc-virginia.fastcomments.com
gdc-singapore.fastcomments.com
gdc-falkenstein2.fastcomments.com
gdc-sao-paulo.fastcomments.com
eudc-helsinki2.fastcomments.com
eudc-limburg.fastcomments.com
eudc-france.fastcomments.com

Napomena: ako to uradite, možda ćete želeti da definišete rezervni plan, pošto smo u prošlosti ukinuli ulazne čvorove i koristimo nove nazive za prebacivanje.

API Resursi

Korišćenje resursa

Treba napomenuti da preuzimanje podataka sa API‑ja računa se kao korišćenje na vašem nalogu.

Svaki resurs će navesti to korišćenje u svom odeljku.

Neki resursi koštaju više za servisiranje od drugih. Svaki endpoint ima fiksnu cenu u kreditima po API pozivu. Za neke endpoint‑e, broj kredita varira u zavisnosti od opcija i veličina odgovora.

API korišćenje možete proveriti na stranici Billing Analytics i ažurira se svakih nekoliko minuta.

Napomena!

Preporučujemo da prvo pročitate dokumentaciju za Pages, kako biste smanjili zabunu prilikom određivanja koje vrednosti proslediti za urlId u Comment API‑ju.

Webhook‑ovi

Pretplate na webhook‑ove imaju svoj vodič. POST, GET i DELETE /api/v1/webhooks, i GET /api/v1/webhooks/sample-payloads, su dokumentovani u odeljku Managing Subscriptions via API, a strukture događaja u Webhook Structures.

OAuth Autorizacija

FastComments je OAuth 2.1 autorizacioni server. Aplikacija može da dobije token koji je vezan za jedan FastComments nalog i da ga koristi na svakom endpointu u ovom vodiču umesto API ključa. Na ovaj way se povezuju Zapier aplikacija, MCP server i druge integracije trećih strana.

Tokeni se izdaju kroz authorization code flow sa PKCE. Ne postoji client credentials niti implicit grant.

Discovery

Lokacije endpointa, podržani grantovi i auth metode su objavljene na standardnom metadata URL-u:

Metadata autorizacionog servera

Copy

https://fastcomments.com/.well-known/oauth-authorization-server

Endpointi koje on opisuje:

OAuth endpointi

Copy

GET  https://fastcomments.com/oauth/authorize
POST https://fastcomments.com/oauth/token
POST https://fastcomments.com/oauth/revoke
POST https://fastcomments.com/oauth/register

Nalozi u EU regionu koriste https://eu.fastcomments.com kao issuer, sa istim putanjama.

Registracija klijenta

Klijent treba client_id i registrovan redirect_uri pre nego što započne flow. Postoje dva načina da se to dobije:

Dinamička registracija klijenta (Dynamic Client Registration). POST /oauth/register sa JSON telom prema RFC 7591 (redirect_uris, client_name, client_uri, logo_uri, token_endpoint_auth_method). Odgovor sadrži client_id i, za poverljive (confidential) klijente, client_secret. Registracija je neautentikovana i rate limited po IP adresi.
Client ID Metadata Document. Klijent koristi https URL koji kontroliše kao svoj client_id. FastComments preuzima taj URL i čita ista metadata polja sa njega. Nije potreban poziv za registraciju.

Partnerske aplikacije navedene u FastComments dashboard-u, kao što je Zapier, registruje FastComments direktno. Kontaktirajte podršku ako pravite marketplace listing i treba vam first-party klijent.

Scopes

Copy

read   GET i HEAD zahtevi
write  sve ostale metode

Zahtev koji ne traži scope dobija oba. Korisnik vidi tražene scopes na stranici za saglasnost (consent). Zahtev za scope drugačiji od ova dva neuspeva sa invalid_scope.

Korak 1 - Autorizacioni zahtev

Pošaljite korisnikov browser na authorize endpoint. PKCE sa metodom S256 je obavezan za svaki klijent.

Autorizacioni zahtev

Copy

GET https://fastcomments.com/oauth/authorize
    ?response_type=code
    &client_id=YOUR_CLIENT_ID
    &redirect_uri=https://example.com/oauth/callback
    &scope=read%20write
    &state=RANDOM_STATE
    &code_challenge=BASE64URL_SHA256_OF_VERIFIER
    &code_challenge_method=S256

Parametri autorizacionog zahteva

Copy

interface OAuthAuthorizeQueryParams {
    response_type: 'code'
    client_id: string
    /** Must exactly match one of the client's registered redirect URIs. **/
    redirect_uri: string
    /** Space separated. Omit to request both scopes. **/
    scope?: 'read' | 'write' | 'read write'
    /** Returned unchanged on the redirect. Use it to bind the callback to the session that started the flow. **/
    state?: string
    /** base64url(sha256(code_verifier)). **/
    code_challenge: string
    code_challenge_method: 'S256'
    /** Optional RFC 8707 resource indicator. If sent, the same value must be sent to the token endpoint. **/
    resource?: string
}

Korisnik se prijavljuje na FastComments ako je potrebno i vidi stranicu za saglasnost koja navodi vašu aplikaciju, nalog na koji će biti povezana i tražene scopes. Korisnik mora imati dozvolu API Admin na tom nalogu; svi ostali umesto forme za saglasnost vide grešku o dozvolama. Odobravanje preusmerava browser na vaš redirect_uri sa code i state. Odbijanje preusmerava sa error=access_denied.

Autorizacioni kod je validan 10 minuta i može se zameniti jednom. Druga zamena istog koda opoziva sve tokene koje je prva zamena proizvela.

Korak 2 - Zahtev za token

Zamenite kod za tokene. Telo je form encoded. Poverljivi (confidential) klijenti se autentikuju sa client_secret_basic (HTTP Basic) ili client_secret_post (tajna u telu). Javni klijenti šalju samo client_id.

cURL primer zahteva za token

Copy

curl --request POST \
  --url 'https://fastcomments.com/oauth/token' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data 'grant_type=authorization_code' \
  --data 'client_id=YOUR_CLIENT_ID' \
  --data 'client_secret=YOUR_CLIENT_SECRET' \
  --data 'code=fcac_...' \
  --data 'code_verifier=YOUR_PKCE_VERIFIER' \
  --data 'redirect_uri=https://example.com/oauth/callback'

Telo zahteva za token (authorization_code)

Copy

interface OAuthTokenRequestAuthorizationCode {
    grant_type: 'authorization_code'
    client_id: string
    /** Confidential clients only. May be sent as HTTP Basic auth instead. **/
    client_secret?: string
    code: string
    code_verifier: string
    /** Must match the authorization request when sent. **/
    redirect_uri?: string
    resource?: string
}

Struktura odgovora sa tokenom

Copy

interface OAuthTokenResponse {
    /** Prefixed fcat_. Valid for one hour. **/
    access_token: string
    token_type: 'bearer'
    /** Seconds until the access token expires. 3600. **/
    expires_in: number
    /** Prefixed fcrt_. Valid for 30 days from issue. **/
    refresh_token: string
    /** Space separated scopes granted. **/
    scope: string
}

Greške prate RFC 6749: JSON telo sa error i error_description, HTTP 400 za invalid_request, invalid_grant, invalid_scope, invalid_target i unsupported_grant_type, HTTP 401 za invalid_client, HTTP 429 kada je rate limited.

Korak 3 - Pozivanje API-ja

Pošaljite access token kao bearer token. Tenant je implikiran tokenom, pa je tenantId opcionalan. Ako je dat, mora se poklapati sa tokenom ili zahtev neuspeva.

cURL primer sa bearer tokenom

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/me' \
  --header 'Authorization: Bearer fcat_...'

GET /api/v1/me vraća tenant, korisnika koji je autorizovao i dodeljene scopes, što ga čini pravim pozivom za test konekcije. Zahtev sa isteklim ili opozvanim tokenom dobija HTTP 401. Zahtev čija metoda zahteva scope koji token nema dobija HTTP 403.

Korak 4 - Osvežavanje (refresh)

cURL primer refresh zahteva

Copy

curl --request POST \
  --url 'https://fastcomments.com/oauth/token' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data 'grant_type=refresh_token' \
  --data 'client_id=YOUR_CLIENT_ID' \
  --data 'client_secret=YOUR_CLIENT_SECRET' \
  --data 'refresh_token=fcrt_...'

Telo zahteva za token (refresh_token)

Copy

interface OAuthTokenRequestRefreshToken {
    grant_type: 'refresh_token'
    client_id: string
    client_secret?: string
    refresh_token: string
    /** Optional. Narrows to a subset of the scopes originally granted. **/
    scope?: string
    resource?: string
}

Odgovor ima isti oblik kao zamena koda. Refresh tokeni se rotiraju: svaki refresh vraća novi refresh_token i opoziva stari nakon 30-sekundnog grace prozora za konkurentne zahteve. Predstavljanje refresh tokena koji je rotiran pre više od 30 sekundi tretira se kao replay i opoziva ceo grant. Partnerske aplikacije registrovane od strane FastComments-a izuzete su od rotacije i dobijaju isti refresh token sa istekom produženim za još 30 dana.

Refresh takođe ponovo proverava da li autorizujući korisnik i dalje ima API Admin na nalogu. Ako nema, grant se opoziva i odgovor je invalid_grant.

Opoziv (Revocation)

cURL primer zahteva za opoziv

Copy

curl --request POST \
  --url 'https://fastcomments.com/oauth/revoke' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data 'client_id=YOUR_CLIENT_ID' \
  --data 'client_secret=YOUR_CLIENT_SECRET' \
  --data 'token=fcrt_...' \
  --data 'token_type_hint=refresh_token'

Opoziv refresh tokena opoziva sve access tokene izdate iz istog granta. Opoziv access tokena opoziva samo taj token. Endpoint vraća HTTP 200 sa praznim JSON objektom bez obzira da li je token pronađen, prema RFC 7009.

Korisnici mogu da opozvu konekciju i iz Connected Apps u FastComments dashboard-u. Svi tokeni za tu aplikaciju odmah prestaju da rade.

Agregirajte Vaše podatke

Resource: Aggregate as GET /api/v1/aggregate Credit Cost: 1

Ovaj API agregira dokumente grupisanjem (ako je groupBy prosleđen) i primenom više operacija. Podržane su različite operacije (npr. sum, countDistinct, avg, itd.).

Trošak je varijabilan. Svakih 500 pregledanih objekata košta 1 API kredit.

Maksimalna količina memorije dozvoljena po API pozivu po defoltu je 64MB, i po podrazumevanju možete imati samo jednu agregaciju koja radi u isto vreme. Ako pošaljete više agregacija istovremeno, biće stavljene u red i izvršene redom kako su poslate. Agregacije u čekanju će čekati najviše 60 sekundi, nakon čega će zahtev isteći. Pojedinačne agregacije mogu se izvršavati do 5 minuta.

Ako imate upravljane tenant-e, možete agregirati sve resurse podređenih tenant-a u jednom pozivu prosleđivanjem query parametra parentTenantId.

Primeri

Primer: Brojanje jedinstvenih

Primer cURL zahteva: Brojanje jedinstvenih vrednosti

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "distinct", "field": "urlId", "alias": "urlId" },
        { "op": "distinct", "field": "commenterEmail", "alias": "commenterEmail" }
    ]
}'

Odgovor: Brojanje jedinstvenih vrednosti

Copy

{
    "status": "success",
    "data": [
        {
            "commenterEmail": {
                "distinctCounts": {
                    "someone@somewhere.com": 1,
                    "someone2@somewhere.com": 1
                }
            }
        },
        {
            "urlId": {
                "distinctCounts": {
                    "some-page": 2
                }
            }
        }
    ],
    "stats": { "scanned": 2 }
}

Primer: Brojanje različitih vrednosti

Primer cURL zahteva: Brojanje različitih vrednosti

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "countDistinct", "field": "urlId", "alias": "urlId" },
        { "op": "countDistinct", "field": "commenterEmail", "alias": "commenterEmail" }
    ]
}'

Odgovor:

Odgovor: Brojanje različitih vrednosti

Copy

{
    "status": "success",
    "data": [
        {
            "commenterEmail": { "distinctCount": 2 },
            "urlId": { "distinctCount": 1 }
        }
    ],
    "stats": { "scanned": 2 }
}

Primer: Sabiranje vrednosti više polja

Primer cURL zahteva: Sabiranje vrednosti

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "sum", "field": "votes", "alias": "votes" },
        { "op": "sum", "field": "votesUp", "alias": "votesUp" }
    ]
}'

Odgovor:

Odgovor: Sabiranje vrednosti

Copy

{
    "status": "success",
    "data": [
        {
            "votes": { "numericValue": 2 },
            "votesUp": { "numericValue": 2 }
        }
    ],
    "stats": { "scanned": 2 }
}

Primer: Prosečne vrednosti više polja

Primer cURL zahteva: Prosečne vrednosti

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "avg", "field": "votes", "alias": "votes" },
        { "op": "avg", "field": "votesUp", "alias": "votesUp" }
    ]
}'

Odgovor:

Odgovor: Prosečne vrednosti

Copy

{
    "status": "success",
    "data": [
        {
            "votes": { "numericValue": 1 },
            "votesUp": { "numericValue": 1 }
        }
    ],
    "stats": { "scanned": 2 }
}

Primer: Min/Max vrednosti više polja

Primer cURL zahteva: Min/Max vrednosti

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "min", "field": "votes", "alias": "votes" },
        { "op": "min", "field": "votesUp", "alias": "votesUp" },
        { "op": "max", "field": "votes", "alias": "votes" },
        { "op": "max", "field": "votesUp", "alias": "votesUp" }
    ]
}'

Odgovor:

Odgovor: Min/Max vrednosti

Copy

{
    "status": "success",
    "data": [
        {
            "votes": { "numericValue": 0 },
            "votesUp": { "numericValue": 0 },
            "votes": { "numericValue": 2 },
            "votesUp": { "numericValue": 2 }
        }
    ],
    "stats": { "scanned": 2 }
}

Primer: Brojanje jedinstvenih vrednosti više polja

Primer cURL zahteva: Brojanje jedinstvenih vrednosti

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "distinct", "field": "urlId", "alias": "urlId" },
        { "op": "distinct", "field": "commenterEmail", "alias": "commenterEmail" }
    ]
}'

Odgovor:

Odgovor: Brojanje jedinstvenih vrednosti

Copy

{
    "status": "success",
    "data": [
        {
            "commenterEmail": {
                "distinctCounts": {
                    "someone@somewhere.com": 1,
                    "someone2@somewhere.com": 1
                }
            },
            "urlId": {
                "distinctCounts": {
                    "some-page": 2
                }
            }
        }
    ],
    "stats": { "scanned": 2 }
}

Primer: Kreiranje upita

Primer cURL zahteva: Kreiranje upita

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "groupBy": ["commenterName"],
    "query": [
        { "key": "approved", "value": true, "operator": "eq" },
        { "key": "commenterName", "value": "some-username-2", "operator": "eq" }
    ],
    "operations": [
        { "op": "sum", "field": "votes", "alias": "votes" }
    ]
}'

Odgovor:

Odgovor: Kreiranje upita

Copy

{
    "status": "success",
    "data": [
        {
            "groups": { "commenterName": "some-username-2" },
            "votes": { "numericValue": 2 }
        }
    ],
    "stats": { "scanned": 1 }
}

Primer: Brojanje komentara koji čekaju pregled

Primer cURL zahteva: Brojanje komentara koji čekaju pregled

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "query": [
        { "key": "reviewed", "value": true, "operator": "not_eq" }
    ],
    "operations": [
        { "op": "count", "field": "id", "alias": "count" }
    ]
}'

Odgovor:

Odgovor: Brojanje komentara koji čekaju pregled

Copy

{
    "status": "success",
    "data": [
        { "count": { "numericValue": 2 } }
    ],
    "stats": { "scanned": 2 }
}

Primer: Raspodela odobrenih, pregledanih i spam komentara

Primer cURL zahteva: Raspodela komentara

Copy

curl --request POST --url 'https://fastcomments.com/api/v1/aggregate?tenantId=demo&API_KEY=DEMO_API_SECRET&includeStats=true' --header 'Content-Type: application/json' --data '{
    "resourceName": "Comment",
    "operations": [
        { "op": "distinct", "field": "approved", "alias": "approved" },
        { "op": "distinct", "field": "reviewed", "alias": "reviewed" },
        { "op": "distinct", "field": "isSpam", "alias": "isSpam" }
    ]
}'

Odgovor:

Odgovor: Raspodela komentara

Copy

{
    "status": "success",
    "data": [
        {
            "approved": { "distinctCounts": { "true": 2 } },
            "reviewed": { "distinctCounts": { "false": 2 } },
            "isSpam": { "distinctCounts": { "false": 2 } }
        }
    ],
    "stats": { "scanned": 2 }
}

Strukture

Struktura zahteva za agregaciju

Copy

export type AggregationOpType = 'sum' | 'countDistinct' | 'distinct' | 'avg' | 'min' | 'max' | 'count';
/** Operacija koja će biti primenjena na polje */
export interface AggregationOperation {
    /** Polje na kojem će se izvršavati operacija */
    field: string;
    /** Tip operacije */
    op: AggregationOpType;
    /** Opcioni alias za izlaz; ako nije naveden, izračuna se podrazumevani alias */
    alias?: string;
    expandArray?: boolean;
}
export interface QueryPredicate {
    key: string
    value: string | number | boolean
    operator: 'eq' | 'not_eq' | 'greater_than' | 'less_than' | 'contains'
}
export interface AggregationRequest {
    query?: QueryPredicate[];
    resourceName: string;
    groupBy?: string[];
    operations: AggregationOperation[];
    sort?: {
        field: string;
        dir: 'asc' | 'desc';
    };
}
type DistinctAccumulator = Record<string, number>;
type GroupValues = Record<string, string>;
export type AggregationValue = {
    distinctCounts?: DistinctAccumulator
    distinctCount?: number
    numericValue?: number
    stringValue?: string
    groups?: GroupValues
};

Struktura odgovora za agregaciju

Copy

export type AggregationItem = Record<string, AggregationValue> & { groups?: GroupValues };
export interface AggregationResponse {
    status: APIStatus,
    data: AggregationItem[];
    stats?: {
        scanned: number;
        timeMS: number;
    };
}

Sledeći resursi se mogu agregirati:

AffiliateEvent
AnonymousVote
BannedUser
BatchJob
BlockedUser
Comment
CommentDeleted
CommentIdToSyncOutbound
CommentScheduled
CommentSyncLog
CustomConfig
CustomEmailTemplateRenderError
EmailToSend
EventLogEntry
ImportedCommentScheduled
ModerationGroup
Moderator
Page
PageReact
PendingVote
QuestionResult
SSOUser
SentEmail
SpamEvent
Tenant
TenantAuditLog
TenantBadge
TenantDailyUsage
TenantInvoiceHistory
TenantPackage
User
UserBadge
UserBadgeProgress
UserNotification
UserSubscription
UserUsage
Vote

Struktura audit loga

An AuditLog je objekat koji predstavlja revizijski događaj za zakupce koji imaju pristup ovoj funkciji.

Struktura za objekat AuditLog je sledeća:

Struktura AuditLog-a

Copy

interface AuditLog {
    id: string;
    /** Ko je izvršio događaj. **/
    userId?: string;
    username?: string;
    resourceName: string;
    crudType: 'c' | 'r' | 'u' | 'd' | 'login';
    from: string;
    url?: string;
    ip?: string;
    /** Pregledač koji je izvršio događaj, kada je došao iz pregledača. **/
    ua?: string;
    /** Hash sesije iz koje je događaj došao, za povezivanje radnji jedne osobe. Nikada sama sesija. **/
    sIdHashed?: string;
    when: string;
    description?: string;
    serverStartDate: string;
    /** ID objekta na kojem je događaj izvršen, nasuprot tome ko ga je izvršio. **/
    targetId?: string;
    /** Ljudski čitljiva oznaka za taj objekat, npr. "jsmith (jsmith@example.com)". **/
    targetLabel?: string;
    objectDetails?: object;
}

targetId i targetLabel opisuju na čemu je događaj izvršen; userId i username opisuju ko ga je izvršio. Za ažuriranja, objectDetails.changes sadrži {field: {from, to}} mapu onoga što se zaista promenilo.

Revizijski zapis je nepromenljiv. Takođe se ne može ručno upisivati. FastComments.com može samo odlučiti kada da upiše u revizijski zapis. Međutim, možete ga čitati putem ovog API-ja.

Događaji u revizijskom zapisu ističu nakon dve godine.

GET /api/v1/audit-logs

Resource: AuditLog as GET /api/v1/audit-logs Credit Cost: 10

Ovaj API koristi paginaciju, koju obezbeđuju parametri skip, limit, before i after. AuditLog‑ovi se vraćaju u stranicama od po 1000 po defaultu, do maksimalnog limit od 10000, poređani po when i id. Stranice su velike jer se ovaj endpoint obično koristi za izvoz istorije, a ne za interaktivno listanje.

Svaki 100 vraćenih logova košta 1 kredit.

Podrazumevano, dobićete listu sa najnovijim stavkama prvo. Na ovaj način možete da poll‑ujete počevši od skip=0, paginirajući dok ne nađete poslednji zapis koji ste potrošili.

Alternativno, možete sortirati od najstarijih ka najnovijim i paginirati dok ne ostane više zapisa.

Sortiranje se može izvršiti postavljanjem order na ASC ili DESC. Podrazumevano je DESC.

Upit po datumu je moguć putem before i after kao vremenskih oznaka u milisekundama. before i after NISU inkluzivni i bilo koji se može koristiti samostalno.

Pronalaženje šta se desilo osobi

Svaki događaj beleži ko ga je izvršio (username, userId, ip) i, odvojeno, na čemu je izvršen. targetLabel je čitljiva oznaka za taj objekat, na primer jsmith (jsmith@example.com), a targetId je njegov ID. Koristite target za podudaranje podstringa neosetljivog na veličinu slova na oznaci kada znate ime ili email osobe, ali ne i njen ID.

Brisanja beleže oznaku u trenutku događaja, tako da uklonjeni korisnik ili moderator i dalje mogu biti identifikovani nakon što osnovni zapis više ne postoji.

Upravljani tenant‑i

Ako vaš tenant upravlja drugim tenant‑ima, postavite includeManagedTenants=true da biste vratili događaje iz vašeg tenant‑a i svakog tenant‑a koji on upravlja u jednom odgovoru. tenantId svakog vraćenog loga pokazuje iz kojeg tenant‑a potiče.

AuditLog cURL Primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/audit-logs?tenantId=demo&API_KEY=DEMO_API_SECRET&skip=0&order=ASC&before=123&after=456'

AuditLog Struktura Zahteva

Copy

interface AuditLogsRequestQueryParams {
    tenantId: string
    API_KEY: string
    order?: 'ASC' | 'DESC'
    /** Maksimum 10000. Podrazumevano 1000. **/
    limit?: number
    skip?: number
    before?: number
    after?: number
    /** Samo događaji izvršeni od strane ovog korisničkog imena. **/
    username?: string
    /** Samo događaji sa ove IP adrese. **/
    ip?: string
    /** Samo događaji ovog tipa. **/
    crudType?: 'c' | 'r' | 'u' | 'd' | 'login'
    /** Samo događaji za ovaj resurs, npr. User ili Moderator. **/
    resourceName?: string
    /** Samo događaji čiji pogođeni objekat ima ovaj ID. **/
    targetId?: string
    /** Podudaranje podstringa neosetljivog na veličinu slova na oznaci pogođenog objekta. **/
    target?: string
    /** Takođe vrati događaje iz tenant‑a koje ovaj tenant upravlja. **/
    includeManagedTenants?: boolean
}

AuditLog Struktura Odgovora

Copy

interface AuditLogsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'invalid-limit' | 'invalid-skip'
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Logovi! **/
    auditLogs: AuditLog[]
}

Struktura batch job-a

A BatchJob je zadatak koji traje dugo, poput uvoza, izvoza ili migracije stranice. Poslovi se stavljaju u red, a zatim se preuzimaju i izvršavaju u pozadini.

processedCount i totalCount prikazuju napredak. Njihova jedinica zavisi od type:

-a migrate-pages: migracije završene, od zahtevanih migracija.

undo-page-migration: zapisi vraćeni. Nema totalCount.
import, export i drugi poslovi: obrađeni redovi.

Struktura objekta BatchJob je sledeća:

Struktura BatchJob

Copy

interface BatchJob {
    id: string
    /** Na primer migrate-pages, undo-page-migration, migrate-domains, import, export, users-export ili copy-comments. **/
    type: string
    status: 'requested' | 'running' | 'success' | 'failed'
    createdAt: string
    completedAt?: string
    processedCount: number
    /** Ukupni rad, kada je poznat unapred. **/
    totalCount?: number
    /** migrate-pages: jedan unos po završnoj migraciji, po redosledu zahteva. **/
    pageMigrationResults?: Array<PageMigrationSuccess | PageMigrationFailure>
    /**
     * migrate-pages: postavljeno kada posao završi (uspeh ili neuspeh). Prosledite na POST /api/v1/pages/migrations/:undoId/undo u roku od 90 dana.
     * undo-page-migration: migracija koja se poništava.
     **/
    undoId?: string
    /** undo-page-migration: postavljeno kada posao završi. **/
    pageMigrationUndoResult?: PageMigrationUndoResult
}
interface PageMigrationSuccess {
    from: string
    to: string
    type: 'urlId' | 'domain'
    status: 'success'
    commentsMigrated: number
}
interface PageMigrationFailure {
    from: string
    to: string
    type: 'urlId' | 'domain'
    status: 'failed'
    code: string
    reason: string
}
interface PageMigrationUndoResult {
    /** Zapisi vraćeni na svoje vrednosti pre migracije. **/
    restored: number
    /** Zapisi ostavljeni nepromenjeni jer su se promenili nakon migracije, ili više ne postoje. **/
    skipped: number
    /** Zapisi migracije obrisani prilikom spajanja stranica. Ovi se ne mogu vratiti. **/
    notRestorable: number
}

Pokušaji ponovnog izvršavanja

Ako se server koji izvršava posao migracije stranice restartuje, posao se vraća u red i nastavlja nakon poslednje završene migracije. Posao se pokušava najviše 3 puta, nakon čega njegov status postaje failed.

GET /api/v1/batch-jobs

Resource: BatchJob as GET /api/v1/batch-jobs Credit Cost: 1

Ova ruta vraća batch poslove zakupca svih tipova, najnovije prvo, po 100 po stranici. Koristite type i status da suzite listu, i skip za paginaciju.

BatchJob Lista cURL Primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/batch-jobs?tenantId=demo&API_KEY=DEMO_API_SECRET&type=migrate-pages&status=running'

BatchJob Lista Struktura Zahteva

Copy

interface BatchJobsQueryParams {
    tenantId: string
    API_KEY: string
    /** Samo poslovi ovog tipa, na primer migrate-pages. **/
    type?: string
    status?: 'requested' | 'running' | 'success' | 'failed'
    /** Koliko poslova treba preskočiti, za paginaciju. Ne-negativni ceo broj. **/
    skip?: number
}

BatchJob Lista Struktura Odgovora

Copy

interface BatchJobsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'invalid-skip' | 'internal'
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Najnovije prvo, najviše 100. **/
    batchJobs?: BatchJob[]
}

GET /api/v1/batch-jobs/:id

Resource: BatchJob as GET /api/v1/batch-jobs/:id Credit Cost: 1

Ova ruta vraća status, napredak i, kada se završi, rezultat jednog batch posla. Koristite je da pratite posao koji je započet putem POST /api/v1/pages/migrations ili POST /api/v1/pages/migrations/:undoId/undo.

Posao se smatra završenim kada je njegov status success ili failed. Svaki poziv košta 1 kredit, pa zato poll-ujte svakih nekoliko sekundi umesto kontinuirano.

BatchJob po ID cURL primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/batch-jobs/my-batch-job-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

BatchJob po ID struktura zahteva

Copy

interface BatchJobQueryParams {
    tenantId: string
    API_KEY: string
}

BatchJob po ID struktura odgovora

Copy

interface BatchJobResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'internal'
    /** Uključeno u slučaju greške. **/
    reason?: string
    batchJob?: BatchJob
}

Završeni primer zadatka migracije stranice

Copy

{
    "status": "success",
    "batchJob": {
        "id": "my-batch-job-id",
        "type": "migrate-pages",
        "status": "success",
        "createdAt": "2026-10-19T16:00:00.000Z",
        "completedAt": "2026-10-19T16:00:12.000Z",
        "processedCount": 2,
        "totalCount": 2,
        "pageMigrationResults": [
            {"from": "old-post-id", "to": "new-post-id", "type": "urlId", "status": "success", "commentsMigrated": 42},
            {"from": "old.example.com", "to": "new.example.com", "type": "domain", "status": "success", "commentsMigrated": 1250}
        ],
        "undoId": "my-undo-id"
    }
}

Struktura komentara

A Comment object predstavlja komentar ostavljen od strane korisnika.

Odnos između roditeljskih i dečijih komentara je definisan putem parentId.

Struktura za Comment objekat je sledeća:

Struktura Comment objekta

Copy

interface Comment {
    /** SAMO ZA ČITANJE: Podesiti na true ako je anti-spam motor odredio da je komentar spam. **/
    aiDeterminedSpam?: boolean
    /** Da li je komentar odobren za prikaz. Podesi na true prilikom čuvanja komentara, u suprotnom će biti sakriven. **/
    approved?: boolean
    /** Korisnikov avatar. **/
    avatarSrc?: string
    /** Dečiji komentari. Nisu popunjeni u svim scenarijima. Koristi se kada je asTree podešen na true preko API-ja. **/
    children: Comment[]
    /** Sirovi komentar koji je unela osoba. **/
    comment: string
    /** SAMO ZA ČITANJE: Komentar parse-ovan u HTML. **/
    commentHTML?: string
    /** Email osobe koja komentariše. Obavezno ako je anonimno komentarisanje isključeno. **/
    commenterEmail?: string
    /** Link osobe koja komentariše (na primer njihov blog). **/
    commenterLink?: string
    /** Ime osobe koja komentariše. Uvek obavezno. Ako nije dostupno, postavite nešto poput "Anonymous". **/
    commenterName: string
    /** Datum kada je komentar ostavljen, u UTC epoch formatu. **/
    date: number
    /** "Prikazna etiketa" za komentar - na primer "Admin", "Moderator", ili nešto poput "VIP User". **/
    displayLabel?: string
    /** Domen na kojem je komentar objavljen. **/
    domain?: string
    /** SAMO ZA ČITANJE: Broj puta koliko je komentar označen (flagovan). **/
    flagCount?: number
    /** Broj #hashtag-ova upisanih u komentar koji su uspešno parsirani. Takođe možete ručno dodavati heštegove, za pretragu, ali oni se neće automatski prikazivati u tekstu komentara. **/
    hashTags?: CommentHashTag[]
    /** SAMO ZA ČITANJE: Da li komentar sadrži slike? **/
    hasImages?: boolean
    /** SAMO ZA ČITANJE: Da li komentar sadrži linkove? **/
    hasLinks?: boolean
    /** SAMO ZA ČITANJE: Jedinstveni id komentara. **/
    id: string
    /** Samo prilikom kreiranja! Ovo se hešira za skladištenje. **/
    ip?: string
    /** SAMO ZA ČITANJE: Da li je trenutni korisnik blokirao korisnika koji je napisao ovaj komentar? **/
    isBlocked?: boolean
    /** SAMO ZA ČITANJE: Da li je komentar od admina? Automatski se podešava na osnovu userId. **/
    isByAdmin?: boolean
    /** SAMO ZA ČITANJE: Da li je komentar od moderatora? Automatski se podešava na osnovu userId. **/
    isByModerator?: boolean
    /** Podesiti na true ako je komentar privremeno obrisan (morao je ostati rezervni zapis zbog neke druge konfiguracije). **/
    isDeleted?: boolean
    /** Podesiti na true ako je korisnički nalog obrisan, a komentar je morao biti sačuvan. **/
    isDeletedUser?: boolean
    /** SAMO ZA ČITANJE: Da li je komentara označen od strane trenutno prijavljenog korisnika (contextUserId)? **/
    isFlagged?: boolean
    /** Da li je komentar prikvačen (pinned)? **/
    isPinned?: boolean
    /** Da li je komentar zaključan? Kada je true, niko (uključujući moderatore) ne može odgovoriti, izmeniti ili obrisati komentar dok se ne otključa. **/
    isLocked?: boolean
    /** Da li je komentar spam? **/
    isSpam?: boolean
    /** SAMO ZA ČITANJE: Da li je komentar ocenjen negativno od strane trenutnog korisnika (contextUserId)? **/
    isVotedDown?: boolean
    /** SAMO ZA ČITANJE: Da li je komentar ocenjen pozitivno od strane trenutnog korisnika (contextUserId)? **/
    isVotedUp?: boolean
    /** Lokal u kojem je komentar. Ako nije naveden, biće izveden iz HTTP Accept-Language zaglavlja. **/
    locale?: 'de_de' | 'en_us' | 'es_es' | 'fr_fr' | 'it_it' | 'ja_jp' | 'ko_kr' | 'pl_pl' | 'pt_br' | 'ru_ru' | 'tr_tr' | 'zh_cn' | 'zh_tw'
    /** SAMO ZA ČITANJE: @pomeni upisani u komentar koji su uspešno parsirani. **/
    mentions?: CommentUserMention[]
    /** Opcionalni metapodaci povezani sa komentarom. **/
    meta?: Record<string, string | number | boolean>
    /** Opcionalna lista ID-eva grupa za moderaciju povezanih sa ovim komentarom. **/
    moderationGroupIds?: string[]|null
    /** SAMO ZA ČITANJE: ID objekta glasanja koji odgovara glasu trenutnog korisnika (contextUserId) za ovaj komentar. **/
    myVoteId?: string
    /** Da li su za ovaj komentar poslata obaveštenja komentarima. Da biste sprečili slanje obaveštenja prilikom uvoza, postavite ovo na true. **/
    notificationSentForParent?: boolean
    /** Da li su za ovaj komentar poslata obaveštenja tenant korisnicima. Da biste sprečili slanje obaveštenja prilikom uvoza, postavite ovo na true. **/
    notificationSentForParentTenant?: boolean
    /** Naslov stranice na kojoj je ovaj komentar. **/
    pageTitle?: string
    /** Ako odgovaramo na komentar, ovo je ID na koji odgovaramo. **/
    parentId?: string|null
    /** Da li je komentar označen kao pregledan. **/
    reviewed: boolean
    /** ID tenanta kojem komentar pripada. **/
    tenantId: string
    /** Korisnik koji je napisao komentar. Kreira se automatski pri čuvanju komentara sa imenom/email-om. **/
    userId?: string|null
    /** URL lokacije na kojoj je ovaj komentar vidljiv, kao na primer blog post. **/
    url: string
    /** "Očišćena" verzija urlId koju ste poslali. Prilikom čuvanja specificirate ovo polje, ali kada povučete komentar nazad ovo će biti "očišćeno" i vaša originalna vrednost biće pomerena u "urlIdRaw". **/
    urlId: string
    /** SAMO ZA ČITANJE: Originalni urlId koji ste poslali. **/
    urlIdRaw?: string
    /** Da li je korisnik i ovaj komentar verifikovan? **/
    verified: boolean
    /** Broj pozitivnih glasova. **/
    votesUp?: number
    /** Broj negativnih glasova. **/
    votesDown?: number
    /** "Karma" komentara (= votes up - votes down). **/
    votes?: number
}

Neka od ovih polja su označena kao READONLY - ona se vraćaju od strane API-ja, ali ne mogu se postaviti.

Struktura teksta komentara

Komentari se pišu u FastComments varijanti markdown-a, što je standardni markdown plus tradicionalne bbcode stil oznake za slike, poput [img]path[/img].

Tekst se čuva u dva polja. Tekst koji je korisnik uneo se čuva neizmenjen u polju comment. Ovo se renderuje i čuva u polju commentHTML.

Dozvoljeni HTML tagovi su b, u, i, strike, pre, span, code, img, a, strong, ul, ol, li, and br.

Preporučuje se da renderujete HTML, pošto je reč o vrlo malom podskupu HTML-a i izrada renderer-a je prilično jednostavna. Postoji više biblioteka za React Native i Flutter, na primer, koje mogu pomoći u tome.

Možete odlučiti da renderujete ne-normalizovanu vrednost polja comment. Primer parsera je ovde..

Primer parsera se takođe može prilagoditi da radi sa HTML-om i transformiše HTML tagove u očekivane elemente za prikaz na vašoj platformi.

Označavanje

Kada su korisnici označeni u komentaru, informacije se čuvaju u listi nazvanoj mentions. Svaki objekat u toj listi ima sledeću strukturu.

Objekat pomena u komentaru

Copy

Run

interface CommentUserMention {
    /** ID korisnika. Za SSO korisnike, ovo će imati prefiks vašeg tenant ID-a. **/
    id: string
    /** Konačni @mention tag tekst, uključujući @ simbol. **/
    tag: string
    /** Originalni @mention tag tekst, uključujući @ simbol. **/
    rawTag: string
    /** Koji tip korisnika je označen. user = FastComments.com nalog. sso = SSOUser. **/
    type: 'user'|'sso'
    /** Ako se korisnik odjavi od notifikacija, ovo će i dalje biti postavljeno na true. **/
    sent: boolean
}

Haštagovi

Kada se koriste haštagovi i uspešno se parsiraju, informacije se čuvaju u listi nazvanoj hashTags. Svaki objekat u toj listi ima sledeću strukturu. Haštagovi se takođe mogu ručno dodati u niz hashTags komentara za potrebe pretrage, ako je retain podešen.

Objekat haštagova komentara

Copy

Run

interface CommentHashTag {
    /** ID haštag-a. **/
    id: string
    /** Konačni #hashtag tag tekst, uključujući # simbol. **/
    tag: string
    /** Ako je haštag povezan sa prilagođenim URL-om, ovo će biti definisano. **/
    url?: string
    /** Da li treba da zadržimo haštag, čak i ako se ne nalazi u tekstu komentara, kada se komentar ažurira. Korisno za označavanje komentara bez promene teksta komentara. **/
    retain?: boolean
}

GET /api/v1/comments

Resource: Comment as GET /api/v1/comments Credit Cost: 1

Ovaj API se koristi za preuzimanje komentara za prikaz korisniku. Na primer, automatski filtrira neodobrene komentare i spam.

Paginacija

Paginacija se može izvršiti na jedan od dva načina, u zavisnosti od zahteva za performansama i slučaja upotrebe:

Najbrže: Prethodno izračunata paginacija:
1. tako FastComments radi kada koristite naše gotove vidžete i klijente.
2. Klik na "next" jednostavno povećava broj stranice.
3. Možete ovo zamisliti kao preuzimanje iz key-value skladišta.
4. Na ovaj način, jednostavno definišite parametar page počevši od 0 i smer sortiranja kao direction.
5. Veličine stranica mogu se prilagoditi pravilima prilagođavanja.
Najfleksibilnije: Fleksibilna paginacija:
1. Na ovaj način možete definisati prilagođene parametre limit i skip. Ne prosleđujte page.
2. Podržan je i smer sortiranja direction.
3. limit je ukupan broj koji se vraća nakon primene skip.
  - Primer: postavite skip = 200, limit = 100 kada je page size = 100 i page = 2.
4. Podređeni komentari se i dalje računaju u paginaciju. Ovo možete zaobići pomoću opcije asTree.
  - Podređene komentare možete paginirati pomoću limitChildren i skipChildren.
  - Dubinu vraćenih niti možete ograničiti pomoću maxTreeDepth.

Niti (Threads)

Kada koristite Precalculated Pagination, komentari su grupisani po stranici i komentari u nitima utiču na ukupnu stranicu.
1. Na ovaj način, niti se mogu odrediti na klijentu na osnovu parentId.
2. Na primer, sa stranicom koja ima jedan komentar najvišeg nivoa i 29 odgovora, i postavljanjem page=0 u API-ju - dobićete samo komentar najvišeg nivoa i 29 podređenih komentara.
Kada koristite Flexible Pagination, možete definisati parametar parentId.
1. Postavite ovo na null da biste dobili samo komentare najvišeg nivoa.
2. Zatim, da biste pregledali niti, ponovo pozovite API i prosledite parentId.
3. Uobičajeno rešenje je da se napravi API poziv za komentare najvišeg nivoa, a zatim paralelni API pozivi za preuzimanje komentara podređenih elemenata svakog komentara.
NOVO od Feb 2023! Preuzimanje kao stablo korišćenjem &asTree=true.
1. Ovo možete zamisliti kao Flexible Pagination as a Tree.
2. Samo komentari najvišeg nivoa se računaju u paginaciju.
3. Postavite parentId=null da stablo počne od korena (morate postaviti parentId).
4. Postavite skip i limit za paginaciju.
5. Postavite asTree na true.
6. Cena u kreditima se povećava 2x, jer naš backend u ovom scenariju mora da uradi mnogo više posla.
7. Postavite maxTreeDepth, limitChildren i skipChildren po želji.

Objašnjenje stabala

Kada koristite asTree, paginacija može biti teška za razumevanje. Evo korisne grafike:

Dijagram paginacije stabla

Preuzimanje komentara u kontekstu korisnika

API /comments može se koristiti u dva konteksta, za različite slučajeve upotrebe:

Za vraćanje komentara sortiranih i označenih informacijama za izgradnju sopstvenog klijenta.
- U tom slučaju, definišite query parametar contextUserId.
Za preuzimanje komentara sa vašeg backend-a za prilagođene integracije.
- Platforma će podrazumevano koristiti ovo bez contextUserId.

Prethodno izračunata paginacija komentara

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&page=0&urlId=test&API_KEY=DEMO_API_SECRET&direction=MR'

Fleksibilna paginacija komentara

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&urlId=test&API_KEY=DEMO_API_SECRET&direction=MR&skip=20&limit=10'

Fleksibilna paginacija komentara u kontekstu korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&urlId=test&API_KEY=DEMO_API_SECRET&direction=MR&skip=20&limit=10&contextUserId=my-user-id'

Fleksibilna paginacija komentara u kontekstu korisnika, samo komentari najvišeg nivoa

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&urlId=test&API_KEY=DEMO_API_SECRET&direction=MR&skip=20&limit=10&contextUserId=my-user-id&parentId=null'

Preuzimanje komentara kao stablo

Moguće je dobiti komentare vraćene kao stablo, gde paginacija računa samo komentare najvišeg nivoa.

Komentari kao stablo u kontekstu korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&urlId=test&API_KEY=DEMO_API_SECRET&direction=MR&skip=20&limit=10&contextUserId=my-user-id&parentId=null&asTree=true'

Želite samo komentare najvišeg nivoa i neposredne podređene komentare? Evo jednog načina:

Komentari kao stablo sa maksimalnom dubinom

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&urlId=test&API_KEY=DEMO_API_SECRET&direction=MR&skip=20&limit=10&contextUserId=my-user-id&parentId=null&asTree=true&maxTreeDepth=1&limitChildren=10'

Međutim, u vašem UI-ju možda treba da znate da li prikazati dugme "prikaži odgovore" na svakom komentaru. Prilikom preuzimanja komentara kao stabla postoji svojstvo hasChildren koje se dodaje komentarima kada je primenljivo.

Preuzimanje komentara kao stablo, pretraga po heštegu

Moguće je pretraživati po heštegu korišćenjem API-ja, u okviru celog vašeg tenanta (ne ograničeno na jednu stranicu ili urlId).

U ovom primeru izostavljamo urlId i pretražujemo po više heštegova. API će vratiti samo komentare koji imaju sve tražene heštegove.

Komentari kao stablo u kontekstu korisnika, po heštegu

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&API_KEY=DEMO_API_SECRET&direction=MR&skip=20&limit=10&contextUserId=my-user-id&parentId=null&asTree=true&hashTag=TestTag&hashTag=OtherTestTag'

Svi parametri zahteva

Struktura zahteva za komentare

Copy

interface CommentsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** The urlId (page url, or article id) the comments are associated with. **/
    urlId?: string
    /** Limit the comments returned by this user. **/
    userId?: string
    /** Use this to search by hashtag. To drill down to the intersection of multiple hashtags, do &hashTag=a&hashTag=b. **/
    hashTag?: string
    /** The sort direction. Default is MR (Most Relevant). Other options are OF (Oldest First) and NF (Newest First). **/
    direction?: 'MR' | 'OF' | 'NF'
    /** Precalculated Pagination: The page to fetch, starting with 0. Pass -1 for all comments (up to 250). **/
    page?: number
    /** Flexible Pagination: How many comments should we return? **/
    limit?: number
    /** Flexible Pagination: How many child comments should we return for each parent? **/
    limitChildren?: number
    /** Flexible Pagination: How many comments should we skip? **/
    skip?: number
    /** Flexible Pagination: How many child comments should we skip for each parent? **/
    skipChildren?: number
    /** For determining blocked and flagged comments. **/
    contextUserId?: string
    /** For determining blocked and flagged comments. **/
    anonUserId?: string
    /** For fetching child comments. **/
    parentId?: string
    /** For fetching as a tree. **/
    asTree?: boolean
    /** How far into the tree should we return data? 0 returns no children. 1 returns immediate children, etc. **/
    maxTreeDepth?: number
}

Odgovor

Struktura odgovora za komentare

Copy

interface CommentsResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'missing-date' | 'unauthorized-page' | 'invalid-pagination-request' | 'invalid-limit' | 'invalid-limit-children' | 'invalid-skip' | 'invalid-skip-children' | 'invalid-max-tree-depth'
    /** Included on failure. **/
    reason?: string
    /** The comments! **/
    comments: Comment[]
}

Korisni saveti

URL ID

Verovatno želite da koristite Comment API sa parametrom urlId. Prvo možete pozvati Pages API da vidite kako izgledaju dostupne vrednosti urlId.

Anonimne akcije

Za anonimno komentiranje verovatno želite da prosledite anonUserId prilikom preuzimanja komentara, kao i prilikom prijavljivanja i blokiranja.

(!) Ovo je obavezno za mnoge prodavnice aplikacija, jer korisnici moraju moći da prijave sadržaj koji su kreirali korisnici a koji mogu da vide, čak i ako nisu prijavljeni. Nepoštovanje ovoga može dovesti do uklanjanja vaše aplikacije iz date prodavnice.

Komentari se ne vraćaju

Proverite da li su vaši komentari odobreni i da nisu spam.

GET /api/v1/comments/:id

Resource: Comment as GET /api/v1/comments/:id Credit Cost: 1

Ovaj API omogućava preuzimanje pojedinačnog komentara po id-u.

Primer cURL zahteva: Preuzimanje komentara po id-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/comments/some-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za preuzimanje komentara po id-u

Copy

interface CommentsGetByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za preuzimanje komentara po id-u

Copy

interface CommentGetByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'missing-id'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Komentar! **/
    comment?: Comment
}

POST /api/v1/comments

Resource: Comment as POST /api/v1/comments Credit Cost: 1

Ovaj API endpoint omogućava kreiranje komentara.

Uobičajeni slučajevi upotrebe su prilagođeni UI-ji, integracije, ili uvozi.

Napomene:

Ovaj API može ažurirati widget za komentare „u realnom vremenu“ ako se želi (ovo povećava creditsCost sa 1 na 2).
Ovaj API će automatski kreirati objekte korisnika u našem sistemu ako je naveden email.
Pokušaj da se sačuvaju dva komentara sa različitim emailovima, ali istim korisničkim imenom, rezultiraće greškom za drugi komentar.
Ako specificirate parentId, i ukoliko dečiji komentar ima notificationSentForParent postavljeno na false, poslaćemo notifikacije za roditeljski komentar. Ovo se radi na svakih sat vremena (grupisemo notifikacije kako bismo smanjili broj poslatih emailova).
Ako želite slati welcome email-ove prilikom kreiranja korisnika, ili email-ove za verifikaciju komentara, postavite sendEmails na true u query parametrima.
Komentari kreirani preko ovog API-ja će se pojaviti na stranicama Analitike i Moderacije u admin aplikaciji.
"neprimerene reči" su i dalje maskirane u imenima komentatora i tekstu komentara ako je podešavanje uključeno.
Komentari kreirani putem ovog API-ja i dalje mogu biti provereni za spam ako je potrebno.
Konfiguracije kao što je maksimalna dužina komentara, ukoliko su podešene preko admin stranice Customization Rule, važiće ovde.

Minimalni podaci potrebni za slanje koji će se prikazati u widgetu za komentare su sledeći:

Minimalni cURL POST primer za komentar

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&API_KEY=DEMO_API_SECRET&isLive=true' \
  --header 'Content-Type: application/json' \
  --data '{
	"approved": true,
	"comment": "some-comment",
	"commenterName": "some-commenter-name",
	"date": 1622644382148,
	"urlId": "some-place",
	"url": "https://exmaple.com/some-page",
	"verified": true
}'

Realniji zahtev može izgledati ovako:

cURL POST primer za komentar

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments?tenantId=demo&API_KEY=DEMO_API_SECRET&isLive=true&doSpamCheck=true' \
  --header 'Content-Type: application/json' \
  --data '{
	"approved": true,
	"avatarSrc": "https://static.fastcomments.com/1605337537848-DSC_0841.JPG",
	"comment": "some-comment",
	"commenterName": "some-commenter-name",
	"commenterEmail": "fordperfect@spaceship.com",
	"date": 1622644382148,
	"isSpam": false,
	"locale": "en_us",
	"notificationSentForParent": true,
	"notificationSentForParentTenant": true,
	"reviewed": true,
	"urlId": "some-place",
	"url": "https://exmaple.com/some-page",
	"verified": true,
	"votes": 1,
	"votesUp": 2,
	"votesDown": 1,
	"ip": "123.456.789.000"
}'

Struktura POST zahteva za komentar

Copy

interface CommentPostQueryParams {
    tenantId: string
    API_KEY: string
    doSpamCheck?: 'true' | 'false'
	/** Da li komentar treba da se pojavi "uživo" korisnicima koji gledaju instance widgeta za komentare sa istim urlId. NAPOMENA: Duplira trošak kredita sa 1 na 2. **/
    isLive?: 'true' | 'false'
    sendEmails?: 'true' | 'false'
    populateNotifications?: 'true' | 'false'
}

Struktura odgovora POST zahteva za komentar

Copy

interface CommentPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'empty-comment' | 'comment-too-big' | 'hash-tags-readonly' | 'mentions-readonly' | 'invalid-user' | 'unauthorized' | 'invalid-date' | 'invalid-name' | 'invalid-name-is-email' | 'banned' | 'invalid-email';
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Kreirani komentar. **/
    comment?: Comment
    /** Povezani korisnik, koji je možda već postojao ili možda nije. **/
    user?: User
}

PATCH /api/v1/comments/:id

Resource: Comment as PATCH /api/v1/comments/:id Credit Cost: 1

Ovaj API endpoint omogućava ažuriranje jednog komentara.

Notes:

Ovaj API može ažurirati widget komentara "uživo" ako je potrebno (ovo povećava osnovni creditsCost sa 1 na 2).
- Ovo može učiniti migraciju komentara između stranica "uživo" (promena urlId).
- Migracije koštaju dodatna 2 kredita jer se stranice prethodno proračunavaju i to je zahtevno za CPU.
Za razliku od create API-ja, ovaj API NEĆE automatski kreirati korisničke objekte u našem sistemu ako je email naveden.
Komentari ažurirani putem ovog API-ja i dalje mogu biti provereni na spam ako je potrebno.
Konfiguracije poput maksimalne dužine komentara, ako su podešene preko Customization Rule admin stranice, primenjivaće se ovde.
Da biste dozvolili korisnicima da ažuriraju tekst komentara, možete jednostavno navesti comment u telu zahteva. Mi ćemo generisati odgovarajući commentHTML.
- Ako definišete i comment i commentHTML, mi nećemo automatski generisati HTML.
- Ako korisnik doda pominjanja ili heštegove u svom novom tekstu, oni će i dalje biti obrađeni kao kod POST API-ja.
Prilikom ažuriranja commenterEmail na komentaru, najbolje je takođe navesti userId. U suprotnom, morate osigurati da korisnik sa tom email adresom pripada vašem tenant-u, inače će zahtev neuspeti.
Ako je ciljanim komentar zaključan (isLocked: true), zahtev se odbija sa code: 'locked'. Prvo otključajte komentar, ažurirajte ga, a zatim ga ponovo zaključajte ako želite.

Minimalni primer cURL PATCH za komentar

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET&isLive=true' \
  --header 'Content-Type: application/json' \
  --data '{
	"comment": "some-new-comment-text"
}'

Struktura PATCH zahteva za komentar

Copy

interface CommentPatchQueryParams {
    tenantId: string
    API_KEY: string
	/** Korisnik koji vrši ažuriranje. Po potrebi se može koristiti da se proveri da li mogu da urede komentar.  **/
    contextUserId?: string
	/** Da li treba da proverimo da li novi komentar izgleda kao spam?  **/
    doSpamCheck?: 'true' | 'false'
	/** Da li komentar treba da se pojavi "uživo" korisnicima koji gledaju instance widgeta komentara sa istim urlId. NAPOMENA: Povećava cenu kredita sa 1 na 2. **/
    isLive?: 'true' | 'false'
}

Struktura PATCH odgovora za komentar

Copy

interface CommentPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'empty-comment' | 'comment-too-big' | 'hash-tags-readonly' | 'mentions-readonly' | 'invalid-user' | 'unauthorized' | 'invalid-date' | 'invalid-name' | 'invalid-name-is-email' | 'banned' | 'invalid-email' | 'invalid-input' | 'missing-id' | 'not-found' | 'locked'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

DELETE /api/v1/comments/:id

Resource: Comment as DELETE /api/v1/comments/:id Credit Cost: 1

Ovaj API endpoint omogućava brisanje komentara.

Napomene:

Ovaj API može ažurirati widget komentara uživo ako je potrebno (ovo povećava creditsCost sa 1 na 2).
Ovaj API će obrisati sve podkomentare.
Ako je ciljani komentar zaključan (isLocked: true), zahtev se odbija sa code: 'locked'. Prvo otključajte komentar, pa zatim obrišite.

Primer cURL zahteva za brisanje komentara

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json'

Struktura zahteva za brisanje komentara

Copy

interface CommentDeleteQueryParams {
    tenantId: string
    API_KEY: string
	/** Korisnik koji vrši ažuriranje. Po potrebi se može koristiti za proveru da li može obrisati komentar.  **/
    contextUserId?: string
	/** Da li komentar treba biti obrisan uživo za korisnike koji gledaju instance widgeta komentara sa istim urlId. NAPOMENA: Udupljuje trošak kredita sa 1 na 2. **/
    isLive?: 'true' | 'false'
}

Struktura odgovora za brisanje komentara

Copy

interface CommentDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'locked'
    /** Uključeno pri neuspehu. **/
    reason?: string
}

POST /api/v1/comments/:id/flag

Resource: Comment as POST /api/v1/comments/:id/flag Credit Cost: 1

Ovaj API endpoint omogućava označavanje (flag) komentara za određenog korisnika.

Napomene:

Ovaj poziv mora uvek biti izvršen u kontekstu korisnika. Korisnik može biti FastComments.com korisnik, SSO korisnik, ili Tenant korisnik.
Ako je postavljen prag za sakrivanje prilikom dostizanja broja oznaka, komentar će biti automatski sakriven uživo nakon što je označen definisani broj puta.
Nakon što je automatski neodobren (sakriven) — komentar može ponovo odobriti samo administrator ili moderator. Uklanjanje oznake neće ponovo odobriti komentar.

Primer cURL zahteva za označavanje komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/flag?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=some-user-id' \
  --header 'Content-Type: application/json'

Za anonimno označavanje, moramo navesti anonUserId. Ovo može biti ID koji predstavlja anonimnu sesiju, ili nasumični UUID. Ovo nam omogućava podršku za označavanje i uklanjanje oznake komentara čak i ako korisnik nije prijavljen. Na taj način, komentar može biti prikazan kao označen kada se komentari dohvate sa istim anonUserId.

Primer cURL zahteva za anonimno označavanje komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/flag?tenantId=demo&API_KEY=DEMO_API_SECRET&anonUserId=some-anon-user-id' \
  --header 'Content-Type: application/json'

Struktura zahteva za označavanje komentara

Copy

interface CommentFlagQueryParams {
    tenantId: string
    API_KEY: string
    userId?: string
    anonUserId?: string
}

Struktura odgovora za označavanje komentara

Copy

interface CommentFlagResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id'
    /** Uključeno pri neuspehu. **/
    reason?: string
    /** Da li je komentar bio neodobren (sakriven) zbog toga što je bio označen previše puta? **/
    wasUnapproved?: boolean;
}

POST /api/v1/comments/:id/un-flag

Resource: Comment as POST /api/v1/comments/:id/un-flag Credit Cost: 1

Ovaj API endpoint omogućava uklanjanje oznake (un-flag) sa komentara za određenog korisnika.

Napomene:

Ovaj poziv mora uvek biti izvršen u kontekstu korisnika. Korisnik može biti FastComments.com User, SSO User, ili Tenant User.
Nakon što je komentar automatski neodobren (sakriven) - komentar može ponovo biti odobren samo od strane administratora ili moderatora. Uklanjanje oznake (un-flag) neće ponovo odobriti komentar.

cURL primer: uklanjanje oznake komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/un-flag?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=some-user-id' \
  --header 'Content-Type: application/json'

Za anonimno označavanje, moramo navesti anonUserId. To može biti ID koji predstavlja anonimnu sesiju, ili nasumičan UUID.

cURL primer: anonimno uklanjanje oznake komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/un-flag?tenantId=demo&API_KEY=DEMO_API_SECRET&anonUserId=some-anon-user-id' \
  --header 'Content-Type: application/json'

Struktura zahteva za uklanjanje oznake komentara

Copy

interface CommentFlagQueryParams {
    tenantId: string
    API_KEY: string
    userId?: string
    anonUserId?: string
}

Struktura odgovora za uklanjanje oznake komentara

Copy

interface CommentUnFlagResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

POST /api/v1/comments/:id/block

Resource: Comment as POST /api/v1/comments/:id/block Credit Cost: 1

Ovaj API endpoint omogućava blokiranje korisnika koji je napisao određeni komentar. Podržava blokiranje komentara koje su napisali FastComments.com Users, SSO Users i Tenant Users.

Podržava commentIdsToCheck body parametar za proveru da li bi bilo koji drugi potencijalno vidljivi komentari na klijentu trebali biti blokirani/odblokirani nakon izvođenja ove akcije.

Beleške:

Ovaj poziv mora uvek biti izvršen u kontekstu korisnika. Korisnik može biti FastComments.com User, SSO User ili Tenant User.
userId u zahtevu je korisnik koji izvršava blokiranje. Na primer: User A želi da blokira User B. Prosledi userId=User A i id komentara koji je User B napisao.
Potpuno anonimni komentari (bez user id, bez email-a) ne mogu biti blokirani i vratiće se greška.

Primer cURL zahteva za blokiranje komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/block?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=some-user-id' \
  --header 'Content-Type: application/json'

Za anonimno blokiranje, moramo navesti anonUserId. To može biti ID koji predstavlja anonimnu sesiju, ili nasumični UUID. Ovo nam omogućava podršku za blokiranje komentara čak i ako korisnik nije prijavljen, tako što ćemo dovući komentare sa istim anonUserId.

Primer cURL zahteva za blokiranje anonimnog komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/block?tenantId=demo&API_KEY=DEMO_API_SECRET&anonUserId=some-anon-user-id' \
  --header 'Content-Type: application/json'

Struktura zahteva za blokiranje komentara

Copy

interface CommentBlockQueryParams {
    tenantId: string
    API_KEY: string
    userId?: string
    anonUserId?: string
    commentIdsToCheck?: string[]
}

Struktura odgovora za blokiranje komentara

Copy

interface CommentBlockResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id' | 'comment-cannot-be-blocked'
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Ako je commentIdsToCheck definisan, unosi u ovoj mapi sa vrednošću true su takođe blokirani. **/
    commentStatuses?: Record<string, boolean>;
}

POST /api/v1/comments/:id/un-block

Resource: Comment as POST /api/v1/comments/:id/un-block Credit Cost: 1

Ovaj API endpoint omogućava poništavanje blokiranja korisnika koji je napisao dati komentar. Podržava poništavanje blokiranja komentara koje su napisali FastComments.com korisnici, SSO korisnici i Tenant korisnici.

Podržan je body parametar commentIdsToCheck koji proverava da li bi ostali potencijalno vidljivi komentari na klijentu trebalo da budu blokirani/poništeni nakon što se ova akcija izvrši.

Napomene:

Ovaj poziv mora uvek biti izvršen u kontekstu korisnika. Korisnik može biti FastComments.com korisnik, SSO korisnik ili Tenant korisnik.
userId u zahtevu je korisnik koji poništava blokiranje. Na primer: User A želi da poništi blokiranje User B. Prosledi userId=User A i ID komentara koji je User B napisao.
Potpuno anonimni komentari (bez user id, bez email) ne mogu biti blokirani i biće vraćena greška.

Primer cURL zahteva za poništavanje blokiranja komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/un-block?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=some-user-id' \
  --header 'Content-Type: application/json'

Primer cURL zahteva za poništavanje blokiranja anonimnog komentara

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/comments/some-comment-id/un-block?tenantId=demo&API_KEY=DEMO_API_SECRET&anonUserId=some-anon-user-id' \
  --header 'Content-Type: application/json'

Struktura zahteva za poništavanje blokiranja komentara

Copy

interface CommentUnBlockQueryParams {
    tenantId: string
    API_KEY: string
    userId?: string
    anonUserId?: string
    commentIdsToCheck?: string[]
}

Struktura odgovora za poništavanje blokiranja komentara

Copy

interface CommentUnBlockResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id' | 'comment-cannot-be-blocked'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Ako je commentIdsToCheck definisan, unosi u ovoj mapi sa vrednošću true su i dalje blokirani. Ako su sa vrednošću false, možda ćete želeti da ponovo prikažete komentare korisniku kako ne bi morao da osvežava stranicu. **/
    commentStatuses?: Record<string, boolean>;
}

Struktura email šablona

Objekat EmailTemplate predstavlja konfiguraciju za prilagođeni email šablon, za tenant.

Sistem će izabrati email šablon za upotrebu na osnovu:

Njegovog identifikatora tipa, koji nazivamo emailTemplateId. To su konstante.
domain. Prvo ćemo pokušati da pronađemo šablon za domen sa kojim je povezan relevantan objekat (npr. Comment), a ako se poklapanje ne pronađe pokušaćemo da pronađemo šablon gde je domain null ili *.

Struktura objekta EmailTemplate je sledeća:

Struktura email šablona

Copy

interface EmailTemplate {
    id: string
    tenantId: string
    emailTemplateId: string
    displayName: string
    /** SAMO ZA ČITANJE **/
    createdAt: string
    /** SAMO ZA ČITANJE **/
    updatedAt: string
    /** SAMO ZA ČITANJE **/
    updatedByUserId: string
    /** Domen sa kojim bi šablon trebalo da bude povezan. **/
    domain?: string | '*' | null
    /** Sadržaj email šablona u EJS sintaksi. **/
    ejs: string
    /** Mapa zamenjenih prevodnih ključeva na vrednosti, za svaki podržani locale. **/
    translationOverridesByLocale: Record<string, Record<string, string>>
    /** Objekat koji predstavlja kontekst renderovanja šablona. **/
    testData: object
}

Napomene

Možete dobiti validne emailTemplateId vrednosti sa /definitions endpoint-a.
/definitions endpoint takođe uključuje podrazumevane prevode i test podatke.
Šabloni neće moći da se sačuvaju ako struktura ili test podaci nisu validni.

GET /api/v1/email-templates/:id

Resource: EmailTemplate as GET /api/v1/email-templates/:id Credit Cost: 1

Pojedinačni EmailTemplates mogu se dohvatiti pomoću odgovarajućeg id (NE emailTemplateId).

Primer cURL zahteva za EmailTemplate po ID

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/email-templates/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za EmailTemplate po ID

Copy

interface EmailTemplatesByIdRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za EmailTemplate po ID

Copy

interface EmailTemplateResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'internal' | 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    emailTemplate?: EmailTemplate | null
}

GET /api/v1/email-templates

Resource: EmailTemplate as GET /api/v1/email-templates Credit Cost: 1

Ovaj API koristi paginaciju, obezbeđenu parametrom upita page. EmailTemplates se vraćaju u stranicama po 100, sortirane po createdAt i zatim po id.

EmailTemplate cURL primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/email-templates?tenantId=demo&page=0&API_KEY=DEMO_API_SECRET'

Struktura zahteva za EmailTemplate

Copy

interface EmailTemplatesRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Stranica za preuzimanje, počinje od 0. **/
    page: number
}

Struktura odgovora za EmailTemplate

Copy

interface EmailTemplatesResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju greške. **/
    reason?: string
    emailTemplates: EmailTemplate[]
}

PATCH /api/v1/email-templates/:id

Resource: EmailTemplate as PATCH /api/v1/email-templates/:id Credit Cost: 1

Ovaj API endpoint omogućava ažuriranje email šablona navodeći samo id i atribute koje treba ažurirati.

Imajte na umu da se sve iste validacije kao pri kreiranju šablona takođe primenjuju, na primer:

Šablon mora da se renderuje. Ovo se proverava pri svakom ažuriranju.
Ne možete imati duplikate šablona za isti domen (inače bi jedan bio tiho zanemaren).

EmailTemplate PATCH cURL primer

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/email-templates/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"displayName": "Some New Name",
}'

Struktura PATCH zahteva za EmailTemplate

Copy

interface EmailTemplatePatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za EmailTemplate PATCH

Copy

interface EmailTemplatePatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input' | 'not-found' | 'unexpected-param' | 'invalid-email-template-id' | 'unauthorized' | 'domain-invalid' | 'duplicate' | 'does-not-render';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Ažurirani email šablon. **/
    emailTemplate?: EmailTemplate
}

POST /api/v1/email-templates

Resource: EmailTemplate as POST /api/v1/email-templates Credit Cost: 1

Ovaj API endpoint pruža mogućnost kreiranja email šablona.

Napomene:

Ne možete imati više šablona sa istim emailTemplateId za istu domenu.
Međutim, možete imati wildcard šablon (domain = * and a domain specific template for the same emailTemplateId).
Navođenje domain je relevantno samo ako imate različite domene, ili želite koristiti specifične šablone za testiranje (domain set to localhost etc).
Ako navedete domain it must match a DomainConfig. On error a list of valid domains is provided.
Sintaksa šablona je EJS i renderuje se sa timeout-om od 500ms. P99 za renderovanje je <5ms, tako da ako dosegnete 500ms nešto nije u redu.
Vaš šablon mora biti renderovan sa zadatim testData da bi se sačuvao. Greške pri renderovanju se agregiraju i prijavljuju na dashboard (uskoro dostupno preko API-ja).

Minimalni podaci potrebni za dodavanje šablona su sledeći:

Minimalni EmailTemplate POST cURL primer

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/email-templates?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "emailTemplateId": "comment-user-mention",
    "displayName": "I'm a custom template.",
    "ejs": "This is an @mention notification! My name is <%= comment.commenterName %>."
}'

Možda ćete želeti da imate šablone po sajtu, u kom slučaju definišete domain:

EmailTemplate POST cURL primer

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/email-templates?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "emailTemplateId": "comment-user-mention",
    "displayName": "I'm a custom template.",
    "ejs": "This is some email content!",
    "domain": "somespecificsite.com",
}'

Struktura EmailTemplate POST zahteva

Copy

interface EmailTemplatePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura EmailTemplate POST odgovora

Copy

interface EmailTemplatePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'unexpected-param' | 'invalid-email-template-id' | 'domain-invalid' | 'duplicate' | 'does-not-render';
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Kreirani šablon. **/
    emailTemplate?: EmailTemplate
}

POST /api/v1/email-templates/render

Resource: EmailTemplate as POST /api/v1/email-templates/render Credit Cost: 1

Ovaj API endpoint omogućava pregled email šablona.

Minimalni cURL primer: POST zahtev za pregled EmailTemplate

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/email-templates/render?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "emailTemplateId": "comment-user-mention",
    "displayName": "I'm a custom template.",
    "ejs": "This is an @mention notification! My name is <%= comment.commenterName %>."
}'

Struktura POST zahteva za EmailTemplate

Copy

interface EmailTemplatePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za EmailTemplate

Copy

interface EmailTemplatePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'unexpected-param' | 'does-not-render';
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Renderovani HTML u slučaju uspeha. **/
    html?: string
}

DELETE /api/v1/email-templates/:id

Resource: EmailTemplate as DELETE /api/v1/email-templates/:id Credit Cost: 1

Ovaj endpoint omogućava uklanjanje jednog EmailTemplate po id-u.

Primer cURL zahteva za uklanjanje EmailTemplate

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/email-templates/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje EmailTemplate

Copy

interface EmailTemplateRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje EmailTemplate

Copy

interface EmailTemplateDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura Feed posta

A FeedPost objekat predstavlja objavu u FastComments feedu. Feed je tok objava sa svojim nitima komentara, prikazan od strane Feed widgeta. Svaka objava ima autora, opcioni bogati sadržaj, medije i linkove, i može biti označena tako da se feed može filtrirati.

Struktura za FeedPost objekat je sledeća:

Struktura FeedPost

Copy

interface FeedPost {
    /** READONLY **/
    _id: string
    /** READONLY **/
    tenantId: string
    title?: string
    /** ID FastComments ili SSO korisnika koji je autor objave. **/
    fromUserId?: string
    /** Popunjava se iz podataka korisnika ako nije postavljeno. **/
    fromUserDisplayName?: string | null
    /** READONLY. Popunjava se iz podataka korisnika. **/
    fromUserAvatar?: string | null
    /** Koristi se za filtriranje feeda. **/
    tags?: string[]
    /** Težina sortiranja unutar feeda. Veće vrednosti se sortiraju prve. **/
    weight?: number
    /** Slobodni parovi ključ/vrednost za vašu ličnu upotrebu. **/
    meta?: Record<string, string>
    /** Sanitisani HTML. **/
    contentHTML?: string
    media?: FeedPostMediaItem[]
    links?: FeedPostLink[]
    /** READONLY **/
    createdAt: string
    /** READONLY. Tip reakcije za brojanje. **/
    reacts?: Record<string, number>
    /** READONLY **/
    commentCount?: number | null
}
interface FeedPostMediaItem {
    title?: string
    /** Gde medijski element vodi kada se klikne. **/
    linkUrl?: string
    /** Jedan unos po rendiciji. Widget bira najbolje. **/
    sizes: FeedPostMediaItemAsset[]
}
interface FeedPostMediaItemAsset {
    w: number
    h: number
    src: string
}
interface FeedPostLink {
    /** Tekst linka, npr. "Registrujte se sada". **/
    text?: string
    /** Naslov prikazan uz link. **/
    title?: string
    /** Opis prikazan uz link. **/
    description?: string
    url?: string
}

Napomene:

Neka od ovih polja su označena READONLY – ona se vraćaju iz API‑ja, ali se ne mogu postaviti.
Komentari na objavi su regularni komentari čiji je urlId post: praćen ID‑jem objave _id. Koristite tu vrednost sa Comment API‑jem da biste čitali ili kreirali komentare na objavi.

GET /api/v1/feed-posts

Resource: FeedPost as GET /api/v1/feed-posts Credit Cost: 1

Preuzima postove u feedu, najnovije prvo. Paginiranje je zasnovano na kursoru: prosledite _id poslednjeg posta koji ste primili kao afterId da biste dobili sledeću stranicu.

Košta jedan kredit po deset vraćenih postova, sa minimalno jednim kreditom.

Primer cURL zahteva za FeedPost

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/feed-posts?tenantId=demo&limit=10&API_KEY=DEMO_API_SECRET'

Struktura zahteva za FeedPost

Copy

interface FeedPostsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Vrati postove posle ovog ID-a posta. Izostavite za prvu stranicu. **/
    afterId?: string
    /** Podrazumevano je 10. Maksimum je 1000. **/
    limit?: number
    /** Vrati samo postove sa ovim oznakama. Ponovite parametar za više od jedne oznake. **/
    tags?: string[]
}

Struktura odgovora za FeedPost

Copy

interface FeedPostsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'limit-invalid' | 'internal'
    /** Uključeno u slučaju greške. **/
    reason?: string
    feedPosts: FeedPost[]
}

POST /api/v1/feed-posts

Resource: FeedPost as POST /api/v1/feed-posts Credit Cost: 1

Ova ruta kreira jedan FeedPost. Svaki post ima autora, pa je fromUserId obavezan i mora biti ID postojećeg FastComments ili SSO korisnika na nalogu.

Primer cURL zahteva za kreiranje FeedPost-a

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/feed-posts?tenantId=demo&isLive=true&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "fromUserId": "some-user-id",
    "title": "Release 2.0 is out",
    "contentHTML": "<p>Read the notes and tell us what you think.</p>",
    "tags": ["releases"],
    "links": [
        {
            "url": "https://example.com/releases/2.0",
            "title": "Release notes",
            "description": "Everything that changed in 2.0."
        }
    ]
}'

Struktura zahteva za kreiranje FeedPost-a

Copy

interface FeedPostPostQueryParams {
    tenantId: string
    API_KEY: string
    /** Pošaljite post u feedove koji su trenutno otvoreni u pretraživaču. Podrazumevano je false. **/
    isLive?: boolean
    /** Prođite post kroz spam motor pre čuvanja. Podrazumevano je false. **/
    doSpamCheck?: boolean
    /** Preskočite proveru ponovljenog sadržaja koja se izvršava kao deo doSpamCheck. Podrazumevano je false. **/
    skipDupCheck?: boolean
    /** Do 256 karaktera. Emituje se živim slušaocima kako klijent može da ignoriše sopstveno emitovanje. **/
    broadcastId?: string
}
interface FeedPostPostBody {
    /** Obavezno. ID FastComments ili SSO korisnika. **/
    fromUserId: string
    title?: string
    /** HTML. Saniran prilikom čuvanja. **/
    contentHTML?: string
    /** Zamenjuje prikazano ime preuzeto od korisnika. **/
    fromUserDisplayName?: string
    tags?: string[]
    media?: FeedPostMediaItem[]
    links?: FeedPostLink[]
    meta?: Record<string, string>
}

Struktura odgovora za kreiranje FeedPost-a

Copy

interface FeedPostPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-from-user-id' | 'invalid-user' | 'broadcast-id-too-long' | 'spam-blocked' | 'user-rate-limited' | 'internal'
    /** Uključeno u slučaju greške. **/
    reason?: string
    feedPost?: FeedPost; // Vraćamo kompletan kreirani post pri uspehu.
}

PATCH /api/v1/feed-posts/:id

Resource: FeedPost as PATCH /api/v1/feed-posts/:id Credit Cost: 1

Ova ruta ažurira jedan FeedPost. Pošaljite samo polja koja želite da promenite.

Primer cURL zahteva za ažuriranje FeedPost

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/feed-posts/some-post-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "title": "Release 2.0.1 is out",
    "tags": ["releases", "hotfix"]
}'

Struktura zahteva za ažuriranje FeedPost

Copy

interface FeedPostPatchQueryParams {
    tenantId: string
    API_KEY: string
}
/** Bilo koje upisivo polje iz strukture FeedPost. **/
type FeedPostPatchBody = Partial<Pick<FeedPost, 'title' | 'contentHTML' | 'fromUserDisplayName' | 'tags' | 'weight' | 'meta' | 'media' | 'links'>>

Struktura odgovora za ažuriranje FeedPost

Copy

interface FeedPostPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'internal'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

Struktura hashtag-a

Objekat HashTag predstavlja oznaku koju korisnik može ostaviti. HashTags se mogu koristiti za povezivanje sa spoljnim sadržajem ili za povezivanje povezanih komentara.

Struktura HashTag objekta je sledeća:

Struktura HashTag objekta

Copy

interface HashTag {
    /** Treba da počinje sa "#" ili željenim karakterom. **/
    tag: string
    /** Opcioni URL na koji hashtag može da pokazuje. Umesto filtriranja komentara po hashtag-u, UI će preusmeriti na ovaj URL nakon klika. **/
    url?: string
    /** SAMO ZA ČITANJE **/
    createdAt: string
}

Napomene:

U nekim API endpoint-ima videćete da se hashtag koristi u URL-u. Zapamtite da treba URI-enkodirati vrednosti. Na primer, # bi trebalo da bude predstavljeno kao %23.
Neki od ovih polja su označeni kao READONLY - ona se vraćaju iz API-ja, ali se ne mogu postaviti.

GET /api/v1/hash-tags

Resource: HashTag as GET /api/v1/hash-tags Credit Cost: 1

Ovaj API koristi paginaciju, obezbeđenu parametrom upita page. Haštagovi se vraćaju u stranicama po 100, poređani po tag.

Primer cURL zahteva za HashTag

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/hash-tags?tenantId=demo&page=0&API_KEY=DEMO_API_SECRET'

Struktura zahteva za HashTag

Copy

interface HashTagsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Stranica koja se preuzima, počevši od 0. **/
    page: number
}

Struktura odgovora za HashTag

Copy

interface HashTagsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Haštagovi! **/
    hashTags: HashTag[]
}

PATCH /api/v1/hash-tags/:tag

Resource: HashTag as PATCH /api/v1/hash-tags/:tag Credit Cost: 1

Ovaj endpoint omogućava ažuriranje jednog HashTag-a.

Primer cURL zahteva za ažuriranje HashTag-a

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/hash-tags/%23example_hash_tag?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"url": "https://example.com/some-`page`"
}'

Struktura zahteva za ažuriranje HashTag-a

Copy

interface HashTagPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ažuriranje HashTag-a

Copy

interface HashTagPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-hash-tag' | 'tag-does-not-exist' | 'url-too-long' | 'invalid-tag' |  'already-exists'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    hashTag?: HashTag; // Vraćamo kompletan ažurirani hashtag pri uspehu.
}

POST /api/v1/hash-tags

Resource: HashTag as POST /api/v1/hash-tags Credit Cost: 1

Ova ruta omogućava dodavanje jednog HashTag.

Primer cURL zahteva za kreiranje HashTag

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/hash-tags?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "tag": "#example",
	"url": "https://example.com/some-page"
}'

Struktura zahteva za kreiranje HashTag

Copy

interface HashTagPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za kreiranje HashTag

Copy

interface HashTagPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-hash-tag' | 'tag-does-not-exist' | 'url-too-long' | 'invalid-tag'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    hashTag?: HashTag; // Vraćamo kompletan kreirani HashTag pri uspehu.
}

POST /api/v1/hash-tags/bulk

Resource: HashTag as POST /api/v1/hash-tags/bulk Credit Cost: 1

Ova ruta omogućava dodavanje do 100 HashTag objekata odjednom.

Primer cURL zahteva za masovno kreiranje HashTag-ova

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/hash-tags/bulk?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "tags": [
        {
            "tag": "#example",
            "url": "https://example.com/some-page"
        }
    ]
}'

Struktura zahteva za masovno kreiranje HashTag-ova

Copy

interface HashTagPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za masovno kreiranje HashTag-ova

Copy

interface HashTagBulkPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-hash-tag' | 'tag-does-not-exist' | 'url-too-long' | 'invalid-tag'
    /** Uključeno u slučaju greške. **/
    reason?: string
    results?: HashTagPostResponse[]; // Vraćamo listu objekata HashTagPostResponse za svaki prosleđeni tag.
}

DELETE /api/v1/hash-tags/:tag

Resource: HashTag as DELETE /api/v1/hash-tags/:tag Credit Cost: 1

Ovaj endpoint omogućava uklanjanje HashTag korisnika po prosleđenom tagu.

Imajte na umu da, osim ako automatsko kreiranje HashTag nije onemogućeno, heštegovi mogu biti ponovo kreirani od strane korisnika koji navede hešteg prilikom komentarisanja.

Primer cURL zahteva za uklanjanje HashTag-a

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/hash-tags/%23example_hash_tag?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje HashTag-a

Copy

interface HashTagDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje HashTag-a

Copy

interface HashTagDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-hash-tag' | 'tag-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

GET /api/v1/me

Resource: Me as GET /api/v1/me Credit Cost: 1

Opisuje akreditiv koji vrši zahtev: tenant kojem pripada i, za OAuth pristupne tokene, korisnika koji je autorizovao aplikaciju. Integracije ga koriste za testiranje veze i označavanje.

Sa API ključem odgovor identifikuje samo tenant. Sa OAuth tokenom nosi i korisnika koji je autorizovao i opsege koji su dodeljeni.

Me cURL Primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/me?tenantId=demo&API_KEY=DEMO_API_SECRET'

Me Struktura Odgovora

Copy

interface MeResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju greške. **/
    reason?: string
    tenantId: string
    tenantName: string
    /** Kako je zahtev autentifikovan. **/
    authType: 'api-key' | 'oauth'
    /** Opsezi (scopes) koje akreditiv poseduje. API ključevi poseduju oba. **/
    scopes: ('read' | 'write')[]
    /** Prisutno samo za OAuth tokene. **/
    userId?: string
    username?: string
    email?: string
}

Struktura moderatora

Objekat Moderator predstavlja konfiguraciju za moderatora.

Postoje tri vrste moderatora:

Administrator korisnici koji imaju oznaku isCommentModeratorAdmin.
SSO korisnici sa oznakom isCommentModeratorAdmin.
Obični komentatori, odnosno FastComments.com korisnici, koji su pozvani kao Moderatori.

Struktura Moderator se koristi za predstavljanje stanja moderacije za slučaj upotrebe 3.

Ako želite da pozovete korisnika da postane moderator, putem API-ja koristite Moderator API kreiranjem Moderator i inviting njih.

Ako korisnik nema FastComments.com nalog, mejl sa pozivnicom će im pomoći da se podese. Ako već imaju nalog, biće im dodeljen pristup za moderaciju vašeg tenanta i Moderator object's userId biće ažuriran da pokazuje na njihovog korisnika. Nećete imati API pristup njihovom korisniku, jer u tom slučaju nalog pripada njima i njime upravlja FastComments.com.

Ako vam je potrebno potpuno upravljanje nalogom korisnika, preporučujemo ili korišćenje SSO, ili dodavanje njih kao a Korisnik tenanta i potom dodavanje Moderator objekta da biste pratili njihove statistike.

Struktura Moderator može se koristiti kao mehanizam za praćenje statistike za slučajeve upotrebe 1 i 2. Nakon kreiranja korisnika, dodajte Moderator objekat sa definisanim userId i njihove statistike će biti praćene na Stranici moderatora komentara.

Struktura za Moderator objekat je sledeća:

Struktura Moderatora

Copy

interface Moderator {
    name: string
    email: string
    tenantId: string
    userId?: string|null
    acceptedInvite?: boolean
    markReviewedCount?: number
    deletedCount?: number
    markedSpamCount?: number
    approvedCount?: number
    editedCount?: number
    bannedCount?: number
    createdAt: string
    moderationGroupIds?: string[]|null
}

GET /api/v1/moderators/:id

Resource: Moderator as GET /api/v1/moderators/:id Credit Cost: 1

Ova ruta vraća jednog moderatora po njegovom id-u.

Primer cURL zahteva za moderatora po ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/moderators/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za moderatora

Copy

interface ModeratorByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za moderatora

Copy

interface ModeratorByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
    moderator?: Moderator
}

GET /api/v1/moderators

Resource: Moderator as GET /api/v1/moderators Credit Cost: 1

Ovaj API koristi paginaciju, koju obezbeđuje parametar upita skip. Moderatori se vraćaju u stranicama po 100, poređani po createdAt i id.

Trošak se zasniva na broju vraćenih moderatora: 1 credit per 10 moderatora.

cURL primer za Moderator

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/moderators?tenantId=demo&skip=0&API_KEY=DEMO_API_SECRET'

Struktura zahteva za Moderatore

Copy

interface ModeratorsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Broj moderatora koji se preskače za paginaciju. **/
    skip?: number
}

Struktura odgovora za Moderatore

Copy

interface ModeratorsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    moderators?: Moderator[]
}

PATCH /api/v1/moderators/:id

Resource: Moderator as PATCH /api/v1/moderators/:id Credit Cost: 1

Ovaj API endpoint pruža mogućnost ažuriranja Moderator po id.

Ažuriranje Moderator ima sledeća ograničenja:

Sledeće vrednosti ne smeju biti prosleđene prilikom ažuriranja Moderator:
- acceptedInvite
- markReviewedCount
- deletedCount
- markedSpamCount
- approvedCount
- editedCount
- bannedCount
- verificationId
- createdAt
Kada je naveden userId, taj korisnik mora postojati.
Kada je naveden userId, on mora pripadati istom tenantId koji je naveden u query parametrima.
Dva moderatora u istom tenantu ne mogu biti dodata sa istim email.
Ne smete menjati tenantId povezan sa Moderator.

Primer cURL zahteva za Moderator PATCH

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/moderators/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"name": "Some New Name",
}'

Struktura zahteva za Moderator PATCH

Copy

interface ModeratorPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Moderator PATCH

Copy

interface ModeratorPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'name-required' | 'email-required' | 'unexpected-param' | 'not-found';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

POST /api/v1/moderators

Resource: Moderator as POST /api/v1/moderators Credit Cost: 1

Ova ruta pruža mogućnost dodavanja jednog Moderator.

Kreiranje Moderator ima sledeća ograničenja:

Uvek je potrebno navesti name i email. userId je opciono.
Sledeće vrednosti ne smeju biti prosleđene pri kreiranju Moderator:
- acceptedInvite
- markReviewedCount
- deletedCount
- markedSpamCount
- approvedCount
- editedCount
- bannedCount
- verificationId
- createdAt
Kada je naveden userId, taj korisnik mora postojati.
Kada je naveden userId, on mora pripadati istom tenantId koji je naveden u parametrima upita.
Dva moderatora u istom tenantu ne mogu biti dodata sa istim email.

Možemo kreirati Moderator za korisnika o kojem znamo samo email:

Primer cURL zahteva za kreiranje Moderator-a putem email-a

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/moderators?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Some Name",
	"email": "someone@someone.com"
}'

Ili možemo kreirati Moderator za korisnika koji pripada našem tenantu, da bismo pratili njihove statistike moderacije:

Primer cURL zahteva za kreiranje Moderator-a za korisnika tenant-a

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/moderators?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Some Name",
	"email": "someone@someone.com",
    "userId": "some-tenant-user-id"
}'

Struktura zahteva za kreiranje Moderator-a

Copy

interface ModeratorPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora pri kreiranju Moderator-a

Copy

interface ModeratorPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'name-required' | 'email-required' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    moderator?: Moderator; // Vraćamo kompletno kreiranog moderatora pri uspehu.
}

POST /api/v1/moderators/:id/send-invite

Resource: Moderator as POST /api/v1/moderators/:id/send-invite Credit Cost: 10

Ovaj endpoint omogućava da pozovete jednog Moderator.

Sledeća ograničenja važe za slanje email pozivnice Moderator-u:

Moderator mora već postojati.
fromName ne sme biti duže od 100 characters.

Napomene:

Ako korisnik sa datom email adresom već postoji, biće pozvan da moderira komentare vašeg tenanta.
Ako korisnik sa datom email adresom ne postoji, link u pozivnici će ih uputiti kroz proces kreiranja naloga.
Pozivnica ističe nakon 30 days.

Možemo kreirati Moderator za korisnika za kog znamo samo email:

Primer cURL pozivnice za Moderator

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/moderators/xyz/send-invite?tenantId=demo&API_KEY=DEMO_API_SECRET&fromName=Bob' \
  --header 'Content-Type: application/json'

Ovo će poslati email koji izgleda otprilike ovako: Bob at TenantName is inviting you to be a moderator...

Struktura zahteva za poziv Moderator-u

Copy

interface ModeratorSendInviteQueryParams {
    tenantId: string
    API_KEY: string
    /** Email poslat korisniku će izgledati kao da je poslat sa ovog imena. **/
    fromName: string
}

Struktura odgovora za poziv Moderator-u

Copy

interface ModeratorSendInviteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'not-found | 'from-name-required' | 'from-name-invalid'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

DELETE /api/v1/moderators/:id

Resource: Moderator as DELETE /api/v1/moderators/:id Credit Cost: 5

Ova ruta omogućava uklanjanje Moderator po id-u.

Primer cURL zahteva za uklanjanje Moderatora

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/moderators/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje Moderatora

Copy

interface ModeratorDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje Moderatora

Copy

interface ModeratorDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura broja obaveštenja

Objekat NotificationCount predstavlja broj nepročitanih obaveštenja i metapodatke za korisnika.

Ako nema nepročitanih obaveštenja, za korisnika neće postojati NotificationCount.

NotificationCount objekti se automatski kreiraju i ne mogu se kreirati preko API-ja. Takođe ističu nakon jedne godine.

Možete obrisati broj nepročitanih obaveštenja korisnika tako što ćete izbrisati njihov NotificationCount.

Struktura objekta NotificationCount je sledeća:

Struktura NotificationCount

Copy

interface NotificationCount {
    id: string // id korisnika
    count: number
    createdAt: string // datum kao string
    expireAt: string // datum kao string
}

GET /api/v1/notification-count/:user_id

Resource: NotificationCount as GET /api/v1/notification-count/:user_id Credit Cost: 1

Ova ruta vraća jedan NotificationCount po ID-u korisnika. Sa SSO, ID korisnika je u formatu <tenant id>:<user id>.

Ako nema nepročitanih notifikacija, neće postojati NotificationCount — dobićete 404.

Ovo se razlikuje od notifications/count po tome što je mnogo brže, ali ne dozvoljava filtriranje.

Primer cURL zahteva za NotificationCount po ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/notification-count/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'
# -> {"status":"success","data":{"count":1,"createdAt":"2023-03-06T18:45:01.726Z","expireAt":"2024-03-06T01:25:01.726Z","id":"example"}}

Struktura zahteva za NotificationCount

Copy

interface NotificationCountGetQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za NotificationCount

Copy

interface NotificationCountGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
    data?: NotificationCount
}

DELETE /api/v1/notification-count/:user_id

Resource: NotificationCount as DELETE /api/v1/notification-count/:user_id Credit Cost: 1

Ova ruta briše pojedinačni NotificationCount po korisničkom ID-u. Sa SSO, korisnički ID je u formatu <tenant id>:<user id>.

Ovo će očistiti broj nepročitanih obaveštenja korisnika (crveno zvonce u komentarskom widgetu će izbledeti i broj će nestati).

DELETE NotificationCount cURL primer

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/notification-count/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'
# -> {"status":"success"}

Struktura zahteva za brisanje NotificationCount

Copy

interface NotificationCountDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za brisanje NotificationCount

Copy

interface NotificationCountDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura obaveštenja

Objekat Notification predstavlja notifikaciju za korisnika.

Objekti Notification se kreiraju automatski i ne mogu se kreirati putem API-ja. Takođe ističu nakon godinu dana. Notifikacije se ne mogu brisati. Međutim, mogu se ažurirati tako da se viewed postavi na false, i možete pretraživati po viewed.

Korisnik takođe može odustati od notifikacija za određeni komentar postavljanjem optedOut u notifikaciji na true. Možete se ponovo uključiti postavljanjem na false.

Postoje različiti tipovi notifikacija - pogledajte relatedObjectType i type.

Načini na koje se notifikacije kreiraju su prilično fleksibilni i mogu se aktivirati u mnogim scenarijima (vidite NotificationType).

Do danas, postojanje Notification zapravo ne podrazumeva da je email poslat ili da bi trebalo da bude poslat. Umesto toga, notifikacije se koriste za feed notifikacija i povezane integracije.

Struktura objekta Notification je sledeća:

Struktura Notification

Copy

enum NotificationObjectType {
    Comment = 0,
    Profile = 1,
    Tenant = 2
}
enum NotificationType {
    /** Ako vam je neko odgovorio. **/
    RepliedToMe = 0,
    /** Ako je neko odgovorio bilo gde u nizu (čak i deci dece) niza u kom ste komentarisali. **/
    RepliedTransientChild = 1,
    /** Ako je vaš komentar dobio plus. **/
    VotedMyComment = 2,
    /** Ako je novi komentar ostavljen na korenu stranice na koju ste pretplaćeni. **/
    SubscriptionReplyRoot = 3,
    /** Ako je neko komentarisao na vašem profilu. **/
    CommentedOnProfile = 4,
    /** Ako imate direktnu poruku. **/
    DirectMessage = 5,
    /** TrialLimits je samo za korisnike tenanta. **/
    TrialLimits = 6,
    /** Ako ste bili @pomenuti. **/
    Mentioned = 7
}
interface Notification {
    id: string
    tenantId: string
    /** Sa SSO, id korisnika je u formatu `<tenant id>:<user id>`. **/
    userId?: string
    /** Kada radite sa SSO, morate voditi računa samo o `userId`. **/
    anonUserId?: string
    /** urlId je skoro uvek definisan. Opciono je samo za notifikacije na nivou tenanta, koje su retke. **/
    urlId?: string
    /** URL se kešira za brzu navigaciju do izvora notifikacije. **/
    url?: string
    /** Naslov stranice se kešira za brzo čitanje izvora notifikacije. **/
    pageTitle?: string
    relatedObjectType: NotificationObjectType
    /** Na primer, id komentara. **/
    relatedObjectId: string
    viewed: boolean
    createdAt: string // date string
    type: NotificationType
    fromCommentId?: string
    fromVoteId?: string
    /** fromUserName i fromUserAvatarSrc su keširani ovde za brzo prikazivanje notifikacije. Ažuriraju se kada se korisnik ažurira. **/
    fromUserName: string
    fromUserId: string
    fromUserAvatarSrc?: string
    /** Postavite ovo na true da biste prestali da dobijate notifikacije za ovaj objekat. **/
    optedOut?: boolean
}

GET /api/v1/notifications

Resource: Notification as GET /api/v1/notifications Credit Cost: 1

Ova ruta vraća do 30 Notification objekata sortiranih po createdAt, najnoviji prvi.

Možete filtrirati po userId. Sa SSO, user id je u formatu <tenant id>:<user id>.

Primer cURL zahteva za nepročitane notifikacije korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/notifications?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=SOME_USER_ID&viewed=false'

Struktura zahteva za notifikacije

Copy

interface NotificationsGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Paginacija preskakanjem zapisa. **/
    skip?: number
    /** Filtriraj po korisniku. **/
    userId?: string
    /** Filtriraj po urlId. **/
    urlId?: string
    /** Filtriraj po komentaru izvora. **/
    fromCommentId?: string
    /** Filtriraj po pročitano/nepročitano. **/
    viewed?: 'true' | 'false'
    /** Filtriraj po tipu. **/
    type?: NotificationType
}

Struktura odgovora za notifikacije

Copy

interface NotificationsGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    notifications?: Notification[]
}

GET /api/v1/notifications/count

Resource: Notification as GET /api/v1/notifications/count Credit Cost: 2

Ovaj endpoint vraća objekat koji sadrži broj notifikacija u parametru count.

Sporiji je od /notification-count/ i dvostruko je skuplji po cenama kredita, ali omogućava filtriranje po više dimenzija.

Možete filtrirati istim parametrima kao i endpoint /notifications, kao što je userId. Kod SSO-a, userId je u formatu <tenant id>:<user id>.

cURL primer: broj nepročitanih notifikacija za korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/notifications/count?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=SOME_USER_ID&viewed=false'

cURL primer: broj nepročitanih notifikacija korisnika za određenu stranicu

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/notifications/count?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=SOME_USER_ID&viewed=false&urlId=some-article-id-or-url'

Struktura zahteva za broj notifikacija

Copy

interface NotificationCountGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Filtriraj po korisniku. **/
    userId?: string
    /** Filtriraj po urlId. **/
    urlId?: string
    /** Filtriraj po izvornom komentaru. **/
    fromCommentId?: string
    /** Filtriraj po pročitanom/nepročitanom. **/
    viewed?: 'true' | 'false'
    /** Filtriraj po tipu. **/
    type?: NotificationType
}

Struktura odgovora za broj notifikacija

Copy

interface NotificationCountGetResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno pri neuspehu. **/
    reason?: string
    count?: number
}

PATCH /api/v1/notifications/:id

Resource: Notification as PATCH /api/v1/notifications/:id Credit Cost: 1

Ovaj API endpoint pruža mogućnost ažuriranja Notification po id.

Ažuriranje Notification ima sledeća ograničenja:

Možete ažurirati samo sledeća polja:
- viewed
- optedOut

Primer cURL PATCH zahteva za Notification

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/notifications/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"viewed": false,
}'

Struktura PATCH zahteva za Notification

Copy

interface NotificationPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura PATCH odgovora za Notification

Copy

interface NotificationPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'unauthorized' | 'not-found';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Javni API za reakcije na stranicama

Page Reacts omogućavaju vašim korisnicima da lajkuju stranicu ili reaguju na nju sa vašim sopstvenim skupom slika reakcija. The Page Reacts widget and the Floating Likes widget are built on these endpoints, and you can call them yourself to build your own like button.

Za razliku od ostatka ovog vodiča, Page Reacts endpoint‑i su javni. Pozivaju se iz pregledača vaših korisnika, ne zahtevaju API ključ i ne troše API kredite. Svaka reakcija pripada korisniku koji je poslao zahtev, tako da korisnik može da doda ili ukloni samo svoje reakcije.

Postoje dva skupa endpoint‑a:

/page-reacts/v1/likes/:tenantId – jedan “like” po korisniku po stranici. Koristite ovo za dugme za lajkovanje.
/page-reacts/v2/:tenantId – više reakcija po stranici, svaka identifikovana kratkim id‑om koji vi izaberete (na primer heart ili laugh).

Oba su takođe dostupna u našim SDK‑ovima kao deo PublicApi, na primer getV1PageLikes, createV1PageReact i deleteV1PageReact u JavaScript SDK.

Prikazivanje ko je reagovao

Prosledite includeUserInfo=public GET endpoint‑ima da biste takođe dobili korisnike koji su lajkovali ili reagovali, sa njihovim korisničkim imenima i avatarima, najnoviji prvi. Korisnici koji su postavili svoju aktivnost profila na privatnu su izostavljeni, kao i anonimni korisnici. Vraća se najviše 100 reakcija.

SSO korisnici se kreiraju sa privatnom aktivnošću profila osim ako vaš SSO payload ne postavi isProfileActivityPrivate na false, pa to podesite za korisnike koje želite da se pojave u ovim listama.

Na stranicama koje zahtevaju SSO, samo SSO korisnici koji mogu da vide stranicu mogu da prikažu ko je reagovao. Ostali dobijaju 403 sa kodom sso-required ili page-forbidden.

Sa vašeg servera, GET /api/v1/pages/likes i GET /api/v1/pages/reacts vraćaju iste liste uz API ključ, i takođe prihvataju includeUserInfo=include-private da uključe korisnike sa privatnim profilima.

Identifikacija korisnika

Reakcije su vezane za korisnika koji šalje zahtev:

SSO korisnici: prosledite sso query parametar, postavljen na URI‑enkodovan JSON istog SSO objekta koji dajete widget‑u za komentare. Pogledajte SSO.
Anonimni korisnici: kada ne postoji sso parametar i nema FastComments prijave, server dodeljuje pregledaču anonimni ID koji se čuva u FastComments sesijskom kolačiću. Šaljite zahteve sa credentials: 'include' kako bi kolačić bio zadržan između zahteva. Pregledači koji blokiraju kolačiće trećih strana neće zadržati anonimni ID, pa koristite SSO kada svaki korisnik mora da bude pouzdano prepoznat.

urlId

urlId identifikuje stranicu, isto kao i za komentare. Koristite isti urlId koji dajete widget‑u za komentare kako bi lajkovi i komentari bili brojani na istoj stranici. Zapamtite da ga URI‑enkodujete.

Primer dugmeta za lajkovanje

Copy

const tenantId = 'demo';
const urlId = 'https://example.com/my-article';
// Optional, for SSO users. The same object you give the comment widget's "sso" option.
const sso = null;
function likesUrl() {
    let url = `https://fastcomments.com/page-reacts/v1/likes/${tenantId}?urlId=${encodeURIComponent(urlId)}`;
    if (sso) {
        url += '&sso=' + encodeURIComponent(JSON.stringify(sso));
    }
    return url;
}
async function getLikes() {
    const response = await fetch(likesUrl(), {credentials: 'include'});
    return response.json(); // {status, likeCount, didLike, commentCount, urlIdWS}
}
async function like() {
    await fetch(likesUrl(), {method: 'POST', credentials: 'include'});
}
async function unlike() {
    await fetch(likesUrl(), {method: 'DELETE', credentials: 'include'});
}

GET /page-reacts/v1/likes/:tenantId

Resource: Page Likes as GET /page-reacts/v1/likes/:tenantId Credit Cost: 0

Vraća broj lajkova na stranici i da li je trenutni korisnik lajkovao. Stranice koje još ne postoje vraćaju likeCount od 0.

Prosledite includeUserInfo=public da biste takođe dobili korisnike koji su lajkovali stranicu, najnoviji prvi. Korisnici sa privatnom aktivnošću profila i anonimni korisnici su izostavljeni, a pretražuje se do 100 lajkova. Ovde je prihvaćen samo public; include-private vraća 422 i dostupan je iz GET /api/v1/pages/likes uz API ključ. Na stranicama koje zahtevaju SSO, includeUserInfo vraća 403 za korisnike koji ne mogu da vide stranicu.

Primer cURL zahteva za lajkove stranice

Copy

curl --request GET \
  --url 'https://fastcomments.com/page-reacts/v1/likes/demo?urlId=example-id-or-url'

Struktura zahteva za lajkove stranice

Copy

interface PageLikesRequestQueryParams {
    urlId: string
    /** URI enkodovan JSON vašeg SSO objekta. Izostavite za anonimne korisnike. **/
    sso?: string
    /** Postavite na 'public' da uključite korisnike koji su lajkovali stranicu. **/
    includeUserInfo?: 'public'
}

Struktura odgovora za lajkove stranice

Copy

interface PageLikesResponse {
    status: 'success' | 'failed'
    /** Uključeno pri grešci. **/
    code?: 'include-private-not-allowed' | 'sso-required' | 'page-forbidden' | string
    /** Uključeno pri grešci. **/
    reason?: string
    likeCount: number
    /** Da li je korisnik koji je poslao zahtev lajkovao stranicu. **/
    didLike: boolean
    /** Broj komentara najvišeg nivoa na stranici. **/
    commentCount: number
    /** ID koji se koristi za pretplatu na ažuriranja u realnom vremenu za ovu stranicu. **/
    urlIdWS: string
    /** Najnoviji prvi. Postavlja se samo kada je prosleđen includeUserInfo. **/
    users?: PageReactUser[]
}
interface PageReactUser {
    userId: string
    username: string
    displayName?: string
    avatarSrc?: string
}

POST /page-reacts/v1/likes/:tenantId

Resource: Page Likes as POST /page-reacts/v1/likes/:tenantId Credit Cost: 0

Lajkuje stranicu kao trenutni korisnik. Svaki korisnik može lajkovati stranicu jednom: ponovni lajk uspešno prolazi sa kodom already-liked i ne menja broj.

Stranica se kreira ako još ne postoji. Prosledite title da postavite ili ažurirate naslov stranice.

Primer cURL zahteva za lajk stranice

Copy

curl --request POST \
  --url 'https://fastcomments.com/page-reacts/v1/likes/demo?urlId=example-id-or-url&title=My%20Article'

Struktura zahteva za lajk stranice

Copy

interface PageLikeRequestQueryParams {
    urlId: string
    /** Postavlja naslov stranice. **/
    title?: string
    /** URI enkodovan JSON vašeg SSO objekta. Omitujte za anonimne korisnike. **/
    sso?: string
}

Struktura odgovora na lajk stranice

Copy

interface PageLikeResponse {
    status: 'success' | 'failed'
    /** 'already-liked' kada je korisnik već lajkao stranicu. U suprotnom je uključeno pri grešci. **/
    code?: 'already-liked' | string
    /** Uključeno pri grešci. **/
    reason?: string
}

DELETE /page-reacts/v1/likes/:tenantId

Resource: Page Likes as DELETE /page-reacts/v1/likes/:tenantId Credit Cost: 0

Uklanja lajk trenutnog korisnika sa stranice. Ako korisnik nije lajkovao stranicu, zahtev uspešno prolazi sa kodom not-liked i ne menja broj.

Primer cURL zahteva za uklanjanje lajka

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/page-reacts/v1/likes/demo?urlId=example-id-or-url'

Struktura zahteva za uklanjanje lajka

Copy

interface PageUnlikeRequestQueryParams {
    urlId: string
    /** URI enkodovani JSON vašeg SSO objekta. Omitujte za anonimne korisnike. **/
    sso?: string
}

Struktura odgovora za uklanjanje lajka

Copy

interface PageUnlikeResponse {
    status: 'success' | 'failed'
    /** 'not-liked' kada korisnik nije lajkovao stranicu. U suprotnom je uključeno pri grešci. **/
    code?: 'not-liked' | string
    /** Uključeno pri grešci. **/
    reason?: string
}

GET /page-reacts/v2/:tenantId

Resource: Page Reacts as GET /page-reacts/v2/:tenantId Credit Cost: 0

Vraća broj za svaku reakciju na stranici i koje je reakcije trenutni korisnik dodao.

Proslijedite includeUserInfo=public da biste također dobili korisnike koji su reagovali, kao jedan unos po reakciji sa njegovim ID-om reakcije, najnoviji prvi. Korisnici s privatnom aktivnošću profila i anonimni korisnici su izostavljeni, a pretražuje se do 100 reakcija. Ovde se prihvata samo public; include-private vraća 422 i dostupan je putem GET /api/v1/pages/reacts uz API ključ. Na stranicama koje zahtevaju SSO, includeUserInfo vraća 403 za korisnike koji ne mogu da vide stranicu.

Primer cURL zahteva za Page Reacts

Copy

curl --request GET \
  --url 'https://fastcomments.com/page-reacts/v2/demo?urlId=example-id-or-url'

Struktura zahteva za Page Reacts

Copy

interface PageReactsRequestQueryParams {
    urlId: string
    /** URI enkodovani JSON vašeg SSO objekta. Omitujte za anonimne korisnike. **/
    sso?: string
    /** Postavite na 'public' da biste uključili korisnike koji su reagovali. **/
    includeUserInfo?: 'public'
}

Struktura odgovora za Page Reacts

Copy

interface PageReactsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'include-private-not-allowed' | 'sso-required' | 'page-forbidden' | string
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Broj po ID-ju reakcije, na primer {"heart": 12, "laugh": 3}. Nije postavljeno kada stranica nema reakcije. **/
    counts?: Record<string, number>
    /** ID-ovi reakcija koje je korisnik koji je poslao zahtev dodao. Nije postavljeno ako nijednu nije dodao. **/
    reactedIds?: string[]
    /** Jedan unos po reakciji, najnoviji prvi. Postavlja se samo kada je prosleđen includeUserInfo. **/
    users?: PageCustomReactUser[]
}
interface PageCustomReactUser {
    /** ID reakcije, na primer "heart". **/
    reactId: string
    userId: string
    username: string
    displayName?: string
    avatarSrc?: string
}

GET /page-reacts/v2/:tenantId/list

Resource: Page React Users as GET /page-reacts/v2/:tenantId/list Credit Cost: 0

Vraća imena korisnika koji su dodali reakciju na stranicu, sortirana abecedno. Pretražuje se do 100 reakcija, a anonimni korisnici i korisnici sa privatnom aktivnošću profila nisu uključeni. Na stranicama koje zahtevaju SSO, korisnici koji ne mogu da vide stranicu dobijaju 403 sa kodom sso-required ili page-forbidden.

Da biste takođe dobili avatare i ID‑ove korisnika, koristite GET /page-reacts/v2/:tenantId sa includeUserInfo=public.

Primer cURL zahteva za Page React Users

Copy

curl --request GET \
  --url 'https://fastcomments.com/page-reacts/v2/demo/list?urlId=example-id-or-url&id=heart'

Struktura zahteva za Page React Users

Copy

interface PageReactUsersRequestQueryParams {
    urlId: string
    /** The reaction id. **/
    id: string
    /** URI encoded JSON of your SSO object. Omit for anonymous users. **/
    sso?: string
}

Struktura odgovora za Page React Users

Copy

interface PageReactUsersResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: string
    /** Included on failure. **/
    reason?: string
    userNames: string[]
}

POST /page-reacts/v2/:tenantId

Resource: Page Reacts as POST /page-reacts/v2/:tenantId Credit Cost: 0

Dodaje reakciju na stranicu kao trenutni korisnik. Korisnik može dodati svaki ID reakcije samo jednom: ponovnim dodavanjem se uspešno vraća kod already-reacted i ne menja brojanje. Korisnik može dodati više različitih reakcija na istu stranicu.

ID‑ove reakcija biraš ti i mogu imati najviše 36 znakova. Stranica se kreira ako još ne postoji. Prosledi title da postaviš ili ažuriraš naslov stranice.

Primer cURL zahteva za reakciju na stranicu

Copy

curl --request POST \
  --url 'https://fastcomments.com/page-reacts/v2/demo?urlId=example-id-or-url&id=heart'

Struktura zahteva za reakciju na stranicu

Copy

interface PageReactRequestQueryParams {
    urlId: string
    /** ID reakcije, najviše 36 znakova. **/
    id: string
    /** Postavlja naslov stranice. **/
    title?: string
    /** URI‑enkodovan JSON vašeg SSO objekta. Omitujte za anonimne korisnike. **/
    sso?: string
}

Struktura odgovora za reakciju na stranicu

Copy

interface PageReactResponse {
    status: 'success' | 'failed'
    /** 'already-reacted' kada je korisnik već dodao ovu reakciju. 'react-id-too-long' (HTTP 422) kada je ID duži od 36 znakova. U suprotnom je uključeno u slučaju greške. **/
    code?: 'already-reacted' | 'react-id-too-long' | string
    /** Uključeno u slučaju greške. **/
    reason?: string
}

DELETE /page-reacts/v2/:tenantId

Resource: Page Reacts as DELETE /page-reacts/v2/:tenantId Credit Cost: 0

Uklanja jednu od reakcija trenutnog korisnika sa stranice. Ako korisnik nije dodao tu reakciju, zahtev uspešno prolazi sa kodom no-react i ne menja broj.

Primer cURL zahteva za brisanje reakcije na stranici

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/page-reacts/v2/demo?urlId=example-id-or-url&id=heart'

Struktura zahteva za brisanje reakcije na stranici

Copy

interface PageReactDeleteRequestQueryParams {
    urlId: string
    /** ID reakcije. **/
    id: string
    /** URI enkodovan JSON vašeg SSO objekta. Omitujte za anonimne korisnike. **/
    sso?: string
}

Struktura odgovora za brisanje reakcije na stranici

Copy

interface PageReactDeleteResponse {
    status: 'success' | 'failed'
    /** 'no-react' kada korisnik nije dodao ovu reakciju. U suprotnom je uključeno pri grešci. **/
    code?: 'no-react' | string
    /** Uključeno pri grešci. **/
    reason?: string
}

Struktura stranice

Objekat Page predstavlja stranicu kojoj može pripadati mnogo komentara. Ovaj odnos je definisan preko urlId.

Page čuva informacije kao što su naslov stranice, broj komentara i urlId.

Struktura za Page objekat je sledeća:

Struktura Page objekta

Copy

interface Page {
    id: string
    urlId: string
    url: string
    title?: string
    createdAt: string
    commentCount: number
    rootCommentCount: number
    /** Postavljanje na null znači da svi SSO korisnici mogu videti stranicu. Prazna lista znači da je zatvorena za sve korisnike. **/
    accessibleByGroupIds?: string[] | null
    /** Da li je ova stranica zatvorena za nove komentare? **/
    isClosed?: boolean
}

GET /api/v1/pages

Resource: Page as GET /api/v1/pages Credit Cost: 10

Trenutno možete dohvatiti samo sve stranice (ili pojedinačnu stranicu putem /by-url-id) povezane sa vašim nalogom. Ako želite preciznije pretraživanje, kontaktirajte nas.

Primer cURL zahteva

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/pages?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za Pages

Copy

interface PagesRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Pages

Copy

interface PagesResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    pages: Page[]
}

Koristan savet

Comment API zahteva urlId. Možete prvo pozvati Pages API, da vidite kako vrednosti urlId koje su vam dostupne izgledaju.

GET /api/v1/pages/by-url-id

Resource: Page as GET /api/v1/pages/by-url-id Credit Cost: 1

Pojedinačne stranice mogu se dobiti putem odgovarajućeg urlId. Ovo može biti korisno za pretragu naslova stranica ili broja komentara.

Primer cURL zahteva za stranicu po URL ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/pages/by-url-id?tenantId=demo&API_KEY=DEMO_API_SECRET&urlId=example-id-or-url'

Struktura zahteva za stranicu po URL ID-u

Copy

interface PagesRequestQueryParams {
    tenantId: string
    API_KEY: string
    urlId: string
}

Struktura odgovora za stranicu po URL ID-u

Copy

interface PagesResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id'
    /** Included on failure. **/
    reason?: string
    page?: Page[] | null
}

Koristan savet

Ne zaboravite da URI kodirate vrednosti poput urlId.

GET /api/v1/pages/likes

Resource: Page Likes as GET /api/v1/pages/likes Credit Cost: 1

Vraća broj lajkova na stranici, i po želji i korisnike koji su je lajkovali, najnoviji prvi. Ovo je server‑side verzija GET /page-reacts/v1/likes/:tenantId.

includeUserInfo kontroliše koji se korisnici vraćaju:

public izostavlja korisnike koji su učinili svoju aktivnost profila privatnom.
include-private uključuje ih. Koristite ovo samo kada lista nije prikazana javnosti.

Anonimni korisnici se nikada ne uključuju, a pretražuje se do 100 lajkova. Stranice koje ne postoje vraćaju likeCount od 0 i prazan users spisak.

Primer cURL zahteva za Page Likes

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/pages/likes?tenantId=demo&API_KEY=DEMO_API_SECRET&urlId=example-id-or-url&includeUserInfo=public'

Struktura zahteva za Page Likes

Copy

interface PageLikesRequestQueryParams {
    tenantId: string
    API_KEY: string
    urlId: string
    /** Izostavite da biste dobili samo broj lajkova. **/
    includeUserInfo?: 'public' | 'include-private'
}

Struktura odgovora za Page Likes

Copy

interface PageLikesResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id'
    /** Uključeno u slučaju greške. **/
    reason?: string
    likeCount?: number
    /** Najnoviji prvi. Postavlja se samo kada je prosleđen includeUserInfo. **/
    users?: PageReactUser[]
}
interface PageReactUser {
    userId: string
    username: string
    displayName?: string
    avatarSrc?: string
}

Korisni savet

Zapamtite da URI‑enkodujete vrednosti poput urlId.

GET /api/v1/pages/reacts

Resource: Page Reacts as GET /api/v1/pages/reacts Credit Cost: 1

Vraća broj za svaku reakciju na stranici, i po želji i korisnike koji su reagovali, kao jedan unos po reakciji sa njegovim ID‑om reakcije, najnoviji prvi. Ovo je server‑side verzija GET /page-reacts/v2/:tenantId.

includeUserInfo kontroliše koji se korisnici vraćaju:

public izostavlja korisnike koji su učinili svoju aktivnost profila privatnom.
include-private uključuje ih. Koristite ovo samo kada lista nije prikazana javnosti.

Anonimni korisnici se nikada ne uključuju, a pretražuje se do 100 reakcija. Stranice koje ne postoje ne vraćaju counts i vraćaju praznu listu users.

Primer cURL zahteva za Page Reacts

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/pages/reacts?tenantId=demo&API_KEY=DEMO_API_SECRET&urlId=example-id-or-url&includeUserInfo=public'

Struktura zahteva za Page Reacts

Copy

interface PageReactsRequestQueryParams {
    tenantId: string
    API_KEY: string
    urlId: string
    /** Izostavite da biste dobili samo brojeve. **/
    includeUserInfo?: 'public' | 'include-private'
}

Struktura odgovora za Page Reacts

Copy

interface PageReactsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id'
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Broj po ID‑u reakcije, na primer {"heart": 12, "laugh": 3}. Nije postavljeno kada stranica nema reakcije. **/
    counts?: Record<string, number>
    /** Jedan unos po reakciji, najnoviji prvi. Postavlja se samo kada je prosleđen includeUserInfo. **/
    users?: PageCustomReactUser[]
}
interface PageCustomReactUser {
    /** ID reakcije, na primer "heart". **/
    reactId: string
    userId: string
    username: string
    displayName?: string
    avatarSrc?: string
}

Korisni savet

Zapamtite da URI‑enkodujete vrednosti poput urlId.

PATCH /api/v1/pages/:id

Resource: Page as PATCH /api/v1/pages/:id Credit Cost: 1

Ova ruta omogućava ažuriranje jednog Page. Odgovarajući komentari će biti ažurirani.

Primer cURL zahteva za ažuriranje stranice

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/pages/my-page-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"url": "https://example.com/some-page"
}'

Struktura zahteva za ažuriranje stranice

Copy

interface PagePatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora na ažuriranje stranice

Copy

interface PagePatchResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'missing-id' | 'page-does-not-exist' | 'empty-request' | 'internal' | 'invalid-input' | 'invalid-title' | 'extra-params' | 'accessible-by-group-ids-not-array' | 'too-many-group-ids' | 'group-id-too-large'
    /** Included on failure. **/
    reason?: string
    user?: Page; // We return the complete updated page on success.
}

Napomena

Neki parametri u Page objektu se automatski ažuriraju. To su atributi za brojače i naslov. Brojači se ne mogu ažurirati putem API-ja jer su izračunate vrednosti. Naslov stranice (title) može se postaviti putem API-ja, ali biće prepisan ako se widget za komentare koristi na stranici sa istim urlId ali drugačijim naslovom stranice.

POST /api/v1/pages

Resource: Page as POST /api/v1/pages Credit Cost: 1

Ovaj API endpoint omogućava kreiranje stranica.

Uobičajen slučaj upotrebe je kontrola pristupa.

Napomene:

Ako ste komentarisali u niti komentara, ili pozvali API da kreirate Comment, već ste kreirali Page objekat! Možete ga pokušati dohvatiti putem /by-url-id Page rute, prosleđujući isti urlId koji je prosleđen comment widgetu.
Struktura Page sadrži neke izračunate vrednosti. Trenutno su to commentCount i rootCommentCount. Popunjavaju se automatski i ne mogu se postaviti preko API-ja. Pokušaj da se postave prouzrokovaće da API vrati grešku.

Primer cURL zahteva za Page POST

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/pages?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"title": "Test Page",
	"url": "some0-url",
	"urlId": "page2",
	"accessibleByGroupIds": ["SOME_GROUP_ID"]
}'

Struktura Page POST zahteva

Copy

interface PagePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Page POST

Copy

interface PagePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'empty-request' | 'internal' | 'invalid-input' | 'invalid-title' | 'extra-params' | 'accessible-by-group-ids-not-array' | 'too-many-group-ids' | 'group-id-too-large';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Kreirana stranica. **/
    page?: Page
}

DELETE /api/v1/pages/:id

Resource: Page as DELETE /api/v1/pages/:id Credit Cost: 1

Ova ruta omogućava uklanjanje jedne stranice po id-u.

Imajte na umu da će interakcija sa komentarskim vidžetom za stranicu sa istim urlId jednostavno ponovo kreirati Page neprimetno.

Primer cURL zahteva za uklanjanje stranice

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/pages/some-page-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje stranice

Copy

interface PageDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje stranice

Copy

interface PageDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'page-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

POST /api/v1/pages/migrations

Resource: Page Migrations as POST /api/v1/pages/migrations Credit Cost: 1

Ova ruta premešta komentare i stranice sa jednog urlId‑a ili domena na drugi, isto kao i Alat za migraciju domena u kontrolnoj tabli. Do 100 migracija može se poslati po zahtevu. One se izvršavaju redom kojim su navedene, pa a na b praćeno b na c funkcioniše.

Svaka migracija ima type:

urlId premešta stranicu čiji je urlId tačno from. post-1 ne odgovara post-10.
domain pronalazi/zamenjuje from unutar svakog urlId i url, i ažurira domain svakog komentara. Obe vrednosti moraju biti domen, npr. old.example.com.

Komentari, stranica, reakcije na stranicu, glasovi, obaveštenja i pretplate se sve premeštaju. Ako stranica već postoji na to, dve stranice se spajaju.

Migracija se izvršava kao batch posao. Odgovor sadrži batchJobId. Pitanjem GET /api/v1/batch-jobs/:id možete pratiti njegov napredak. Kada posao završi, ima rezultat po migraciji, i undoId koji možete proslediti na POST /api/v1/pages/migrations/:undoId/undo u roku od 90 dana.

Zahtev se validira pre nego što se nešto stavi u red. Ako je neka migracija neispravna, ceo zahtev ne uspeva sa 422 i ništa se ne izvršava.

Stavljanje migracije u red ne košta ništa. Kada posao završi, košta 1 kredit po 1000 premeštenih komentara, uz minimum od 1.

Primer cURL zahteva za migracije stranica

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/pages/migrations?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"migrations": [
		{"from": "old-post-id", "to": "new-post-id", "type": "urlId"},
		{"from": "old.example.com", "to": "new.example.com", "type": "domain"}
	]
}'

Struktura zahteva za migracije stranica

Copy

interface PageMigrationsQueryParams {
    tenantId: string
    API_KEY: string
}
interface PageMigrationsBody {
    /** Run in the order given. At most 100. **/
    migrations: PageMigration[]
}
interface PageMigration {
    /** At most 1000 characters. Leading and trailing whitespace is removed. **/
    from: string
    /** Must be different from "from". At most 1000 characters. **/
    to: string
    /** "urlId" only matches the exact urlId. "domain" find/replaces the value inside every urlId and url. **/
    type: 'urlId' | 'domain'
}

Struktura odgovora za migracije stranica

Copy

interface PageMigrationsResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-migrations' | 'too-many-migrations' | 'invalid-migration' | 'internal'
    /** Included on failure. For invalid-migration, this names the index of the first invalid migration. **/
    reason?: string
    /** Pass to GET /api/v1/batch-jobs/:id for progress and the result. **/
    batchJobId?: string
}

Napomene

Poslovi za jednog zakupca se izvršavaju jedan po jedan, najstariji prvi. Druga migracija čeka da prva završi.
PATCH /api/v1/pages/:id sa novim urlId menja samo stranicu, a ne njene komentare. Koristite ovu rutu da premestite komentare stranice.

POST /api/v1/pages/migrations/:undoId/undo

Resource: Page Migrations as POST /api/v1/pages/migrations/:undoId/undo Credit Cost: 1

Ova ruta poništava svaku migraciju iz jednog POST /api/v1/pages/migrations posla. Preuzmite undoId iz završenog posla migracije pomoću GET /api/v1/batch-jobs/:id. undoId se može koristiti 90 dana i samo jednom.

Poništavanje se izvršava kao batch posao, isto kao i migracija, a odgovor sadrži njegov batchJobId. Kada je posao završen, njegov pageMigrationUndoResult izveštava:

restored: zapisi vraćeni na njihove vrednosti pre migracije.
skipped: zapisi ostavljeni nepromenjeni jer su se promenili posle migracije, ili više ne postoje. Kasnija izmena se nikada ne prepisuje.
notRestorable: zapisi koje je migracija izbrisala prilikom spajanja dve stranice ili uklanjanja duplih reakcija na stranicu. Ovi se ne mogu vratiti.

Migracije se poništavaju najnovije prvo, tako da se lanac poput a do b praćen b do c odmotava nazad do a. Posao migracije koji je neuspeo usred procesa i dalje se može poništiti, što vraća promene koje je napravio pre neuspeha.

Stavljanje poništavanja u red ne košta ništa. Kada posao završi, košta 1 kredit po 1000 vraćenih zapisa, sa minimalno 1.

Primer cURL zahteva za poništavanje migracija stranica

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/pages/migrations/my-undo-id/undo?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za poništavanje migracija stranica

Copy

interface UndoPageMigrationsQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za poništavanje migracija stranica

Copy

interface UndoPageMigrationsResponse {
    status: 'success' | 'failed'
    /**
     * Uključeno pri grešci.
     * undo-not-found (404): nijedna migracija nema ovaj undoId, ili je stariji od 90 dana.
     * already-undone (409) i undo-in-progress (409): migracija je već poništena, ili je poništavanje u redu ili se izvršava.
     **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'undo-not-found' | 'already-undone' | 'undo-in-progress' | 'internal'
    /** Uključeno pri grešci. **/
    reason?: string
    /** Prosledite GET /api/v1/batch-jobs/:id za napredak i rezultat. **/
    batchJobId?: string
}

Struktura ankete

Poll je vezan za komentar, a nije samostalan objekat. Kreira se zajedno sa komentarom (vidi POST /api/v1/comments), ili se kasnije dodaje postojećem komentaru putem PUT /api/v1/polls/:commentId.

Brojevi glasova se čuvaju na samoj anketi, tako da čitanje ankete daje rezultate bez potrebe da bilo šta sabirate. Pojedinačni glasovi iza tih brojeva su PollVote objekti.

Svaka opcija ima id koji se generiše prilikom kreiranja ankete. Taj id koristite za glasanje, za preimenovanje opcije, i za zadržavanje opcije (i njenih glasova) kada PUT-ujete anketu sa dodatim ili uklonjenim opcijama. To je jedini bezbedan način da se referišete na opciju - nikada njen položaj u listi.

Struktura ankete

Copy

interface CommentPollOption {
    id: string
    label: string
    votes: number
}
interface CommentPoll {
    question: string
    options: CommentPollOption[]
    totalVotes: number
    /** Kada je postavljeno i u prošlosti, anketa je zatvorena i više ne prima glasove. **/
    closesAt?: string | null
    /** 0 anonimno (podrazumevano), 1 admini i moderatori, 2 svi. Odsustvo znači anonimno. **/
    privacy?: 0 | 1 | 2 | null
    /** Kada je true, brojevi su skriveni od svih koji još nisu glasali. Odsustvo znači false. **/
    requireVoteToSeeResults?: boolean | null
}

Ograničenja

Pitanje je obavezno i ima najviše 200 znakova.
Anketa ima između 2 i 10 opcija.
Oznaka opcije je obavezna, ima najviše 100 znakova i mora biti jedinstvena u okviru ankete (ignorišući velika/mala slova).
closesAt mora biti u budućnosti prilikom kreiranja ankete. Da biste odmah zatvorili anketu, PATCH-ujte je sa datumom u prošlosti.

Podešavanja sajta

Ankete poštuju konfiguraciju vašeg sajta, koju možete promeniti pod Customize Widget:

Ankete moraju biti omogućene pre nego što se anketa može kreirati, inače API odgovara sa polls-disabled.
Glasanje može biti ograničeno na prijavljene korisnike, u kom slučaju se glas poslat samo sa anonUserId odbija sa poll-login-required.

GET /api/v1/polls/:commentId

Resource: Poll as GET /api/v1/polls/:commentId Credit Cost: 1

Čita anketu priloženu komentaru, sa trenutnim brojem glasova.

Ankete se takođe vraćaju uz sam komentar putem API-ja za komentare, pa koristite ovo kada želite samo rezultate, a ne ceo komentar.

Primer cURL zahteva za Poll Get

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/polls/comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za Poll Get

Copy

interface PollGetQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Poll Get

Copy

interface PollGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'poll-not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
    poll: CommentPoll
}

Komentar koji nema anketu, komentar koji je obrisan i ID komentara koji ne postoji svi odgovaraju na isti način, sa poll-not-found.

PUT /api/v1/polls/:commentId

Resource: Poll as PUT /api/v1/polls/:commentId Credit Cost: 1

Prilaže anketu postojećem komentaru ili postavlja kompletno stanje ankete koju već ima.

Telo predstavlja kompletnu anketu, a opcije koje pošaljete postaju opcije ankete, redosledom kojim su navedene. Svaka opcija se podudara po svom id‑u:

Opcija poslata sa id‑jem postojeće opcije zadržava tu opciju i njene glasove. Njena oznaka i pozicija se ažuriraju prema onome što ste poslali.
Opcija poslata bez id‑ja se dodaje, bez glasova.
Postojeća opcija koju izostavite se uklanja, zajedno sa glasovima koji su na nju dati. totalVotes opada za isti iznos.

Dakle, da biste dodali opciju, pošaljite trenutne opcije sa njihovim id‑jevima plus novu bez id‑ja. Da biste uklonili opciju, pošaljite listu bez nje. id‑je opcija se nalaze u anketi koju vraća GET /api/v1/polls/:commentId.

Slanje bez ikakvih id‑ja zamenjuje svaku opciju i briše sve glasove koji su već dati na anketu. Ako anketa ima glasove, ovo zahteva replaceVotes=true, a bez toga API odgovara sa replace-votes-required.

Ostala polja se takođe zamenjuju: izostavljanje closesAt, privacy ili requireVoteToSeeResults vraća njihovu podrazumevanu vrednost. Da biste izmenili samo jedno polje i ostala ostavili nepromenjena, koristite PATCH /api/v1/polls/:commentId.

Primer cURL zahteva za Poll Put

Copy

curl --request PUT \
  --url 'https://fastcomments.com/api/v1/polls/comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"question": "Which release should we cut first?",
	"options": [
		{"id": "existing-option-id", "label": "The bugfix release"},
		{"label": "The feature release"}
	],
	"closesAt": "2026-12-31T00:00:00.000Z"
}'

Struktura zahteva za Poll Put

Copy

interface PollPutQueryParams {
    tenantId: string
    API_KEY: string
    /** Potrebno da se zadrže nijedni od postojećih id‑ova opcija kada anketa ima glasove, pošto to briše sve. **/
    replaceVotes?: boolean
}
interface PollPutOption {
    /** Id postojeće opcije, da se zadrži ona i njeni glasovi. Izostavite da biste dodali novu opciju. **/
    id?: string | null
    label: string
}
interface PollPutBody {
    question: string
    /** Kompletna, uređena lista. Izostavljene postojeće opcije se uklanjaju zajedno sa svojim glasovima. **/
    options: PollPutOption[]
    /** Mora biti u budućnosti kada komentar još nema anketu. Izostavite za anketu koja ostaje otvorena. **/
    closesAt?: string | null
    /** 0 anonimno (podrazumevano), 1 administratori i moderatori, 2 svi. **/
    privacy?: 0 | 1 | 2 | null
    requireVoteToSeeResults?: boolean | null
}

Struktura odgovora za Poll Put

Copy

interface PollPutResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'polls-disabled' | 'poll-invalid' | 'replace-votes-required' | 'poll-privacy-locked' | 'locked'
    /** Uključeno u slučaju greške. **/
    reason?: string
    poll: CommentPoll
}

Ostale napomene

id koji nije na anketi, ili isti id dat dva puta, izaziva grešku poll-invalid. Komentar bez ankete još nema id‑je opcija, pa svaka poslata opcija mora izostaviti id.
Privatnost ankete može se suziti, ali ne i proširiti nakon što ima glasove.
Ovaj API poštuje podešavanja vašeg sajta. Ako ankete nisu omogućene za sajt ili stranicu, vraća grešku polls-disabled.
Zaključani komentar ne može imati izmenjenu anketu i vraća grešku locked.
Povezani vidžeti se ažuriraju u realnom vremenu, tako da posmatrači vide novu anketu bez ponovnog učitavanja.

PATCH /api/v1/polls/:commentId

Resource: Poll as PATCH /api/v1/polls/:commentId Credit Cost: 1

Uređuje anketu bez ometanja njenih glasova. Koristite ovo da ispravite tipografsku grešku u pitanju ili opciji, da zatvorite ili ponovo otvorite anketu, ili da promenite ko može da vidi ko je glasao.

Opcije se adresiraju po njihovom id, a PATCH preimenuje one koje navedete. Da biste dodali, uklonili ili promenili redosled opcija, pošaljite kompletnu listu opcija na PUT /api/v1/polls/:commentId: opcije koje pošaljete sa njihovim id-jevima zadržavaju i svoje glasove.

Svako polje je opciono, ali mora biti navedeno bar jedno.

Primer cURL zahteva za ažuriranje ankete

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/polls/comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"question": "Which release should we cut first?",
	"options": [{"id": "the-option-id", "label": "The bugfix release"}]
}'

Primer cURL zahteva za zatvaranje ankete odmah

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/polls/comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"closesAt": "2020-01-01T00:00:00.000Z"
}'

Struktura zahteva za ažuriranje ankete

Copy

interface PollPatchQueryParams {
    tenantId: string
    API_KEY: string
}
interface PollPatchBody {
    question?: string | null
    /** Preimenuje postojeće opcije. Svaki prosleđeni id mora već biti u anketi. **/
    options?: { id: string, label: string }[] | null
    /** Datum u prošlosti zatvara anketu odmah. null ponovo otvara zatvorenu anketu. **/
    closesAt?: string | null
    /** 0 anonimno, 1 administratori i moderatori, 2 svi. **/
    privacy?: 0 | 1 | 2 | null
    requireVoteToSeeResults?: boolean | null
}

Struktura odgovora za ažuriranje ankete

Copy

interface PollPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'poll-not-found' | 'poll-invalid' | 'poll-privacy-locked' | 'locked'
    /** Uključeno u slučaju greške. **/
    reason?: string
    poll: CommentPoll
}

Ostale napomene

Davanje id-a opciji koja nije u anketi rezultuje greškom poll-invalid umesto tihe neaktivnosti.
Oznake moraju ostati jedinstvene unutar ankete, uzimajući u obzir i opcije koje ne menjate.
Za razliku od kreiranja ankete, closesAt ovde može biti u prošlosti – tako odmah zatvarate anketu.
Privatnost ankete može se suziti, ali ne i proširiti nakon što ima glasova.
Zaključani komentar ne može imati izmenjenu anketu i rezultuje greškom locked.

DELETE /api/v1/polls/:commentId

Resource: Poll as DELETE /api/v1/polls/:commentId Credit Cost: 1

Uklanja anketu iz njenog komentara, zajedno sa svim glasovima koji su na nju dati. Sam komentar ostaje nepromenjen.

Brisanje komentara takođe uklanja njegovu anketu i glasove, pa je ovo potrebno samo kada želite da zadržite komentar.

Primer cURL brisanja ankete

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/polls/comment-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za brisanje ankete

Copy

interface PollDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora na brisanje ankete

Copy

interface PollDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'poll-not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

Struktura glasanja u anketi

A PollVote je odgovor jedne osobe na anketu. Brojke prikazane na samoj anketi ažurirane su u skladu s ovim, pa su vam potrebne samo kada želite da znate ko je glasao za šta, a ne ukupne rezultate.

Glasač može imati najviše jedan glas po anketi. Ponovno glasanje premješta njihov postojeći glas na novu opciju umesto da doda drugi, a updatedAt beleži kada se to dogodilo.

voterId je userId kada je glasač bio prijavljen, a anonUserId u suprotnom.

Struktura PollVote

Copy

interface PollVote {
    id: string
    tenantId: string
    commentId: string
    urlId: string
    /** userId kada je glasač bio prijavljen, u suprotnom anonUserId. **/
    voterId: string
    optionId: string
    createdAt: string
    /** Kada je glasač poslednji put premestio svoj glas na drugu opciju. **/
    updatedAt?: string
}

Privatnost

Anoniman (podrazumevano): niko ne može videti kako je ko glasao, pa glasovi ne mogu biti pročitani. GET /api/v1/poll-votes i GET /api/v1/poll-votes/:id odgovaraju sa poll-anonymous. Brojke ankete i dalje su dostupne putem GET /api/v1/polls/:commentId.
Administratori i moderatori: vaš API ključ pripada administratoru vašeg sajta, pa može čitati glasove.
Svi: glasovi se mogu čitati.

Privatnost ankete može biti sužena, ali ne i proširena nakon što ima glasova.

GET /api/v1/poll-votes

Resource: PollVote as GET /api/v1/poll-votes Credit Cost: 1

Izlistava pojedinačne glasove iza broja glasova jedne ankete, najstarije prvo. Jedan kredit po 100 vraćenih glasova.

Anketa pripada komentaru, pa se glasovi čitaju po jednoj anketi odjednom i commentId je obavezan. Dodatno suzite pretragu sa voterId da proverite kako je jedna osoba glasala, ili sa optionId da izlistate sve koji su odabrali određenu opciju.

Maksimalno 1000 glasova se vraća po pozivu. Koristite skip da paginirate dalje.

Poštuje se podešavanje privacy ankete: glasovi na anonimnoj anketi ne mogu biti pročitani, i zahtev ne uspeva sa poll-anonymous. Pogledajte strukturu PollVote za detalje.

PollVotes Get cURL Primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/poll-votes?tenantId=demo&API_KEY=DEMO_API_SECRET&commentId=comment-id'

PollVotes Get Struktura Zahteva

Copy

interface PollVotesGetQueryParams {
    tenantId: string
    API_KEY: string
    commentId: string
    voterId?: string
    optionId?: string
    skip?: number
}

PollVotes Get Struktura Odgovora

Copy

interface PollVotesGetResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-comment-id' | 'poll-not-found' | 'poll-anonymous'
    /** Included on failure. **/
    reason?: string
    pollVotes: PollVote[]
}

Brojanje glasova po opciji

Ne morate da sabirate ovo da biste dobili rezultate - anketa nosi svoje sopstvene brojeve. Umesto toga pročitajte anketu sa GET /api/v1/polls/:commentId, i koristite ovaj API kada treba da znate ko je glasao.

Svaka anketa na stranici

Ne postoji listanje glasova za celu stranicu. Da biste izveštavali o celoj stranici, preuzmite njene komentare sa GET /api/v1/comments, što vraća anketu svakog komentara i njegove brojeve, a zatim pročitajte glasove za ankete koje vas zanimaju.

GET /api/v1/poll-votes/:id

Resource: PollVote as GET /api/v1/poll-votes/:id Credit Cost: 1

Čita jedan glas ankete po njegovom ID-u.

Glas na anonimnoj anketi ne može biti pročitan, i zahtev ne uspeva sa poll-anonymous. Pogledajte strukturu PollVote da biste videli kako se primenjuje podešavanje privacy ankete.

PollVote Get cURL Primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/poll-votes/my-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

PollVote Get Struktura Zahteva

Copy

interface PollVoteGetQueryParams {
    tenantId: string
    API_KEY: string
}

PollVote Get Struktura Odgovora

Copy

interface PollVoteGetResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'not-found' | 'poll-not-found' | 'poll-anonymous'
    /** Included on failure. **/
    reason?: string
    pollVote: PollVote
}

POST /api/v1/poll-votes

Resource: PollVote as POST /api/v1/poll-votes Credit Cost: 1

Zapisuje glas na anketi.

Glasač može imati najviše jedan glas po anketi. Ponovnim pozivanjem za istog glasača njegov glas se premesti na novu opciju umesto da se doda drugi, a glasanje za opciju koju je već izabrao ne radi ništa.

Odgovor uključuje anketu, tako da dobijate ažurirane brojeve bez drugog zahteva.

Primer cURL zahteva za kreiranje PollVote

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/poll-votes?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"commentId": "comment-id",
	"optionId": "the-option-id",
	"userId": "user-id"
}'

Primer cURL zahteva za anonimno kreiranje PollVote

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/poll-votes?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"commentId": "comment-id",
	"optionId": "the-option-id",
	"anonUserId": "some-randomly-generated-identifier",
	"ip": "203.0.113.4"
}'

Struktura zahteva za kreiranje PollVote

Copy

interface PollVoteCreateQueryParams {
    tenantId: string
    API_KEY: string
}
interface PollVoteCreateBody {
    commentId: string
    optionId: string
    /** Jedan od userId ili anonUserId je obavezan. **/
    userId?: string
    anonUserId?: string
    /** IP krajnjeg korisnika, korišćen za anonimno ograničenje brzine. Podrazumevano je IP pozivaoca. **/
    ip?: string
}

Struktura odgovora za kreiranje PollVote

Copy

interface PollVoteCreateResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-comment-id' | 'missing-user-id' | 'invalid-user' | 'unauthorized' | 'poll-not-found' | 'poll-invalid-option' | 'poll-closed' | 'poll-login-required' | 'rate-limited'
    /** Uključeno u slučaju greške. **/
    reason?: string
    pollVote: PollVote
    /** Anketa sa ažuriranim brojevima. **/
    poll: CommentPoll
}

Anonimni glasovi

Postavite anonUserId umesto userId da zabeležite glas za nekoga ko nije prijavljen. Taj ID ne mora da odgovara nekom korisniku - on samo identifikuje sesiju, tako da ista osoba ne bude brojana dva puta.

Anonimno glasanje mora biti omogućeno za vaš sajt. Ako je glasanje ograničeno na prijavljene korisnike, glas sa samo anonUserId će propasti sa poll-login-required.

Anonimni glasovi su takođe ograničeni po IP-u po anketi, kako bi se sprečilo da jedna osoba napuni anketu brisanjem sesije. Pošaljite ip krajnjeg korisnika da se ograničenje primeni na njega, a ne na vaš server.

Ostale napomene

userId mora biti korisnik koji postoji na vašem sajtu. Glasovi za korisnika koji pripada drugom sajtu se odbacuju.
Glasanje na zatvorenoj anketi propada sa poll-closed.
Ovaj API ažurira brojeve na anketi i šalje ih u povezane vidžete u realnom vremenu.

DELETE /api/v1/poll-votes/:id

Resource: PollVote as DELETE /api/v1/poll-votes/:id Credit Cost: 1

Povlači glas. Opcija na koju je glas bio izdat vraća svoj broj, a glasač može ponovo glasati.

PollVote Delete cURL Primer

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/poll-votes/my-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

PollVote Delete Struktura Zahteva

Copy

interface PollVoteDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

PollVote Delete Struktura Odgovora

Copy

interface PollVoteDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'poll-not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
    /** Anketa sa ažuriranim brojačima. **/
    poll: CommentPoll
}

Ostale napomene

Brisanje istog glasa dva puta vraća not-found drugi put, a brojači ostaju nepromenjeni.
Ako je anketa zamenjena od kada je glas izdat, glas se uklanja, ali se brojači ne menjaju, jer je zamena počela od nule.

Struktura pending webhook događaja

Objekat PendingWebhookEvent predstavlja webhook događaj koji stoji u redu i čeka obradu.

PendingWebhookEvent objekti se kreiraju automatski i ne mogu se ručno kreirati putem API-ja. Takođe ističu nakon jedne godine. Mogu se obrisati što uklanja zadatak iz reda.

Postoje različiti tipovi događaja - proverite eventType (OutboundSyncEventType) i type (OutboundSyncType).

Uobičajen slučaj upotrebe ovog API-ja je implementacija prilagođenog nadzora. Možda ćete želeti da pozivate /count endpoint periodično da biste ispitivali broj stavki na čekanju za date filtere.

Struktura PendingWebhookEvent objekta je sledeća:

Struktura objekta PendingWebhookEvent

Copy

enum OutboundSyncEventType {
    Create: 0,
    Delete: 1,
    Update: 2
}
enum OutboundSyncType {
    /** Zadatak sinhronizacije specifičan za WordPress. **/
    WP: 0,
    Webhook: 1
}
interface PendingWebhookEvent {
    id: string
    /** ID komentara povezan sa događajem. **/
    commentId: string
    /** Objekat komentara za događaj u trenutku događaja. Počeli smo da ih dodajemo u novembru 2023. **/
    comment: Comment
    /** Spoljni id koji može biti povezan sa komentarom. **/
    externalId: string | null
    createdAt: Date
    tenantId: string
    attemptCount: number
    /** Podešava se pre prvog pokušaja i nakon svakog neuspeha. **/
    nextAttemptAt: Date
    /** Da li je u pitanju događaj kreiranja, brisanja ili ažuriranja... **/
    eventType: OutboundSyncEventType
    /** Tip sinhronizacije koja treba da se izvrši (WordPress, poziv API-ja, itd.). **/
    type: OutboundSyncType
    /** Domen koji je odgovarao komentaru. Koristimo ovaj domen za izbor API ključa. **/
    domain: string
    /** Poslednja greška koja se desila. Ovaj tip nije tipiziran i predstavlja "dump" onoga što se desilo. Obično sadrži objekat sa statusCode, body, i mapom headers. **/
    lastError: object | null
}

GET /api/v1/pending-webhook-events

Resource: PendingWebhookEvent as GET /api/v1/pending-webhook-events Credit Cost: 2

Ovaj endpoint vraća listu čekajućih webhook događaja u parametru pendingWebhookEvents.

Ovaj API koristi paginaciju, obezbeđenu parametrom skip. PendingWebhookEvents se vraćaju u stranicama po 100, poređani po createdAt, od najnovijih ka najstarijima.

Primer cURL zahteva za PendingWebhookEvent

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/pending-webhook-events?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za PendingWebhookEvent

Copy

interface PendingWebhookEventsGetQueryParams {
    tenantId: string
    API_KEY: string
    commentId?: string
    externalId?: string
    eventType?: OutboundSyncEventType
    type?: OutboundSyncType
    domain?: string
    /** Upit za događaje sa brojem pokušaja većim od navedenog. **/
    attemptCountGT?: number
}

Struktura odgovora za PendingWebhookEvent

Copy

interface PendingWebhookEventsGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    pendingWebhookEvents?: PendingWebhookEvent[]
}

GET /api/v1/pending-webhook-events/count

Resource: PendingWebhookEvent as GET /api/v1/pending-webhook-events/count Credit Cost: 2

Ova ruta vraća objekat koji sadrži broj webhook događaja na čekanju u parametru count.

Možete filtrirati po istim parametrima kao i endpoint /pending-webhook-events

Primer cURL zahteva za PendingWebhookEvent Count

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/pending-webhook-events/count?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za PendingWebhookEvent Count

Copy

interface PendingWebhookEventsCountQueryParams {
    tenantId: string
    API_KEY: string
    commentId?: string
    externalId?: string
    eventType?: OutboundSyncEventType
    type?: OutboundSyncType
    domain?: string
    /** Upit za događaje sa brojem pokušaja većim od navedenog broja. **/
    attemptCountGT?: number
}

Struktura odgovora za PendingWebhookEvent Count

Copy

interface PendingWebhookEventsCountResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
    count?: number
}

DELETE /api/v1/pending-webhook-events/:id

Resource: PendingWebhookEvent as DELETE /api/v1/pending-webhook-events/:id Credit Cost: 1

Ovaj endpoint omogućava brisanje jednog PendingWebhookEvent.

Ako trebate masovno brisanje, pozovite GET API sa paginacijom, a zatim pozovite ovaj API sekvencijalno.

DELETE PendingWebhookEvent cURL Primer

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/pending-webhook-events/some-id?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za brisanje PendingWebhookEvent

Copy

interface PendingWebhookEventDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za brisanje PendingWebhookEvent

Copy

interface PendingWebhookEventDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura SSO korisnika

FastComments pruža jednostavno rešenje za SSO. Ažuriranje informacija o korisniku putem HMAC-bazirane integracije je jednostavno kao to da korisnik učita stranicu sa ažuriranim payload-om.

Međutim, može biti poželjno upravljati korisnikom van tog toka, radi bolje konzistentnosti vaše aplikacije.

SSO User API pruža način za CRUD operacije nad objektima koje nazivamo SSOUsers. Ovi objekti su različiti od običnih Users i održavaju se odvojeno radi sigurnosti tipova.

Struktura SSOUser objekta je sledeća:

Struktura SSOUser

Copy

interface SSOUser {
    id: string
    username: string
    email?: string
    websiteUrl?: string
    signUpDate: number
    createdFromUrlId?: string
    loginCount?: number
    avatarSrc?: string
    optedInNotifications?: boolean
    optedInSubscriptionNotifications?: boolean
    displayLabel?: string
    displayName?: string
    isAccountOwner?: boolean // Admin dozvola - SSO korisnici sa ovom oznakom se naplaćuju kao SSO Admini (odvojeno od običnih SSO korisnika)
    isAdminAdmin?: boolean // Admin dozvola - SSO korisnici sa ovom oznakom se naplaćuju kao SSO Admini (odvojeno od običnih SSO korisnika)
    isCommentModeratorAdmin?: boolean // Dozvola moderatora - SSO korisnici sa ovom oznakom se naplaćuju kao SSO Moderatori (odvojeno od običnih SSO korisnika)
    /** Ako je null, Kontrola pristupa se ne primenjuje na korisnika. Ako je prazna lista, ovaj korisnik neće moći da vidi nijednu stranicu niti da @mention-uje druge korisnike. **/
    groupIds?: string[] | null
    createdFromSimpleSSO?: boolean
    /** Ne dozvolite drugim korisnicima da vide aktivnost ovog korisnika, uključujući komentare, na njegovom profilu. Podrazumevano je true radi sigurnih profila. **/
    isProfileActivityPrivate?: boolean
    /** Ne dozvolite drugim korisnicima da ostavljaju komentare na profilu korisnika, niti da vide postojeće komentare profila. Podrazumevano false. **/
    isProfileCommentsPrivate?: boolean
    /** Ne dozvolite drugim korisnicima da šalju direktne poruke ovom korisniku. Podrazumevano false. **/
    isProfileDMDisabled?: boolean
    karma?: number
    /** Opciona konfiguracija za bedževe korisnika. **/
    badgeConfig?: {
        /** Niz ID-jeva bedževa koje treba dodeliti korisniku. Ograničeno na 30 bedževa. Redosled se poštuje. Ovo su globalni bedževi vidljivi na svim stranicama. **/
        badgeIds: string[]
        /** Niz ID-jeva bedževa ograničenih na trenutnu stranicu (urlId). Ovi bedževi se prikazuju samo na stranici na kojoj su dodeljeni. **/
        pageBadgeIds?: string[]
        /** Ako je true, zamenjuje sve postojeće prikazane bedževe datim. Globalni bedževi i bedževi ograničeni na stranicu se zamenjuju nezavisno. Ako je false, dodaje se na postojeće bedževe. **/
        override?: boolean
        /** Ako je true, ažurira svojstva prikaza bedževa iz konfiguracije tenanta. **/
        update?: boolean
    }
}

Naplata SSO korisnika

SSO korisnici se naplaćuju različito u zavisnosti od oznaka dozvola:

Obični SSO korisnici: Korisnici bez admin ili moderatorskih dozvola naplaćuju se kao obični SSO korisnici
SSO Admini: Korisnici sa oznakama isAccountOwner ili isAdminAdmin naplaćuju se odvojeno kao SSO Admini (ista stopa kao za obične admine tenanta)
SSO Moderatori: Korisnici sa oznakom isCommentModeratorAdmin naplaćuju se odvojeno kao SSO Moderatori (ista stopa kao za obične moderatore)

Važno: Da bi se sprečilo dvostruko naplaćivanje, sistem automatski deduplira SSO korisnike u odnosu na obične korisnike i moderatore tenanta prema email adresi. Ako SSO korisnik ima isti email kao običan korisnik ili moderator tenanta, neće se naplaćivati dva puta.

Kontrola pristupa

Korisnici mogu biti podeljeni u grupe. Za to služi polje groupIds, i opciono je.

@Mentions

Podrazumevano, @mentions koriste username za pretragu drugih SSO korisnika kada se ukuca znak @. Ako se koristi displayName, rezultati koji se podudaraju sa username biće ignorisani kada postoji podudaranje sa displayName, a rezultati pretrage @mention koristiće displayName.

Pretplate

U FastComments-u, korisnici mogu da se pretplate na stranicu klikom na ikonu zvonce u vidžetu za komentare i klikom na Subscribe.

Kod običnog korisnika, šaljemo mu email obaveštenja na osnovu njegovih podešavanja obaveštenja.

Kod SSO korisnika, ovo razdvajamo radi unazad kompatibilnosti. Korisnici će primati ove dodatne emailove o pretplati samo ako postavite optedInSubscriptionNotifications na true.

Bedževi

Možete dodeliti bedževe SSO korisnicima pomoću svojstva badgeConfig. Bedževi su vizuelni indikatori koji se pojavljuju pored imena korisnika u komentarima.

badgeIds - Niz ID-jeva bedževa koje treba dodeliti korisniku. Ovo su globalni bedževi vidljivi na svim stranicama. Mora biti reč o važećim ID-jevima bedževa kreiranih u vašem FastComments nalogu. Ograničeno na 30 bedževa.
pageBadgeIds - Opcioni niz ID-jeva bedževa ograničenih na trenutnu stranicu (urlId). Ovi bedževi se prikazuju samo na stranici na kojoj su dodeljeni. Različite stranice mogu imati različite bedževe ograničene na stranicu za istog korisnika.
override - Ako je true, svi postojeći prikazani bedževi biće zamenjeni datim. Globalni bedževi i bedževi ograničeni na stranicu se zamenjuju nezavisno — zamena globalnih bedževa ne utiče na bedževe ograničene na stranicu, i obrnuto. Ako je false ili izostavljeno, dati bedževi biće dodati na postojeće.
update - Ako je true, svojstva prikaza bedževa biće ažurirana iz konfiguracije tenanta svaki put kada se korisnik prijavi.

GET /api/v1/sso-users

Resource: SSOUser as GET /api/v1/sso-users Credit Cost: 10

Ova ruta vraća SSO korisnike u stranicama po 100. Paginacija se obezbeđuje parametrom skip. Korisnici su sortirani po njihovom signUpDate i id.

Primer cURL zahteva za SSOUsers

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/sso-users?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva SSOUsers

Copy

interface SSOUsersRequestQueryParams {
    tenantId: string
    API_KEY: string
    skip?: number
}

Struktura odgovora SSOUsers

Copy

interface SSOUsersResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    users: SSOUser[]
}

GET /api/v1/sso-users/by-id/:id

Resource: SSOUser as GET /api/v1/sso-users/by-id/:id Credit Cost: 1

Ovaj endpoint vraća jednog SSO korisnika po ID-u.

Primer cURL zahteva za SSOUser po ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/sso-users/by-id/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za SSOUser

Copy

interface SSOUserRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za SSOUser

Copy

interface SSOUserByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'user-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    user: SSOUser
}

GET /api/v1/sso-users/by-email/:email

Resource: SSOUser as GET /api/v1/sso-users/by-email/:email Credit Cost: 1

Ovaj endpoint vraća jednog SSO korisnika po njihovoj email adresi.

SSOUser Po Emailu cURL Primer

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/sso-users/by-email/someone@somewhere.com?tenantId=demo&API_KEY=DEMO_API_SECRET'

SSOUser Struktura zahteva

Copy

interface SSOUserRequestByEmailQueryParams {
    tenantId: string
    API_KEY: string
}

SSOUser Struktura odgovora

Copy

interface SSOUserByEmailResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-email' | 'user-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    user: SSOUser
}

PATCH /api/v1/sso-users/:id

Resource: SSOUser as PATCH /api/v1/sso-users/:id Credit Cost: 1

Ovaj endpoint omogućava ažuriranje jednog SSO korisnika.

Primer cURL zahteva za ažuriranje SSOUser

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/sso-users/my-user-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"username": "notfordperfect"
}'

Struktura zahteva za ažuriranje SSOUser

Copy

interface SSOUserPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Kada se promeni email ili korisničko ime, možete ovo postaviti na true da biste takođe ažurirali komentare korisnika. Ovo će udvostručiti trošak kredita. **/
    updateComments: 'true' | 'false'
}

Struktura odgovora za ažuriranje SSOUser

Copy

interface SSOUserPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'invalid-input' | 'missing-id' | 'user-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    user?: SSOUser; // U slučaju uspeha vraćamo kompletno ažuriranog korisnika.
}

POST /api/v1/sso-users

Resource: SSOUser as POST /api/v1/sso-users Credit Cost: 1

Ovaj endpoint omogućava kreiranje jednog SSO korisnika.

Pokušaj kreiranja dva korisnika sa istim ID-jem će rezultovati greškom.

Primer cURL zahteva za kreiranje SSOUser-a

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/sso-users?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"id": "my-user-id",
	"username": "fordperfect",
	"displayName": "Ford Perfect",
	"email": "fordperfect@galaxy.com",
    "groupIds": ["some-optional-group-id"]
}'

U ovom primeru navodimo groupIds za kontrolu pristupa, ali ovo je opciono.

Struktura zahteva za kreiranje SSOUser-a

Copy

interface SSOUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za kreiranje SSOUser-a

Copy

interface SSOUserPostResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'invalid-input' | 'missing-id' | 'user-exists'
    /** Uključeno pri neuspehu. **/
    reason?: string
    user?: SSOUser; // Vraćamo kreiranog korisnika pri uspehu.
}

Napomena o integraciji

Podaci poslati preko API-ja mogu se jednostavno prebrisati prosleđivanjem drugačijeg SSO User HMAC payload-a. Na primer, ako postavite username putem API-ja, ali zatim prosledite drugačiji putem SSO toka pri učitavanju stranice, automatski ćemo ažurirati njihov username.

Nećemo ažurirati parametre korisnika u ovom toku osim ako ih eksplicitno ne navedete ili postavite na null (ne undefined).

PUT /api/v1/sso-users/:id

Resource: SSOUser as PUT /api/v1/sso-users Credit Cost: 1

Ovaj endpoint omogućava ažuriranje jednog SSO korisnika.

Primer cURL zahteva za ažuriranje SSOUser

Copy

curl --request PUT \
  --url 'https://fastcomments.com/api/v1/sso-users/my-user-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"username": "fordperfect",
	"displayName": "Ford Perfect",
	"email": "fordperfect@galaxy.com",
    "groupIds": ["some-optional-group-id"]
}'

U ovom primeru navodimo groupIds za kontrolu pristupa, ali to je opciono.

Struktura zahteva za ažuriranje SSOUser

Copy

interface SSOUserPutQueryParams {
    tenantId: string
    API_KEY: string
    /** Kada se promeni email ili korisničko ime, možete ovo postaviti na true da takođe ažurirate korisnikove komentare. Ovo će udvostručiti cenu u kreditima. **/
    updateComments: 'true' | 'false'
}

Struktura odgovora za ažuriranje SSOUser

Copy

interface SSOUserPutResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'invalid-input' | 'missing-id' | 'user-exists'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    user?: SSOUser; // Vraćamo ažuriranog korisnika pri uspehu.
}

DELETE /api/v1/sso-users/:id

Resource: SSOUser as DELETE /api/v1/sso-users/:id Credit Cost: 1

Ovaj endpoint omogućava uklanjanje pojedinačnog SSO korisnika po njegovom id-u.

Imajte na umu da ponovno učitavanje komentarskog widgeta sa payload-om za ovog korisnika jednostavno ponovo kreira korisnika bez prekida.

Brisanje korisnikovih komentara je moguće putem query parametra deleteComments. Imajte na umu da ako je ovo tačno:

Svi korisnikovi komentari biće obrisani uživo.
Svi child (sada siroti) komentari biće obrisani ili anonimizovani u zavisnosti od konfiguracije stranice kojoj svaki komentar pripada. Na primer, ako je režim brisanja niti "anonymize", onda će odgovori ostati, a korisnikovi komentari će biti anonimizovani. Ovo se primenjuje samo kada je commentDeleteMode postavljen na Remove (podrazumevana vrednost).
creditsCost postaje 2.

Anonimizovani komentari

Možete zadržati korisnikove komentare, ali ih jednostavno anonimizovati postavljanjem commentDeleteMode=1.

Ako su korisnikovi komentari anonimizovani, sledeće vrednosti se postavljaju na null:

- commenterName
- commenterEmail
- avatarSrc
- userId
- anonUserId
- mentions
- badges

isDeleted i isDeletedUser se postavljaju na true.

Prilikom renderovanja, komentarski widget će za korisničko ime koristiti DELETED_USER_PLACEHOLDER (podrazumevano: "[deleted]") a za sadržaj komentara DELETED_CONTENT_PLACEHOLDER. Ovo se može prilagoditi preko korisničkog interfejsa za prilagođavanje widgeta.

Primeri

Primer cURL zahteva za uklanjanje SSOUser

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/sso-users/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje SSOUser

Copy

enum SSOUserCommentDeleteMode {
    Remove = 0, // podrazumevano
    Anonymize = 1
}
interface SSOUsersDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** Možete ovo postaviti na true da biste takođe obrisali komentare korisnika. Ovo će duplirati trošak u kreditima. **/
    deleteComments?: 'true' | 'false'
    /** Možete ovo postaviti po želji da odredite kako postupati sa komentarima korisnika. **/
    commentDeleteMode?: SSOUserCommentDeleteMode
}

Struktura odgovora za uklanjanje SSOUser

Copy

interface SSOUsersResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'user-does-not-exist'
    /** Uključeno u slučaju greške. **/
    reason?: string
    user?: SSOUser; // Vraćamo uklonjenog korisnika u slučaju uspeha.
}

Struktura pretplate

Subscription objekat predstavlja pretplatu za korisnika.

Subscription objekti se kreiraju kada korisnik klikne na ikonu zvona za obaveštenja u komentarskom widgetu i klikne na "Pretplati se na ovu stranicu".

Pretplate se takođe mogu kreirati putem API-ja.

Pojava Subscription objekta izaziva generisanje Notification objekata i slanje mejlova kada se ostave novi komentari na root-u povezane stranice za koju je Subscription. Slanje mejlova zavisi od tipa korisnika. Za obične korisnike ovo zavisi od optedInNotifications. Za SSO korisnike ovo zavisi od optedInSubscriptionNotifications. Imajte na umu da neke aplikacije možda nemaju koncept veb-pristupačne stranice, u kom slučaju jednostavno postavite urlId na id stavke na koju se pretplaćujete (ista vrednost za urlId koju biste prosledili komentarskom widgetu).

Struktura za Subscription objekat je sledeća:

Struktura Subscription objekta

Copy

interface Subscription {
    id: string
    tenantId: string
    /** Kod SSO, user id je u formatu `<tenant id>:<user id>`. **/
    userId: string
    anonUserId?: string
    urlId: string
    url?: string
    pageTitle?: string
    createdAt: string // string datuma
}

GET /api/v1/subscriptions/:id

Resource: Subscription as GET /api/v1/subscriptions Credit Cost: 1

Ova ruta vraća do 30 Subscription objekata sortiranih po createdAt, najnoviji prvi.

Možete filtrirati po userId. Sa SSO, korisnički id je u formatu <tenant id>:<user id>.

Primer cURL zahteva za pretplate korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/subscriptions?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=SOME_USER_ID'

Struktura zahteva za pretplate

Copy

interface SubscriptionsGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Paginacija preskakanjem zapisa. **/
    skip?: number
    /** Filtriraj po korisniku. **/
    userId?: string
}

Struktura odgovora za pretplate

Copy

interface SubscriptionsGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
    subscriptions?: Subscription[]
}

POST /api/v1/subscriptions

Resource: Subscription as POST /api/v1/subscriptions Credit Cost: 1

Ovaj API endpoint omogućava kreiranje Subscription. Imajte na umu da korisnik može imati samo jednu pretplatu po stranici, jer su više njih suvišne, i pokušaj kreiranja više od jedne pretplate za istog korisnika za istu stranicu rezultiraće greškom.

Kreiranje pretplate će dovesti do kreiranja objekata Notification kada se ostavi novi komentar na korenu pretplaćenog urlId (kada je parentId komentara null).

Primer cURL zahteva za Subscription POST

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/subscriptions?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "userId": "tenantId:test-user-id",
    "urlId": "some-page-id-or-url",
    "url": "https://example.com/page",
    "pageTitle": "Some Example Page!"
}'

Struktura zahteva za Subscription POST

Copy

interface SubscriptionPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Subscription POST

Copy

interface SubscriptionPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'unauthorized' | 'not-found';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

DELETE /api/v1/subscriptions/:id

Resource: Subscription as DELETE /api/v1/subscriptions Credit Cost: 1

Ovaj endpoint briše jedan objekat Subscription po id-u.

Primer cURL zahteva za uklanjanje Subscription

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/subscriptions/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje Subscription

Copy

interface SubscriptionsDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje Subscription

Copy

interface SubscriptionDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura dnevne upotrebe zakupca

Objekat TenantDailyUsage predstavlja upotrebu za tenant-a za određeni dan. Ako nije bilo aktivnosti za datog tenant-a na određen dan, taj dan neće imati objekat TenantDailyUsage.

Objekat TenantDailyUsage je NIJE u realnom vremenu i može kasniti za nekoliko minuta u odnosu na stvarnu upotrebu.

Struktura objekta TenantDailyUsage je sledeća:

Struktura TenantDailyUsage

Copy

export interface TenantDailyUsage {
    yearNumber: number
    monthNumber: number
    dayNumber: number
    commentFetchCount?: number
    commentCreateCount?: number
    conversationCreateCount?: number
    voteCount?: number
    accountCreatedCount?: number
    userMentionSearch?: number
    hashTagSearch?: number
    gifSearchTrending?: number
    gifSearch?: number
    apiCreditsUsed?: number
    createdAt: string
    billed: boolean
    /** Ignorisano za naplatu. **/
    ignored: boolean
}

GET /api/v1/tenant-daily-usage

Resource: TenantDailyUsage as GET /api/v1/tenant-daily-usage Credit Cost: 1

Ovaj endpoint omogućava pretragu upotrebe tenanta po godini, mesecu i danu. Može se vratiti najviše 365 objekata, a cena je 1 api credit na 10 objekata.

Objekti odgovora su sortirani po datumu kada su kreirani (najstariji prvi).

Primer cURL zahteva za pretragu TenantDailyUsage

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenant-daily-usage?tenantId=demo&API_KEY=DEMO_API_SECRET&yearNumber=2022&monthNumber=2&dayNumber=10'

Struktura zahteva TenantDailyUsage

Copy

interface TenantDailyUsageQueryParams {
    tenantId: string
    API_KEY: string
    /** Bazirano na UTC. **/
    yearNumber?: number
    /** Indeksirano od nule. Bazirano na UTC. **/
    monthNumber?: number
    /** Indeksirano počev od 1. Bazirano na UTC. **/
    dayNumber?: number
}

Struktura odgovora TenantDailyUsage

Copy

interface TenantDailyUsageResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenantDailyUsages: TenantDailyUsage[]
}

Struktura zakupca

Tenant definiše FastComments.com kupca. Mogu se kreirati preko API-ja od strane tenanta koji imaju pristup za white labeling. White labeled tenanti ne mogu kreirati druge white labeled tenante (dozvoljen je samo jedan nivo ugnježđivanja).

Struktura Tenant objekta je sledeća:

Struktura Tenant objekta

Copy

export enum SiteType {
    Unknown = 0,
    WordPress = 1
}
/** Ovo se takođe može rešiti putem DomainConfig API-ja. **/
export interface TenantDomainConfig {
    domain: string
    emailFromName?: string
    emailFromEmail?: string
    createdAt?: string,
    siteType?: FastCommentsSiteType, // verovatno želite Unknown
    logoSrc?: string, // putanja do originalne slike
    logoSrc100px?: string, // promenjena veličina za sličice
    footerUnsubscribeURL?: string,
    emailHeaders?: Record<string, string>,
    disableUnsubscribeLinks?: boolean,
    dkim?: {
        domainName: string,
        keySelector: string,
        privateKey: string
    }
}
export interface TenantBillingInfo {
    name: string
    address: string
    city: string
    state: string
    zip: string
    country: string
}
export enum TenantPaymentFrequency {
    Monthly = 0,
    Annually = 1
}
export interface Tenant {
    id: string
    name: string
    email?: string
    signUpDate: number; // broj zbog "legacy" razloga
    packageId?: string | null
    paymentFrequency?: TenantPaymentFrequency
    billingInfoValid?: boolean
    billingHandledExternally?: boolean
    createdBy?: string
    isSetup?: boolean
    domainConfiguration: FastCommentsAPITenantDomainConfig[]
    billingInfo?: FastCommentsAPITenantBillingInfo
    stripeCustomerId?: string
    stripeSubscriptionId?: string
    stripePlanId?: string
    enableProfanityFilter?: boolean
    enableSpamFilter?: boolean
    lastBillingIssueReminderDate?: string
    removeUnverifiedComments?: boolean
    unverifiedCommentsTTLms?: number
    commentsRequireApproval?: boolean
    autoApproveCommentOnVerification?: boolean
    sendProfaneToSpam?: boolean
    /** @readonly - Izračunava se na osnovu packageId. **/
    hasFlexPricing?: boolean
    /** @readonly **/
    flexLastBilledAmount?: number
    /** @readonly - Izračunava se na osnovu packageId. **/
    hasAuditing?: boolean
    /** Možete sačuvati par ključ-vrednost sa tenant-om koji možete koristiti za upite. Ključevi ne mogu sadržati "." ili "$", ili biti duži od 100 karaktera. Vrednosti ne mogu biti duže od 2k karaktera. **/
    meta?: Record<string, string | null>
}

GET /api/v1/tenants/:id

Resource: Tenant as GET /api/v1/tenants/:id Credit Cost: 1

Ova ruta vraća jednog Tenanta po id-u.

Primer cURL zahteva za Tenant po ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenants/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za Tenant

Copy

interface TenantByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Tenant

Copy

interface TenantByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenant?: Tenant
}

GET /api/v1/tenants

Resource: Tenant as GET /api/v1/tenants Credit Cost: 1

Ovaj API vraća tenante kojima upravlja vaš tenant.

Paginacija se obezbeđuje pomoću query parametra skip. Tenanti se vraćaju u stranicama po 100, sortirani po signUpDate i id.

Trošak se zasniva na broju vraćenih tenanata, iznosi 1 credit per 10 vraćenih tenanata.

Primer cURL zahteva za Tenant

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenants?tenantId=demo&skip=0&API_KEY=DEMO_API_SECRET'

Možete definisati meta parametre na Tenant objektima i upitavati za odgovarajuće tenante. Na primer, za ključ someKey i meta vrednost some-value, možemo konstruisati JSON objekat sa ovim parom ključ/vrednost i zatim ga URI enkodovati kao query parametar za filtriranje:

Primer cURL zahteva za pretragu Tenant-a po meta

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenants?tenantId=demo&skip=0&API_KEY=DEMO_API_SECRET&meta=%7B%22someKey%22%3A%22some-value%22%7D'

Struktura zahteva za Tenant

Copy

interface TenantsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Broj tenanata koji će biti preskočeni za paginaciju. **/
    skip?: number
    /** Filtriraj po meta parametrima. **/
    meta?: string
}

Struktura odgovora za Tenant

Copy

interface TenantsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenants?: Tenant[]
}

POST /api/v1/tenants

Resource: Tenant as POST /api/v1/tenants Credit Cost: 1

Ovaj endpoint omogućava dodavanje jednog Tenant.

Kreiranje Tenant ima sledeća ograničenja:

name je obavezno.
domainConfiguration je obavezno.
Sledeće vrednosti se ne smeju navoditi prilikom kreiranja Tenant:
- hasFlexPricing
- lastBillingIssueReminderDate
- flexLastBilledAmount
signUpDate ne sme biti u budućnosti.
name ne sme biti duže od 200 characters.
email ne sme biti duže od 300 characters.
email mora biti jedinstven među svim tenantima na FastComments.com.
Ne možete kreirati tenant-e ako roditeljski tenant nema definisan validan TenantPackage.
- Ako je vaš tenant kreiran preko FastComments.com, ovo ne bi trebalo da predstavlja problem.
Ne možete kreirati više tenant-a nego što je definisano u maxWhiteLabeledTenants u vašem paketu.
Morate navesti query param tenantId koji je id vašeg parent tenant sa omogućenim white labeling-om.

Možemo kreirati Tenant koristeći samo nekoliko parametara:

Primer cURL zahteva za kreiranje Tenant-a

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/tenants?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Some Name",
	"email": "someone@someone.com",
    "domainConfiguration": [ { "domain": "somedomain.com" } ]
}'

Struktura zahteva za kreiranje Tenant-a

Copy

interface TenantPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora pri kreiranju Tenant-a

Copy

interface TenantPostResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'not-found' | 'unexpected-param' | 'sign-up-date-in-future' | 'payment-frequency-invalid' | 'cannot-change-payment-frequency' | 'name-invalid' | 'email-invalid' | 'email-taken' | 'no-package' | 'invalid-package' | 'unauthorized' | 'tenant-limit-reached' | 'cannot-move-tenant' | 'cannot-change-package' | 'invalid-billing-info'
    /** Uključeno pri neuspehu. **/
    reason?: string
    tenant?: Tenant; // Vraćamo kompletno kreiran tenant pri uspehu.
}

PATCH /api/v1/tenants/:id

Resource: Tenant as PATCH /api/v1/tenants/:id Credit Cost: 1

Ova API krajnja tačka omogućava ažuriranje Tenant po id.

Ažuriranje Tenant ima sledeća ograničenja:

Sledeće vrednosti se ne mogu ažurirati:
- hasFlexPricing
- lastBillingIssueReminderDate
- flexLastBilledAmount
- managedByTenantId
Vrednost signUpDate ne sme biti u budućnosti.
Vrednost name ne sme biti duža od 200 characters.
Vrednost email ne sme biti duža od 300 characters.
Vrednost email mora biti jedinstvena među svim tenant-ima FastComments.com.
Kada se billingInfoValid postavi na true, billingInfo mora biti dostavljen u istom zahtevu.
Ne možete da ažurirate packageId koji je povezan sa vašim tenant-om.
Ne možete da ažurirate paymentFrequency koji je povezan sa vašim tenant-om.

Primer cURL PATCH zahteva za Tenant

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/tenants/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"name": "Some New Name",
}'

Struktura PATCH zahteva za Tenant

Copy

interface TenantPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Tenant PATCH

Copy

interface TenantPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'not-found' | 'unexpected-param' | 'sign-up-date-in-future' | 'payment-frequency-invalid' | 'cannot-change-payment-frequency' | 'name-invalid' | 'email-invalid' | 'email-taken' | 'no-package' | 'invalid-package' | 'unauthorized' | 'tenant-limit-reached' | 'cannot-move-tenant' | 'cannot-change-package' | 'invalid-billing-info'; 
    /** Uključeno u slučaju greške. **/
    reason?: string
}

DELETE /api/v1/tenants/:id

Resource: Tenant as DELETE /api/v1/tenants/:id Credit Cost: 1,000

Ova ruta omogućava uklanjanje Tenant i svih povezanih podataka (korisnika, komentara, itd.) po id-u.

Sledeća ograničenja važe prilikom uklanjanja tenanta:

Tenant mora biti vaš, ili white-label tenant kojim upravljate.
Query parametar sure mora biti postavljen na true.

Primer cURL zahteva za uklanjanje Tenanta

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/tenants/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje Tenanta

Copy

interface TenantDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje Tenanta

Copy

interface TenantDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized' | 'unsure'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura paketa zakupca

TenantPackage definiše informacije o paketu dostupnom Tenant. Tenant može imati više dostupnih paketa, ali je u upotrebi samo jedan u datom trenutku.

Tenant se ne može koristiti za bilo koje proizvode dok njegov packageId ne ukazuje na važeći TenantPackage.

Postoje dve vrste TenantPackage objekata:

Paketi sa fiksnim cenama - gde je hasFlexPricing false.
Fleksibilno određivanje cena - gde je hasFlexPricing true.

U oba slučaja ograničenja se definišu na nalogu koji koristi paket, međutim kod Flex-a tenant se naplaćuje osnovna cena plus ono što su koristili, definisano flex* parametrima.

Tenant može imati više tenant paketa i mogućnost da sam promeni paket sa Stranice sa informacijama o naplati.

Ako ćete vi sami obrađivati naplatu za tenante, i dalje ćete morati da definišete paket za svakog tenanta da biste odredili njihova ograničenja. Jednostavno postavite billingHandledExternally na true na Tenant i oni neće moći sami da menjaju svoje podatke o naplati ili aktivni paket.

Ne smete kreirati pakete sa većim ograničenjima od roditeljskog tenanta.

Struktura TenantPackage objekta je sledeća:

Struktura TenantPackage

Copy

export interface TenantPackage {
    id: string
    name: string
    tenantId: string
    createdAt: string
    monthlyCostUSD: number
    yearlyCostUSD: number
    monthlyStripePlanId?: string
    yearlyStripePlanId?: string
    maxMonthlyPageLoads: number
    maxMonthlyAPICredits: number
    maxMonthlyComments: number
    maxConcurrentUsers: number
    maxTenantUsers: number
    maxSSOUsers: number
    maxModerators: number
    maxDomains: number
    maxWhiteLabeledTenants: number
    hasWhiteLabeling: boolean
    hasDebranding: boolean
    forWhoText: string
    featureTaglines: string[]
    hasAuditing: boolean
    hasFlexPricing: boolean
    flexPageLoadCostCents?: null
    flexPageLoadUnit?: null
    flexCommentCostCents?: null
    flexCommentUnit?: null
    flexSSOUserCostCents?: null // Cena po običnom SSO korisniku (bez administratorskih ili moderatorskih dozvola)
    flexSSOUserUnit?: null
    flexAPICreditCostCents?: null
    flexAPICreditUnit?: null
    flexModeratorCostCents?: null
    flexModeratorUnit?: null
    flexAdminCostCents?: null
    flexAdminUnit?: null
    flexDomainCostCents?: null
    flexDomainUnit?: null
    flexSSOAdminCostCents?: null // Cena po SSO korisniku sa administratorskim privilegijama (oznake isAccountOwner ili isAdminAdmin)
    flexSSOAdminUnit?: null
    flexSSOModeratorCostCents?: null // Cena po SSO korisniku sa moderatorskim privilegijama (oznake isCommentModeratorAdmin)
    flexSSOModeratorUnit?: null
    flexMinimumCostCents?: null
}

GET /api/v1/tenant-packages/:id

Resource: TenantPackage as GET /api/v1/tenant-packages/:id Credit Cost: 1

Ovaj endpoint vraća jedan Tenant Package po id-u.

Primer cURL zahteva za TenantPackage po id-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenant-packages/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za TenantPackage

Copy

interface TenantPackageByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za TenantPackage

Copy

interface TenantPackageByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenantPackage: TenantPackage
}

GET /api/v1/tenant-packages

Resource: TenantPackage as GET /api/v1/tenant-packages Credit Cost: 1

Ovaj API koristi paginaciju, koju obezbeđuje query parametar skip. TenantPackages se vraćaju u stranicama po 100, sortirane po createdAt i id.

Cena se zasniva na broju vraćenih TenantPackages, i iznosi 1 credit per 10 vraćenih TenantPackages.

Primer cURL-a za TenantPackage

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenant-packages?tenantId=demo&skip=0&API_KEY=DEMO_API_SECRET'

Struktura zahteva za TenantPackage

Copy

interface TenantPackagesRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Broj TenantPackages koje treba preskočiti za paginaciju. **/
    skip?: number
}

Struktura odgovora za TenantPackage

Copy

interface TenantPackagesResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju greške. **/
    reason?: string
    tenantPackages?: TenantPackage[]
}

POST /api/v1/tenant-packages

Resource: TenantPackage as POST /api/v1/tenant-packages Credit Cost: 1

Ovaj endpoint omogućava dodavanje jednog TenantPackage.

Kreiranje TenantPackage ima sledeća ograničenja:

Sledeći parametri su obavezni:
- name
- tenantId
- monthlyCostUSD - Može biti null.
- yearlyCostUSD - Može biti null.
- maxMonthlyPageLoads
- maxMonthlyAPICredits
- maxMonthlyComments
- maxConcurrentUsers
- maxTenantUsers
- maxSSOUsers
- maxModerators
- maxDomains
- hasDebranding
- forWhoText
- featureTaglines
- hasFlexPricing - Ako je true, tada su svi flex* parametri obavezni.
Vrednost name ne sme biti duža od 50 characters.
Svaki element forWhoText ne sme biti duži od 200 characters.
Svaki element featureTaglines ne sme biti duži od 100 characters.
TenantPackage mora biti "manji" od roditeljskog tenant-a. Na primer, svi max* parametri moraju imati niže vrednosti nego kod roditeljskog tenant-a.
Tenant sa white-labeling pristupom može imati najviše pet paketa.
Samo tenant-i sa pristupom za white labeling mogu kreirati TenantPackage.
Ne možete dodavati pakete svom sopstvenom tenant-u. :)

Možemo kreirati a TenantPackage na sledeći način:

Primer cURL zahteva za kreiranje TenantPackage putem e-pošte

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/tenant-packages?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "Default Package",
  "tenantId": "some-child-tenant-id",
  "monthlyCostUSD": null,
  "yearlyCostUSD": null,
  "maxMonthlyPageLoads": 50000,
  "maxMonthlyAPICredits": 50000,
  "maxMonthlyComments": 50000,
  "maxConcurrentUsers": 50000,
  "maxTenantUsers": 10,
  "maxSSOUsers": 50000,
  "maxModerators": 100,
  "maxDomains": 3,
  "hasWhiteLabeling": false,
  "hasDebranding": true,
  "forWhoText": "For Everyone",
  "featureTaglines": [
    "Some Tag",
    "Some Other Tag"
  ],
  "hasFlexPricing": true,
  "flexPageLoadCostCents": 100,
  "flexPageLoadUnit": 100000,
  "flexCommentCostCents": 100,
  "flexCommentUnit": 100000,
  "flexSSOUserCostCents": 100,
  "flexSSOUserUnit": 1000,
  "flexAPICreditCostCents": 100,
  "flexAPICreditUnit": 50000,
  "flexModeratorCostCents": 500,
  "flexModeratorUnit": 1,
  "flexAdminCostCents": 1000,
  "flexAdminUnit": 1,
  "flexDomainCostCents": 1000,
  "flexDomainUnit": 1,
  "flexMinimumCostCents": 99
}'

Struktura zahteva za kreiranje TenantPackage

Copy

interface TenantPackagePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za kreiranje TenantPackage

Copy

interface TenantPackagePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'not-found' 'white-labeling-not-allowed' | 'name-too-long' | 'for-who-text-too-long' | 'feature-tag-lines-too-long' | 'no-package' | 'invalid-package' | 'unauthorized' | 'child-tenant-too-large' | 'flex-param-missing' | 'unexpected-flex-param' | 'package-limit-reached' | 'flex-param-missing' | 'unexpected-flex-param'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenantPackage?: TenantPackage; // Vraćamo kompletan kreirani TenantPackage pri uspehu.
}

PATCH /api/v1/tenant-packages/:id

Resource: TenantPackage as PATCH /api/v1/tenant-packages/:id Credit Cost: 1

Ovaj API endpoint omogućava ažuriranje TenantPackage po id.

Ažuriranje TenantPackage ima sledeća ograničenja:

Ako postavljate hasFlexPricing na true, onda su svi flex* parametri obavezni u tom istom zahtevu.
name ne sme biti duže od 50 characters.
Svaki element forWhoText ne sme biti duži od 200 characters.
Svaki element featureTaglines ne sme biti duži od 100 characters.
TenantPackage mora biti "manji" od roditeljskog tenanta. Na primer, svi max* parametri moraju imati niže vrednosti od roditeljskog tenanta.
Ne smete menjati tenantId povezan sa TenantPackage.

Primer cURL zahteva za TenantPackage PATCH

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/tenant-packages/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"name": "Some New Name",
}'

Struktura zahteva za TenantPackage PATCH

Copy

interface TenantPackagePatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za TenantPackage PATCH

Copy

interface TenantPackagePatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'not-found' | 'white-labeling-not-allowed' | 'name-too-long' | 'for-who-text-too-long' | 'feature-tag-lines-too-long' | 'no-package' | 'invalid-package' | 'unauthorized' | 'child-tenant-too-large' | 'flex-param-missing' | 'unexpected-flex-param' | 'package-limit-reached' | 'flex-param-missing' | 'unexpected-flex-param'; 
    /** Uključeno u slučaju greške. **/
    reason?: string
}

DELETE /api/v1/tenant-packages/:id

Resource: TenantPackage as DELETE /api/v1/tenant-packages/:id Credit Cost: 5

Ova ruta omogućava uklanjanje TenantPackage po id-u.

Ne možete ukloniti TenantPackage koji je u upotrebi (tenant-ov packageId pokazuje na paket). Prvo ažurirajte Tenant.

Primer cURL zahteva za uklanjanje TenantPackage-a

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/tenant-packages/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje TenantPackage-a

Copy

interface TenantPackageDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje TenantPackage-a

Copy

interface TenantPackageDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized' | 'package-in-use'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

Struktura korisnika zakupca

The TenantUser definiše User koji je pod upravljanjem konkretnog tenanta. Njihov nalog se u potpunosti nalazi pod kontrolom tenanta sa kojim su povezani, i njihov nalog može biti ažuriran ili obrisan putem UI ili API-ja.

Tenant korisnici mogu biti administratori sa svim dozvolama i pristupom Tenant-u, ili mogu biti ograničeni na određene dozvole za moderiranje komentara, pristup API ključevima, itd.

Struktura za TenantUser objekat je sledeća:

Struktura TenantUser objekta

Copy

/** Ovo je za notifikacije. **/
export enum UserDigestEmailFrequency {
    Disabled = -1,
    Daily = 0,
    Weekly = 1,
    Monthly = 2
}
export interface TenantUser {
    id: string
    tenantId: string
    username: string
    /** Na primer, link ka blogu komentatora. **/
    websiteUrl?: string
    email: string
    signUpDate: number
    createdFromUrlId: string
    createdFromTenantId: string
    verified: boolean
    loginCount: number
    optedInNotifications: boolean
    optedInTenantNotifications: boolean
    hideAccountCode: boolean
    avatarSrc?: string
    /** Da li korisnik prima zahteve za pomoć od komentatora? **/
    isHelpRequestAdmin: boolean
    isAccountOwner: boolean
    isAdminAdmin: boolean
    isBillingAdmin: boolean
    isAnalyticsAdmin: boolean
    isCustomizationAdmin: boolean
    isManageDataAdmin: boolean
    isCommentModeratorAdmin: boolean
    isAPIAdmin: boolean
    moderatorIds: string[]
    locale: FastCommentsLocale
    digestEmailFrequency: UserDigestEmailFrequency
    lastLoginDate: string
    displayLabel?: string
    karma?: number
}

GET /api/v1/tenant-users/:id

Resource: TenantUser as GET /api/v1/tenant-users/:id Credit Cost: 1

Ovaj endpoint vraća jednog TenantUser po id.

Primer cURL zahteva za TenantUser po id-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenant-users/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za TenantUser

Copy

interface TenantUserByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za TenantUser

Copy

interface TenantUserByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenantUser?: TenantUser
}

GET /api/v1/tenant-users

Resource: TenantUser as GET /api/v1/tenant-users Credit Cost: 1

Ovaj API koristi paginaciju, obezbeđenu query parametrom skip. TenantUsers se vraćaju u stranicama po 100, sortirani po signUpDate, username i id.

Cena se zasniva na broju vraćenih tenant korisnika, iznosi 1 credit per 10 vraćenih tenant korisnika.

Primer cURL zahteva za TenantUser

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/tenant-users?tenantId=demo&page=0&API_KEY=DEMO_API_SECRET'

Struktura zahteva za TenantUser

Copy

interface TenantUsersRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Broj tenant korisnika koje treba preskočiti za paginaciju. **/
    skip?: number
}

Struktura odgovora TenantUser

Copy

interface TenantUsersResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    tenantUsers?: TenantUser[]
}

POST /api/v1/tenant-users

Resource: TenantUser as POST /api/v1/tenant-users Credit Cost: 1

Ova ruta omogućava dodavanje jednog TenantUser.

Kreiranje TenantUser ima sledeća ograničenja:

username je obavezan.
email je obavezan.
signUpDate ne sme biti u budućnosti.
locale mora biti na listi Podržane lokalizacije.
username mora biti jedinstven na celoj FastComments.com. Ako je ovo problem, predlažemo korišćenje SSO umesto toga.
email mora biti jedinstven na celoj FastComments.com. Ako je ovo problem, predlažemo korišćenje SSO umesto toga.
Ne smete kreirati više tenant korisnika nego što je definisano pod maxTenantUsers u vašem paketu.

Možemo kreirati TenantUser na sledeći način

TenantUser - primer cURL zahteva za kreiranje

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/tenants?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "username": "Some Name",
	"email": "someone@someone.com"
}'

Struktura zahteva za kreiranje TenantUser

Copy

interface TenantUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za kreiranje TenantUser

Copy

interface TenantUserPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'username-required' | 'email-required' | 'sign-up-date-in-future' | 'unsupported-locale' | 'unauthorized' | 'username-taken' | 'email-taken' | 'tenant-user-limit-reached'
    /** Uključeno u slučaju greške. **/
    reason?: string
    tenantUser?: TenantUser; // Vraćamo kompletno kreiranog tenant korisnika pri uspehu.
}

Resource: TenantUser as POST /api/v1/tenant-users/:id/send-login-link Credit Cost: 10

Ova ruta omogućava slanje linka za prijavu jednom TenantUser-u.

Koristan kada se korisnici masovno kreiraju i ne želite da ih uputite kako da se prijave na FastComments.com. Ovo će im jednostavno poslati "magični link" za prijavu koji ističe nakon 30 days.

Postoje sledeća ograničenja za slanje linka za prijavu TenantUser-u:

TenantUser mora već postojati.
Morate imati pristup za upravljanje Tenant-om kojem TenantUser pripada.

Link za prijavu TenantUser-u možemo poslati na sledeći način:

Primer cURL zahteva za link za prijavu TenantUser-a

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/tenant-users/xyz/send-login-link?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json'

Ovo će poslati email poput Bob at TenantName is inviting you to be a moderator...

Struktura zahteva za link za prijavu TenantUser-a

Copy

interface TenantUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za link za prijavu TenantUser-a

Copy

interface TenantUserPostResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'not-found'
    /** Uključeno pri neuspehu. **/
    reason?: string
}

PATCH /api/v1/tenant-users/:id

Resource: TenantUser as PATCH /api/v1/tenant-users/:id Credit Cost: 1

Ovaj endpoint omogućava ažuriranje pojedinačnog TenantUser.

Ažuriranje TenantUser ima sledeća ograničenja:

signUpDate ne sme biti u budućnosti.
locale mora biti na listi Podržane lokalizacije.
username mora biti jedinstven na čitavom FastComments.com. Ako je to problem, predlažemo da umesto toga koristite SSO.
email mora biti jedinstven na čitavom FastComments.com. Ako je to problem, predlažemo da umesto toga koristite SSO.
Ne možete ažurirati tenantId korisnika.

Možemo ažurirati TenantUser na sledeći način

Primer cURL zahteva za ažuriranje TenantUser

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/tenant-users/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "username": "Some Name",
	"email": "someone@someone.com"
}'

Struktura zahteva za ažuriranje TenantUser

Copy

interface TenantUserPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Kada se email ili username promene, možete ovo postaviti na true da biste takođe ažurirali komentare korisnika. Ovo će udvostručiti trošak u kreditima. **/
    updateComments: 'true' | 'false'
}

Struktura odgovora za ažuriranje TenantUser

Copy

interface TenantUserPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'sign-up-date-in-future' | 'unsupported-locale' | 'unauthorized' | 'username-taken' | 'email-taken' | 'unauthorized' | 'no-package' | 'invalid-package' | 'tenant-user-limit-reached' | 'user-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

DELETE /api/v1/tenant-users/:id

Resource: TenantUser as DELETE /api/v1/tenant-users/:id Credit Cost: 5

Ova ruta omogućava uklanjanje TenantUser objekta po id-u.

Brisanje korisničkih komentara je moguće putem deleteComments query parametra. Napomena: ako je ovo true:

Svi komentari korisnika biće obrisani uživo.
Svi child (sada orphan) komentari biće obrisani ili anonimizirani u zavisnosti od konfiguracije stranice povezane sa svakim komentarom. Na primer, ako je režim brisanja nita "anonymize", odgovori će ostati, a korisnički komentari će biti anonimizirani. Ovo važi samo kada je commentDeleteMode Remove (podrazumevana vrednost).
creditsCost postaje 2.

Anonimizirani komentari

Možete zadržati komentare korisnika, ali ih jednostavno anonimizirati postavljanjem commentDeleteMode=1.

Ako su komentari korisnika anonimizirani, sledeće vrednosti se postavljaju na null:

- commenterName
- commenterEmail
- avatarSrc
- userId
- anonUserId
- mentions
- badges

isDeleted i isDeletedUser se postavljaju na true.

Prilikom renderovanja, widget za komentare će koristiti DELETED_USER_PLACEHOLDER (podrazumevano: "[deleted]") za ime korisnika i DELETED_CONTENT_PLACEHOLDER za komentar. Ovo se može prilagoditi putem Widget Customization UI-ja.

Primeri

Primer cURL zahteva za uklanjanje TenantUser-a

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/tenant-users/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje TenantUser-a

Copy

enum TenantUserCommentDeleteMode {
    Remove = 0, // podrazumevano
    Anonymize = 1
}
interface TenantUserDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** Možete postaviti ovo na true da biste takođe obrisali komentare korisnika. Ovo duplira cenu u kreditima. **/
    deleteComments?: 'true' | 'false'
    /** Možete postaviti ovo po želji da biste odredili kako se postupati sa komentarima korisnika. **/
    commentDeleteMode?: TenantUserCommentDeleteMode
}

Struktura odgovora za uklanjanje TenantUser-a

Copy

interface TenantUserDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura korisnika

User je objekat koji predstavlja najčešći zajednički imenilac svih korisnika.

Imajte na umu da u FastComments imamo više različitih slučajeva upotrebe za korisnike:

Secure SSO
Simple SSO
Tenant korisnici (na primer: Administratori)
Komentatori

Ovaj API je za Komentatore i korisnike kreirane putem Simple SSO. U suštini, svaki korisnik kreiran preko vašeg sajta može se pristupiti putem ovog API-ja. Tenant korisnici takođe mogu biti dobijeni na ovaj način, ali ćete dobiti više informacija koristeći /tenant-users/ API.

Za Secure SSO koristite /sso-users/ API.

Ne možete izmeniti ove tipove korisnika. Oni su kreirali svoj nalog preko vašeg sajta, tako da pružamo osnovni pristup samo za čitanje, ali ne možete vršiti izmene. Ako želite imati ovaj tip toka - morate podesiti Secure SSO.

Struktura za the User objekat je sledeća:

Struktura objekta User

Copy

export interface User {
    /** Ovo je takođe id koji se koristi kao userId na objektima komentara. **/
    id: string
    username: string
    /** Link ka blogu komentatora, na primer. **/
    websiteUrl?: string
    email: string
    signUpDate: number
    createdFromUrlId: string
    createdFromTenantId: string
    avatarSrc?: string
    locale: FastCommentsLocale
    displayLabel?: string
    karma?: number
}

GET /api/v1/users/:id

Resource: User as GET /api/v1/users/:id Credit Cost: 1

Ova ruta vraća jednog User-a po id-u.

Primer cURL zahteva za User po ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/users/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za User

Copy

interface UserByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za User

Copy

interface UserByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    user?: User
}

Struktura glasanja

Objekat Vote predstavlja glas koji je ostavio korisnik.

Veza između komentara i glasa definiše se preko commentId.

Struktura objekta Vote je sledeća:

Struktura objekta Vote

Copy

interface Vote {
    id: string
    urlId: string
    commentId: string
    userId: string
    direction: 1 | -1
    createdAt: string
}

GET /api/v1/votes

Resource: Vote as GET /api/v1/votes Credit Cost: 10

Glasovi se moraju preuzeti pomoću urlId.

Tipovi glasova

Postoje tri tipa glasova:

Authenticated Votes, koji se primenjuju na odgovarajući komentar. Možete ih kreirati putem ovog API-ja.
Authenticated Votes, koji su pending verifikacije, i stoga još nisu primenjeni na komentar. Ovi se kreiraju kada korisnik koristi FastComments.com login to vote mehanizam.
Anonymous Votes, koji se primenjuju na odgovarajući komentar. Oni se kreiraju zajedno sa anonimnim komentisanjem.

Oni se vraćaju u odvojenim listama u API-ju kako bi se smanjila zabuna.

cURL primer za glasove

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/votes?tenantId=demo&API_KEY=DEMO_API_SECRET&urlId=test'

Struktura zahteva za glasove

Copy

interface VotesRequestQueryParams {
    tenantId: string
    API_KEY: string
    urlId: string
}

Struktura odgovora za glasove

Copy

interface VotesResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Autorizovani, verifikovani glasovi, primenjeni na odgovarajuće komentare. **/
    appliedAuthorizedVotes: Vote[]
    /** Anonimni glasovi, primenjeni na odgovarajuće komentare. **/
    appliedAnonymousVotes: Vote[]
    /** Glasovi koji čekaju verifikaciju, još nisu primenjeni na odgovarajuće komentare. **/
    pendingVotes: Vote[]
}

Napomene o anonimnim glasovima

Imajte na umu da će anonimni glasovi kreirani putem ovog API-ja pojavljivati u listi appliedAuthorizedVotes. Smatraju se autorizovanim jer su kreirani putem API-ja uz API key.

Struktura appliedAnonymousVotes je za glasove kreirane bez email-a, API key-a, itd.

GET /api/v1/votes/for-user

Resource: Vote as GET /api/v1/votes/for-user Credit Cost: 1

Omogućava dohvat glasova koje je korisnik ostavio na datom urlId. Prima userId koji može biti bilo koji FastComments.com korisnik ili SSO User.

Ovo je korisno ako želite prikazati da li je korisnik glasao za komentar. Pri dohvatanju komentara, jednostavno pozovite ovaj API istovremeno za korisnika sa istim urlId.

Ako koristite anonimno glasanje, umesto toga prosledite anonUserId.

Primer cURL zahteva za glasove korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/votes/for-user?tenantId=demo&API_KEY=DEMO_API_SECRET&urlId=test&userId=some-user-id'

Primer cURL zahteva za glasove anonimnog korisnika

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/votes/for-user?tenantId=demo&API_KEY=DEMO_API_SECRET&urlId=test&anonUserId=some-user-id'

Imajte na umu da će anonimni glasovi biti prikazani u listi appliedAuthorizedVotes. Oni se smatraju autorizovanim jer su kreirani preko API-ja uz API ključ.

Struktura zahteva za glasove korisnika

Copy

interface VotesForUserRequestQueryParams {
    tenantId: string
    API_KEY: string
    urlId: string
    userId?: string
    anonUserId?: string
}

Struktura odgovora za glasove korisnika

Copy

interface VotesForUserResponse {
    status: 'success' | 'failed'
    /** Uključeno pri grešci. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'invalid-user-id'
    /** Uključeno pri grešci. **/
    reason?: string
    /** Autorizovani, verifikovani glasovi, primenjeni na odgovarajuće komentare. **/
    appliedAuthorizedVotes: Vote[]
    /** Glasovi koji čekaju verifikaciju, još nisu primenjeni na odgovarajuće komentare. **/
    pendingVotes: Vote[]
}

POST /api/v1/votes

Resource: Vote as POST /api/v1/votes Credit Cost: 1

Ovaj endpoint omogućava dodavanje jednog autorizovanog Vote. Glasovi mogu biti up (+1) ili down (-1).

Primer cURL zahteva za kreiranje glasa

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/votes?tenantId=demo&API_KEY=DEMO_API_SECRET&userId=user-id&commentId=comment-id&direction=up' \
  --header 'Content-Type: application/json'

Primer anonimnog cURL zahteva za kreiranje glasa

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/votes?tenantId=demo&API_KEY=DEMO_API_SECRET&anonUserId=some-randomly-generated-identifier&commentId=comment-id&direction=up' \
  --header 'Content-Type: application/json'

Struktura zahteva za kreiranje glasa

Copy

interface VotePostQueryParams {
    tenantId: string
    API_KEY: string
    userId?: string
    anonUserId?: string
    commentId: string
    direction: 'up' | 'down'
}

Struktura odgovora za kreiranje glasa

Copy

interface VotePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-user-id' | 'invalid-user-id' | 'invalid-comment-id' | 'invalid-direction' | 'duplicate' | 'voting-disabled'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    voteId?: string
}

Kreiranje anonimnih glasova

Anonimni glasovi se mogu kreirati postavljanjem anonUserId u parametrima upita umesto userId.

Ovaj id ne mora odgovarati nijednom objektu korisnika (otuda anonimno). To je jednostavno identifikator za sesiju, tako da možete ponovo dohvatiti glasove u istoj sesiji, da proverite da li je komentar dobio glas.

Ako nemate takvu stvar kao „anonimne sesije“ kao što FastComments ima - možete jednostavno postaviti ovo na nasumični ID, kao što je UUID (iako cenimo manje identifikatore radi uštede prostora).

Ostale napomene

Ovaj API poštuje podešavanja na nivou tenanta. Na primer, ako onemogućite glasanje za određenu stranicu, i pokušate da kreirate glas preko API-ja, to će se završiti greškom sa kodom voting-disabled.
Ovaj API je podrazumevano aktivan.
Ovaj API će ažurirati votes odgovarajućeg Comment.

DELETE /api/v1/votes/:id

Resource: Vote as DELETE /api/v1/votes/:id Credit Cost: 1

Ova ruta omogućava brisanje pojedinačnog Vote.

Primer cURL zahteva za brisanje Vote

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/votes/some-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json'

Struktura zahteva za brisanje Vote

Copy

interface VoteDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za brisanje Vote

Copy

interface VoteDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

Napomene:

Ovaj API poštuje postavke na nivou tenanta. Na primer, ako onemogućite glasanje za određenu stranicu, i pokušate da kreirate glas preko API-ja, to će završiti greškom sa kodom voting-disabled.
Ovaj API je podrazumevano aktivan.
Ovaj API će ažurirati votes odgovarajućeg Comment.

Struktura konfiguracije domena

Objekat DomainConfig predstavlja konfiguraciju za domen za tenant.

Struktura objekta DomainConfig je sledeća:

Struktura objekta DomainConfig

Copy

interface DomainConfig {
    /** A domain, not a URL, like "fastcomments.com" or "www.example.com". Subdomain may be included if limiting to a subdomain is desired. Max 1000 characters. **/
    domain: string
    /** The From-Name used when sending emails. **/
    emailFromName?: string
    /** The From-Email used when sending emails. Ensure SPF is setup to allow mail.fastcomments.com to send emails as the domain used in this attribute. **/
    emailFromEmail?: string
    /** READONLY. When the object was created. **/
    createdAt: string
    /** The logo related to this domain. Used in emails. Use HTTPS. **/
    logoSrc?: string
    /** A smaller logo related to this domain. Use HTTPS. **/
    logoSrc100px?: string
    /** SSO ONLY. The URL used in the footer of every email sent. Supports a "[userId]" variable. **/
    footerUnsubscribeURL?: string
    /** SSO ONLY. The headers used in of every email sent. Useful for example for setting unsubscribe related headers to improve delivery. The List-Unsubscribe entry in this Record, if it exists, supports a "[userId]" variable. **/
    emailHeaders?: Record<string, string>
    /** Disable all unsubscribe links. Not recommended, may hurt delivery rates. **/
    disableUnsubscribeLinks?: boolean
    /** DKIM Configuration. **/
    dkim?: DomainConfigDKIM
}

Struktura DKIM konfiguracije

Copy

interface DomainConfigDKIM {
    /** The domain name in your DKIM record. **/
    domainName: string
    /** The DKIM key selector to use. **/
    keySelector: string
    /** The public key, in PEM format. Returned in GET responses. **/
    publicKey: string
    /** @deprecated No longer returned in API responses. Accepted on write for backwards compatibility. **/
    privateKey?: string
}

Za autentifikaciju

Konfiguracija domena se koristi da odredi koje sajtove mogu da hostuju FastComments widget za vaš nalog. Ovo je osnovni oblik autentifikacije, što znači da dodavanje ili uklanjanje bilo kojih konfiguracija domena može uticati na dostupnost vaše FastComments instalacije u produkciji.

Ne uklanjajte niti ne ažurirajte domain svojstvo Domain Config za domen koji se trenutno koristi osim ako nije namera da se taj domen onemogući.

Ovo ima isto ponašanje kao uklanjanje domena sa /auth/my-account/configure-domains.

Takođe imajte na umu da uklanjanje domena iz My Domains UI ukloniće bilo koju odgovarajuću konfiguraciju za taj domen koja je možda dodata putem ovog UI.

Za prilagođavanje e-pošte

Link za odjavu u podnožju e-pošte, i funkcija jednim klikom za odjavu koju nude mnogi klijenti e-pošte, mogu se konfigurisati putem ovog API-ja definisanjem footerUnsubscribeURL i emailHeaders, redom.

Za DKIM

Nakon što definišete DKIM DNS zapise, jednostavno ažurirajte DomainConfig sa vašom DKIM konfiguracijom koristeći definisanu strukturu.

GET /api/v1/domain-configs

Resource: Comment as GET /api/v1/domain-configs Credit Cost: 1

Ovaj API omogućava dohvat svih DomainConfig objekata za tenanta.

Primer GET cURL zahteva za DomainConfig

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/domain-configs?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura GET zahteva za DomainConfig

Copy

interface GetDomainConfigsRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura GET odgovora za DomainConfig

Copy

interface GetDomainConfigsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Konfiguracije! **/
    configurations: DomainConfig[] | null
}

GET /api/v1/domain-configs/:domain

Resource: DomainConfig as GET /api/v1/domain-configs/:domain Credit Cost: 1

Pojedinačni DomainConfigs se mogu preuzeti pomoću odgovarajućeg domain.

Domain Config po domenu — primer cURL zahteva

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/domain-configs/example.com?tenantId=demo&API_KEY=DEMO_API_SECRET'

Domain Config po domenu — struktura zahteva

Copy

interface DomainConfigsByDomainRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Domain Config po domenu — struktura odgovora

Copy

interface DomainConfigResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'internal' | 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'missing-domain' | 'update-would-create-duplicate' | 'domain-does-not-exist'
    /** Uključeno u slučaju greške. **/
    reason?: string
    configuration?: DomainConfig | null
}

POST /api/v1/domain-configs

Resource: DomainConfig as POST /api/v1/domain-configs Credit Cost: 1

Ovaj API endpoint omogućava kreiranje konfiguracija domena.

Dodavanje konfiguracije za domen ovlašćuje taj domen za FastComments nalog.

Uobičajene upotrebe ovog API-ja su početno podešavanje, ako je potrebno dodati mnogo domena, ili prilagođena konfiguracija za slanje e-pošte.

DomainConfig POST cURL Primer

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/domain-configs?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"domain": "example.com",
	"emailFromName": "some from name",
	"emailFromEmail": "some@test.com",
	"logoSrc": "https://example.com/my-logo-big.png",
	"logoSrc100px": "https://example.com/my-logo-100px.png",
	"footerUnsubscribeURL": "http://example.com/unsubscribe-ui",
	"emailHeaders": {
		"List-Unsubscribe-Post": "List-Unsubscribe=One-Click",
		"List-Unsubscribe": "<https://example.com/opt-out/[userId]>"
	}
}'

Struktura POST zahteva za DomainConfig

Copy

interface DomainConfigPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za DomainConfig

Copy

interface DomainConfigPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input' | 'missing-domain' | 'configuration-exists-for-domain' | 'domain-too-long' | 'domain-invalid';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Kreirana konfiguracija. **/
    configuration?: DomainConfig
}

PATCH /api/v1/domain-configs/:domain

Resource: DomainConfig as PATCH /api/v1/domain-configs/:domain Credit Cost: 1

Ovaj API endpoint omogućava ažuriranje konfiguracije domena tako što se navede samo domen i atribut koji treba ažurirati.

Primer cURL zahteva za DomainConfig PATCH

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/domain-configs/example.com?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"emailFromName": "Some New From Name",
}'

Struktura zahteva za DomainConfig PATCH

Copy

interface DomainConfigPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za DomainConfig PATCH

Copy

interface DomainConfigPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input' | 'missing-domain' | 'domain-does-not-exist' | 'update-would-create-duplicate' | 'domain-too-long' | 'domain-invalid';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Ažurirana konfiguracija. **/
    configuration?: DomainConfig
}

PUT /api/v1/domain-configs/:domain

Resource: DomainConfig as PUT /api/v1/domain-configs/:domain Credit Cost: 1

Ovaj API endpoint omogućava zamenu konfiguracije domena.

DomainConfig PUT cURL primer

Copy

curl --request PUT \
  --url 'https://fastcomments.com/api/v1/domain-configs/example.com?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"domain": "new-domain-example.com",
	"emailFromName": "some from name",
	"emailFromEmail": "some@test.com",
	"logoSrc": "https://example.com/my-logo-big.png",
	"logoSrc100px": "https://example.com/my-logo-100px.png",
	"footerUnsubscribeURL": "http://example.com/unsubscribe-ui",
	"emailHeaders": {
		"List-Unsubscribe-Post": "List-Unsubscribe=One-Click",
		"List-Unsubscribe": "<https://example.com/opt-out/[userId]>"
	}
}'

DomainConfig PUT struktura zahteva

Copy

interface DomainConfigPutQueryParams {
    tenantId: string
    API_KEY: string
}

DomainConfig PUT struktura odgovora

Copy

interface DomainConfigPutResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input' | 'missing-domain' | 'domain-does-not-exist' | 'update-would-create-duplicate' | 'domain-too-long' | 'domain-invalid';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Ažurirana konfiguracija. **/
    configuration?: DomainConfig
}

DELETE /api/v1/domain-configs/:domain

Resource: DomainConfig as DELETE /api/v1/domain-configs/:domain Credit Cost: 1

Ovaj endpoint omogućava uklanjanje pojedinačnog DomainConfig po id-u.

Napomena: Brisanjem DomainConfig domen će biti deautorizovan za korišćenje FastComments.
Napomena: Ponovnim dodavanjem domena preko UI će se objekat ponovo kreirati (sa samo domain popunjenim).

Primer cURL zahteva za uklanjanje DomainConfig

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/domain-configs/example.com?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje DomainConfig

Copy

interface DomainConfigRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje DomainConfig

Copy

interface DomainConfigDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-domain' | 'domain-config-does-not-exist'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura konfiguracije pitanja

FastComments pruža način za konstrukciju pitanja i agregiranje njihovih rezultata. Primer pitanja (u daljem tekstu nazvan QuestionConfig) može biti ocena zvezdicama, klizač, ili NPS pitanje (određeno putem type).

Podaci pitanja mogu se agregirati pojedinačno, zajedno, tokom vremena, ukupno, po stranici, i tako dalje.

Framework ima sve mogućnosti potrebne za izgradnju klijentskih widgeta (sa vašim serverom ispred ovog API-ja), administratorskih kontrolnih tabli, i alata za izveštavanje.

Prvo moramo definisati QuestionConfig. Struktura je sledeća:

Struktura QuestionConfig

Copy

type QuestionConfigType = 'nps' | 'slider' | 'star' | 'thumbs';
interface QuestionConfig {
    id: string
    tenantId: string
    name: string
    question: string
    helpText?: string
    createdAt: string
    createdBy: string
    /** SAMO ZA ČITANJE - uvećava se za svaki novi odgovor. **/
    usedCount: number
    /** String datuma koji označava kada je konfiguracija poslednji put korišćena (ostavljen rezultat). **/
    lastUsed?: string
    type: QuestionConfigType
    numStars?: number
    min?: number
    max?: number
    defaultValue?: number
    labelNegative?: string
    labelPositive?: string
    subQuestionIds?: string[]
    alwaysShowSubQuestions?: boolean
    reportingOrder: number
}

GET /api/v1/question-configs

Resource: QuestionConfig as GET /api/v1/question-configs Credit Cost: 1

Ova ruta vraća do 100 QuestionConfig objekata odjednom, paginirano. Cena je 1 za svakih 100 objekata. Oni su poređani po tekstu pitanja uzlazno (question field).

Primer QuestionConfig

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/question-configs?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za QuestionConfig

Copy

interface QuestionConfigRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
    /** Za paginaciju. Počinje od 0. **/
    skip?: number
}

Struktura odgovora za QuestionConfig

Copy

interface QuestionConfigByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    questionConfigs: QuestionConfig[]
}

GET /api/v1/question-configs/:id

Resource: QuestionConfig as GET /api/v1/question-configs/:id Credit Cost: 1

Ova ruta vraća jednu QuestionConfig po njenom id-u.

Primer cURL zahteva za QuestionConfig po ID

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/question-configs/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za QuestionConfig

Copy

interface QuestionConfigRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za QuestionConfig

Copy

interface QuestionConfigByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    questionConfig?: QuestionConfig
}

POST /api/v1/question-configs

Resource: QuestionConfig as POST /api/v1/question-configs Credit Cost: 1

Ovaj API endpoint omogućava kreiranje QuestionConfig.

Primer cURL zahteva za QuestionConfig POST

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/question-configs?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Some name that shows on reports.",
    "question": "how much do you like this api?",
    "type": 'slider',
    "reportingOrder": 0,
    "min": 0,
    "max": 10
}'

Struktura zahteva za QuestionConfig POST

Copy

interface QuestionConfigPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za QuestionConfig POST

Copy

interface QuestionConfigPostResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input';  
    /** Uključeno pri neuspehu. **/
    reason?: string
    /** Kreirani objekat. **/
    questionConfig?: QuestionConfig
}

PATCH /api/v1/question-configs/:id

Resource: QuestionConfig as PATCH /api/v1/question-configs/:id Credit Cost: 1

Ovaj endpoint omogućava ažuriranje jedne QuestionConfig.

Sledeća struktura predstavlja sve vrednosti koje se mogu promeniti:

Struktura QuestionConfig

Copy

interface QuestionConfigPatchBody {
    name?: string
    question?: string
    helpText?: string
    /** Pažnja! Menjanje type može poremetiti izveštavanje ako su min/max različiti. **/
    type?: QuestionConfigType
    numStars?: number
    min?: number
    max?: number
    defaultValue?: number
    labelNegative?: string
    labelPositive?: string
    subQuestionIds?: string[]
    alwaysShowSubQuestions?: boolean
    reportingOrder?: number
}

Primer cURL zahteva za ažuriranje QuestionConfig

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/question-configs/my-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"question": "some new question text"
}'

Struktura zahteva za ažuriranje QuestionConfig

Copy

interface QuestionConfigPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ažuriranje QuestionConfig

Copy

interface QuestionConfigPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'unauthorized' | 'missing-api-key' | 'missing-id' | 'not-found' | 'empty-request' | 'invalid-input'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

DELETE /api/v1/question-configs/:id

Resource: QuestionConfig as DELETE /api/v1/question-configs/:id Credit Cost: 100

Ovaj endpoint omogućava brisanje QuestionConfig po id-u.

Ovo će obrisati sve odgovarajuće rezultate pitanja (ali ne i komentare). Ovo je deo visoke cene u kreditima.

Primer cURL zahteva za brisanje QuestionConfig-a

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/question-configs/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za brisanje QuestionConfig-a

Copy

interface QuestionConfigDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za brisanje QuestionConfig-a

Copy

interface QuestionConfigResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

Struktura rezultata pitanja

Da biste sačuvali rezultate za pitanja, kreirate QuestionResult. Zatim možete agregirati rezultate pitanja i povezati ih sa komentarima za potrebe izveštavanja.

Struktura QuestionResult

Copy

interface QuestionResultMeta {
    name: string
    values: string[]
}
interface QuestionResult {
    id: string
    tenantId: string
    urlId: string
    anonUserId?: string
    userId?: string
    createdAt?: string
    value: number
    commentId?: string
    questionId: string
    meta?: QuestionResultMeta[]
}

GET /api/v1/question-results

Resource: QuestionResults as GET /api/v1/question-results Credit Cost: 1

Ovaj ruta vraća do 1000 QuestionResults objekata odjednom, paginirano. Cena je 1 za svaka 100 objekata. Oni su sorted by createdAt, ascending. Možete filtrirati po raznim parametrima.

Primer QuestionResults

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/question-results?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za QuestionResults

Copy

interface QuestionResultsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Za paginaciju. Počinje od 0. **/
    skip?: number
    /** Za paginaciju. **/
    limit?: number
    /** Dobijte rezultate sa određene stranice. **/
    urlId?: string
    /** Dobijte rezultate od određenog korisnika. **/
    userId?: string
    startDate?: string | number
    questionId?: string | string[]
}

Struktura odgovora za QuestionResults

Copy

interface QuestionResultsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    questionResults: QuestionResults[]
}

GET /api/v1/question-results/:id

Resource: QuestionResult as GET /api/v1/question-results/:id Credit Cost: 1

Ova ruta vraća jedan QuestionResult po njegovom id-u.

QuestionResult cURL primer po ID-u

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/question-results/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za QuestionResult

Copy

interface QuestionResultRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za QuestionResult

Copy

interface QuestionResultByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    questionResult?: QuestionResult
}

POST /api/v1/question-results

Resource: QuestionResult as POST /api/v1/question-results Credit Cost: 1

Ovaj API endpoint omogućava kreiranje QuestionResult.

Primer cURL zahteva za QuestionResult POST

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/question-results?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "urlId": "some-page-id",
    "anonUserId": 'anon-0',
    "userId": 'user-0',
    "value": 10,
    "questionId": "some-question-id",
    "meta": [
        {
            name: "example",
            values: ["value-1", "value-2"]
        }
    ]
}'

Struktura POST zahteva za QuestionResult

Copy

interface QuestionResultPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za QuestionResult

Copy

interface QuestionResultPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input';  
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Kreirani objekat. **/
    questionResult?: QuestionResult
}

PATCH /api/v1/question-results/:id

Resource: QuestionResult as PATCH /api/v1/question-results/:id Credit Cost: 1

Ova ruta omogućava ažuriranje pojedinačnog QuestionResult.

Sledeća struktura prikazuje sve vrednosti koje se mogu promeniti:

Struktura QuestionResult

Copy

interface QuestionResultPatchBody {
    urlId?: string
    anonUserId?: string
    userId?: string
    value?: string
    commentId?: string
    questionId?: string
    meta?: QuestionResultMeta[]
}

Primer cURL zahteva za ažuriranje QuestionResult

Copy

curl --request PATCH \
  --url 'https://fastcomments.com/api/v1/question-results/my-id?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
	"value": 5
}'

Struktura zahteva za ažuriranje QuestionResult

Copy

interface QuestionResultPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ažuriranje QuestionResult

Copy

interface QuestionResultPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju greške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'unauthorized' | 'missing-api-key' | 'missing-id' | 'not-found' | 'empty-request' | 'invalid-input'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

DELETE /api/v1/question-results/:id

Resource: QuestionResult as DELETE /api/v1/question-results/:id Credit Cost: 1

Ovaj endpoint omogućava uklanjanje QuestionResult po id-u.

Primer cURL zahteva za uklanjanje QuestionResult

Copy

curl --request DELETE \
  --url 'https://fastcomments.com/api/v1/question-results/xyz?tenantId=demo&API_KEY=DEMO_API_SECRET'

Struktura zahteva za uklanjanje QuestionResult

Copy

interface QuestionResultDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje QuestionResult

Copy

interface QuestionResultResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
}

GET /api/v1/question-results-aggregate

Resource: QuestionResultsAggregate as GET /api/v1/question-results-aggregate Credit Cost: 2

Ovde se vrši agregacija rezultata.

Struktura odgovora agregacije je sledeća:

Struktura QuestionResultsAggregationResult

Copy

interface QuestionResultDataPoint {
    /** A map of value to count of occurrences of that value for the current data point (date bucket or page). **/
    v: Map<ValueAsString, number>
    total: number
}
interface QuestionResultsAggregationResult {
    /** Note - is null when timeBucket not specified. **/
    dataByDateBucket?: Map<DateString, QuestionResultDataPoint>
    dataByUrlId?: Map<URLIdString, QuestionResultDataPoint>
    countsByValue?: Map<ValueAsString, number>
    /** The total number of results aggregated. **/
    total: number
    /** The resulting weighted average. It is a float, usually two decimals or fewer. **/
    average: number
    /** A date string representing when this data was calculated, since it might come from cache. **/
    createdAt: string
}

Evo parametara upita dostupnih za agregaciju:

Struktura QuestionResultsAggregation zahteva

Copy

interface QuestionResultsAggregateRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** You can aggregate results for one or more questions. **/
    questionId: string | string[]
    startDate?: string | number
    timeBucket?: 'day' | 'month' | 'year'
    /** Aggregate for a specific page. **/
    urlId?: string
    /** Aggregate for a specific user. **/
    userId?: string
    /** Force recalculate now and update the cache. **/
    forceRecalculate?: boolean
}

Evo primera zahteva:

Primer agregacije rezultata pitanja

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/question-results-aggregation?tenantId=demo&API_KEY=DEMO_API_SECRET&questionId=some-question-id'

Primer odgovora:

Primer odgovora agregacije rezultata pitanja

Copy

    {
        "average": 8.33,
        "countsByValue": {
            "5": 1,
            "10": 2
        },
        "createdAt": "2023-08-30T00:00:00.000Z",
        "dataByUrlId": {
            "some-page": {
                "total": 3,
                "v": {
                    "5": 1,
                    "10": 2
                }
            }
        },
        "total": 3
    }

Struktura odgovora agregacije rezultata pitanja

Copy

interface QuestionResultsAggregationResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Included on failure. **/
    reason?: string
    data: QuestionResultsAggregationResult
}

Napomene o performansama

U slučaju promašaja keša, agregacija generalno traje pet sekundi po milionu rezultata.
U suprotnom, zahtevi su konstantnog vremena izvršavanja.

Napomene o keširanju i trošku

Kada je naveden forceRecalculate, trošak je uvek 10, umesto uobičajenog 2.
Ako keš istekne i podaci se ponovo izračunaju, trošak je i dalje konstantan 2 ako forceRecalculate nije naveden. Keš ističe na osnovu veličine agregiranog skupa podataka (može varirati između 30 sekundi i 5 minuta).
Ovo je kako bi se podstaklo korišćenje keša.

GET /api/v1/question-results-aggregate/combine/comments

Resource: QuestionResultsCombinedWithComments as GET /api/v1/question-results-aggregate/combine/comments Credit Cost: 2

Ovde se vrši kombinovanje rezultata sa komentarima. Korisno je, na primer, za kreiranje grafikona "nedavni pozitivni i negativni komentari" za proizvod.

Možete pretraživati po opsegu vrednosti (uključivo), po jednom ili više pitanja, i po početnom datumu (uključivo).

Struktura odgovora je sledeća:

Struktura odgovora QuestionResultsCombinedWithComments

Copy

interface SimpleComment {
    id: string
    commenterName: string
    userId?: string
    date: string
    commentHTML: string
}
interface SimpleQuestionResult {
    id: string
    value: number
}
interface CommentAndResult {
    comment: SimpleComment
    result: SimpleQuestionResult
}
interface QuestionResultsCombinedWithCommentsResponse {
    /** A date string representing when this data was calculated, since it might come from cache. **/
    createdAt: string
    results: CommentAndResult[]
}

Evo parametara upita dostupnih za agregaciju:

Struktura zahteva QuestionResultsCombineComments

Copy

interface QuestionResultsAggregateRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** You can aggregate results for one or more questions. **/
    questionId: string | string[]
    startDate?: string | number
    urlId?: string
    minValue: number
    maxValue: number
    limit?: number
    forceRecalculate?: boolean
}

Evo primera zahteva:

Primer QuestionResultsCombineComments

Copy

curl --request GET \
  --url 'https://fastcomments.com/api/v1/question-results-aggregation/combine/comments?tenantId=demo&API_KEY=DEMO_API_SECRET&questionId=some-question-id&minValue=5&maxValue=10'

Primer odgovora:

Primer odgovora QuestionResultsCombineComments

Copy

{
    "createdAt": "2023-08-30T00:00:00.000Z",
    "results": [
        {
            "comment": {
                "id": "some-id",
                "commentHTML": "test-2",
                "commenterName": "Test",
                "date": "2023-08-30T00:00:00.000Z",
                "userId": "some-user-id"
            },
            "result": {
                "id": "some-id",
                "value": 10
            }
        },
        {
            "comment": {
                "id": "some-id",
                "commentHTML": "test-0",
                "commenterName": "Some Name",
                "date": "2023-08-30T00:00:00.000Z",
                "userId": "some-user-id"
            },
            "result": {
                "id": "some-id",
                "value": 5
            }
        }
    ]
}

Struktura odgovora QuestionResultsCombineComments

Copy

interface QuestionResultsCombineCommentsResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Included on failure. **/
    reason?: string
    data: QuestionResultsCombinedWithCommentsResponse
}

Napomene o keširanju i ceni

Kada je naveden forceRecalculate, cena je uvek 10, umesto uobičajenih 2.
Ako keš istekne i podaci se ponovo izračunaju, cena je i dalje konstantnih 2 ako forceRecalculate nije naveden.
Ovo je kako bi se podstaklo korišćenje keša.

Struktura značke korisnika

UserBadge je objekat koji predstavlja značku dodeljenu korisniku u FastComments sistemu.

Značke mogu biti dodeljene korisnicima automatski na osnovu njihove aktivnosti (kao što su broj komentara, vreme odgovora, veteranski status) ili ručno od strane administratora sajta.

Struktura za UserBadge objekat je sledeća:

Struktura UserBadge

Copy

export interface UserBadge {
    /** Jedinstveni identifikator za ovu dodelu značke korisniku */
    id: string
    /** ID korisnika kojem je ova značka dodeljena */
    userId: string
    /** ID definicije značke iz kataloga znački tenanta */
    badgeId: string
    /** ID tenanta koji je kreirao/dodelio ovu značku */
    fromTenantId: string
    /** Kada je ova značka kreirana (milisekunde od epohe) */
    createdAt?: number
    /** Kada je korisnik primio ovu značku (milisekunde od epohe) */
    receivedAt?: number
    /** 
     * Tip značke: 
     * 0=CommentCount, 1=CommentUpVotes, 2=CommentReplies, 3=CommentsPinned, 
     * 4=Veteran, 5=NightOwl, 6=FastReplyTime, 7=ModeratorCommentsDeleted,
     * 8=ModeratorCommentsApproved, 9=ModeratorCommentsUnapproved, 10=ModeratorCommentsReviewed,
     * 11=ModeratorCommentsMarkedSpam, 12=ModeratorCommentsMarkedNotSpam, 13=RepliedToSpecificPage,
     * 14=Manual
     */
    type: number
    /** Za značke zasnovane na pragu, vrednost praga */
    threshold?: number
    /** Ime/oznaka značke */
    name?: string
    /** Detaljan opis značke */
    description?: string
    /** Tekst koji se prikazuje na znački */
    displayLabel?: string
    /** URL slike koja se prikazuje na znački */
    displaySrc?: string
    /** Boja pozadine za značku (hex kod) */
    backgroundColor?: string
    /** Boja ivice značke (hex kod) */
    borderColor?: string
    /** Boja teksta na znački (hex kod) */
    textColor?: string
    /** Dodatna CSS klasa za stilizovanje */
    cssClass?: string
    /** Za veteransku značku, vremenski prag u milisekundama */
    veteranUserThresholdMillis?: number
    /** Da li se ova značka prikazuje na komentarima korisnika */
    displayedOnComments: boolean
    /** Redosled prikaza značke */
    order?: number
    /** Ako je postavljeno, ova značka se prikazuje samo na stranici sa odgovarajućim urlId. Null za globalne značke. */
    urlId?: string | null
}

GET /api/v1/user-badges

Ovaj endpoint vam omogućava da dohvatite korisničke bedževe na osnovu različitih kriterijuma.

Primer zahteva:

Listanje korisničkih bedževa - GET primer

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badges?tenantId=demo&API_KEY=DEMO_API_SECRET"

Možete dodati različite query parametre za filtriranje rezultata:

userId - Dohvatanje bedževa za određenog korisnika
badgeId - Dohvatanje instanci određenog bedža
type - Filtriranje po tipu bedža (0=CommentCount, 1=CommentUpVotes, 2=CommentReplies, itd. Pogledajte strukturu UserBadge za kompletnu listu)
displayedOnComments - Filtriranje po tome da li se bedž prikazuje na komentarima (true/false)
limit - Maksimalan broj bedževa za vraćanje (podrazumevano 30, maksimum 200)
skip - Broj bedževa koje treba preskočiti (za paginaciju)

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadges": [
    {
      "id": "badge123",
      "userId": "user456",
      "badgeId": "badgeDef789",
      "fromTenantId": "tenant001",
      "createdAt": 1650532511000,
      "receivedAt": 1650532511000,
      "type": 14,
      "name": "Special Contributor",
      "description": "Awarded to special contributors to our community",
      "displayLabel": "Special",
      "backgroundColor": "#4a5568",
      "textColor": "#ffffff",
      "displayedOnComments": true,
      "order": 1
    },
    {
      "id": "badge124",
      "userId": "user456",
      "badgeId": "badgeDef790",
      "fromTenantId": "tenant001",
      "createdAt": 1650532598000,
      "receivedAt": 1650532598000,
      "type": 0,
      "threshold": 100,
      "name": "Centurion",
      "description": "Made 100 comments",
      "displayLabel": "100",
      "backgroundColor": "#2b6cb0",
      "textColor": "#ffffff",
      "displayedOnComments": true,
      "order": 2
    }
  ]
}

Mogući odgovori sa greškom:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nevažeći limit

Copy

{
  "status": "failed",
  "code": "invalid-limit",
  "reason": "The limit (query param: limit) is too large (> 200)."
}

GET /api/v1/user-badges/:id

Ovaj endpoint vam omogućava da preuzmete određeni korisnički bedž po njegovom jedinstvenom ID-u.

Primer zahteva:

Primer GET zahteva

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badges/badge123?tenantId=demo&API_KEY=DEMO_API_SECRET"

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadge": {
    "id": "badge123",
    "userId": "user456",
    "badgeId": "badgeDef789",
    "fromTenantId": "tenant001",
    "createdAt": 1650532511000,
    "receivedAt": 1650532511000,
    "type": 14,
    "name": "Special Contributor",
    "description": "Awarded to special contributors to our community",
    "displayLabel": "Special",
    "backgroundColor": "#4a5568",
    "textColor": "#ffffff",
    "displayedOnComments": true,
    "order": 1
  }
}

Mogući odgovori sa greškom:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nije pronađeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge badge123 was not found."
}

POST /api/v1/user-badges

Ovaj endpoint vam omogućava da kreirate novu dodelu korisničkog bedža.

Primer zahteva:

Primer POST zahteva

Copy

Run

curl -X POST "https://fastcomments.com/api/v1/user-badges?tenantId=demo&API_KEY=DEMO_API_SECRET" \
-H "Content-Type: application/json" \
-d '{
  "userId": "user456",
  "badgeId": "badgeDef789",
  "displayedOnComments": true
}'

Telo zahteva mora da sadrži sledeće parametre:

userId (required) - ID korisnika kome se dodeljuje bedž
badgeId (required) - ID bedža koji se dodeljuje
displayedOnComments (optional) - Da li bedž treba da se prikazuje na korisnikovim komentarima (podrazumevano je true)

Važne napomene:

Bedž mora postojati i biti omogućen u katalogu bedževa vašeg tenant-a
Bedževe možete dodeljivati samo korisnicima koji pripadaju vašem tenant-u ili su komentarisali na vašem sajtu

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadge": {
    "id": "badge123",
    "userId": "user456",
    "badgeId": "badgeDef789",
    "fromTenantId": "tenant001",
    "createdAt": 1650532511000,
    "receivedAt": 1650532511000,
    "type": 14,
    "name": "Special Contributor",
    "description": "Awarded to special contributors to our community",
    "displayLabel": "Special",
    "backgroundColor": "#4a5568",
    "textColor": "#ffffff",
    "displayedOnComments": true,
    "order": 1
  }
}

Mogući odgovori sa greškom:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nedostaje ID korisnika

Copy

{
  "status": "failed",
  "code": "missing-user-id",
  "reason": "User ID (body param: userId) is required."
}

Greška: Nedostaje ID bedža

Copy

{
  "status": "failed",
  "code": "missing-badge-id",
  "reason": "Badge ID (body param: badgeId) is required."
}

Greška: Bedž nije pronađen

Copy

{
  "status": "failed",
  "code": "badge-not-found",
  "reason": "The badge badgeDef789 was not found or is not enabled."
}

Greška: Neautorizovan korisnik

Copy

{
  "status": "failed",
  "code": "unauthorized-user",
  "reason": "You can only add badges to users who belong to your tenant or have commented on your site."
}

PUT /api/v1/user-badges/:id

Ovaj endpoint vam omogućava da ažurirate dodelu korisničke značke.

Trenutno jedino svojstvo koje može biti ažurirano je displayedOnComments, koje kontroliše da li se značka prikazuje na komentarima korisnika.

Primer zahteva:

Primer PUT zahteva

Copy

Run

curl -X PUT "https://fastcomments.com/api/v1/user-badges/badge123?tenantId=demo&API_KEY=DEMO_API_SECRET" \
-H "Content-Type: application/json" \
-d '{
  "displayedOnComments": false
}'

Primer odgovora:

Odgovor

Copy

{
  "status": "success"
}

Mogući odgovori sa greškom:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nedostaje ID

Copy

{
  "status": "failed",
  "code": "missing-id",
  "reason": "The User Badge ID (url param: id) is missing."
}

Greška: Nije pronađeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge badge123 was not found."
}

DELETE /api/v1/user-badges/:id

Ovaj endpoint vam omogućava da obrišete dodelu korisničkog bedža.

Primer zahteva:

Primer DELETE zahteva

Copy

Run

curl -X DELETE "https://fastcomments.com/api/v1/user-badges/badge123?tenantId=demo&API_KEY=DEMO_API_SECRET"

Primer odgovora:

Odgovor

Copy

{
  "status": "success"
}

Mogući odgovori sa greškom:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nedostaje ID

Copy

{
  "status": "failed",
  "code": "missing-id",
  "reason": "The User Badge ID (url param: id) is missing."
}

Greška: Nije pronađeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge badge123 was not found."
}

Struktura napretka značke korisnika

UserBadgeProgress je objekat koji predstavlja napredak korisnika u sticanju različitih znački u FastComments sistemu.

Ovo praćenje pomaže da se odredi kada korisnici treba da dobiju automatske značke na osnovu njihove aktivnosti i učešća u vašoj zajednici.

Struktura UserBadgeProgress objekta je sledeća:

Struktura UserBadgeProgress objekta

Copy

export interface UserBadgeProgress {
    /** Jedinstveni identifikator ovog zapisa o napretku */
    id: string
    /** ID tenanta kome ovaj zapis o napretku pripada */
    tenantId: string
    /** ID korisnika koga ovaj zapis o napretku prati */
    userId: string
    /** ID prvog komentara korisnika u sistemu */
    firstCommentId?: string
    /** Datum prvog komentara korisnika (milisekunde od epohe) */
    firstCommentDate?: number
    /** Automatski izračunat faktor poverenja na osnovu aktivnosti korisnika */
    autoTrustFactor?: number
    /** Ručno postavljen faktor poverenja od strane administratora */
    manualTrustFactor?: number
    /** Detaljan objekat napretka sa različitim metrikama, ključevi odgovaraju BadgeType enum-u */
    progress: {
        /** 0: CommentCount - Broj komentara koje je korisnik ostavio */
        '0'?: number
        /** 1: CommentUpVotes - Broj pozitivnih glasova koje je korisnik dobio */
        '1'?: number
        /** 2: CommentReplies - Broj odgovora koje je korisnik postavio */
        '2'?: number
        /** 3: CommentsPinned - Broj prikačenih komentara koje korisnik ima */
        '3'?: number
        /** 4: Veteran - Starost naloga korisnika */
        '4'?: number
        /** 5: NightOwl - Broj puta kada je korisnik objavio tokom noćnih sati */
        '5'?: number
        /** 6: FastReplyTime - Prosečno vreme odgovora u milisekundama */
        '6'?: number
        /** 7: ModeratorCommentsDeleted - Za moderatorške značke, broj obrisanih komentara */
        '7'?: number
        /** 8: ModeratorCommentsApproved - Za moderatorške značke, broj odobrenih komentara */
        '8'?: number
        /** 9: ModeratorCommentsUnapproved - Za moderatorške značke, broj neodobrenih komentara */
        '9'?: number
        /** 10: ModeratorCommentsReviewed - Za moderatorške značke, broj pregledanih komentara */
        '10'?: number
        /** 11: ModeratorCommentsMarkedSpam - Za moderatorške značke, broj komentara označenih kao spam */
        '11'?: number
        /** 12: ModeratorCommentsMarkedNotSpam - Za moderatorške značke, broj komentara označenih kao ne-spam */
        '12'?: number
        /** 13: RepliedToSpecificPage - Za svaku stranicu, broj odgovora */
        '13'?: Record<string, number>
    }
}

GET /api/v1/user-badge-progress

Ovaj endpoint vam omogućava da dohvatite zapise o napretku korisničkih bedževa na osnovu različitih kriterijuma.

Primer zahteva:

Lista napretka bedževa - primer GET

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badge-progress?tenantId=demo&API_KEY=DEMO_API_SECRET"

Možete dodati različite query parametre za filtriranje rezultata:

userId - Pribavite napredak za određenog korisnika
limit - Maksimalan broj zapisa za vraćanje (podrazumevano 30, maksimalno 200)
skip - Broj zapisa koje treba preskočiti (za paginaciju)

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadgeProgresses": [
    {
      "id": "progress123",
      "tenantId": "tenant001",
      "userId": "user456",
      "firstCommentId": "comment789",
      "firstCommentDate": 1650532511000,
      "autoTrustFactor": 0.75,
      "progress": {
        "0": 42,
        "1": 120,
        "2": 15,
        "3": 3,
        "5": 5,
        "6": 1800000,
        "8": 0,
        "7": 0
      }
    },
    {
      "id": "progress124",
      "tenantId": "tenant001",
      "userId": "user789",
      "firstCommentId": "comment790",
      "firstCommentDate": 1650532598000,
      "autoTrustFactor": 0.5,
      "progress": {
        "0": 12,
        "1": 15,
        "2": 4
      }
    }
  ]
}

Mogući odgovori u slučaju greške:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nevažeći limit

Copy

{
  "status": "failed",
  "code": "invalid-limit",
  "reason": "The limit (query param: limit) is too large (> 200)."
}

GET /api/v1/user-badge-progress/:id

Ovaj endpoint vam omogućava da dohvatite određeni zapis napretka korisničke značke po njegovom jedinstvenom ID-u.

Primer zahteva:

Primer GET zahteva

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badge-progress/progress123?tenantId=demo&API_KEY=DEMO_API_SECRET"

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadgeProgress": {
    "id": "progress123",
    "tenantId": "tenant001",
    "userId": "user456",
    "firstCommentId": "comment789",
    "firstCommentDate": 1650532511000,
    "autoTrustFactor": 0.75,
    "progress": {
      "0": 42,
      "1": 120,
      "2": 15,
      "3": 3,
      "5": 5,
      "6": 1800000,
      "8": 0,
      "7": 0
    }
  }
}

Mogući odgovori sa greškom:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nije pronađeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge progress progress123 was not found."
}

GET /api/v1/user-badge-progress/user/:userId

Ovaj endpoint vam omogućava da dohvatite zapis o napretku bedža korisnika po njihovom user ID-u.

Example Request:

Primer GET zahteva

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badge-progress/user/user456?tenantId=demo&API_KEY=DEMO_API_SECRET"

Example Response:

Odgovor

Copy

{
  "status": "success",
  "userBadgeProgress": {
    "id": "progress123",
    "tenantId": "tenant001",
    "userId": "user456",
    "firstCommentId": "comment789",
    "firstCommentDate": 1650532511000,
    "autoTrustFactor": 0.75,
    "progress": {
      "0": 42,
      "1": 120,
      "2": 15,
      "3": 3,
      "5": 5,
      "6": 1800000,
      "8": 0,
      "7": 0
    }
  }
}

Possible Error Responses:

Greška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Greška: Nedostaje User ID

Copy

{
  "status": "failed",
  "code": "missing-user-id",
  "reason": "The User ID (path param: userId) is missing."
}

Greška: Nije pronađeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "No badge progress found for user user456 in tenant tenant001."
}

Zaključno

Nadamo se da ste našli našu API dokumentaciju sveobuhvatnom i lakom za razumevanje. Ako primetite bilo kakve nedostatke, javite nam ispod.

Jezik 🇷🇸 Srpski (Latinica)

API Resursi

Autentifikacija

Agregacije

Audit logovi

Batch poslovi

Komentari

Email šabloni

Feed postovi

Hashtagovi

Meni

Moderatori

Broj obaveštenja

Obaveštenja

Reakcije na stranicama

Stranice

Ankete

Glasovi u anketi

Pending webhook događaji

SSO korisnici

Pretplate

Dnevna upotreba zakupca

Zakupci

Paketi zakupca

Korisnici zakupca

Korisnici

Glasovi

Konfiguracije domena

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

Značke korisnika

Napredak značke korisnika

API-ji za komentarisanje uživo

FastComments API

Generisani SDK‑ovi

Autentifikacija

Napomena o bezbednosti

Opcija autentifikacije 1 – Zaglavlja

Opcija autentifikacije 2 – Parametri upita

Opcija autentifikacije 3 – OAuth Bearer token

Čitanje sopstvenih upisa

API Resursi

Korišćenje resursa

Napomena!

Webhook‑ovi

OAuth Autorizacija

Discovery

Registracija klijenta

Scopes

Korak 1 - Autorizacioni zahtev

Korak 2 - Zahtev za token

Korak 3 - Pozivanje API-ja

Korak 4 - Osvežavanje (refresh)

Opoziv (Revocation)

Agregirajte Vaše podatke

Primeri

Primer: Brojanje jedinstvenih

Primer: Brojanje različitih vrednosti

Primer: Sabiranje vrednosti više polja

Primer: Prosečne vrednosti više polja

Primer: Min/Max vrednosti više polja

Primer: Brojanje jedinstvenih vrednosti više polja

Primer: Kreiranje upita

Primer: Brojanje komentara koji čekaju pregled

Primer: Raspodela odobrenih, pregledanih i spam komentara

Strukture

Struktura audit loga

GET /api/v1/audit-logs

Pronalaženje šta se desilo osobi

Upravljani tenant‑i

Struktura batch job-a

Pokušaji ponovnog izvršavanja

GET /api/v1/batch-jobs

GET /api/v1/batch-jobs/:id

Struktura komentara

Struktura teksta komentara

Označavanje

Haštagovi

GET /api/v1/comments