API | FastComments Docs

FastComments API

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

U ovoj dokumentaciji pronaći ćete sve podržane resurse koje API dokumentira zajedno s njihovim tipovima zahtjeva i odgovora.

Za Enterprise korisnike, sav pristup API-ju bilježi se u dnevniku revizije.

Generirani SDK-ovi

FastComments sada generira API Spec iz našeg koda (ovo još nije potpuno dovršeno, ali uključuje mnoge API-je).

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

Autentifikacija

API se autentificira prosljeđivanjem vašeg API ključa kao ili X-API-KEY zaglavlje ili API_KEY query parametar. Također ćete trebati svoj tenantId za pozivanje API-ja. To se može dohvatiti na istoj stranici kao i vaš api ključ.

Sigurnosna napomena

Ove rute namijenjene su pozivanju s poslužitelja. NEMOJTE ih pozivati iz preglednika. To će otkriti vaš API ključ - to će pružiti potpuni pristup vašem računu svima koji mogu pregledati izvorni kod stranice!

Opcija autentifikacije 1 - Zaglavlja

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

Opcija autentifikacije 2 - Parametri upita

Parametar upita: API_KEY
Parametar upita: tenantId

Resursi API-ja

Korištenje resursa

Treba napomenuti da se dohvaćanje podataka iz API-ja računa kao korištenje na vašem računu.

Svaki resurs navodi to korištenje u svom vlastitom odjeljku.

Neki resursi koštaju više za posluživanje od drugih. Svaka krajnja točka ima fiksni trošak kredita po API pozivu. Za neke krajnje točke, broj kredita varira ovisno o opcijama i veličinama odgovora.

Korištenje API-ja može se provjeriti na stranici Analitika naplate i ažurira se svakih nekoliko minuta.

Napomena!

Preporučujemo da prvo pročitate dokumentaciju Stranica kako biste ograničili zabunu pri određivanju vrijednosti za urlId u API-ju za komentare.

Agregirajte svoje podatke

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

Ovaj API agregira dokumente grupiranjem (ako je naveden groupBy) i primjenom 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 dopuštena upotreba memorije po API pozivu po zadanim postavkama iznosi 64MB, a po zadanim postavkama možete imati samo jednu agregaciju koja se izvršava u jednom trenutku. Ako istodobno pošaljete više agregacija, bit će stavljenje u red i izvršene redoslijedom podnošenja. Neobrađene agregacije čekat će najviše 60 sekundi, nakon čega će zahtjev isteći. Pojedinačne agregacije mogu se izvršavati do 5 minuta.

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

Primjeri

Primjer: Brojanje jedinstvenih

Primjer cURL zahtjeva: broj jedinstvenih vrijednosti

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: broj jedinstvenih vrijednosti

Copy

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

Primjer: Brojanje različitih vrijednosti

Primjer cURL zahtjeva: broj različitih vrijednosti

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: broj različitih vrijednosti

Copy

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

Primjer: Zbroj vrijednosti više polja

Primjer cURL zahtjeva: zbroj vrijednosti

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: zbroj vrijednosti

Copy

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

Primjer: Prosjek vrijednosti više polja

Primjer cURL zahtjeva: prosjek vrijednosti

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: prosjek vrijednosti

Copy

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

Primjer: Min/Max vrijednosti više polja

Primjer cURL zahtjeva: min/max vrijednosti

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 vrijednosti

Copy

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

Primjer: Brojanje jedinstvenih vrijednosti više polja

Primjer cURL zahtjeva: broj jedinstvenih vrijednosti

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: broj jedinstvenih vrijednosti

Copy

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

Primjer: Kreiranje upita

Primjer cURL zahtjeva: 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 }
}

Primjer: Brojanje komentara na čekanju pregleda

Primjer cURL zahtjeva: broj komentara na čekanju pregleda

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: broj komentara na čekanju pregleda

Copy

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

Primjer: Pregled raspodjele odobrenih, pregledanih i spam komentara

Primjer cURL zahtjeva: pregled raspodjele 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: pregled raspodjele komentara

Copy

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

Strukture

Struktura zahtjeva za agregaciju

Copy

export type AggregationOpType = 'sum' | 'countDistinct' | 'distinct' | 'avg' | 'min' | 'max' | 'count';
/** Operacija koja će se primijeniti na polje */
export interface AggregationOperation {
    /** Polje na kojem će se izvršiti operacija */
    field: string;
    /** Tip operacije */
    op: AggregationOpType;
    /** Opcionalni alias za izlaz; ako nije naveden, koristi se izračunati zadani 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;
    };
}

Sljedeći resursi mogu se 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 zapisnika revizije

AuditLog je objekt koji predstavlja revidirani događaj za stanare koji imaju pristup ovoj značajci.

Struktura za AuditLog objekt je sljedeća:

Struktura AuditLog

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

Revizijski zapisnik je nepromjenjiv. Također se ne može ručno pisati u njega. FastComments.com može odlučiti samo kada pisati u revizijski zapisnik. Međutim, možete ga čitati putem ovog API-ja.

Događaji u revizijskom zapisniku istječu nakon dvije godine.

GET /api/v1/audit-logs

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

Ovaj API koristi paginaciju, koju omogućuju parametri skip, before i after. AuditLogs se vraćaju na stranicama od 1000, poredani po when i id.

Dohvaćanje svakih 1000 zapisnika ima trošak kredita od 10.

Prema zadanim postavkama, primit ćete popis s najnovijim stavkama na prvom mjestu. Na taj način možete početi s skip=0, paginirajući dok ne pronađete zadnji zapis koji ste konzumirali.

Alternativno, možete sortirati od najstarijeg prema naprijed i paginirati dok nema više zapisa.

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

Upit prema datumu moguć je putem before i after kao vremenskih oznaka s milisekundama. before i after NISU uključivi.

Primjer cURL 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 zahtjeva AuditLog

Copy

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

Struktura odgovora AuditLog

Copy

interface CommentsResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Included on failure. **/
    reason?: string
    /** The logs! **/
    auditLogs: AuditLog[]
}

Struktura komentara

Objekt Comment predstavlja komentar koji je ostavio korisnik.

Odnos između roditeljskih i podređenih komentara definira se putem parentId.

Struktura objekta Comment je sljedeća:

Struktura komentara

Copy

interface Comment {
    /** READONLY: Postavljeno na true ako je antispam mehanizam utvrdio da je komentar spam. **/
    aiDeterminedSpam?: boolean
    /** Je li komentar odobren za prikaz. Postaviti na true prilikom spremanja komentara, inače će biti skriven. **/
    approved?: boolean
    /** Avatar korisnika. **/
    avatarSrc?: string
    /** Podređeni komentari. Nisu popunjeni u svim scenarijima. Koriste se kada je asTree postavljeno na true putem API-ja. **/
    children: Comment[]
    /** Izvorni komentar autora. **/
    comment: string
    /** READONLY: Komentar autora parsiran u HTML. **/
    commentHTML?: string
    /** Email autora komentara. Obavezno ako je anonimno komentiranje isključeno. **/
    commenterEmail?: string
    /** Link autora komentara (na primjer, njihov blog). **/
    commenterLink?: string
    /** Ime autora komentara. Uvijek obavezno. Ako nije dostupno, postavite nešto poput "Anoniman". **/
    commenterName: string
    /** Datum kada je komentar ostavljen, u UTC epoch formatu. **/
    date: number
    /** "Prikazna oznaka" komentara - na primjer "Admin", "Moderator", ili nešto poput "VIP User". **/
    displayLabel?: string
    /** Domena na kojoj je komentar objavljen. **/
    domain?: string
    /** READONLY: Broj puta koliko je komentar prijavljen. **/
    flagCount?: number
    /** #hashtagovi napisani u komentaru koji su uspješno parsirani. Također možete ručno dodati hashtagove za pretraživanje, ali oni se neće automatski prikazati u tekstu komentara. **/
    hashTags?: CommentHashTag[]
    /** READONLY: Sadrži li komentar slike? **/
    hasImages?: boolean
    /** READONLY: Sadrži li komentar linkove? **/
    hasLinks?: boolean
    /** READONLY: Jedinstveni ID komentara. **/
    id: string
    /** Samo pri kreiranju! Ovo se hashira za pohranu. **/
    ip?: string
    /** READONLY: Je li trenutni korisnik blokirao korisnika koji je napisao ovaj komentar? **/
    isBlocked?: boolean
    /** READONLY: Je li komentar od administratora? Automatski postavljeno na temelju userId. **/
    isByAdmin?: boolean
    /** READONLY: Je li komentar od moderatora? Automatski postavljeno na temelju userId. **/
    isByModerator?: boolean
    /** Postaviti na true ako je komentar privremeno obrisan (morao je biti ostavljen zamjenski zapis zbog neke druge konfiguracije). **/
    isDeleted?: boolean
    /** Postaviti na true ako je račun korisnika obrisan, a komentar je morao biti sačuvan. **/
    isDeletedUser?: boolean
    /** READONLY: Je li komentar označen od trenutno prijavljenog korisnika (contextUserId)? **/
    isFlagged?: boolean
    /** Je li komentar prikvačen? **/
    isPinned?: boolean
    /** Je li komentar zaključan za nove odgovore (moderatori još uvijek mogu odgovarati)? **/
    isLocked?: boolean
    /** Je li komentar spam? **/
    isSpam?: boolean
    /** READONLY: Je li komentar ocijenjen negativno od trenutnog korisnika (contextUserId)? **/
    isVotedDown?: boolean
    /** READONLY: Je li komentar ocijenjen pozitivno od trenutnog korisnika (contextUserId)? **/
    isVotedUp?: boolean
    /** Lokalizacija u kojoj je komentar. Ako nije navedeno, izvest će se 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'
    /** READONLY: @mentions napisani u komentaru koji su uspješno parsirani. **/
    mentions?: CommentUserMention[]
    /** Opcionalni meta-podaci povezani s komentarom. **/
    meta?: Record<string, string | number | boolean>
    /** Opcionalna lista ID-eva grupa za moderaciju povezanih s ovim komentarom. **/
    moderationGroupIds?: string[]|null
    /** READONLY: ID objekta glasovanja koji odgovara glasu trenutnog korisnika (contextUserId) na ovom komentaru. **/
    myVoteId?: string
    /** Jesu li za ovaj komentar poslane obavijesti komentatorima. Kako biste spriječili slanje obavijesti prilikom uvoza, postavite ovo na true. **/
    notificationSentForParent?: boolean
    /** Jesu li za ovaj komentar poslane obavijesti korisnicima tenanta. Kako biste spriječili slanje obavijesti prilikom uvoza, postavite ovo na true. **/
    notificationSentForParentTenant?: boolean
    /** Naslov stranice na kojoj je ovaj komentar bio. **/
    pageTitle?: string
    /** Ako odgovaramo na komentar, ovo je ID na koji odgovaramo. **/
    parentId?: string|null
    /** Je li komentar označen kao pregledan. **/
    reviewed: boolean
    /** ID tenanta kojem komentar pripada. **/
    tenantId: string
    /** Korisnik koji je napisao komentar. Automatski se stvara prilikom spremanja komentara s imenom/emailom. **/
    userId?: string|null
    /** URL lokacije na kojoj je ovaj komentar vidljiv, poput objave na blogu. **/
    url: string
    /** "Očišćena" verzija urlId-a koji ste nam poslali. Prilikom spremanja specificirate ovo polje, ali kada dohvatite komentar nazad, ovo će biti "očišćeno" i vaša originalna vrijednost premještena u "urlIdRaw". **/
    urlId: string
    /** READONLY: Izvorni urlId koji ste nam poslali. **/
    urlIdRaw?: string
    /** Je li korisnik i ovaj komentar verificiran? **/
    verified: boolean
    /** Broj pozitivnih glasova. **/
    votesUp?: number
    /** Broj negativnih glasova. **/
    votesDown?: number
    /** "Karma" komentara (= pozitivni glasovi - negativni glasovi). **/
    votes?: number
}

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

Struktura teksta komentara

Komentari su pisani u FastComments varijanti Markdowna, što je običan Markdown uz tradicionalne bbcode stil oznake za slike, poput [img]path[/img].

Tekst se pohranjuje u dva polja. Tekst koji je korisnik unio pohranjuje se neizmijenjen u polje comment. Taj tekst se renderira i pohranjuje u polje commentHTML.

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

Preporučuje se renderiranje HTML-a; budući da je riječ o vrlo malom podskupu HTML-a, izrada renderera je relativno jednostavna. Na primjer, postoje više knjižnica za React Native i Flutter koje mogu pomoći s tim

Možete odabrati renderiranje ne-normiranog sadržaja polja comment. Primjer parsera nalazi se ovdje..

Primjer parsera također se može prilagoditi za rad s HTML-om te transformirati HTML oznake u očekivane elemente za renderiranje na vašoj platformi.

Označavanje

Kada su korisnici označeni u komentaru, informacija se pohranjuje u listu nazvanu mentions. Svaki objekt u toj listi ima sljedeću strukturu.

Objekt spominjanja komentara

Copy

Run

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

HashTags

Kada se koriste hashtagovi i uspješno su parsirani, informacija se pohranjuje u listu nazvanu hashTags. Svaki objekt u toj listi ima sljedeću strukturu. Hashtagovi se također mogu ručno dodati u niz hashTags komentara za upite, ako je retain postavljen.

Objekt hashtagova komentara

Copy

Run

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

GET /api/v1/comments

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

Ovaj API se koristi za dohvaćanje komentara za prikaz korisniku. Na primjer, automatski filtrira neopravdane ili spam komentare.

Straničenje

Straničenje se može obaviti na jedan od dva načina, ovisno o zahtjevima za performansama i upotrebi:

Najbrže: Prethodno izračunato straničenje:
1. Ovo je način na koji FastComments radi kada koristite naše predloške widgeta i klijente.
2. Klik na "next" jednostavno povećava broj stranice.
3. Možete to promatrati kao dohvaćanje iz key-value spremišta.
4. Na ovaj način jednostavno definirajte parametar page počevši od 0 i smjer sortiranja kao direction.
5. Veličine stranica se mogu prilagoditi putem pravila za prilagodbu.
Najfleksibilnije: Fleksibilno straničenje:
1. Na ovaj način možete definirati prilagođene parametre limit i skip. Nemojte slati page.
2. Podržan je i smjer sortiranja direction.
3. limit je ukupni broj koji treba vratiti nakon primjene skip.
  - Primjer: postavite skip = 200, limit = 100 kada je page size = 100 i page = 2.
4. Dječji komentari se i dalje računaju u straničenju. Možete zaobići ovo koristeći opciju asTree.
  - Dječje komentare možete straničiti putem limitChildren i skipChildren.
  - Možete ograničiti dubinu niti koja se vraća putem maxTreeDepth.

Niti

Kada koristite Precalculated Pagination, komentari se grupiraju po stranici i komentari u nitima utječu na ukupnu stranicu.
1. Na ovaj način, niti se mogu odrediti na klijentu na temelju parentId.
2. Na primjer, za stranicu s jednim komentarom najviše razine i 29 odgovora, te postavljenim page=0 u API-ju — dobit ćete samo komentar najviše razine i 29 djece.
3. Primjer slike koja ilustrira više stranica.
Kada koristite Flexible Pagination, možete definirati parametar parentId.
1. Postavite ga na null da biste dobili samo komentare najviše razine.
2. Zatim, za pregled niti, pozovite API ponovo i proslijedite parentId.
3. Uobičajeno rješenje je napraviti API poziv za komentare najviše razine i potom paralelne API pozive za dohvaćanje komentara za djecu svakog komentara.
NOVO od veljače 2023.! Dohvatite kao stablo koristeći &asTree=true.
1. Možete ovo promatrati kao Fleksibilno straničenje kao stablo.
2. Samo komentari najviše razine se računaju u straničenju.
3. Postavite parentId=null da započnete stablo u korijenu (morate postaviti parentId).
4. Postavite skip i limit za straničenje.
5. Postavite asTree na true.
6. Trošak kredita se povećava za 2x, jer naš backend mora obaviti puno više posla u ovom scenariju.
7. Po potrebi postavite maxTreeDepth, limitChildren i skipChildren.

Objašnjenje stabala

Kod korištenja asTree, može biti teško razmišljati o straničenju. Evo korisne grafike:

Dijagram straničenja stabla

Dohvaćanje komentara u kontekstu korisnika

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

Za vraćanje komentara sortiranih i označenih informacijama za izgradnju vlastitog klijenta.
- U tom slučaju definirajte upitni parametar contextUserId.
Za dohvaćanje komentara iz vašeg backend-a za prilagođene integracije.
- Platforma će prema zadanim postavkama koristiti ovo bez contextUserId.

Prethodno izračunato straničenje 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'

Fleksibilno straničenje 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'

Fleksibilno straničenje 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'

Fleksibilno straničenje komentara u kontekstu korisnika samo za komentare najviše razine

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'

Dohvati komentare kao stablo

Moguće je dobiti komentare vraćene kao stablo, pri čemu se straničenje računa samo za komentare najviše razine.

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 li dobiti samo komentare najviše razine i neposrednu djecu? Evo jednog načina:

Komentari kao stablo s maksimalnom dubinom

Copy

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

Međutim, u vašem UI-ju možda ćete trebati znati treba li pokazati gumb "prikaži odgovore" na svakom komentaru. Kada dohvaćate komentare putem stabla, postoji svojstvo hasChildren dodano komentarima kada je primjenjivo.

Dohvaćanje komentara kao stabla, pretraživanje po hashtag-u

Moguće je pretraživati po hashtag-u koristeći API, preko cijelog vašeg tenanta (nije ograničeno na jednu stranicu ili urlId).

U ovom primjeru izostavljamo urlId, i pretražujemo po više hashtagova. API će vratiti samo komentare koji imaju sve tražene hashtagove.

Komentari kao stablo u kontekstu korisnika, po hashtag-u

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 zahtjeva

Struktura zahtjeva za komentare

Copy

interface CommentsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** urlId (URL stranice ili id članka) s kojim su komentari povezani. **/
    urlId?: string
    /** Ograniči komentare koji se vraćaju za ovog korisnika. **/
    userId?: string
    /** Koristite ovo za pretraživanje po hashtag-u. Za sužavanje na presjek više hashtagova koristite &hashTag=a&hashTag=b. **/
    hashTag?: string
    /** Smjer sortiranja. Zadano je MR (Najrelevantnije). Ostale opcije su OF (Najstariji prvi) i NF (Najnoviji prvi). **/
    direction?: 'MR' | 'OF' | 'NF'
    /** Prethodno izračunato straničenje: Stranica za dohvat, počinje od 0. Proslijedite -1 za sve komentare (do 250). **/
    page?: number
    /** Fleksibilno straničenje: Koliko komentara treba vratiti? **/
    limit?: number
    /** Fleksibilno straničenje: Koliko dječjih komentara treba vratiti za svaki roditeljski komentar? **/
    limitChildren?: number
    /** Fleksibilno straničenje: Koliko komentara treba preskočiti? **/
    skip?: number
    /** Fleksibilno straničenje: Koliko dječjih komentara treba preskočiti za svaki roditeljski komentar? **/
    skipChildren?: number
    /** Za određivanje blokiranih i prijavljenih komentara. **/
    contextUserId?: string
    /** Za određivanje blokiranih i prijavljenih komentara. **/
    anonUserId?: string
    /** Za dohvaćanje dječjih komentara. **/
    parentId?: string
    /** Za dohvaćanje kao stablo. **/
    asTree?: boolean
    /** Koliko duboko u stablu treba vratiti podatke? 0 ne vraća djecu. 1 vraća neposrednu djecu, itd. **/
    maxTreeDepth?: number
}

Odgovor

Struktura odgovora za komentare

Copy

interface CommentsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    /** Komentari! **/
    comments: Comment[]
}

Korisni savjeti

URL ID

Vjerojatno želite koristiti Comment API s parametrima urlId. Možete prvo pozvati Pages API da vidite kako izgledaju dostupne vrijednosti urlId.

Anonimne radnje

Za anonimno komentiranje vjerojatno želite proslijediti anonUserId pri dohvaćanju komentara, kao i pri prijavljivanju i blokiranju.

(!) Ovo je zahtjev za mnoge trgovine aplikacija jer korisnici moraju moći prijaviti sadržaj koji su korisnici stvorili i koji mogu vidjeti, čak i ako nisu prijavljeni. Nepoštivanje toga može uzrokovati uklanjanje vaše aplikacije iz navedene trgovine.

Komentari se ne vraćaju

Provjerite jesu li 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ćuje dohvat jednog komentara prema ID-u.

Primjer cURL zahtjeva za dohvat 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 zahtjeva za dohvat komentara po ID-u

Copy

interface CommentsGetByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za dohvat komentara po ID-u

Copy

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

POST /api/v1/comments

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

This API endpoint provides the ability to create comments.

Common use cases are custom UIs, integrations, or imports.

Notes:

This API can update the comment widget "live" if desired (this increases creditsCost from 1 to 2).
This API will automatically create user objects in our system if email is provided.
Trying to save two comments with different emails, but the same username, will result in an error for the second comment.
If you are specifying parentId, and a child comment has notificationSentForParent as false, we will send notifications for the parent comment. This is done every hour (we batch the notifications together to decrease the number of emails sent).
If you want to send welcome emails when creating users, or comment verification emails, set sendEmails to true in query parameters.
Comments created via this API will show up in the Analytics and Moderation pages of the admin app.
"bad words" are still masked in the commenter names and comment text if the setting is turned on.
Comments created via this API can still be checked for spam if desired.
Configuration such as max comment length, if configured via the Customization Rule admin page, will apply here.

The minimum data required to submit that will show in the comment widget, is as follows:

Minimalni primjer POST cURL zahtjeva 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
}'

A more realistic request may look like:

Primjer POST cURL zahtjeva 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 zahtjeva za komentar

Copy

interface CommentPostQueryParams {
    tenantId: string
    API_KEY: string
    doSpamCheck?: 'true' | 'false'
    /** Treba li komentar biti vidljiv "uživo" korisnicima koji gledaju instance widgeta komentara s istim urlId-om. NAPOMENA: Udvostručuje trošak kredita s 1 na 2. **/
    isLive?: 'true' | 'false'
    sendEmails?: 'true' | 'false'
    populateNotifications?: 'true' | 'false'
}

Struktura POST odgovora za komentar

Copy

interface CommentPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    /** Stvoreni komentar. **/
    comment?: Comment
    /** Povezani korisnik, koji je možda već postojao ili nije. **/
    user?: User
}

PATCH /api/v1/comments/:id

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

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

Napomene:

Ovaj API može ažurirati widget komentara "uživo" ako želite (to povećava osnovni creditsCost s 1 na 2).
- To može učiniti migraciju komentara između stranica "uživo" (promjenom urlId).
- Migracije koštaju dodatna 2 kredita jer se stranice prethodno izračunavaju i to je CPU-intenzivno.
Za razliku od create API-ja, ovaj API NEĆE automatski kreirati korisničke objekte u našem sustavu ako je naveden email.
Komentari ažurirani putem ovog API-ja i dalje se mogu provjeriti na spam ako želite.
Konfiguracije poput maksimalne duljine komentara, ako su postavljene putem stranice administracije Customization Rule, primjenjuju se ovdje.
Da biste omogućili korisnicima ažuriranje teksta komentara, možete jednostavno navesti comment u tijelu zahtjeva. Mi ćemo generirati rezultirajući commentHTML.
- Ako definirate oba comment i commentHTML, nećemo automatski generirati HTML.
- Ako korisnik u svom novom tekstu doda spominjanja ili hashtagove, oni će se i dalje obraditi kao kod POST API-ja.
Pri ažuriranju commenterEmail na komentaru, najbolje je također navesti userId. Inače morate osigurati da korisnik s tim emailom pripada vašem tenantu, inače će zahtjev biti odbijen.

Minimalni primjer cURL PATCH zahtjeva za komentar

Copy

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

Struktura PATCH zahtjeva za komentar

Copy

interface CommentPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Korisnik koji vrši ažuriranje. Po želji se može koristiti za provjeru mogu li urediti komentar.  **/
    contextUserId?: string
    /** Trebamo li provjeriti izgleda li novi komentar kao spam?  **/
    doSpamCheck?: 'true' | 'false'
    /** Treba li komentar biti prikazan "uživo" korisnicima koji pregledavaju instance widgeta komentara s istim urlId. NAPOMENA: udvostručuje trošak kredita s 1 na 2. **/
    isLive?: 'true' | 'false'
}

Struktura odgovora PATCH zahtjeva za komentar

Copy

interface CommentPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    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 pri neuspjehu. **/
    reason?: string
}

DELETE /api/v1/comments/:id

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

Ova API krajnja točka pruža mogućnost brisanja komentara.

Napomene:

Ovaj API može ažurirati widget za komentare "uživo" ako je potrebno (ovo povećava creditsCost s 1 na 2).
Ovaj API će izbrisati sve podređene komentare.

Primjer cURL za DELETE 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 zahtjeva za DELETE komentara

Copy

interface CommentDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** The user doing the update. If desired can be used to check that they can delete the comment.  **/
    contextUserId?: string
    /** Whether the comment should be deleted "live" to users viewing instances of the comment widget with the same urlId. NOTE: Doubles credit cost from 1 to 2. **/
    isLive?: 'true' | 'false'
}

Struktura odgovora za DELETE komentara

Copy

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

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

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

Ova API krajnja točka pruža mogućnost označavanja komentara za određenog korisnika.

Napomene:

Ovaj poziv se uvijek mora izvršiti u kontekstu korisnika. Korisnik može biti FastComments.com korisnik, SSO korisnik ili korisnik stanara.
Ako je postavljen prag za skrivanje označavanjem, komentar će automatski biti skriven uživo nakon što je označen definirani broj puta.
Nakon što je automatski skriven (neodobren) - komentar može ponovno odobriti samo administrator ili moderator. Uklanjanje oznake neće ponovno odobriti komentar.

Primjer cURL 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ćuje podršku za označavanje i uklanjanje oznake s komentara čak i ako korisnik nije prijavljen. Na taj način, komentar može biti označen kao označen kada se komentari dohvaćaju s istim anonUserId.

Primjer cURL 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 zahtjeva 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'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id'
    /** Included on failure. **/
    reason?: string
    /** Was the comment un-approved (hidden) due to being flagged too many times? **/
    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 pruža mogućnost uklanjanja označavanja (un-flag) komentara za određenog korisnika.

Napomene:

Ovaj poziv uvijek se mora izvršiti u kontekstu korisnika. Korisnik može biti FastComments.com User, SSO User, ili Tenant User.
Nakon što je komentar automatski odbijen (sakriven) - komentar može ponovno odobriti samo administrator ili moderator. Uklanjanje oznake (un-flagging) neće ponovno odobriti komentar.

Primjer cURL zahtjeva za 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čni UUID.

Primjer cURL zahtjeva za 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

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

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

Ova API krajnja točka pruža mogućnost blokiranja korisnika koji je napisao dani komentar. Podržava blokiranje iz komentara koje su napisali FastComments.com korisnici, SSO korisnici i korisnici stanara.

Podržava parametar tijela commentIdsToCheck za provjeru treba li bilo koji drugi potencijalno vidljivi komentari na klijentu biti blokirani/odblokirani nakon izvršenja ove radnje.

Napomene:

Ovaj poziv se uvijek mora izvršiti u kontekstu korisnika. Korisnik može biti FastComments.com korisnik, SSO korisnik ili korisnik stanara.
userId u zahtjevu je korisnik koji vrši blokiranje. Na primjer: Korisnik A želi blokirati Korisnika B. Proslijedite userId=Korisnik A i ID komentara koji je napisao Korisnik B.
Potpuno anonimni komentari (bez ID-a korisnika, bez e-pošte) ne mogu se blokirati i bit će vraćena pogreška.

Primjer cURL 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. Ovo može biti ID koji predstavlja anonimnu sesiju ili nasumični UUID. Ovo nam omogućuje podršku za blokiranje komentara čak i ako korisnik nije prijavljen dohvaćanjem komentara s istim anonUserId.

Primjer cURL za anonimno blokiranje 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 zahtjeva 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'
    /** Included on failure. **/
    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'
    /** Included on failure. **/
    reason?: string
    /** If commentIdsToCheck is defined, entries in this map with true are also blocked. **/
    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ćuje deblokiranje korisnika koji je napisao određeni komentar. Podržava deblokiranje komentara koje su napisali FastComments.com korisnici, SSO korisnici i Tenant korisnici.

Podržava body parametar commentIdsToCheck za provjeru trebaju li nakon ove radnje biti blokirani/deblokirani neki drugi potencijalno vidljivi komentari na klijentu.

Napomene:

Ovaj poziv uvijek se mora izvršiti u kontekstu korisnika. Korisnik može biti FastComments.com korisnik, SSO korisnik ili Tenant korisnik.
The userId in the request is the user that is doing the un-blocking. For example: User A wants to Un-Block User B. Pass userId=User A and the comment id that User B wrote.
Potpuno anonimni komentari (bez ID-a korisnika, bez e-maila) ne mogu biti blokirani i bit će vraćena pogreška.

Primjer cURL zahtjeva za deblokiranje 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'

Primjer cURL zahtjeva za deblokiranje 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 zahtjeva za deblokiranje komentara

Copy

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

Struktura odgovora za deblokiranje komentara

Copy

interface CommentUnBlockResponse {
    status: 'success' | 'failed'
    /** Uključeno kod neuspjeha. **/
    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 kod neuspjeha. **/
    reason?: string
    /** Ako je commentIdsToCheck definiran, unosi u ovoj mapi s vrijednošću true i dalje su blokirani. Ako su false, možda ćete htjeti ponovno prikazati komentare korisniku kako se ne bi morali osvježavati. **/
    commentStatuses?: Record<string, boolean>;
}

Struktura predloška e-pošte

Objekt EmailTemplate predstavlja konfiguraciju za prilagođeni predložak e-pošte za zakupnika.

Sustav će odabrati predložak e-pošte za upotrebu putem:

Njegovog identifikatora tipa, koji nazivamo emailTemplateId. To su konstante.
Polja domain. Najprije ćemo pokušati pronaći predložak za domenu s kojom je povezani objekt (poput Comment) povezan, a ako se podudaranje ne pronađe tada ćemo pokušati pronaći predložak gdje je domain null ili *.

Struktura objekta EmailTemplate je sljedeća:

Struktura predloška e-pošte

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
    /** Domena s kojom bi predložak trebao biti povezan. **/
    domain?: string | '*' | null
    /** Sadržaj predloška e-pošte u EJS sintaksi. **/
    ejs: string
    /** Mapa zamjenskih prijevoda (ključ → vrijednost) za svaku podržanu lokalizaciju. **/
    translationOverridesByLocale: Record<string, Record<string, string>>
    /** Objekt koji predstavlja kontekst za renderiranje predloška. **/
    testData: object
}

Bilješke

Valjane vrijednosti emailTemplateId možete dobiti s endpointa /definitions.
Endpoint /definitions također uključuje zadane prijevode i testne podatke.
Predlošci će propasti pri spremanju ako struktura ili testni podaci nisu valjani.

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

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

Pojedinačne EmailTemplates mogu se dohvatiti prema njihovom odgovarajućem id-u (NE emailTemplateId).

Primjer cURL zahtjeva za EmailTemplate prema ID-u

Copy

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

Struktura zahtjeva za EmailTemplate prema ID-u

Copy

interface EmailTemplatesByIdRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za EmailTemplate prema ID-u

Copy

interface EmailTemplateResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    code?: 'internal' | 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    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, zadanu parametrom upita page. EmailTemplates se vraćaju u stranicama po 100, poredane prema createdAt, a zatim prema id.

Primjer cURL zahtjeva za EmailTemplate

Copy

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

Struktura zahtjeva za EmailTemplate

Copy

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

Struktura odgovora za EmailTemplate

Copy

interface EmailTemplatesResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspjeha. **/
    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ćuje ažuriranje predloška e-pošte tako da se navede samo id i atributi koje treba ažurirati.

Imajte na umu da vrijede ista pravila validacije kao i pri stvaranju predloška, na primjer:

Predložak se mora renderirati. To se provjerava pri svakom ažuriranju.
Ne možete imati duplicirane predloške za istu domenu (inače bi jedan bio tiho ignoriran).

EmailTemplate PATCH primjer cURL-a

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",
}'

EmailTemplate PATCH Struktura zahtjeva

Copy

interface EmailTemplatePatchQueryParams {
    tenantId: string
    API_KEY: string
}

EmailTemplate PATCH Struktura odgovora

Copy

interface EmailTemplatePatchResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    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 pri neuspjehu. **/
    reason?: string
    /** Ažurirani predložak e-pošte. **/
    emailTemplate?: EmailTemplate
}

POST /api/v1/email-templates

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

Ovaj API endpoint omogućuje kreiranje predložaka e-pošte.

Bilješke:

Ne možete imati više predložaka s istim emailTemplateId za istu domenu.
Međutim, možete imati univerzalni predložak (domain = *) i predložak specifičan za domenu za isti emailTemplateId.
Navođenje domain ima smisla samo ako imate različite domene ili želite koristiti specifične predloške za testiranje (domain postavljen na localhost itd.).
Ako navedete domain, mora odgovarati DomainConfig. U slučaju greške daje se popis valjanih domena.
Sintaksa predloška je EJS i renderira se s timeoutom od 500 ms. P99 za renderiranje je <5 ms, tako da ako dosegnete 500 ms nešto nije u redu.
Vaš predložak mora renderirati s danim testData da bi se spremio. Greške pri renderiranju se agregiraju i prikazuju u nadzornoj ploči (uskoro dostupno putem API-ja).

Minimalni podaci potrebni za dodavanje predloška su sljedeći:

Minimalni EmailTemplate POST cURL primjer

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 htjeti imati predloške po web-mjestu, u kojem slučaju definirate domain:

EmailTemplate POST cURL primjer

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 zahtjeva

Copy

interface EmailTemplatePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura EmailTemplate POST odgovora

Copy

interface EmailTemplatePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    /** Kreirani predložak. **/
    emailTemplate?: EmailTemplate
}

POST /api/v1/email-templates/render

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

Ovaj API endpoint omogućuje pregled predložaka e-pošte.

Minimalni cURL primjer za POST 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'unexpected-param' | 'does-not-render';
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    /** Renderirani HTML u slučaju uspjeha. **/
    html?: string
}

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

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

Ova ruta omogućuje uklanjanje jednog EmailTemplate po id-u.

Primjer cURL zahtjeva za uklanjanje EmailTemplate

Copy

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

Struktura zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
}

Struktura hashtagova

Objekt HashTag predstavlja oznaku koju može ostaviti korisnik. HashTagovi se mogu koristiti za povezivanje na vanjski sadržaj ili za povezivanje srodnih komentara.

Struktura za objekt HashTag je sljedeća:

Struktura HashTag-a

Copy

interface HashTag {
    /** Treba počinjati znakom "#" ili željenim znakom. **/
    tag: string
    /** Opcionalni URL na koji hashtag može pokazivati. Umjesto filtriranja komentara po hashtag-u, korisničko sučelje će pri kliku preusmjeriti na ovu adresu. **/
    url?: string
    /** SAMO ZA ČITANJE **/
    createdAt: string
}

Notes:

In some API endpoints you will see that the hashtag is used in the URL. Remember to URI-Encoded values. For example, # should instead be represented as %23.
Some of these fields are marked READONLY - these are returned by the API but cannot be set.

GET /api/v1/hash-tags

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

Ovaj API koristi paginaciju, koju osigurava query parametar page. HashTagovi se vraćaju po 100 po stranici, poredani po tag.

HashTag cURL primjer

Copy

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

Struktura zahtjeva za HashTag

Copy

interface HashTagsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Stranica koju treba dohvatiti, počinje od 0. **/
    page: number
}

Struktura odgovora za HashTag

Copy

interface HashTagsResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Included on failure. **/
    reason?: string
    /** Hashtagovi! **/
    hashTags: HashTag[]
}

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

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

Ova ruta omogućuje ažuriranje pojedinačnog HashTag-a.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    hashTag?: HashTag; // Vraćamo kompletno ažurirani hashtag u slučaju uspjeha.
}

POST /api/v1/hash-tags

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

Ova ruta omogućuje dodavanje jednog HashTag.

Primjer cURL zahtjeva za stvaranje HashTaga

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 zahtjeva za stvaranje HashTaga

Copy

interface HashTagPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za stvaranje HashTaga

Copy

interface HashTagPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    hashTag?: HashTag; // Vraćamo kompletan kreirani hashtag u slučaju uspjeha.
}

POST /api/v1/hash-tags/bulk

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

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

Primjer cURL zahtjeva za masovno stvaranje HashTagova

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 zahtjeva za masovno stvaranje HashTagova

Copy

interface HashTagPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za masovno stvaranje HashTagova

Copy

interface HashTagBulkPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    results?: HashTagPostResponse[]; // Vraćamo popis objekata HashTagPostResponse za svaki dostavljeni tag.
}

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

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

Ova ruta omogućuje uklanjanje HashTag korisnika pomoću zadanog taga.

Imajte na umu da, osim ako automatsko stvaranje HashTag nije onemogućeno, hashtagovi se mogu ponovno stvoriti ako korisnik unese hashtag pri komentiranju.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

Struktura moderatora

Objekt Moderator predstavlja konfiguraciju za moderatora.

Postoje tri vrste moderatora:

Korisnici administratorske uloge koji imaju oznaku isCommentModeratorAdmin.
SSO korisnici s oznakom isCommentModeratorAdmin.
Obični komentatori, odnosno korisnici FastComments.com-a, koji su pozvani kao Moderatori.

Struktura Moderator koristi se za prikaz stanja moderiranja za slučaj upotrebe 3.

Ako želite pozvati korisnika da postane moderator putem API-ja, upotrijebite Moderator API stvaranjem Moderator i inviting njih.

Ako korisnik nema račun na FastComments.com, e‑poruka s pozivnicom pomoći će im pri postavljanju računa. Ako već imaju račun, dobit će pristup moderiranju vašem tenantu i svojstvo userId na objektu Moderator bit će ažurirano tako da pokazuje na njihovog korisnika. Nećete imati API pristup njihovom korisničkom računu, jer u tom slučaju on pripada njima i upravlja ga FastComments.com.

Ako vam je potrebna potpuna kontrola nad korisničkim računom, preporučujemo ili korištenje SSO-a, ili dodavanje korisnika kao Korisnik tenanta i potom dodavanje Moderator objekta za praćenje njihovih statistika.

Struktura Moderator može se koristiti kao mehanizam za praćenje statistike za slučajeve upotrebe 1 i 2. Nakon stvaranja korisnika, dodajte Moderator objekt s definiranim userId i njihove će statistike biti praćene na Stranica moderatora komentara.

Struktura objekta Moderator je sljedeć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 prema njihovom ID-u.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    moderator?: Moderator
}

GET /api/v1/moderators

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

Ovaj API koristi paginaciju, koju pruža query parametar skip. Moderatori se vraćaju u stranicama po 100, poredani po createdAt i id.

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

Primjer cURL zahtjeva za Moderator

Copy

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

Struktura zahtjeva za Moderator

Copy

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

Struktura odgovora za Moderator

Copy

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

PATCH /api/v1/moderators/:id

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

This API endpoint provides the ability to update a Moderator by id.

Updating a Moderator has the following restrictions:

The following values may not be provided when updating a Moderator:
- acceptedInvite
- markReviewedCount
- deletedCount
- markedSpamCount
- approvedCount
- editedCount
- bannedCount
- verificationId
- createdAt
When a userId is specified, that user must exist.
When a userId is specified, they must belong to the same tenantId specified in query params.
Two moderators in the same tenant cannot be added with the same email.
You may not change the tenantId associated with a Moderator.

Moderator PATCH cURL Primjer

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",
}'

Moderator PATCH Struktura zahtjeva

Copy

interface ModeratorPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Moderator PATCH Struktura odgovora

Copy

interface ModeratorPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

POST /api/v1/moderators

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

Ova ruta omogućuje dodavanje jednog Moderator.

Kreiranje Moderator ima sljedeća ograničenja:

Obavezno je navesti name i email. userId je neobavezno.
Sljedeće vrijednosti se ne smiju navoditi pri stvaranju Moderator:
- acceptedInvite
- markReviewedCount
- deletedCount
- markedSpamCount
- approvedCount
- editedCount
- bannedCount
- verificationId
- createdAt
Ako je naveden userId, taj korisnik mora postojati.
Ako je naveden userId, mora pripadati istom tenantId navedenom u parametrima upita.
Dva moderatora unutar istog tenanta ne mogu biti dodana s istim email.

Možemo stvoriti Moderator za korisnika za kojeg znamo samo email:

Primjer cURL zahtjeva za stvaranje Moderator-a putem e-pošte

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 stvoriti Moderator za korisnika koji pripada našem tenantu, kako bismo pratili njihove statistike moderiranja:

Primjer cURL zahtjeva za stvaranje Moderator-a putem korisnika iz tenanta

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 zahtjeva za stvaranje Moderator-a

Copy

interface ModeratorPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za stvaranje Moderator-a

Copy

interface ModeratorPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    moderator?: Moderator; // Vraćamo kompletno kreiranog moderatora u slučaju uspjeha.
}

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

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

Ovaj endpoint omogućuje slanje pozivnice jednom Moderatoru.

Sljedeća ograničenja vrijede za slanje pozivnice e-poštom Moderatoru:

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

Napomene:

Ako korisnik s navedenom e-poštom već postoji, bit će pozvan da moderira komentare vašeg tenanta.
Ako korisnik s navedenom e-poštom ne postoji poveznica za pozivnicu će ih voditi kroz stvaranje njihovog računa.
Pozivnica će isteći nakon 30 days.

Možemo stvoriti Moderator za korisnika za kojeg znamo samo e-poštu:

Primjer cURL pozivnice za Moderatora

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'

This will send an email like Bob at TenantName is inviting you to be a moderator...

Struktura zahtjeva za pozivnicu Moderatora

Copy

interface ModeratorSendInviteQueryParams {
    tenantId: string
    API_KEY: string
    /** E-pošta poslana korisniku prikazivat će se kao da je poslana s ovim imenom. **/
    fromName: string
}

Struktura odgovora na pozivnicu Moderatora

Copy

interface ModeratorSendInviteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

DELETE /api/v1/moderators/:id

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

Ovaj endpoint omogućuje uklanjanje Moderatora prema njegovom id-u.

Primjer cURL zahtjeva za uklanjanje Moderator-a

Copy

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

Struktura zahtjeva za uklanjanje Moderator-a

Copy

interface ModeratorDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje Moderator-a

Copy

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

Struktura broja obavijesti

Objekt NotificationCount predstavlja broj nepročitanih obavijesti i metapodatke za korisnika.

Ako nema nepročitanih obavijesti, za korisnika neće postojati NotificationCount.

NotificationCount objekti se stvaraju automatski i ne mogu se stvoriti putem API-ja. Također istječu nakon jedne godine.

Možete obrisati broj nepročitanih obavijesti korisnika brisanjem njihovog NotificationCount.

Struktura NotificationCount objekta je sljedeća:

Struktura NotificationCount objekta

Copy

interface NotificationCount {
    id: string // ID korisnika
    count: number
    createdAt: string // string datuma
    expireAt: string // string datuma
}

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 korisničkom ID-u. Kod SSO, korisnički ID je u formatu <tenant id>:<user id>.

Ako nema nepročitanih obavijesti, neće postojati NotificationCount - pa ćete dobiti 404.

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

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    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 jedan NotificationCount prema user id. With SSO, user id je u formatu <tenant id>:<user id>.

Ovo će očistiti broj nepročitanih obavijesti korisnika (crveni zvončić u widgetu za komentare će izblijediti i broj će nestati).

Primjer cURL zahtjeva za brisanje NotificationCount

Copy

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

Struktura zahtjeva za uklanjanje NotificationCount

Copy

interface NotificationCountDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje NotificationCount

Copy

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

Struktura obavijesti

Objekt Notification predstavlja obavijest za korisnika.

Notification objekti se stvaraju automatski i ne mogu se stvarati putem API-ja. Također istječu nakon jedne godine. Obavijesti se ne mogu izbrisati. Međutim, mogu se ažurirati postavljanjem viewed na false, i možete ih pretraživati po viewed.

Korisnik se također može odjaviti od obavijesti za određeni komentar postavljanjem optedOut u obavijesti na true. Možete se ponovno prijaviti postavljanjem na false.

Postoje različite vrste obavijesti - provjerite relatedObjectType i type.

Načini na koje se obavijesti stvaraju su prilično fleksibilni i mogu biti pokrenuti u mnogim scenarijima (pogledajte NotificationType).

Trenutno, postojanje Notification ne znači nužno da je e-pošta poslana ili bi trebala biti poslana. Umjesto toga, obavijesti se koriste za feed obavijesti i povezane integracije.

Struktura za Notification objekt izgleda ovako:

Struktura objekta Notification

Copy

enum NotificationObjectType {
    Comment = 0,
    Profile = 1,
    Tenant = 2
}
enum NotificationType {
    /** Ako vam je netko odgovorio. **/
    RepliedToMe = 0,
    /** Ako je netko odgovorio negdje u niti (čak i u pod-nitima) niti na kojoj ste komentirali. **/
    RepliedTransientChild = 1,
    /** Ako je vaš komentar dobio glas. **/
    VotedMyComment = 2,
    /** Ako je ostavljen novi komentar na korijenu stranice na koju ste pretplaćeni. **/
    SubscriptionReplyRoot = 3,
    /** Ako je netko komentirao vaš profil. **/
    CommentedOnProfile = 4,
    /** Ako imate privatnu poruku (DM). **/
    DirectMessage = 5,
    /** TrialLimits je samo za korisnike tenant-a. **/
    TrialLimits = 6,
    /** Ako ste bili @mentioned. **/
    Mentioned = 7
}
interface Notification {
    id: string
    tenantId: string
    /** With SSO, the user id is in the format `<tenant id>:<user id>`. **/
    userId?: string
    /** When working with SSO, you only have to worry about `userId`. **/
    anonUserId?: string
    /** urlId is almost always defined. It is only optional for tenant-level notifications, which are infrequent. **/
    urlId?: string
    /** URL is cached for quick navigation to the source of the notification. **/
    url?: string
    /** Page Title is cached for quick reading of notification source. **/
    pageTitle?: string
    relatedObjectType: NotificationObjectType
    /** For example, comment id. **/
    relatedObjectId: string
    viewed: boolean
    createdAt: string // string datuma
    type: NotificationType
    fromCommentId?: string
    fromVoteId?: string
    /** fromUserName and fromUserAvatarSrc are cached here for quick displaying of the notification. They are updated when the user is updated. **/
    fromUserName: string
    fromUserId: string
    fromUserAvatarSrc?: string
    /** Set this to true to stop getting notifications for this object. **/
    optedOut?: boolean
}

GET /api/v1/notifications

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

Ova ruta vraća najviše 30 Notification objekata sortiranih po createdAt, najnoviji prvi.

Možete filtrirati po userId. Kod SSO, ID korisnika ima format <tenant id>:<user id>.

Primjer cURL zahtjeva za nepročitane obavijesti 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 zahtjeva za obavijesti

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 ID-u izvornog komentara. **/
    fromCommentId?: string
    /** Filtriraj po pročitanom/nepročitanom. **/
    viewed?: 'true' | 'false'
    /** Filtriraj po tipu. **/
    type?: NotificationType
}

Struktura odgovora za obavijesti

Copy

interface NotificationsGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    notifications?: Notification[]
}

GET /api/v1/notifications/count

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

Ova ruta vraća objekt koji sadrži broj obavijesti u parametru count.

Sporija je od /notification-count/ i košta dvostruko više kredita, ali omogućava filtriranje po više dimenzija.

Možete filtrirati istim parametrima kao i endpoint /notifications, kao što je userId. S SSO-om, identifikator korisnika ima format <tenant id>:<user id>.

Primjer cURL zahtjeva: Broj nepročitanih obavijesti 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'

Primjer cURL zahtjeva: Broj nepročitanih obavijesti za 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 zahtjeva za broj obavijesti

Copy

interface NotificationCountGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Filtriraj po korisniku. **/
    userId?: string
    /** Filtriraj po urlId-u. **/
    urlId?: string
    /** Filtriraj po izvoru komentara. **/
    fromCommentId?: string
    /** Filtriraj po pročitano/nepročitano. **/
    viewed?: 'true' | 'false'
    /** Filtriraj po vrsti. **/
    type?: NotificationType
}

Struktura odgovora za broj obavijesti

Copy

interface NotificationCountGetResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    count?: number
}

PATCH /api/v1/notifications/:id

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

Ovaj API endpoint omogućuje ažuriranje Notification po id.

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

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

Primjer cURL PATCH zahtjeva 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 zahtjeva za Notification

Copy

interface NotificationPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Notification PATCH

Copy

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

Struktura stranice

Objekt Page predstavlja stranicu kojoj može pripadati više komentara. Ovaj odnos definira se pomoću urlId.

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

Struktura za objekt Page je sljedeća:

Struktura stranice

Copy

interface Page {
    id: string
    urlId: string
    url: string
    title?: string
    createdAt: string
    commentCount: number
    rootCommentCount: number
    /** Postavljanje ovog na null znači da svi SSO korisnici mogu vidjeti stranicu. Prazna lista znači da je zatvorena za sve korisnike. **/
    accessibleByGroupIds?: string[] | null
    /** Je li 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 s vašim računom. Ako želite detaljnije pretraživanje, obratite nam se.

Primjer cURL zahtjeva za stranice

Copy

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

Struktura zahtjeva za stranice

Copy

interface PagesRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za stranice

Copy

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

Koristan savjet

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

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

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

Pojedinačne stranice mogu se dohvatiti pomoću odgovarajućeg urlId. Ovo može biti korisno za pronalaženje naslova stranica ili broja komentara.

Primjer cURL zahtjeva za stranicu po URL ID-u

Copy

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

Struktura zahtjeva za stranicu po URL ID-u

Copy

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

Struktura odgovora za stranicu po URL ID-u

Copy

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

Koristan savjet

Zapamtite URI-enkodirati vrijednosti poput urlId.

PATCH /api/v1/pages/:id

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

Ova ruta omogućuje ažuriranje jedne Page. Odgovarajući komentari bit će ažurirani.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    user?: Page; // Vraćamo kompletno ažuriranu stranicu pri uspjehu.
}

Note

Neki parametri u objektu Page se automatski ažuriraju. To su brojači i atributi naslova. Brojače nije moguće ažurirati putem API-ja jer su to izračunate vrijednosti. title stranice može se postaviti putem API-ja, ali bit će prepisan ako se widget za komentare koristi na stranici s istim urlId i različitim naslovom stranice.

POST /api/v1/pages

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

Ovaj API endpoint omogućuje stvaranje stranica.

Uobičajen slučaj upotrebe je kontrola pristupa.

Napomene:

Ako ste komentirali u niti komentara, ili ste pozvali API za kreiranje Comment, već ste stvorili objekt Page! Možete ga pokušati dohvatiti putem /by-url-id Page rute, prosljeđujući isti urlId koji je proslijeđen widgetu za komentare.
Struktura Page sadrži neke izračunate vrijednosti. Trenutno su to commentCount i rootCommentCount. One se automatski popunjavaju i ne mogu se postaviti putem API-ja. Pokušaj postavljanja uzrokovat će da API vrati grešku.

Primjer cURL zahtjeva 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 POST zahtjeva za Page

Copy

interface PagePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za Page POST

Copy

interface PagePostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    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ćuje uklanjanje jedne stranice po id-u.

Imajte na umu da će interakcija s widgetom komentara za stranicu s istim urlId jednostavno neprimjetno ponovno stvoriti Page.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'page-does-not-exist'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
}

Struktura događaja webhooka na čekanju

A PendingWebhookEvent object predstavlja webhook događaj u redu koji je na čekanju.

PendingWebhookEvent objects se stvaraju automatski i ne mogu se ručno stvarati putem API-ja. Također istječu nakon jedne godine. Mogu se izbrisati, što uklanja zadatak iz reda.

Postoje različite vrste događaja - provjerite eventType (OutboundSyncEventType) i type (OutboundSyncType).

Uobičajen slučaj upotrebe ovog API-ja je implementacija prilagođenog nadzora. Možda ćete htjeti periodički pozivati endpoint /count kako biste provjeravali broj preostalih zadataka za zadane filtere.

Struktura objekta PendingWebhookEvent je sljedeća:

Struktura objekta PendingWebhookEvent

Copy

enum OutboundSyncEventType {
    Create: 0,
    Delete: 1,
    Update: 2
}
enum OutboundSyncType {
    /** Zadatak sinkronizacije specifičan za WordPress. **/
    WP: 0,
    Webhook: 1
}
interface PendingWebhookEvent {
    id: string
    /** ID komentara povezan s događajem. **/
    commentId: string
    /** Objekt komentara za događaj u trenutku događaja. Počeli smo ih dodavati u studenom 2023. **/
    comment: Comment
    /** Vanjski ID koji može biti povezan s komentarom. **/
    externalId: string | null
    createdAt: Date
    tenantId: string
    attemptCount: number
    /** Postavlja se prije prvog pokušaja i nakon svakog neuspjeha. **/
    nextAttemptAt: Date
    /** Je li ovo događaj stvaranja, brisanja ili ažuriranja... **/
    eventType: OutboundSyncEventType
    /** Vrsta sinkronizacije koju treba izvršiti (WordPress, poziv API-ja, itd.). **/
    type: OutboundSyncType
    /** Domena koja odgovara komentaru. Tu domenu koristimo za odabir API ključa. **/
    domain: string
    /** Zadnja pogreška koja se dogodila. Ovaj tip nije tipiziran i predstavlja "dump" onoga što se dogodilo. Obično sadrži objekt 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 popis neobrađenih webhook događaja u parametru pendingWebhookEvents.

Ovaj API koristi paginaciju, koju upravlja parametar skip. PendingWebhookEvents se vraćaju u stranicama po 100, poredane po createdAt od najnovijih prema najstarijima.

Primjer cURL zahtjeva za PendingWebhookEvent

Copy

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

Struktura zahtjeva za PendingWebhookEvent

Copy

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

Struktura odgovora za PendingWebhookEvent

Copy

interface PendingWebhookEventsGetResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Uključeno pri neuspjehu. **/
    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 objekt koji sadrži broj čekajućih webhook događaja u parametru count.

Možete filtrirati istim parametrima kao i krajnja točka /pending-webhook-events

Primjer cURL zahtjeva za broj PendingWebhookEvent

Copy

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

Struktura zahtjeva za broj PendingWebhookEvent

Copy

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

Struktura odgovora za broj PendingWebhookEvent

Copy

interface PendingWebhookEventsCountResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    count?: number
}

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

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

Ova ruta omogućuje brisanje jednog PendingWebhookEvent.

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

Primjer cURL DELETE zahtjeva za PendingWebhookEvent

Copy

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

Struktura zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

Struktura SSO korisnika

FastComments pruža jednostavno SSO rješenje. Ažuriranje korisničkih podataka s HMAC-integracijom je jednostavno kao da korisnik učita stranicu s ažuriranim payloadom.

Međutim, može biti poželjno upravljati korisnikom izvan tog tijeka, kako biste poboljšali konzistentnost vaše aplikacije.

SSO User API pruža način za CRUD objekata koje nazivamo SSOUsers. Ti su objekti različiti od običnih korisnika i držani su odvojeno radi sigurnosti tipova.

Struktura SSOUser objekta je sljedeć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 s ovom oznakom naplaćuju se kao SSO administratori (odvojeno od običnih SSO korisnika)
    isAdminAdmin?: boolean // Dozvola administratora - SSO korisnici s ovom oznakom naplaćuju se kao SSO administratori (odvojeno od običnih SSO korisnika)
    isCommentModeratorAdmin?: boolean // Dozvola moderatora - SSO korisnici s ovom oznakom naplaćuju se kao SSO moderatori (odvojeno od običnih SSO korisnika)
    /** Ako je null, Kontrola pristupa neće biti primijenjena na korisnika. Ako je prazna lista, ovaj korisnik neće moći vidjeti nijednu stranicu niti spominjati druge korisnike pomoću @. **/
    groupIds?: string[] | null
    createdFromSimpleSSO?: boolean
    /** Ne dopustite drugim korisnicima da vide aktivnost ovog korisnika, uključujući komentare, na njegovom profilu. Zadana vrijednost je true kako bi profili bili sigurni prema zadanim postavkama. **/
    isProfileActivityPrivate?: boolean
    /** Ne dopuštajte drugim korisnicima da ostavljaju komentare na korisnikov profil niti da vide postojeće komentare na profilu. Zadana vrijednost je false. **/
    isProfileCommentsPrivate?: boolean
    /** Ne dozvolite drugim korisnicima da šalju izravne poruke ovom korisniku. Zadana vrijednost je false. **/
    isProfileDMDisabled?: boolean
    karma?: number
    /** Opcionalna konfiguracija znački za korisnika. **/
    badgeConfig?: {
        /** Niz ID-eva znački koji će biti dodijeljeni korisniku. Ograničeno na 30 znački. Redoslijed se poštuje. **/
        badgeIds: string[]
        /** Ako je true, zamjenjuje sve postojeće prikazane značke s navedenima. Ako je false, dodaje se postojećim značkama. **/
        override?: boolean
        /** Ako je true, ažurira svojstva prikaza znački iz konfiguracije tenanta. **/
        update?: boolean
    }
}

Naplata za SSO korisnike

SSO korisnici se naplaćuju različito ovisno o njihovim oznakama dozvola:

Regular SSO Users: Korisnici bez administratorskih ili moderatorskih dozvola naplaćuju se kao regularni SSO korisnici
SSO Admins: Korisnici s oznakama isAccountOwner ili isAdminAdmin naplaćuju se odvojeno kao SSO administratori (ista stopa kao obični administratori tenanta)
SSO Moderators: Korisnici s oznakom isCommentModeratorAdmin naplaćuju se odvojeno kao SSO moderatori (ista stopa kao obični moderatori)

Važno: Kako bi se spriječilo dvostruko naplaćivanje, sustav automatski deduplikira SSO korisnike naspram običnih tenant korisnika i moderatora po e-mail adresi. Ako SSO korisnik ima istu e-mail adresu kao običan tenant korisnik ili moderator, neće biti naplaćeni dvaput.

Kontrola pristupa

Korisnici se mogu podijeliti u grupe. To je svrha polja groupIds, i ono je opcionalno.

@Mentions

Po defaultu @mentions će koristiti username za pretraživanje drugih SSO korisnika kada se upiše znak @. Ako se koristi displayName, rezultati koji odgovaraju username će biti zanemareni kada postoji podudaranje za displayName, te će rezultati pretraživanja @mention koristiti displayName.

Pretplate

S FastComments, korisnici se mogu pretplatiti na stranicu klikom na ikonu zvona u widgetu komentara i pritiskom na Pretplati se.

Kod običnog korisnika, šaljemo im obavijesti putem e-pošte na temelju njihovih postavki obavijesti.

Kod SSO korisnika, to razdvajamo radi kompatibilnosti s prethodnim verzijama. Korisnici će dobivati ove dodatne e-poruke o pretplati samo ako postavite optedInSubscriptionNotifications na true.

Značke

Možete dodijeliti značke SSO korisnicima koristeći svojstvo badgeConfig. Značke su vizualni indikatori koji se pojavljuju pored imena korisnika u komentarima.

badgeIds - Niz ID-eva znački koje treba dodijeliti korisniku. Moraju biti valjani ID-evi znački kreirani na vašem FastComments računu. Ograničeno na 30 znački.
override - Ako je true, sve postojeće značke prikazane u komentarima bit će zamijenjene navedenima. Ako je false ili izostavljeno, navedene značke će se dodati postojećim značkama.
update - Ako je true, svojstva prikaza znački bit će ažurirana iz konfiguracije tenanta svaki put kada se korisnik prijavi.

GET /api/v1/sso-users

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

Ova ruta vraća SSO korisnike u stranicama po 100. Paginacija se vrši pomoću parametra skip. Korisnici su sortirani po njihovom signUpDate i id.

SSOUsers cURL primjer

Copy

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

SSOUsers struktura zahtjeva

Copy

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

SSOUsers struktura odgovora

Copy

interface SSOUsersResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspjeha. **/
    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 prema njegovom id-u.

Primjer cURL zahtjeva 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 zahtjeva SSOUser

Copy

interface SSOUserRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora SSOUser

Copy

interface SSOUserByIdResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'user-does-not-exist'
    /** Uključeno pri neuspjehu. **/
    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

Ova ruta vraća jednog SSO korisnika prema njihovoj e-pošti.

Primjer cURL zahtjeva SSOUser po e-mailu

Copy

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

Struktura zahtjeva SSOUser

Copy

interface SSOUserRequestByEmailQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora SSOUser

Copy

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

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

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

Ova ruta omogućava ažuriranje jednog SSO korisnika.

Primjer cURL zahtjeva 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 zahtjeva za ažuriranje SSOUser

Copy

interface SSOUserPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Ako se promijeni email ili korisničko ime, možete ovo postaviti na true kako biste također ažurirali korisnikove komentare. 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    user?: SSOUser; // U slučaju uspjeha vraćamo potpuno ažuriranog korisnika.
}

POST /api/v1/sso-users

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

Ova ruta omogućuje kreiranje jednog SSO korisnika.

Pokušaj kreiranja dvaju korisnika s istim ID-om rezultirat će pogreškom.

Primjer cURL zahtjeva za kreiranje SSOUser

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 primjeru navodimo groupIds za kontrolu pristupa, ali to je opcionalno.

Struktura zahtjeva za kreiranje SSOUser

Copy

interface SSOUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za kreiranje SSOUser

Copy

interface SSOUserPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    user?: SSOUser; // Vraćamo kreiranog korisnika u slučaju uspjeha.
}

Napomena za integraciju

Podaci poslani putem API-ja mogu se prebrisati jednostavnim slanjem drugačijeg SSO User HMAC payloada. Na primjer, ako postavite korisničko ime putem API-ja, ali zatim proslijedite drugačije korisničko ime kroz SSO tok prilikom učitavanja stranice, automatski ćemo ažurirati njihovo korisničko ime.

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

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

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

Ova ruta omogućuje ažuriranje jednog SSO korisnika.

Primjer cURL zahtjeva za ažuriranje SSO korisnika

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 primjeru navodimo groupIds za kontrolu pristupa, ali to je neobavezno.

Struktura zahtjeva za ažuriranje SSO korisnika

Copy

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

Struktura odgovora za ažuriranje SSO korisnika

Copy

interface SSOUserPutResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    user?: SSOUser; // Na uspjehu vraćamo ažuriranog korisnika.
}

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

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

Ova ruta omogućuje uklanjanje pojedinog SSO korisnika prema njegovom id-u.

Imajte na umu da ponovno učitavanje widgeta komentara s podacima za ovog korisnika jednostavno će ponovno stvoriti korisnika bez poteškoća.

Brisanje korisnikovih komentara moguće je putem upitnog parametra deleteComments. Imajte na umu da ako je ovo istinito:

Svi korisnikovi komentari bit će izbrisani uživo.
Svi podređeni (sada bez roditelja) komentari bit će izbrisani ili anonimizirani ovisno o konfiguraciji stranice povezanoj sa svakim komentarom. Na primjer, ako je način brisanja niti "anonymize", tada će odgovori ostati, a korisnikovi komentari će biti anonimizirani. Ovo se primjenjuje samo kada je commentDeleteMode Remove (zadana vrijednost).
creditsCost postaje 2.

Anonimizirani komentari

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

Ako su korisnikovi komentari anonimizirani, sljedeće vrijednosti postaju null:

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

isDeleted i isDeletedUser postavljeni su na true.

Prilikom prikaza, widget komentara koristit će DELETED_USER_PLACEHOLDER (zadano: "[izbrisano]") za korisnikovo ime i DELETED_CONTENT_PLACEHOLDER za komentar. Ovo možete prilagoditi putem sučelja za prilagodbu widgeta.

Primjeri

Primjer cURL uklanjanja SSO korisnika

Copy

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

Struktura zahtjeva za uklanjanje SSO korisnika

Copy

enum SSOUserCommentDeleteMode {
    Remove = 0, // zadano
    Anonymize = 1
}
interface SSOUsersDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** Možete postaviti ovo na true da također izbrišete korisnikove komentare. Ovo će udvostručiti trošak kredita. **/
    deleteComments?: 'true' | 'false'
    /** Možete ovo postaviti po želji kako biste odredili kako postupati s korisnikovim komentarima. **/
    commentDeleteMode?: SSOUserCommentDeleteMode
}

Struktura odgovora za uklanjanje SSO korisnika

Copy

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

Struktura pretplate

Objekt Subscription predstavlja pretplatu za korisnika.

Subscription objekti se stvaraju kada korisnik klikne ikonu za obavijest u widgetu komentara i klikne "Pretplati se na ovu stranicu".

Pretplate se također mogu stvoriti putem API-ja.

Posjedovanje objekta Subscription uzrokuje generiranje objekata Notification i slanje e-poruka kada se ostave novi komentari na korijenu pridružene stranice na koju se odnosi Subscription. Slanje e-poruka ovisi o tipu korisnika. Za obične korisnike to ovisi o optedInNotifications. Za SSO korisnike to ovisi o optedInSubscriptionNotifications. Imajte na umu da neke aplikacije možda nemaju koncept web-pristupačne stranice, u kojem slučaju jednostavno postavite urlId na id stavke na koju se pretplaćujete (ista vrijednost za urlId koju biste proslijedili widgetu komentara).

The structure for the Subscription object is as follows:

Struktura objekta Subscription

Copy

interface Subscription {
    id: string
    tenantId: string
    /** SSO: korisnički 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

Ovaj endpoint vraća do 30 Subscription objekata sortirano po createdAt, najnoviji prvi.

Možete filtrirati po userId. Kod SSO-a, korisnički id ima format <tenant id>:<user id>.

Pretplate za korisnika - primjer cURL zahtjeva

Copy

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

Struktura zahtjeva za pretplate

Copy

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

Struktura odgovora za pretplate

Copy

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

POST /api/v1/subscriptions

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

Ovaj API endpoint omogućuje stvaranje Subscription. Imajte na umu da korisnik može imati samo jednu pretplatu po stranici, jer su više nepotrebne, i pokušaj stvaranja više od jedne pretplate za istog korisnika na istoj stranici rezultirat će pogreškom.

Stvaranje pretplate rezultirat će stvaranjem objekata Notification kada se ostavi novi komentar na vrhu pretplaćenog urlId (kada je comment parentId null).

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unexpected-param' | 'unauthorized' | 'not-found';  
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
}

DELETE /api/v1/subscriptions/:id

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

Ova ruta briše jedan Subscription objekt po id-u.

Primjer cURL zahtjeva za uklanjanje pretplate

Copy

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

Struktura zahtjeva za uklanjanje pretplate

Copy

interface SubscriptionsDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje pretplate

Copy

interface SubscriptionDeleteResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

Struktura dnevne upotrebe najmoprimca

Objekt TenantDailyUsage predstavlja korištenje za tenant na određenom danu. Ako za određenog tenant-a na određen dan nije bilo aktivnosti, taj dan neće imati objekt TenantDailyUsage.

Objekt TenantDailyUsage nije u stvarnom vremenu i može zaostajati nekoliko minuta za stvarnom upotrebom.

Struktura za objekt TenantDailyUsage je sljedeć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
    /** Ignorirano za naplatu. **/
    ignored: boolean
}

GET /api/v1/tenant-daily-usage

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

Ova ruta omogućuje pretraživanje upotrebe tenant-a po godini, mjesecu i danu. Može se vratiti do 365 objekata, a trošak je 1 API kredit na svakih 10 objekata.

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

Primjer cURL pretrage 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 zahtjeva TenantDailyUsage

Copy

interface TenantDailyUsageQueryParams {
    tenantId: string
    API_KEY: string
    /** Temeljeno na UTC. **/
    yearNumber?: number
    /** Nula-bazirano. Temeljeno na UTC. **/
    monthNumber?: number
    /** Jedno-bazirano. Temeljeno na UTC. **/
    dayNumber?: number
}

Struktura odgovora TenantDailyUsage

Copy

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

Struktura najmoprimca

The Tenant definira korisnika FastComments.com. Mogu ih stvarati putem API-ja tenanti s pristupom za white labeling. Tenanti s bijelim označavanjem ne mogu stvarati druge tenante s bijelim označavanjem (dopuštena je samo jedna razina ugnježđivanja).

The structure for the Tenant object is as follows:

Struktura Tenanta

Copy

export enum SiteType {
    Unknown = 0,
    WordPress = 1
}
/** Ovo se također može obraditi putem DomainConfig API-ja. **/
export interface TenantDomainConfig {
    domain: string
    emailFromName?: string
    emailFromEmail?: string
    createdAt?: string,
    siteType?: FastCommentsSiteType, // vjerojatno želite Unknown
    logoSrc?: string, // sirova putanja slike
    logoSrc100px?: string, // promijenjena 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 razloga vezanih uz 'legacy'
    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 temelju packageId. **/
    hasFlexPricing?: boolean
    /** @readonly **/
    flexLastBilledAmount?: number
    /** @readonly - Izračunava se na temelju packageId. **/
    hasAuditing?: boolean
    /** Možete pohraniti par ključ-vrijednost s tenantom koji možete koristiti za upite. Ključevi ne smiju sadržavati "." ili "$", ili biti dulji od 100 znakova. Vrijednosti ne smiju biti dulje od 2k znakova. **/
    meta?: Record<string, string | null>
}

GET /api/v1/tenants/:id

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

Ovaj route vraća jednog Tenanta po id-u.

Primjer cURL zahtjeva 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 zahtjeva 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 pogreške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju pogreške. **/
    reason?: string
    tenant?: Tenant
}

GET /api/v1/tenants

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

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

Paginacija se obavlja pomoću query parametra skip. Tenants se vraćaju u stranicama po 100, sortirano po signUpDate i id.

Trošak se temelji na broju vraćenih tenants-a, iznosi 1 credit per 10 vraćenih tenants-a.

Primjer cURL zahtjeva za Tenant

Copy

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

Možete definirati meta parametre na Tenant objektima i upitom tražiti odgovarajuće tenants-e. Na primjer, za ključ someKey i meta vrijednost some-value, možemo konstruirati JSON objekt s tim parom ključ/vrijednost i onda ga URI enkodirati kao query parametar za filtriranje:

Primjer cURL upita za Tenant 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 zahtjeva za Tenant

Copy

interface TenantsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Broj tenants-a koje treba preskočiti za paginaciju. **/
    skip?: number
    /** Filtriraj po meta parametrima. **/
    meta?: string
}

Struktura odgovora za Tenant

Copy

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

POST /api/v1/tenants

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

Ova ruta omogućuje dodavanje jednog Tenant.

Kreiranje Tenant-a ima sljedeća ograničenja:

name je obavezno.
domainConfiguration je obavezno.
Sljedeće vrijednosti se ne smiju navesti prilikom kreiranja Tenant-a:
- hasFlexPricing
- lastBillingIssueReminderDate
- flexLastBilledAmount
signUpDate ne smije biti u budućnosti.
name ne smije biti duži od 200 characters.
email ne smije biti duži od 300 characters.
email mora biti jedinstven među svim tenantima FastComments.com.
Ne smijete kreirati tenante ako roditeljski tenant nema definirani valjani TenantPackage.
- Ako je vaš tenant kreiran putem FastComments.com, to ne bi trebao biti problem.
Ne smijete kreirati više tenant-a nego što je definirano u maxWhiteLabeledTenants u vašem paketu.
Morate navesti query parametar tenantId koji je id vašeg parent tenant-a s omogućenim white labelingom.

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

Primjer cURL zahtjeva 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 zahtjeva za kreiranje Tenant-a

Copy

interface TenantPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za kreiranje Tenant-a

Copy

interface TenantPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    tenant?: Tenant; // U slučaju uspjeha vraćamo kompletan stvoreni tenant.
}

PATCH /api/v1/tenants/:id

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

Ova krajnja točka API-ja omogućuje ažuriranje Tenant prema id.

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

Sljedeće vrijednosti se ne smiju ažurirati:
- hasFlexPricing
- lastBillingIssueReminderDate
- flexLastBilledAmount
- managedByTenantId
signUpDate ne smije biti u budućnosti.
name ne smije biti duže od 200 characters.
email ne smije biti duže od 300 characters.
email mora biti jedinstven među svim tenantima FastComments.com.
Kada se billingInfoValid postavi na true, billingInfo mora biti dostavljen u istom zahtjevu.
Ne smijete ažurirati packageId povezan s vašim vlastitim tenantom.
Ne smijete ažurirati paymentFrequency povezan s vašim vlastitim tenantom.

Primjer cURL PATCH 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    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 pridruženih podataka (korisnici, komentari, itd.) po id-u.

Sljedeća ograničenja vrijede za uklanjanje tenants:

Tenant mora biti vaš vlastiti, ili white labeled tenant kojeg upravljate.
Parametar upita sure mora biti postavljen na true.

Primjer cURL zahtjeva za uklanjanje Tenanta

Copy

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

Struktura zahtjeva za uklanjanje Tenanta

Copy

interface TenantDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora na uklanjanje Tenanta

Copy

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

Struktura paketa najmoprimca

The TenantPackage definira informacije o paketu dostupnom za Tenant. Tenant može imati mnogo dostupnih paketa, ali je u upotrebi samo jedan u određenom trenutku.

A Tenant se ne može koristiti za bilo koje proizvode dok njegov packageId ne pokazuje na valjani TenantPackage.

Postoje dvije vrste objekata TenantPackage:

Fixed-pricing packages - where hasFlexPricing is false.
Flexible pricing - where hasFlexPricing is true.

U oba slučaja ograničenja su definirana na računu koji koristi paket, međutim kod Flex-a tenant se naplaćuje osnovna cijena plus ono što je koristio, definirano parametrima flex*.

Tenant može imati više tenant paketa i mogućnost promjene paketa sami sa Stranica s informacijama o naplati.

Ako ćete sami voditi naplatu za tenante, i dalje ćete morati definirati paket za svaki tenant kako biste definirali njihova ograničenja. Jednostavno postavite billingHandledExternally na true na Tenant i oni neće moći sami mijenjati svoje podatke za naplatu ili aktivni paket.

Ne smijete kreirati pakete s većim ograničenjima nego što ima roditeljski tenant.

The structure for the TenantPackage object is as follows:

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 // Trošak po običnom SSO korisniku (bez administratorskih/moderatorskih dozvola)
    flexSSOUserUnit?: null
    flexAPICreditCostCents?: null
    flexAPICreditUnit?: null
    flexModeratorCostCents?: null
    flexModeratorUnit?: null
    flexAdminCostCents?: null
    flexAdminUnit?: null
    flexDomainCostCents?: null
    flexDomainUnit?: null
    flexSSOAdminCostCents?: null // Trošak po SSO korisniku s administratorskim pravima (zastavice isAccountOwner ili isAdminAdmin)
    flexSSOAdminUnit?: null
    flexSSOModeratorCostCents?: null // Trošak po SSO korisniku s moderatorskim pravima (zastavica isCommentModeratorAdmin)
    flexSSOModeratorUnit?: null
    flexMinimumCostCents?: null
}

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

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

Ova ruta vraća jedan Tenant Package prema ID-u.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    tenantPackage: TenantPackage
}

GET /api/v1/tenant-packages

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

Ovaj API koristi paginaciju, omogućenu pomoću upitnog parametra skip. TenantPackages se vraćaju u stranicama od 100, posložene po createdAt i id.

Trošak se temelji na broju vraćenih tenant paketa, a iznosi 1 credit per 10 vraćenih tenant paketa.

Primjer 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 zahtjeva TenantPackage

Copy

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

Struktura odgovora za TenantPackage

Copy

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

POST /api/v1/tenant-packages

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

Ova ruta omogućuje dodavanje jednog TenantPackage.

Kreiranje TenantPackage ima sljedeća ograničenja:

Sljedeć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.
name ne smije biti dulji od 50 characters.
Svaki unos forWhoText ne smije biti dulji od 200 characters.
Svaki unos featureTaglines ne smije biti dulji od 100 characters.
TenantPackage mora biti "manji" od roditeljskog tenanta. Na primjer, svi max* parametri moraju imati niže vrijednosti od roditeljskog tenanta.
Tenanti s pristupom white labelingu mogu imati najviše pet paketa.
Samo tenanti s pristupom white labelingu mogu kreirati TenantPackage.
Ne smijete dodavati pakete svom vlastitom tenantu. :)

Možemo kreirati TenantPackage na sljedeći način:

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    tenantPackage?: TenantPackage; // Pri uspjehu vraćamo kompletan kreirani tenant paket.
}

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

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

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

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

Ako postavljate hasFlexPricing na true, tada su svi flex* parametri obavezni u tom istom zahtjevu.
name ne smije biti dulji od 50 characters.
Svaki unos forWhoText ne smije biti dulji od 200 characters.
Svaki unos featureTaglines ne smije biti dulji od 100 characters.
TenantPackage mora biti "manji" od roditeljskog tenanta. Na primjer, svi max* parametri moraju imati niže vrijednosti od roditeljskog tenanta.
Ne smijete mijenjati tenantId povezan s TenantPackage.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

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

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

Ovaj endpoint omogućuje uklanjanje TenantPackage po id-u.

Ne možete ukloniti TenantPackage koji je u upotrebi (tenantov packageId pokazuje na paket). Najprije ažurirajte Tenant.

Primjer cURL zahtjeva za uklanjanje TenantPackage

Copy

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

Struktura zahtjeva za uklanjanje TenantPackage

Copy

interface TenantPackageDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje TenantPackage

Copy

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

Struktura korisnika najmoprimca

The TenantUser definira User kojeg upravlja određeni tenant. Račun tog korisnika je u potpunoj kontroli tena kojem je pridružen te se račun može ažurirati ili izbrisati putem UI ili API-ja.

Korisnici koje upravlja tenant mogu biti administratori s punim dopuštenjima i pristupom Tenantu, ili mogu imati ograničena dopuštenja za moderiranje komentara, pristup API ključevima itd.

The structure for the TenantUser object is as follows:

Struktura objekta TenantUser

Copy

/** Ovo je za obavijesti. **/
export enum UserDigestEmailFrequency {
    Disabled = -1,
    Daily = 0,
    Weekly = 1,
    Monthly = 2
}
export interface TenantUser {
    id: string
    tenantId: string
    username: string
    /** Poveznica na blog komentatora, na primjer. **/
    websiteUrl?: string
    email: string
    signUpDate: number
    createdFromUrlId: string
    createdFromTenantId: string
    verified: boolean
    loginCount: number
    optedInNotifications: boolean
    optedInTenantNotifications: boolean
    hideAccountCode: boolean
    avatarSrc?: string
    /** Prima li korisnik zahtjeve 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

Ova ruta vraća jednog TenantUser po id.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    tenantUser?: TenantUser
}

GET /api/v1/tenant-users

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

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

Trošak se temelji na broju vraćenih tenant users; iznosi 1 credit per 10 vraćenih tenant users.

Primjer cURL zahtjeva za TenantUser

Copy

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

Struktura zahtjeva TenantUser

Copy

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

Struktura odgovora TenantUser

Copy

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

POST /api/v1/tenant-users

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

Ova ruta omogućuje dodavanje jednog TenantUser.

Stvaranje TenantUser ima sljedeća ograničenja:

username je obavezan.
email je obavezan.
signUpDate ne smije biti u budućnosti.
locale mora biti na popisu Podržane lokalizacije.
username mora biti jedinstven na cijelom FastComments.com. Ako je to problem, preporučujemo korištenje SSO.
email mora biti jedinstven na cijelom FastComments.com. Ako je to problem, preporučujemo korištenje SSO.
Ne smijete stvoriti više tenant korisnika nego što je definirano pod maxTenantUsers u vašem paketu.

Možemo stvoriti TenantUser na sljedeći način

Primjer cURL zahtjeva za stvaranje TenantUser

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 zahtjeva za stvaranje TenantUser

Copy

interface TenantUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za stvaranje TenantUser

Copy

interface TenantUserPostResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    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 pri neuspjehu. **/
    reason?: string
    tenantUser?: TenantUser; // Vraćamo kompletno kreiranog tenant korisnika pri uspjehu.
}

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

Ovaj endpoint omogućuje slanje login poveznice (login link) pojedinom TenantUser-u.

Koristan kada masovno kreirate korisnike i ne želite objašnjavati kako da se prijave na FastComments.com. Ovo će im poslati "magic link" za prijavu koji istječe nakon 30 days.

Sljedeća ograničenja vrijede za slanje login poveznice TenantUser-u:

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

Primjer cURL zahtjeva za TenantUser login link

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 e-poštu poput Bob at TenantName is inviting you to be a moderator...

Struktura zahtjeva za TenantUser login link

Copy

interface TenantUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za TenantUser login link

Copy

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

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

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

Ova ruta omogućuje ažuriranje jednog TenantUser.

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

signUpDate ne smije biti u budućnosti.
locale mora biti na popisu Podržane lokalizacije.
username mora biti jedinstven na FastComments.com. Ako je to problem, predlažemo korištenje SSO umjesto toga.
email mora biti jedinstven na FastComments.com. Ako je to problem, predlažemo korištenje SSO umjesto toga.
Ne možete ažurirati tenantId korisnika.

Možemo stvoriti TenantUser na sljedeći način

Primjer cURL zahtjeva 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 zahtjeva za ažuriranje TenantUser

Copy

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

Struktura odgovora za ažuriranje TenantUser

Copy

interface TenantUserPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

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

Resource: TenantUser as DELETE /api/v1/tenant-users/:id Credit Cost: 5

Ova ruta omogućuje uklanjanje TenantUser po id-u.

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

Svi korisnikovi komentari bit će izbrisani odmah.
Svi child (sada siročad) komentari bit će izbrisani ili anonimizirani na temelju konfiguracije stranice povezane s pojedinim komentarom. Na primjer, ako je način brisanja threadova "anonymize", tada će odgovori ostati, a komentari korisnika će biti anonimizirani. Ovo se primjenjuje samo kada je commentDeleteMode Remove (zadana vrijednost).
creditsCost postaje 2.

Anonimizirani komentari

Možete zadržati komentare korisnika, ali ih jednostavno anonimizirati postavljanjem commentDeleteMode=1.

Ako su komentari korisnika anonimizirani, sljedeće vrijednosti se postavljaju na null:

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

isDeleted i isDeletedUser postavljeni su na true.

Prilikom prikaza, widget komentara koristit će DELETED_USER_PLACEHOLDER (zadano: "[deleted]") za ime korisnika i DELETED_CONTENT_PLACEHOLDER za sadržaj komentara. To se može prilagoditi putem sučelja za prilagodbu widgeta.

Primjeri

Primjer cURL zahtjeva za uklanjanje TenantUsera

Copy

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

Struktura zahtjeva za uklanjanje TenantUsera

Copy

enum TenantUserCommentDeleteMode {
    Remove = 0, // zadano
    Anonymize = 1
}
interface TenantUserDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** Možete postaviti ovo na true da biste također izbrisali komentare korisnika. To će udvostručiti trošak kredita. **/
    deleteComments?: 'true' | 'false'
    /** Možete ovo postaviti prema potrebi kako biste odredili kako postupati s komentarima korisnika. **/
    commentDeleteMode?: TenantUserCommentDeleteMode
}

Struktura odgovora za uklanjanje TenantUsera

Copy

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

Struktura korisnika

User je objekt koji predstavlja najčešći zajednički nazivnik svih korisnika.

Imajte na umu da u FastComments imamo nekoliko različitih slučajeva upotrebe za korisnike:

Secure SSO
Simple SSO
Tenant Users (Na primjer: Administratori)
Commenters

Ovaj API je za Komentatore i korisnike stvorene putem Simple SSO. U osnovi, svaki korisnik stvoren putem vaše stranice može se dohvatiti putem ovog API-ja. Tenant Users se također mogu dohvatiti na ovaj način, ali ćete dobiti više informacija interakcijom s /tenant-users/ API-jem.

Za Secure SSO molimo koristite /sso-users/ API.

Ne možete ažurirati ove vrste korisnika. Oni su kreirali svoj račun putem vaše stranice, stoga pružamo osnovni pristup samo za čitanje, ali ne možete napraviti promjene. Ako želite imati takav tijek - morate postaviti Secure SSO.

Struktura za objekt User je sljedeća:

Struktura objekta User

Copy

export interface User {
    /** Ovo je također id koji se koristi kao userId na objektima komentara. **/
    id: string
    username: string
    /** Na primjer, poveznica na blog komentatora. **/
    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 po id-u.

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    user?: User
}

Struktura glasova

Objekt Vote predstavlja glas koji je ostavio korisnik.

Odnos između komentara i glasa definiran je putem commentId.

Struktura objekta Vote je sljedeć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

Glasove treba dohvatiti pomoću urlId.

Vrste glasova

Postoje tri vrste glasova:

Autentificirani glasovi, koji se primjenjuju na odgovarajući komentar. Možete ih stvoriti putem ovog API-ja.
Autentificirani glasovi, koji su na čekanju verifikacije, i stoga još nisu primijenjeni na komentar. Oni se stvaraju kada korisnik koristi FastComments.com prijava za glasanje mehanizam.
Anonimni glasovi, koji se primjenjuju na odgovarajući komentar. Oni se stvaraju zajedno s anonimnim komentiranjem.

Oni se vraćaju u odvojenim popisima u API-ju kako bi se smanjila zabuna.

Primjer cURL zahtjeva

Copy

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

Struktura zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    /** Autorizirani, verificirani glasovi, primijenjeni na njihove odgovarajuće komentare. **/
    appliedAuthorizedVotes: Vote[]
    /** Anonimni glasovi, primijenjeni na njihove odgovarajuće komentare. **/
    appliedAnonymousVotes: Vote[]
    /** Glasovi koji čekaju verifikaciju, još nisu primijenjeni na njihove odgovarajuće komentare. **/
    pendingVotes: Vote[]
}

Napomene o anonimnim glasovima

Napomena: anonimni glasovi stvoreni putem ovog API-ja pojavit će se u popisu appliedAuthorizedVotes. Smatraju se autoriziranim jer su stvoreni putem API-ja s API ključem.

Struktura appliedAnonymousVotes namijenjena je za glasove stvorene bez e-pošte, API ključa itd.

GET /api/v1/votes/for-user

Resource: Vote as GET /api/v1/votes/for-user Credit Cost: 1

Omogućava dohvaćanje glasova koje je korisnik ostavio za određeni urlId. Prima userId koji može biti bilo koji FastComments.com ili SSO User.

Ovo je korisno ako želite prikazati je li korisnik glasovao za komentar. Prilikom dohvaćanja komentara, jednostavno pozovite ovaj API istovremeno za korisnika sa istim urlId.

Ako koristite anonimno glasovanje, tada trebate umjesto toga proslijediti anonUserId.

Primjer cURL zahtjeva 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'

Primjer cURL zahtjeva za 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 se anonimni glasovi pojaviti u listi appliedAuthorizedVotes. Smatraju se autoriziranima budući da su stvoreni putem API-ja s API ključem.

Struktura zahtjeva 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 neuspjehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'invalid-user-id'
    /** Uključeno pri neuspjehu. **/
    reason?: string
    /** Autorizirani, verificirani glasovi, primijenjeni na njihove odgovarajuće komentare. **/
    appliedAuthorizedVotes: Vote[]
    /** Glasovi koji čekaju verifikaciju, još nisu primijenjeni na odgovarajuće komentare. **/
    pendingVotes: Vote[]
}

POST /api/v1/votes

Resource: Vote as POST /api/v1/votes Credit Cost: 1

Ova ruta omogućuje dodavanje jednog autoriziranog Vote. Glasovi mogu biti up (+1) ili down (-1).

Primjer cURL zahtjeva 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'

Primjer cURL zahtjeva za kreiranje anonimnog 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
    voteId?: string
}

Kreiranje anonimnih glasova

Anonimne glasove možete kreirati postavljanjem anonUserId u parametrima upita umjesto userId.

Ovaj id ne mora odgovarati nijednom objektu korisnika (otuda anonimno). To je jednostavno identifikator sesije, tako da možete ponovno dohvatiti glasove u istoj sesiji kako biste provjerili je li komentar već glasovan.

Ako nemate nešto poput "anonimnih sesija" kao što FastComments ima - jednostavno možete postaviti ovo na nasumični ID, poput UUID-a (iako cijenimo manje identifikatore radi uštede prostora).

Ostale napomene

Ovaj API poštuje postavke na razini tenanta. Na primjer, ako onemogućite glasanje za određenu stranicu, a pokušate stvoriti glas putem API-ja, to će rezultirati pogreškom s kodom voting-disabled.
Ovaj API je po zadanom 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ćuje brisanje jednog Vote.

Primjer cURL zahtjeva za brisanje glasa

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 zahtjeva za brisanje glasa

Copy

interface VoteDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za brisanje glasa

Copy

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

Notes:

Ovaj API poštuje postavke na razini tenant-a. Na primjer, ako onemogućite glasovanje za određenu stranicu i pokušate stvoriti glas putem API-ja, to će rezultirati pogreškom s kodom voting-disabled.
Ovaj API je prema zadanim postavkama aktivan.
Ovaj API će ažurirati votes odgovarajućeg Comment.

Struktura konfiguracije domene

Objekt DomainConfig predstavlja konfiguraciju za domenu za tenant.

Struktura objekta DomainConfig je sljedeća:

Struktura konfiguracije domene

Copy

interface DomainConfig {
    /** Domena, ne URL, npr. "fastcomments.com" ili "www.example.com". Poddomena se može uključiti ako želite ograničiti na poddomenu. Maksimalno 1000 znakova. **/
    domain: string
    /** From-Name koji se koristi pri slanju e-pošte. **/
    emailFromName?: string
    /** From-Email koji se koristi pri slanju e-pošte. Osigurajte da je SPF postavljen kako bi mail.fastcomments.com mogao slati e-poštu u ime domene navedene u ovom atributu. **/
    emailFromEmail?: string
    /** SAMO ZA ČITANJE. Kada je objekt kreiran. **/
    createdAt: string
    /** Logo vezan za ovu domenu. Koristi se u e-porukama. Koristite HTTPS. **/
    logoSrc?: string
    /** Manji logo vezan za ovu domenu. Koristite HTTPS. **/
    logoSrc100px?: string
    /** SAMO SSO. URL koji se koristi u podnožju svake poslane e-pošte. Podržava varijablu "[userId]". **/
    footerUnsubscribeURL?: string
    /** SAMO SSO. Zaglavlja koja se koriste u svakoj poslanoj e-pošti. Korisno, na primjer, za postavljanje zaglavlja povezanih s odjavljivanjem 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 poveznice za odjavu. Ne preporučuje se, može negativno utjecati na stopu isporuke. **/
    disableUnsubscribeLinks?: boolean
    /** DKIM konfiguracija. **/
    dkim?: DomainConfigDKIM
}

Struktura DKIM konfiguracije

Copy

interface DomainConfigDKIM {
    /** Naziv domene u vašem DKIM zapisu. **/
    domainName: string
    /** DKIM selektor ključa koji će se koristiti. **/
    keySelector: string
    /** Vaš privatni ključ. Počinje s -----BEGIN PRIVATE KEY----- i završava s -----END PRIVATE KEY----- **/
    privateKey: string
}

Za autentifikaciju

Konfiguracija domene koristi se za određivanje koje web-lokacije mogu biti domaćini FastComments widgeta za vaš račun. To je osnovni oblik autentifikacije, što znači da dodavanje ili uklanjanje bilo koje konfiguracije domene može utjecati na dostupnost vaše FastComments instalacije u produkciji.

Nemojte uklanjati ili ažurirati svojstvo domain u Domain Config za domenu koja je trenutno u upotrebi, osim ako nije namjera onemogućiti tu domenu.

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

Također imajte na umu da će uklanjanje domene iz korisničkog sučelja My Domains ukloniti svaku odgovarajuću konfiguraciju za tu domenu koja je možda bila dodana putem tog sučelja.

Za prilagodbu e-pošte

Poveznica za odjavu u podnožju e-pošte i funkcija jednoklik odjave koju nude mnogi e-mail klijenti mogu se konfigurirati putem ovog API-ja definirajući footerUnsubscribeURL i emailHeaders, redom.

Za DKIM

Nakon što definirate svoje DKIM DNS zapise, jednostavno ažurirajte DomainConfig s vašom DKIM konfiguracijom koristeći zadanu strukturu.

GET /api/v1/domain-configs

Resource: Comment as GET /api/v1/domain-configs Credit Cost: 1

Ovaj API omogućuje dohvaćanje svih objekata DomainConfig za tenanta.

Primjer cURL GET zahtjeva za DomainConfig

Copy

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

Struktura GET zahtjeva za DomainConfig

Copy

interface GetDomainConfigsRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura GET odgovora za DomainConfig

Copy

interface GetDomainConfigsResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno pri neuspjehu. **/
    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čne DomainConfigs moguće je dohvatiti pomoću odgovarajućeg domain.

Primjer cURL zahtjeva za Domain Config po domenu

Copy

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

Struktura zahtjeva Domain Config po domenu

Copy

interface DomainConfigsByDomainRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora Domain Config po domenu

Copy

interface DomainConfigResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    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 pri neuspjehu. **/
    reason?: string
    configuration?: DomainConfig | null
}

POST /api/v1/domain-configs

Resource: DomainConfig as POST /api/v1/domain-configs Credit Cost: 1

Ovaj API endpoint pruža mogućnost kreiranja konfiguracija domena.

Dodavanje konfiguracije za domenu ovlašćuje tu domenu za FastComments račun.

Uobičajeni slučajevi upotrebe ovog API-ja su početno postavljanje, kada je potrebno dodati više domena, ili prilagođena konfiguracija za slanje e-pošte.

Primjer cURL zahtjeva za DomainConfig

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 zahtjeva DomainConfig

Copy

interface DomainConfigPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora DomainConfig

Copy

interface DomainConfigPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    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ćuje ažuriranje konfiguracije domene specificiranjem samo domene i atributa koji se ažurira.

Primjer cURL zahtjeva 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 PATCH zahtjeva za DomainConfig

Copy

interface DomainConfigPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora PATCH za DomainConfig

Copy

interface DomainConfigPatchResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju pogreške. **/
    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 pogreške. **/
    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ćuje zamjenu konfiguracije domene.

DomainConfig PUT cURL Primjer

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 zahtjeva

Copy

interface DomainConfigPutQueryParams {
    tenantId: string
    API_KEY: string
}

DomainConfig PUT Struktura odgovora

Copy

interface DomainConfigPutResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    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 neuspjeha. **/
    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

Ova ruta omogućuje uklanjanje pojedinačnog DomainConfig prema id-u.

Napomena: Uklanjanje DomainConfig će onemogućiti toj domeni korištenje FastComments.
Napomena: Ponovno dodavanje domene putem UI-ja će ponovno stvoriti objekt (samo s domain popunjenim).

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

Struktura konfiguracije pitanja

FastComments pruža način za konstruiranje pitanja i agregiranje njihovih rezultata. Primjer pitanja (u daljnjem tekstu nazvan QuestionConfig) može biti ocjena zvjezdicama, klizač, ili NPS pitanje (određeno putem type).

Podaci o pitanjima mogu se agregirati pojedinačno, zajedno, tijekom vremena, ukupno, po stranici i slično.

Okvir ima sve mogućnosti potrebne za izgradnju klijentskih widgeta (s vašim serverom ispred ovog API-ja), administratorskih nadzornih ploča i alata za izvještavanje.

Prvo moramo definirati a QuestionConfig. Struktura je sljedeć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 - povećava se za svaki novi odgovor. **/
    usedCount: number
    /** Niz datuma koji označava kada je konfiguracija zadnji put korištena (ostavljen je 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

Ovaj endpoint vraća do 100 QuestionConfig objekata odjednom, paginirano. Trošak je 1 za svaka 100 objekata. Razvrstani su po tekstu pitanja uzlazno (question field).

Primjer QuestionConfig

Copy

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

Struktura zahtjeva 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'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspjeha. **/
    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 jedan QuestionConfig prema njegovom id-u.

Primjer cURL zahtjeva za QuestionConfig prema ID-u

Copy

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

Struktura zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    questionConfig?: QuestionConfig
}

POST /api/v1/question-configs

Resource: QuestionConfig as POST /api/v1/question-configs Credit Cost: 1

Ova API krajnja točka omogućuje stvaranje QuestionConfig.

QuestionConfig POST cURL Primjer

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
}'

QuestionConfig POST Struktura zahtjeva

Copy

interface QuestionConfigPostQueryParams {
    tenantId: string
    API_KEY: string
}

QuestionConfig POST Struktura odgovora

Copy

interface QuestionConfigPostResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju pogreške. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input';  
    /** Uključeno u slučaju pogreške. **/
    reason?: string
    /** Stvoreni objekt. **/
    questionConfig?: QuestionConfig
}

PATCH /api/v1/question-configs/:id

Resource: QuestionConfig as PATCH /api/v1/question-configs/:id Credit Cost: 1

Ovaj endpoint omogućuje ažuriranje pojedinačnog QuestionConfig.

Sljedeća struktura predstavlja sve vrijednosti koje se mogu mijenjati:

Struktura QuestionConfig

Copy

interface QuestionConfigPatchBody {
    name?: string
    question?: string
    helpText?: string
    /** Upozorenje! Promjena tipa može narušiti izvješ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
}

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

DELETE /api/v1/question-configs/:id

Resource: QuestionConfig as DELETE /api/v1/question-configs/:id Credit Cost: 100

Ova ruta omogućuje uklanjanje QuestionConfig prema id-u.

Ovo će izbrisati sve odgovarajuće rezultate pitanja (ali ne komentare). Ovo je dio visokih troškova kredita.

Primjer cURL zahtjeva za uklanjanje QuestionConfig

Copy

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

Struktura zahtjeva za uklanjanje QuestionConfig

Copy

interface QuestionConfigDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za uklanjanje QuestionConfig

Copy

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

Struktura rezultata pitanja

Da biste spremili rezultate za pitanja, stvorite QuestionResult. Zatim možete agregirati rezultate pitanja, i također povezati ih s komentarima u svrhu izvješ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

Ova ruta vraća do 1000 QuestionResults objekata odjednom, paginirano. Trošak je 1 za svaka 100 objekata. Oni su sortirani po createdAt, uzlazno. Možete filtrirati prema različitim parametrima.

Primjer QuestionResults

Copy

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

Struktura zahtjeva QuestionResults

Copy

interface QuestionResultsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Za paginaciju. Počinje od 0. **/
    skip?: number
    /** Za paginaciju. **/
    limit?: number
    /** Dohvati rezultate s određene stranice. **/
    urlId?: string
    /** Dohvati rezultate od određenog korisnika. **/
    userId?: string
    startDate?: string | number
    questionId?: string | string[]
}

Struktura odgovora QuestionResults

Copy

interface QuestionResultsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspjeha. **/
    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 prema njegovom id-u.

Primjer cURL zahtjeva za QuestionResult po ID-u

Copy

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

Struktura zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    questionResult?: QuestionResult
}

POST /api/v1/question-results

Resource: QuestionResult as POST /api/v1/question-results Credit Cost: 1

Ovaj API endpoint omogućuje stvaranje QuestionResult.

Primjer cURL zahtjeva 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 zahtjeva za QuestionResult (POST)

Copy

interface QuestionResultPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za QuestionResult (POST)

Copy

interface QuestionResultPostResponse {
    status: 'success' | 'failed'
    /** Uključeno kod neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input';  
    /** Uključeno kod neuspjeha. **/
    reason?: string
    /** Stvoreni objekt. **/
    questionResult?: QuestionResult
}

PATCH /api/v1/question-results/:id

Resource: QuestionResult as PATCH /api/v1/question-results/:id Credit Cost: 1

Ova ruta omogućuje ažuriranje pojedinačnog QuestionResult.

Sljedeća struktura predstavlja sve vrijednosti koje se mogu promijeniti:

Struktura QuestionResult

Copy

interface QuestionResultPatchBody {
    urlId?: string
    anonUserId?: string
    userId?: string
    value?: string
    commentId?: string
    questionId?: string
    meta?: QuestionResultMeta[]
}

Primjer cURL zahtjeva 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 zahtjeva 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 neuspjeha. **/
    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 neuspjeha. **/
    reason?: string
}

DELETE /api/v1/question-results/:id

Resource: QuestionResult as DELETE /api/v1/question-results/:id Credit Cost: 1

Ova ruta omogućuje uklanjanje QuestionResult po id-u.

Primjer cURL zahtjeva za uklanjanje QuestionResult

Copy

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

Struktura zahtjeva 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 neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
}

GET /api/v1/question-results-aggregate

Resource: QuestionResultsAggregate as GET /api/v1/question-results-aggregate Credit Cost: 2

Ovdje se vrši agregacija rezultata.

Struktura odgovora agregacije je sljedeća:

Struktura QuestionResultsAggregationResult

Copy

interface QuestionResultDataPoint {
    /** Mapa vrijednosti na broj pojavljivanja te vrijednosti za trenutnu točku podataka (grupa po datumu ili stranica). **/
    v: Map<ValueAsString, number>
    total: number
}
interface QuestionResultsAggregationResult {
    /** Napomena - null je kada timeBucket nije specificiran. **/
    dataByDateBucket?: Map<DateString, QuestionResultDataPoint>
    dataByUrlId?: Map<URLIdString, QuestionResultDataPoint>
    countsByValue?: Map<ValueAsString, number>
    /** Ukupan broj rezultata koji su agregirani. **/
    total: number
    /** Dobiveni ponderirani prosjek. To je float, obično s dvije decimale ili manje. **/
    average: number
    /** Datum u obliku stringa koji predstavlja kada su ovi podaci izračunati, budući da mogu doći iz cachea. **/
    createdAt: string
}

Ovdje su dostupni parametri upita za agregaciju:

Struktura zahtjeva QuestionResultsAggregation

Copy

interface QuestionResultsAggregateRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Možete agregirati rezultate za jedno ili više pitanja. **/
    questionId: string | string[]
    startDate?: string | number
    timeBucket?: 'day' | 'month' | 'year'
    /** Agregiraj za određenu stranicu. **/
    urlId?: string
    /** Agregiraj za određenog korisnika. **/
    userId?: string
    /** Prisilno ponovno izračunaj sada i ažuriraj predmemoriju. **/
    forceRecalculate?: boolean
}

Evo primjera zahtjeva:

Primjer 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'

Primjer odgovora:

Primjer odgovora 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 QuestionResultsAggregation

Copy

interface QuestionResultsAggregationResponse {
    status: 'success' | 'failed'
    /** Uključeno pri neuspjehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno pri neuspjehu. **/
    reason?: string
    data: QuestionResultsAggregationResult
}

Napomene o performansama

Ako nema u cacheu (cache miss), agregacije obično traju pet sekundi po milijunu rezultata.
U suprotnom, zahtjevi se izvršavaju u konstantnom vremenu.

Napomene o keširanju i troškovima

Kada je forceRecalculate naveden, trošak je uvijek 10, umjesto uobičajenih 2.
Ako cache istekne i podaci se ponovno izračunaju, trošak je i dalje konstantan 2 ako forceRecalculate nije naveden. Cache istječe ovisno o veličini prikupljenog skupa podataka (može varirati između 30 sekundi i 5 minuta).
Ovo služi kao poticaj za korištenje cachea.

GET /api/v1/question-results-aggregate/combine/comments

Resource: QuestionResultsCombinedWithComments as GET /api/v1/question-results-aggregate/combine/comments Credit Cost: 2

Ovdje se kombiniraju rezultati s komentarima. Korisno za izradu grafikona "nedavni pozitivni i negativni komentari" za proizvod, na primjer.

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

Struktura odgovora je sljedeća:

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 {
    /** Datum u obliku stringa koji predstavlja kada su ovi podaci izračunati, budući da mogu biti iz predmemorije. **/
    createdAt: string
    results: CommentAndResult[]
}

Ovo su parametri upita dostupni za agregaciju:

Struktura zahtjeva QuestionResultsCombineComments

Copy

interface QuestionResultsAggregateRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Možete agregirati rezultate za jedno ili više pitanja. **/
    questionId: string | string[]
    startDate?: string | number
    urlId?: string
    minValue: number
    maxValue: number
    limit?: number
    forceRecalculate?: boolean
}

Evo primjera zahtjeva:

Primjer zahtjeva 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'

Primjer odgovora:

Primjer odgovora QuestionResultsCombineComments

Copy

{
    "createdAt": "2023-08-30T00:00:00.000Z",
    "results": [
        {
            "comment": {
                "id": "some-id",
                "commentHTML": "test-2",
                "commenterName": "Test",
                "date": "2023-08-30T00:00:00.000Z",
                "userId": "some-user-id"
            },
            "result": {
                "id": "some-id",
                "value": 10
            }
        },
        {
            "comment": {
                "id": "some-id",
                "commentHTML": "test-0",
                "commenterName": "Some Name",
                "date": "2023-08-30T00:00:00.000Z",
                "userId": "some-user-id"
            },
            "result": {
                "id": "some-id",
                "value": 5
            }
        }
    ]
}

Struktura odgovora QuestionResultsCombineComments

Copy

interface QuestionResultsCombineCommentsResponse {
    status: 'success' | 'failed'
    /** Uključeno u slučaju neuspjeha. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Uključeno u slučaju neuspjeha. **/
    reason?: string
    data: QuestionResultsCombinedWithCommentsResponse
}

Napomene o predmemoriranju i troškovima

Kada je naveden forceRecalculate, trošak je uvijek 10, umjesto uobičajenih 2.
Ako predmemorija istekne i podaci se ponovno izračunaju, trošak je i dalje konstantan 2 ako forceRecalculate nije naveden.
Ovo potiče korištenje predmemorije.

Struktura značke korisnika

UserBadge je objekt koji predstavlja značku dodijeljenu korisniku u sustavu FastComments.

Značke se mogu dodijeliti korisnicima automatski na temelju njihove aktivnosti (kao što su broj komentara, vrijeme odgovora, status veterana) ili ručno od strane administratora stranice.

Struktura objekta UserBadge je sljedeća:

Struktura UserBadge

Copy

export interface UserBadge {
    /** Jedinstveni identifikator za ovu dodjelu značke korisniku */
    id: string
    /** ID korisnika kojem je ova značka dodijeljena */
    userId: string
    /** ID definicije značke iz kataloga znački tenant-a */
    badgeId: string
    /** ID tenanta koji je stvorio/dodijelio ovu značku */
    fromTenantId: string
    /** Kada je ova značka stvorena (milisekunde od epohe) */
    createdAt?: number
    /** Kada je ova značka primljena od strane korisnika (milisekunde od epohe) */
    receivedAt?: number
    /** 
     * Vrsta 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 bazirane na pragovima, vrijednost praga */
    threshold?: number
    /** Naziv/oznaka značke */
    name?: string
    /** Detaljan opis značke */
    description?: string
    /** Tekst prikazan na značci */
    displayLabel?: string
    /** URL slike prikazane na značci */
    displaySrc?: string
    /** Boja pozadine značke (hex kod) */
    backgroundColor?: string
    /** Boja ruba značke (hex kod) */
    borderColor?: string
    /** Boja teksta značke (hex kod) */
    textColor?: string
    /** Dodatna CSS klasa za stiliziranje */
    cssClass?: string
    /** Za veteranske značke, vremenski prag u milisekundama */
    veteranUserThresholdMillis?: number
    /** Prikazuje li se ova značka na korisnikovim komentarima */
    displayedOnComments: boolean
    /** Redoslijed prikaza značke */
    order?: number
}

---

GET /api/v1/user-badges

Ovaj endpoint omogućuje dohvat korisničkih znački na temelju raznih kriterija.

Primjer zahtjeva:

Primjer GET zahtjeva

Copy

Run

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

Možete dodati različite parametre upita za filtriranje rezultata:

userId - Dohvati značke za određenog korisnika
badgeId - Dohvati instance određene značke
type - Filtriraj po tipu značke (0=CommentCount, 1=CommentUpVotes, 2=CommentReplies, etc. See UserBadge structure for full list)
displayedOnComments - Filtriraj prema tome je li značka prikazana u komentarima (true/false)
limit - Maksimalan broj znački za vraćanje (zadano 30, max 200)
skip - Broj znački koje treba preskočiti (za paginaciju)

Primjer 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 s pogreškom:

Pogreška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Pogreš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ćuje dohvaćanje određene korisničke značke prema njenom jedinstvenom ID-u.

Primjer zahtjeva:

Primjer GET zahtjeva

Copy

Run

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

Primjer 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 s pogreškama:

Pogreška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Pogreš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 omogućuje vam stvaranje novog dodjeljivanja značke korisniku.

Primjer zahtjeva:

Primjer POST zahtjeva

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
}'

Tijelo zahtjeva mora sadržavati sljedeće parametre:

userId (obavezno) - ID korisnika kojemu se dodjeljuje značka
badgeId (obavezno) - ID značke koja se dodjeljuje
displayedOnComments (neobavezno) - Treba li se značka prikazivati u korisnikovim komentarima (zadano: true)

Važne napomene:

Značka mora postojati i biti omogućena u katalogu znački vašeg tenanta
Značke možete dodijeliti samo korisnicima koji pripadaju vašem tenantu ili su komentirali na vašoj stranici

Primjer 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 s pogreškom:

Pogreška: Nedostaje ID tenanta

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Pogreška: Nedostaje ID korisnika

Copy

{
  "status": "failed",
  "code": "missing-user-id",
  "reason": "User ID (body param: userId) is required."
}

Pogreška: Nedostaje ID značke

Copy

{
  "status": "failed",
  "code": "missing-badge-id",
  "reason": "Badge ID (body param: badgeId) is required."
}

Pogreška: Značka nije pronađena

Copy

{
  "status": "failed",
  "code": "badge-not-found",
  "reason": "The badge badgeDef789 was not found or is not enabled."
}

Pogreška: Neovlašteni 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 omogućuje ažuriranje dodjele korisničke značke.

Trenutno se može ažurirati samo svojstvo displayedOnComments, koje kontrolira hoće li se značka prikazivati na komentarima korisnika.

Example Request:

Primjer PUT zahtjeva

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
}'

Example Response:

Odgovor

Copy

{
  "status": "success"
}

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 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 omogućuje brisanje dodjele korisničke značke.

Primjer zahtjeva:

Primjer DELETE zahtjeva

Copy

Run

curl -X DELETE "https://fastcomments.com/api/v1/user-badges/badge123?tenantId=demo&API_KEY=DEMO_API_SECRET"

Primjer odgovora:

Odgovor

Copy

{
  "status": "success"
}

Mogući odgovori s pogreškama:

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 objekt koji predstavlja napredak korisnika prema stjecanju različitih bedževa u FastComments sustavu.

Ovo praćenje pomaže odrediti kada korisnici trebaju dobiti automatske bedževe na temelju njihove aktivnosti i sudjelovanja u vašoj zajednici.

Struktura za UserBadgeProgress objekt je sljedeća:

Struktura UserBadgeProgress objekta

Copy

export interface UserBadgeProgress {
    /** Jedinstveni identifikator ovog zapisa napretka */
    id: string
    /** ID tenanta kojem pripada ovaj zapis napretka */
    tenantId: string
    /** ID korisnika kojeg ovaj zapis napretka prati */
    userId: string
    /** ID prvog komentara korisnika u sustavu */
    firstCommentId?: string
    /** Datum prvog komentara korisnika (milisekunde od epohe) */
    firstCommentDate?: number
    /** Automatski izračunati faktor povjerenja na temelju aktivnosti korisnika */
    autoTrustFactor?: number
    /** Faktor povjerenja postavljen ručno od strane administratora */
    manualTrustFactor?: number
    /** Detaljan objekt napretka s različitim metrima, ključevi odgovaraju BadgeType enumeraciji */
    progress: {
        /** 0: CommentCount - Broj komentara koje je korisnik napisao */
        '0'?: number
        /** 1: CommentUpVotes - Broj pozitivnih glasova (upvote) koje je korisnik primio */
        '1'?: number
        /** 2: CommentReplies - Broj odgovora koje je korisnik napisao */
        '2'?: number
        /** 3: CommentsPinned - Broj prikvačenih (pinned) komentara koje korisnik ima */
        '3'?: number
        /** 4: Veteran - Starost korisničkog računa */
        '4'?: number
        /** 5: NightOwl - Broj puta kada je korisnik objavio tijekom noćnih sati */
        '5'?: number
        /** 6: FastReplyTime - Prosječno vrijeme odgovora u milisekundama */
        '6'?: number
        /** 7: ModeratorCommentsDeleted - Za moderator bedževe, broj izbrisanih komentara */
        '7'?: number
        /** 8: ModeratorCommentsApproved - Za moderator bedževe, broj odobrenih komentara */
        '8'?: number
        /** 9: ModeratorCommentsUnapproved - Za moderator bedževe, broj neodobrenih komentara */
        '9'?: number
        /** 10: ModeratorCommentsReviewed - Za moderator bedževe, broj pregledanih komentara */
        '10'?: number
        /** 11: ModeratorCommentsMarkedSpam - Za moderator bedževe, broj komentara označenih kao spam */
        '11'?: number
        /** 12: ModeratorCommentsMarkedNotSpam - Za moderator bedževe, 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 omogućuje dohvat zapisa napretka korisničkih znački na temelju različitih kriterija.

Primjer zahtjeva:

Primjer GET zahtjeva

Copy

Run

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

Možete dodati različite parametre upita za filtriranje rezultata:

userId - Dohvati napredak za određenog korisnika
limit - Maksimalni broj zapisa za vraćanje (zadano 30, max 200)
skip - Broj zapisa koje treba preskočiti (za paginaciju)

Primjer 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 s 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-badge-progress/:id

Ovaj endpoint omogućuje dohvat određenog zapisa o napretku značke korisnika prema njegovom jedinstvenom ID-u.

Example Request:

Primjer GET zahtjeva

Copy

Run

curl -X GET "https://fastcomments.com/api/v1/user-badge-progress/progress123?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 ID zakupnika

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 omogućuje dohvat zapisa o napretku značke pomoću ID‑a korisnika.

Primjer zahtjeva:

Primjer GET zahtjeva

Copy

Run

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

Primjer 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 s pogreškom:

Pogreška: Nedostaje Tenant ID

Copy

{
  "status": "failed",
  "code": "missing-tenant-id",
  "reason": "Tenant ID (query param: tenantId) is missing."
}

Pogreška: Nedostaje User ID

Copy

{
  "status": "failed",
  "code": "missing-user-id",
  "reason": "The User ID (path param: userId) is missing."
}

Pogreš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šu API dokumentaciju smatrali sveobuhvatnom i lako razumljivom. Ako uočite bilo kakve nedostatke, javite nam u nastavku.

Jezik 🇭🇷 Hrvatski

Resursi API-ja

Agregacije

Zapisnici revizije

Komentari

Predlošci e-pošte

Hashtagovi

Moderatori

Broj obavijesti

Obavijesti

Stranice

Događaji webhooka na čekanju

SSO korisnici

Pretplate

Dnevna upotreba najmoprimca

Najmoprimci

Paketi najmoprimaca

Korisnici najmoprimca

Korisnici

Glasovi

Konfiguracije domena

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

Značke korisnika

Napredak značke korisnika

FastComments API

Generirani SDK-ovi

Autentifikacija

Sigurnosna napomena

Opcija autentifikacije 1 - Zaglavlja

Opcija autentifikacije 2 - Parametri upita

Resursi API-ja

Korištenje resursa

Napomena!

Agregirajte svoje podatke

Primjeri

Primjer: Brojanje jedinstvenih

Primjer: Brojanje različitih vrijednosti

Primjer: Zbroj vrijednosti više polja

Primjer: Prosjek vrijednosti više polja

Primjer: Min/Max vrijednosti više polja

Primjer: Brojanje jedinstvenih vrijednosti više polja

Primjer: Kreiranje upita

Primjer: Brojanje komentara na čekanju pregleda

Primjer: Pregled raspodjele odobrenih, pregledanih i spam komentara

Strukture

Struktura zapisnika revizije

GET /api/v1/audit-logs

Struktura komentara

Struktura teksta komentara

Označavanje

HashTags

GET /api/v1/comments

Straničenje

Niti

Objašnjenje stabala

Dohvaćanje komentara u kontekstu korisnika

Dohvati komentare kao stablo

Dohvaćanje komentara kao stabla, pretraživanje po hashtag-u

Svi parametri zahtjeva

Odgovor

Korisni savjeti

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 predloška e-pošte

Bilješke

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

GET /api/v1/email-templates

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

POST /api/v1/email-templates