API | FastComments Docs

FastComments API

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

U ovoj dokumentaciji pronaći ćete sve resurse koje podržava API, dokumentovane sa njihovim tipovima zahteva i odgovora.

Za Enterprise korisnike, sav pristup API-ju se beleži u Audit logu.

Generisani SDK-i

FastComments sada generiše API specifikacija iz našeg koda (ovo još nije kompletno, ali uključuje mnoge API-je).

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

Autentifikacija

API se autentifikuje prosleđivanjem vašeg API ključa kao ili X-API-KEY headera ili API_KEY query parametra. Takođe će vam biti potreban vaš tenantId za pozivanje API-ja. To možete preuzeti sa iste stranice kao i vaš API ključ.

Napomena o bezbednosti

Ove rute su namenjene da budu pozivane sa servera. NE POZIVAJTE ih iz pregledača. Ako to uradite, izložićete vaš API ključ — to će omogućiti potpuni pristup vašem nalogu svima koji mogu da vide izvorni kod stranice!

Opcija autentifikacije 1 - Headeri

Zaglavlje: X-API-KEY
Zaglavlje: X-TENANT-ID

Opcija autentifikacije 2 - Parametri upita

Parametar upita: API_KEY
Parametar upita: tenantId

API resursi

Korišćenje resursa

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

Svaki resurs će u svojoj sekciji navesti šta spada u to korišćenje.

Neki resursi koštaju više da se posluže od drugih. Svaki endpoints ima fiksnu cenu u kreditima po API pozivu. Za neke endpoints, broj kredita varira u zavisnosti od opcija i veličine odgovora.

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

Napomena!

Predlažemo da prvo pročitate Pages dokumentaciju, kako biste smanjili zabunu pri određivanju koje vrednosti proslediti za urlId u Comment API-ju.

Agregirajte 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

AuditLog je objekat koji predstavlja evidentirani događaj za tenant-e koji imaju pristup ovoj funkciji.

Struktura za AuditLog objekat je sledeća:

Struktura AuditLog objekta

Copy

interface AuditLog {
    id: string;
    userId?: string;
    username?: string;
    resourceName: string;
    crudType: 'c' | 'r' | 'u' | 'd' | 'login';
    from: string;
    url?: string;
    ip?: string;
    when: string;
    description?: string;
    serverStartDate: string;
    objectDetails?: object;
}

Audit log je nepromenljiv. Takođe se u njega ne može ručno pisati. FastComments.com jedino odlučuje kada će se upisati u audit log. Međutim, možete ga čitati putem ovog API-ja.

Događaji u audit logu 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, before i after. AuditLogs se vraćaju u stranicama od po 1000, sortirani po when i id.

Preuzimanje svakih 1000 zapisa košta 10 kredita.

Po podrazumevanoj vrednosti dobićete listu sa najnovijim stavkama na vrhu. Na ovaj način možete započeti polling sa skip=0, paginirati dok ne nađete poslednji zapis koji ste obradili.

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

Sortiranje se radi podešavanjem order na ASC ili DESC. Podrazumevano je ASC.

Pretraga po datumu je moguća pomoću before i after kao timestamp-a u milisekundama. before i after nisu uključivi.

Primer cURL zahteva za AuditLog

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'

Struktura zahteva za AuditLog

Copy

interface CommentsRequestQueryParams {
    tenantId: string
    API_KEY: string
    order?: 'ASC' | 'DESC'
    skip?: number
    before?: number
    after?: number
}

Struktura odgovora za AuditLog

Copy

interface CommentsResponse {
    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
    /** Logovi! **/
    auditLogs: AuditLog[]
}

Struktura komentara

Objekat Comment predstavlja komentar koji je ostavio korisnik.

Odnos između roditeljskih i podređenih komentara definiše se preko parentId.

Struktura objekta Comment je sledeća:

Struktura komentara

Copy

interface Comment {
    /** SAMO ZA ČITANJE: Postavljeno na true ako je spam mehanizam utvrdio da je komentar spam. **/
    aiDeterminedSpam?: boolean
    /** Da li je komentar odobren za prikaz. Postavi se na true prilikom čuvanja komentara, inače će biti sakriven. **/
    approved?: boolean
    /** Avatar korisnika. **/
    avatarSrc?: string
    /** Podkomentari. Nisu popunjeni u svim scenarijima. Koriste se kada je asTree podešeno na true preko API-ja. **/
    children: Comment[]
    /** Originalni komentar autora. **/
    comment: string
    /** SAMO ZA ČITANJE: Komentar autora parsiran u HTML. **/
    commentHTML?: string
    /** Email autora komentara. Obavezno ako je anonimno komentarisanje isključeno. **/
    commenterEmail?: string
    /** Link autora komentara (na primer, njihov blog). **/
    commenterLink?: string
    /** Ime autora komentara. Uvek obavezno. Ako nije dostupno, postavite nešto poput "Anonymous". **/
    commenterName: string
    /** Datum kada je komentar ostavljen, u UTC epoch formatu. **/
    date: number
    /** "Prikazna oznaka" za komentar - na primer "Admin", "Moderator", ili nešto kao "VIP User". **/
    displayLabel?: string
    /** Domen na kojem je komentar objavljen. **/
    domain?: string
    /** SAMO ZA ČITANJE: Broj puta koliko je komentar prijavljen. **/
    flagCount?: number
    /** Hashtagovi (#) napisani u komentaru koji su uspešno parsirani. Takođe možete ručno dodati hashtagove 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 pri kreiranju! Ovo se hešira za čuvanje. **/
    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 napisao administrator? Automatski se postavlja na osnovu userId. **/
    isByAdmin?: boolean
    /** SAMO ZA ČITANJE: Da li je komentar napisao moderator? Automatski se postavlja na osnovu userId. **/
    isByModerator?: boolean
    /** Postaviti na true ako je komentar "soft deleted" (ostavljen je zamenski zapis zbog neke druge konfiguracije). **/
    isDeleted?: boolean
    /** Postaviti na true ako je nalog korisnika obrisan, a komentar je morao biti zadržan. **/
    isDeletedUser?: boolean
    /** SAMO ZA ČITANJE: Da li je komentar prijavljen od strane trenutno prijavljenog korisnika (contextUserId)? **/
    isFlagged?: boolean
    /** Da li je komentar pinovan? **/
    isPinned?: boolean
    /** Da li je komentar zaključan za nove odgovore (moderatori i dalje mogu odgovoriti)? **/
    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 (jezik) komentara. Ako nije naveden, biće izveden iz Accept-Language HTTP 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: @pominjanja napisana u komentaru koja su uspešno parsirana. **/
    mentions?: CommentUserMention[]
    /** Opcioni meta-podaci povezani sa komentarom. **/
    meta?: Record<string, string | number | boolean>
    /** Opcionalna lista ID-jeva 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 notifikacije poslate za ovaj komentar komentatorima. Da biste sprečili slanje notifikacija prilikom uvoza, postavite ovo na true. **/
    notificationSentForParent?: boolean
    /** Da li su notifikacije poslate za ovaj komentar korisnicima tenanta. Da biste sprečili slanje notifikacija prilikom uvoza, postavite ovo na true. **/
    notificationSentForParentTenant?: boolean
    /** Naslov stranice na kojoj se ovaj komentar nalazi. **/
    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 kome komentar pripada. **/
    tenantId: string
    /** Korisnik koji je napisao komentar. Kreira se automatski prilikom čuvanja komentara sa imenom/email-om. **/
    userId?: string|null
    /** URL lokacije na kojoj je ovaj komentar vidljiv, na primer objava na blogu. **/
    url: string
    /** "Očišćena" verzija urlId koju ste prosledili. Prilikom čuvanja specificirate ovo polje, ali kada dobijete komentar nazad ovo će biti "očišćeno" i vaša originalna vrednost prebačena u "urlIdRaw". **/
    urlId: string
    /** SAMO ZA ČITANJE: Originalni urlId koji ste prosledili. **/
    urlIdRaw?: string
    /** Da li su korisnik i ovaj komentar verifikovani? **/
    verified: boolean
    /** Broj pozitivnih glasova. **/
    votesUp?: number
    /** Broj negativnih glasova. **/
    votesDown?: number
    /** "Karma" komentara (= broj pozitivnih glasova - broj negativnih glasova). **/
    votes?: number
}

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

Struktura teksta komentara

Komentari su napisani u FastComments varijanti markdown-a, koja je samo markdown plus tradicionalne bbcode stil oznake za slike, kao što je [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 renderovanje HTML-a, s obzirom da je to vrlo mali podskup HTML-a, pa je izgradnja renderera prilično jednostavna. Na primer, postoji više biblioteka za React Native i Flutter koje mogu pomoći u tome

Možete izabrati 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 da transformiše HTML tagove u očekivane elemente za renderovanje na vašoj platformi.

Obelež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 komentara

Copy

Run

interface CommentUserMention {
    /** ID korisnika. Za SSO korisnike, biće prefiksiran vašim tenant ID-jem. **/
    id: string
    /** Konačni tekst @mention tag-a, uključujući simbol @. **/
    tag: string
    /** Originalni tekst @mention tag-a, 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
}

Hashtagovi

Kada se hashtagovi koriste i uspešno parsiraju, informacije se čuvaju u listi nazvanoj hashTags. Svaki objekat u toj listi ima sledeću strukturu. Hashtagove takođe možete ručno dodati u niz hashTags komentara za pretragu, ako je retain postavljeno.

Objekat Hashtag-a komentara

Copy

Run

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

GET /api/v1/comments

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

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

Paginacija

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

Najbrže: Prekalkulisana paginacija:
1. Ovako FastComments radi kada koristite naše ugrađene vidžete i klijente.
2. Klik na "next" jednostavno povećava broj stranice.
3. Ovo možete posmatrati kao dobijeno iz key-value skladišta.
4. Na ovaj način jednostavno definišite parametar page koji počinje od 0 i smer sortiranja kao direction.
5. Veličine stranica mogu se prilagoditi putem pravila za prilagođavanje.
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 što se primeni skip.
  - Primer: postavite skip = 200, limit = 100 kada je page size = 100 i page = 2.
4. Podkomentari i dalje se računaju u paginaciji. Možete to zaobići koristeći opciju asTree.
  - Možete paginirati decu putem limitChildren i skipChildren.
  - Možete ograničiti dubinu vraćenih niti putem maxTreeDepth.

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, za stranicu sa jednim komentarem na vrhu i 29 odgovora, i postavljanjem page=0 u API-ju — dobićete samo top-level komentar i 29 potomaka.
3. Primer slike koja ilustruje više stranica.
Kada koristite Flexible Pagination, možete definisati parametar parentId.
1. Postavite ga na null da biste dobili samo komentare prvog nivoa.
2. Zatim, da biste videli niti, pozovite API ponovo i prosledite parentId.
3. Uobičajeno rešenje je da napravite API poziv za komentare prvog nivoa, a zatim paralelne API pozive da dobijete komentare za decu svakog komentara.
NOVO od februara 2023! Dohvatajte kao stablo koristeći &asTree=true.
1. Ovo možete posmatrati kao Fleksibilna paginacija kao stablo.
2. Samo top-level komentari se računaju u paginaciji.
3. Postavite parentId=null da biste započeli stablo od korena (morate postaviti parentId).
4. Postavite skip i limit za paginaciju.
5. Postavite asTree na true.
6. Trošak kredita se povećava za 2x, jer naš backend mora da obavi mnogo više posla u ovom scenariju.
7. Postavite maxTreeDepth, limitChildren i skipChildren po želji.

Objašnjenje stabala

Kada koristite asTree, može biti teško razmišljati o paginaciji. Evo korisne grafike:

Dijagram paginacije stabla

Preuzimanje komentara u kontekstu korisnika

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

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

Prekalkulisana 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 za komentare prvog 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'

Dobijanje komentara kao stabla

Moguće je dobiti komentare vraćene kao stablo, pri čemu paginacija broji samo komentare prvog 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 da dobijete samo komentare prvog nivoa i neposrednu decu? 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 možda će vam trebati informacija da li prikazati dugme "prikaži odgovore" na svakom komentaru. Kada preuzimate komentare kao stablo, postoji hasChildren svojstvo koje se dodaje komentarima kada je primenljivo.

Dobijanje komentara kao stablo, pretraga po haštagu

Moguće je pretraživati po haštagu koristeći API, preko čitavog vašeg tenant-a (nije ograničeno na jednu stranicu ili urlId).

U ovom primeru izostavljamo urlId, i pretražujemo po više haštagova. API će vratiti samo komentare koji imaju sve tražene haštagove.

Komentari kao stablo u kontekstu korisnika, po haštagu

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
    /** urlId (URL stranice ili ID članka) sa kojim su komentari povezani. **/
    urlId?: string
    /** Ograniči komentare koji se vraćaju za ovog korisnika. **/
    userId?: string
    /** Koristite ovo za pretragu po haštagu. Da biste suzili na preseku više haštagova, koristite &hashTag=a&hashTag=b. **/
    hashTag?: string
    /** Smer sortiranja. Podrazumevano je MR (Najrelevantniji). Druge opcije su OF (Najstarije prvo) i NF (Najnovije prvo). **/
    direction?: 'MR' | 'OF' | 'NF'
    /** Prekalkulisana paginacija: Stranica koju treba dohvatiti, počevši od 0. Prosledite -1 za sve komentare (do 250). **/
    page?: number
    /** Fleksibilna paginacija: Koliko komentara treba da vratimo? **/
    limit?: number
    /** Fleksibilna paginacija: Koliko podkomentara treba da vratimo za svaki roditelj? **/
    limitChildren?: number
    /** Fleksibilna paginacija: Koliko komentara treba da preskočimo? **/
    skip?: number
    /** Fleksibilna paginacija: Koliko podkomentara treba da preskočimo za svaki roditelj? **/
    skipChildren?: number
    /** Za određivanje blokiranih i prijavljenih komentara. **/
    contextUserId?: string
    /** Za određivanje blokiranih i prijavljenih komentara. **/
    anonUserId?: string
    /** Za preuzimanje podkomentara. **/
    parentId?: string
    /** Za preuzimanje kao stablo. **/
    asTree?: boolean
    /** Koliko duboko u stablu treba da vraćamo podatke? 0 vraća nijedno dete. 1 vraća neposrednu decu, itd. **/
    maxTreeDepth?: number
}

Odgovor

Struktura odgovora za komentare

Copy

interface CommentsResponse {
    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' | 'missing-date' | 'unauthorized-page' | 'invalid-pagination-request' | 'invalid-limit' | 'invalid-limit-children' | 'invalid-skip' | 'invalid-skip-children' | 'invalid-max-tree-depth'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    /** Komentari! **/
    comments: Comment[]
}

Korisni saveti

URL ID

Verovatno želite da koristite Comment API sa parametrima urlId. Najpre možete pozvati Pages API da vidite kako izgledaju vrednosti urlId dostupne vama.

Anonimne radnje

Za anonimno komentarisanje verovatno ćete želeti da prosledite anonUserId prilikom preuzimanja komentara, i prilikom prijavljivanja i blokiranja.

(!) Ovo je obavezno za mnoge prodavnice aplikacija jer korisnici moraju biti u mogućnosti da prijave sadržaj koji su korisnici kreirali koji mogu da vide, čak i ako nisu prijavljeni. Nepoštovanje ovoga može dovesti do uklanjanja vaše aplikacije iz pomenute 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 pojedinačnog komentara.

Napomene:

Ovaj API može ažurirati comment widget "live" ako je željeno (ovo povećava base creditsCost from 1 to 2).
- Ovo može omogućiti migraciju komentara između stranica "live" (promena urlId).
- Migracije koštaju dodatna 2 kredita jer se stranice prethodno izračunavaju i ovo je CPU intenzivno.
Za razliku od create API-ja, ovaj API NEĆE automatski kreirati objekte korisnika u našem sistemu ako je email naveden.
Komentari ažurirani putem ovog API-ja i dalje se mogu proveravati na spam ako je potrebno.
Konfiguracije kao što su maksimalna dužina komentara, ako su postavljene preko Customization Rule admin stranice, biće primenjene ovde.
Da biste omogućili korisnicima da ažuriraju tekst svog komentara, možete samo navesti comment u telu zahteva. Mi ćemo generisati rezultujući commentHTML.
- Ako definišete i comment i commentHTML, mi nećemo automatski generisati HTML.
- Ako korisnik doda mentions ili hashtags u svom novom tekstu, to će i dalje biti obrađeno kao kod POST API-ja.
Kada ažurirate commenterEmail na komentaru, najbolje je da takođe navedete userId. Inače, morate osigurati da korisnik sa tim emailom pripada vašem tenant-u, inače će zahtev propasti.

Minimalni cURL primer za PATCH komentara

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 želji može biti korišćen za proveru da li mogu da uređuju komentar.  **/
    contextUserId?: string
    /** Da li da proverimo da li novi komentar izgleda kao spam?  **/
    doSpamCheck?: 'true' | 'false'
    /** Da li komentar treba da se pojavi "live" korisnicima koji gledaju instance widgeta za komentare sa istim urlId. NAPOMENA: Udvostručuje trošak kredita sa 1 na 2. **/
    isLive?: 'true' | 'false'
}

Struktura PATCH odgovora za komentar

Copy

interface CommentPatchResponse {
    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' | 'invalid-input' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju greške. **/
    reason?: string
}

DELETE /api/v1/comments/:id

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

Ovaj API omogućava brisanje komentara.

Napomene:

Ovaj API može ažurirati widget za komentare "uživo" ako je potrebno (ovo povećava creditsCost sa 1 na 2).
Ovaj API će obrisati sve podkomentare.

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 da bude obrisan "uživo" za korisnike koji gledaju instance widgeta za komentare sa istim urlId. NAPOMENA: Udvostručuje 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'
    /** 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 šablona e-pošte

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 haštagova

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
}

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

A Notification objekat predstavlja notifikaciju za korisnika.

Notification objekti se kreiraju automatski i ne mogu se kreirati preko API-ja. Takođe ističu nakon jedne godine. Notifikacije se ne mogu obrisati. Međutim, mogu se ažurirati da se viewed postavi na false, i možete ih pretraživati po viewed.

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

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

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

U ovom trenutku, postojanje Notification zapravo ne znači da je email poslat ili da bi trebao biti poslat. Umesto toga, notifikacije se koriste za feed notifikacija i povezane integracije.

The structure for the Notification object is as follows:

Struktura objekta 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 niti (čak i u potomcima potomaka) na kojoj ste komentarisali. **/
    RepliedTransientChild = 1,
    /** Ako je neko glasao za vaš komentar. **/
    VotedMyComment = 2,
    /** Ako je ostavljen novi komentar na korenu stranice na koju ste pretplaćeni. **/
    SubscriptionReplyRoot = 3,
    /** Ako je neko komentarisao vaš profil. **/
    CommentedOnProfile = 4,
    /** Ako imate privatnu 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, user id je u formatu `<tenant id>:<user id>`. **/
    userId?: string
    /** Kada radite sa SSO, treba da brinete samo o `userId`. **/
    anonUserId?: string
    /** urlId je skoro uvek definisan. Opcionalan je samo za notifikacije na nivou tenanta, koje su retke. **/
    urlId?: string
    /** URL je keširan za brzu navigaciju do izvora notifikacije. **/
    url?: string
    /** Naslov stranice je keširan 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 ovde keširani 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
}

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

Individual pages can be fetched by their corresponding urlId. This can be useful for looking up page titles or comment counts.

Primer cURL zahteva za stranicu po URL ID

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

Copy

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

Struktura odgovora za stranicu po URL ID

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' | 'missing-url-id'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    page?: Page[] | null
}

Koristan savet

Ne zaboravite da URI enkodujete vrednosti poput urlId.

PATCH /api/v1/pages/:id

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

Ovaj endpoint omogućava ažuriranje jedne 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 za ažuriranje stranice

Copy

interface PagePatchResponse {
    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' | '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'
    /** Uključeno u slučaju neuspeha. **/
    reason?: string
    user?: Page; // Vraćamo kompletan ažurirani Page pri uspehu.
}

Napomena

Neki parametri u Page objektu se automatski ažuriraju. To su atributi counts i title. Counts se ne mogu ažurirati putem API-ja jer su to izračunate vrednosti. The page title can be set via the API, but would get overwritten if the comment widget is used on a page with the same urlId and a different page title.

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
}

Struktura očekivanog 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 SSO rešenje. Ažuriranje informacija o korisniku pomoću HMAC-integracije je jednostavno kao učitavanje stranice od strane korisnika sa ažuriranim payload-om.

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

SSO User API pruža način za CRUD objekata koje nazivamo SSOUsers. Ovi objekti se razlikuju od regularnih Users i držani su odvojeno radi bezbednosti 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 // Dozvola administratora - SSO korisnici sa ovom zastavicom se fakturišu kao SSO Admins (odvojeno od regularnih SSO korisnika)
    isAdminAdmin?: boolean // Dozvola administratora - SSO korisnici sa ovom zastavicom se fakturišu kao SSO Admins (odvojeno od regularnih SSO korisnika)
    isCommentModeratorAdmin?: boolean // Dozvola moderatora - SSO korisnici sa ovom zastavicom se fakturišu kao SSO Moderators (odvojeno od regularnih SSO korisnika)
    /** Ako je null, Kontrola pristupa neće biti primenjena na korisnika. Ako je prazan spisak, 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 kako bi profili bili podrazumevano sigurni. **/
    isProfileActivityPrivate?: boolean
    /** Ne dozvolite drugim korisnicima da ostavljaju komentare na korisnikovom profilu, niti da vide postojeće komentare na profilu. Podrazumevano false. **/
    isProfileCommentsPrivate?: boolean
    /** Ne dozvolite drugim korisnicima da šalju direktne poruke ovom korisniku. Podrazumevano false. **/
    isProfileDMDisabled?: boolean
    karma?: number
    /** Opcionalna konfiguracija za značke korisnika. **/
    badgeConfig?: {
        /** Niz ID-jeva znački koje će biti dodeljene korisniku. Ograničeno na 30 znački. Redosled se poštuje. **/
        badgeIds: string[]
        /** Ako je true, zamenjuje sve postojeće prikazane značke sa dostavljenim. Ako je false, dodaje se postojećim značkama. **/
        override?: boolean
        /** Ako je true, ažurira svojstva prikaza znački iz konfiguracije tenant-a. **/
        update?: boolean
    }
}

Naplata za SSO korisnike

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

Regular SSO Users: Korisnici bez administratorskih ili moderatorskih dozvola se naplaćuju kao regularni SSO korisnici
SSO Admins: Korisnici sa isAccountOwner ili isAdminAdmin zastavicama se naplaćuju odvojeno kao SSO Admins (isti tarifni razred kao regularni tenant admini)
SSO Moderators: Korisnici sa isCommentModeratorAdmin zastavicom se naplaćuju odvojeno kao SSO Moderators (isti tarifni razred kao regularni moderatori)

Važno: Da bi se sprečilo dvostruko naplaćivanje, sistem automatski deduplicira SSO korisnike naspram regularnih tenant korisnika i moderatora po email adresi. Ako SSO korisnik ima isti email kao regularni tenant korisnik ili moderator, neće biti naplaćen dva puta.

Kontrola pristupa

Korisnici mogu biti podeljeni u grupe. Za to služi polje groupIds, i nije obavezno.

@Mentions

Po podrazumevanoj vrednosti, @mentions će koristiti username za pretragu drugih sso korisnika kada se unese karakter @. Ako se koristi displayName, tada će rezultati koji odgovaraju username biti zanemareni kada postoji poklapanje za displayName, i rezultati pretrage za @mention će koristiti displayName.

Pretplate

Sa FastComments, korisnici se mogu pretplatiti na stranicu klikom na ikonicu zvona u widgetu za komentare i izborom Subscribe.

Kod regularnog korisnika, šaljemo im email notifikacije na osnovu njihovih podešavanja za notifikacije.

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

Značke

Možete dodeljivati značke SSO korisnicima pomoću svojstva badgeConfig. Značke su vizuelni indikatori koji se pojavljuju pored imena korisnika u komentarima.

badgeIds - Niz ID-jeva znački koje će biti dodeljene korisniku. Moraju biti važeći ID-jevi znački kreirani na vašem FastComments nalogu. Ograničeno na 30 znački.
override - Ako je true, sve postojeće značke prikazane na komentarima biće zamenjene navedenim. Ako je false ili izostavljeno, navedene značke biće dodate postojećim značkama.
update - Ako je true, svojstva prikaza znački će se ažurirati iz konfiguracije tenant-a kad god 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

Ovaj endpoint omogućava uklanjanje TenantUser po id-u.

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 anonimnišu na osnovu konfiguracije svake stranice kojoj komentar pripada. Na primer, ako je režim brisanja niti "anonymize", odgovori će ostati, a korisnikovi komentari će biti anonimizovani. Ovo se primenjuje samo kada je commentDeleteMode postavljen na Remove (podrazumevana vrednost).
creditsCost postaje 2.

Anonymized Comments

Možete zadržati korisnikove komentare, ali ih jednostavno anonimizovati tako što ćete postaviti commentDeleteMode=1.

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

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

isDeleted i isDeletedUser se postavljaju na true.

Pri prikazu, widget za komentare će koristiti DELETED_USER_PLACEHOLDER (podrazumevano: "[deleted]") za korisnikovo ime i DELETED_CONTENT_PLACEHOLDER za komentar. Ovo se može prilagoditi putem korisničkog interfejsa za prilagođavanje widgeta.

Examples

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 korisnikove komentare. Ovo će udvostručiti cenu u kreditima. **/
    deleteComments?: 'true' | 'false'
    /** Možete ovo podesiti kako biste odredili kako postupati sa korisnikovim komentarima. **/
    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 glasa

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 zakupca.

Struktura objekta DomainConfig je sledeća:

Struktura konfiguracije domena

Copy

interface DomainConfig {
    /** Domen, ne URL, kao što je "fastcomments.com" ili "www.example.com". Poddomen može biti uključen ako želite ograničiti na poddomen. Maksimalno 1000 karaktera. **/
    domain: string
    /** Ime pošiljaoca koje se koristi prilikom slanja e-poruke. **/
    emailFromName?: string
    /** From-Email koji se koristi pri slanju e-poruke. Osigurajte da je SPF podešen da dozvoli mail.fastcomments.com da šalje e-poruke u ime domena korišćenog u ovom atributu. **/
    emailFromEmail?: string
    /** SAMO ZA ČITANJE. Kada je objekat kreiran. **/
    createdAt: string
    /** Logo povezan sa ovim domenom. Koristi se u e-porukama. Koristite HTTPS. **/
    logoSrc?: string
    /** Manji logo povezan sa ovim domenom. Koristite HTTPS. **/
    logoSrc100px?: string
    /** SAMO SSO. URL koji se koristi u podnožju svake poslate e-poruke. Podržava varijablu "[userId]". **/
    footerUnsubscribeURL?: string
    /** SAMO SSO. Zaglavlja koja se koriste u svakoj poslatој e-poruci. Korisno, na primer, za postavljanje zaglavlja vezanih za odjavu kako bi se poboljšala isporuka. Unos List-Unsubscribe u ovom zapisu, ako postoji, podržava varijablu "[userId]". **/
    emailHeaders?: Record<string, string>
    /** Onemogući sve linkove za odjavu. Ne preporučuje se, može negativno uticati na stope isporuke. **/
    disableUnsubscribeLinks?: boolean
    /** DKIM konfiguracija. **/
    dkim?: DomainConfigDKIM
}

Struktura DKIM konfiguracije

Copy

interface DomainConfigDKIM {
    /** Naziv domena u vašem DKIM zapisu. **/
    domainName: string
    /** Selektor DKIM ključa koji treba koristiti. **/
    keySelector: string
    /** Vaš privatni ključ. Počinje sa -----BEGIN PRIVATE KEY----- i završava sa -----END PRIVATE KEY----- **/
    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 koje konfiguracije domena može uticati na dostupnost vaše FastComments instalacije u produkciji.

Ne uklanjajte ili ne ažurirajte domain svojstvo Domain Config za domen koji je trenutno u upotrebi, osim ako nije namera da se taj domen onemogući.

Ovo ima isto ponašanje kao uklanjanje domena iz /auth/my-account/configure-domains.

Takođe imajte na umu da uklanjanje domena iz My Domains UI ukloniće svaku odgovarajuću konfiguraciju za taj domen koja je možda dodata putem ovog UI-ja.

Za prilagođavanje e-pošte

Link za odjavu u podnožju e-poruke, i funkcija jednim klikom za odjavu koju nude mnogi email klijenti, mogu se konfigurisati putem ovog API-ja definisanjem footerUnsubscribeURL i emailHeaders, redom.

Za DKIM

Nakon što definišete svoje 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 za agregaciju je sledeća:

Struktura QuestionResultsAggregationResult

Copy

interface QuestionResultDataPoint {
    /** Mapa vrednosti na broj pojavljivanja te vrednosti za trenutnu tačku podataka (vremenski bucket ili stranica). **/
    v: Map<ValueAsString, number>
    total: number
}
interface QuestionResultsAggregationResult {
    /** Napomena - null je kada timeBucket nije naveden. **/
    dataByDateBucket?: Map<DateString, QuestionResultDataPoint>
    dataByUrlId?: Map<URLIdString, QuestionResultDataPoint>
    countsByValue?: Map<ValueAsString, number>
    /** Ukupan broj agregiranih rezultata. **/
    total: number
    /** Dobijena ponderisana sredina. To je decimalni broj, obično sa dve decimale ili manje. **/
    average: number
    /** Datum u obliku stringa koji predstavlja kada su ovi podaci izračunati, pošto mogu poticati iz keša. **/
    createdAt: string
}

Here are the query parameters available for aggregation:

Struktura zahteva za QuestionResultsAggregation

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
}

Here's an example request:

Primer QuestionResultsAggregation

Copy

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

Example response:

Primer odgovora za QuestionResultsAggregation

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 za QuestionResultsAggregation

Copy

interface QuestionResultsAggregationResponse {
    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
    data: QuestionResultsAggregationResult
}

Napomene o performansama

Ako dođe do promašaja keša, agregacije obično traju pet sekundi po milionu rezultata.
U suprotnom, zahtevi se izvršavaju u konstantnom vremenu.

Napomene o keširanju i troškovima

Kada je forceRecalculate naveden, trošak je uvek 10, umesto uobičajenih 2.
Ako keš istekne i podaci se ponovo izračunaju, trošak je i dalje konstantan 2 ako forceRecalculate nije naveden. Keš ističe u zavisnosti od veličine agregiranog skupa podataka (može varirati između 30 sekundi i 5 minuta).
Ovo je da 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 za kreiranje, na primer, grafikona "recent positive and negative comments" za proizvod.

Možete pretraživati po opsegu vrednosti (uključivo), po jednom ili više pitanja, i po datumu početka (uključivo).

The response structure is as follows:

Struktura QuestionResultsCombinedWithCommentsResponse

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 {
    /** Niz datuma koji predstavlja kada su ovi podaci izračunati, pošto mogu doći iz keša. **/
    createdAt: string
    results: CommentAndResult[]
}

Here are the query parameters available for aggregation:

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
}

Here's an example request:

Primer za 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'

Example response:

Primer odgovora za 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 troškovima

When forceRecalculate is specified the cost is always 10, instead of the normal 2.
If the cache expires and data is recalculated, the cost is still a constant 2 if forceRecalculate is not specified.
This is to incentivize using the cache.

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, status veterana) ili ručno od strane administratora sajta.

Struktura objekta UserBadge je sledeća:

Struktura objekta UserBadge

Copy

export interface UserBadge {
    /** Jedinstveni identifikator za ovu dodelu značke korisniku */
    id: string
    /** ID korisnika kome je ova značka dodeljena */
    userId: string
    /** ID definicije značke iz tenant-ovog kataloga */
    badgeId: string
    /** ID tenant-a 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 do slike koja se prikazuje na znački */
    displaySrc?: string
    /** Boja pozadine značke (hex kod) */
    backgroundColor?: string
    /** Boja ivice značke (hex kod) */
    borderColor?: string
    /** Boja teksta značke (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 korisnikovim komentarima */
    displayedOnComments: boolean
    /** Redosled prikaza značke */
    order?: number
}

---

GET /api/v1/user-badges

Ovaj endpoint vam omogućava da preuzmete korisničke značke na osnovu različitih kriterijuma.

Primer zahteva:

Primer GET zahteva

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 da biste filtrirali rezultate:

userId - Dobijte značke za određenog korisnika
badgeId - Dobijte instance određene značke
type - Filtrirajte po tipu značke (0=CommentCount, 1=CommentUpVotes, 2=CommentReplies, etc. See UserBadge structure for full list)
displayedOnComments - Filtrirajte po tome da li se značka prikazuje na komentarima (true/false)
limit - Maksimalan broj znački koji će biti vraćen (podrazumevano 30, max 200)
skip - Broj znački koje će biti preskočene (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: Neispravan 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 znački na osnovu različitih kriterijuma.

Primer zahteva:

Primer GET zahteva

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badge-progress?tenantId=demo&API_KEY=DEMO_API_SECRET"

Možete dodati razne parametre upita da filtrirate rezultate:

userId - Dobijte napredak za određenog korisnika
limit - Maksimalan broj zapisa za vraćanje (podrazumevano 30, maksimum 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 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-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

Agregacije

Audit logovi

Komentari

Šabloni e-pošte

Haštagovi

Moderatori

Broj obaveštenja

Obaveštenja

Stranice

Očekivani webhook događaji

SSO korisnici

Pretplate

Dnevna upotreba zakupca

Zakupci

Paketi zakupaca

Korisnici zakupaca

Korisnici

Glasovi

Konfiguracije domena

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

Značke korisnika

Napredak značke korisnika

FastComments API

Generisani SDK-i

Autentifikacija

Napomena o bezbednosti

Opcija autentifikacije 1 - Headeri

Opcija autentifikacije 2 - Parametri upita

API resursi

Korišćenje resursa

Napomena!

Agregirajte 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

Struktura komentara

Struktura teksta komentara

Obeležavanje

Hashtagovi

GET /api/v1/comments

Paginacija

Threads

Objašnjenje stabala

Preuzimanje komentara u kontekstu korisnika

Dobijanje komentara kao stabla

Dobijanje komentara kao stablo, pretraga po haštagu

Svi parametri zahteva

Odgovor

Korisni saveti

URL ID

Anonimne radnje

Komentari se ne vraćaju

GET /api/v1/comments/:id

POST /api/v1/comments

PATCH /api/v1/comments/:id

DELETE /api/v1/comments/:id

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

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

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

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

Struktura šablona e-pošte

Napomene

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

GET /api/v1/email-templates

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

POST /api/v1/email-templates