API | FastComments Docs

API FastComments

FastComments nudi API za interakcijo z mnogimi viri. Zgradite integracije z našo platformo ali celo ustvarite svoje lastne odjemalce!

V tej dokumentaciji najdete vse vire, ki jih API podpira, dokumentirane z njihovimi tipi zahtevkov in odgovorov.

Za Enterprise naročnike je ves dostop do API zabeležen v revizijskem dnevniku.

Generirani SDK-ji

FastComments sedaj generira API specifikacijo iz naše kode (to še ni popolno, vendar vključuje mnoge API-je).

Imamo tudi SDK-je za priljubljene jezike:

Avtentikacija

API se avtenticira tako, da posredujete svoj API ključ bodisi kot X-API-KEY header ali API_KEY query parameter. Za klice API boste potrebovali tudi svoj tenantId za izvajanje klicev API. To lahko pridobite na isti strani kot svoj API ključ.

Varnostno opozorilo

Te poti so namenjene klicanju z strežnika. NE jih kličite iz brskalnika. S tem boste razkrili svoj API ključ - to bo vsakomur, ki si lahko ogleda izvorno kodo strani, omogočilo popoln dostop do vašega računa!

Authentication Option One - Headers

Glava: X-API-KEY
Glava: X-TENANT-ID

Authentication Option Two - Query Parameters

Parameter poizvedbe: API_KEY
Parameter poizvedbe: tenantId

Viri API

Uporaba virov

Treba je opozoriti, da se pridobivanje podatkov iz API-ja šteje kot poraba na vašem računu.

Vsak vir bo v svojem razdelku navedel, kakšna je ta poraba.

Nekateri viri zahtevajo več sredstev kot drugi. Vsaka končna točka ima določeno ceno v kreditih na klic API-ja. Pri nekaterih končnih točkah se število kreditov spreminja glede na možnosti in velikosti odgovorov.

Uporabo API-ja lahko preverite na strani Analitika obračunavanja in se posodablja vsake nekaj minut.

Opomba!

Priporočamo, da najprej preberete dokumentacijo Pages, da zmanjšate zmedo pri določanju, katere vrednosti posredovati za urlId v Comment API.

Združite svoje podatke

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

Ta API agregira dokumente tako, da jih združi (če je podan groupBy) in uporabi več operacij. Podprte so različne operacije (npr. sum, countDistinct, avg itd.).

Strošek je spremenljiv. Vsakih 500 pregledanih objektov stane 1 API kredit.

Privzeto je največja dovoljena poraba pomnilnika na klic API 64 MB, privzeto pa lahko hkrati teče samo ena agregacija. Če pošljete več agregacij hkrati, bodo postavljene v čakalno vrsto in izvršene v vrstnem redu pošiljanja. Čakanje na obdelavo v čakalni vrsti traja največ 60 sekund, po tem poizvedba poteče. Posamezne agregacije se lahko izvršujejo do 5 minut.

Če imate upravljane najemnike (managed tenants), lahko v enem klicu agregirate vire vseh otroških najemnikov tako, da pošljete query parameter parentTenantId.

Primeri

Primer: Štetje edinstvenih vrednosti

Primer cURL: Štetje edinstvenih vrednosti

Copy

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

Odgovor: Štetje edinstvenih vrednosti

Copy

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

Primer: Štetje različnih

Primer cURL: Štetje različnih vrednosti

Copy

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

Odgovor:

Odgovor: Štetje različnih vrednosti

Copy

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

Primer: Seštevek vrednosti več polj

Primer cURL: Seštevek vrednosti

Copy

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

Odgovor:

Odgovor: Seštevek vrednosti

Copy

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

Primer: Povprečne vrednosti več polj

Primer cURL: Povprečne vrednosti

Copy

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

Odgovor:

Odgovor: Povprečne vrednosti

Copy

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

Primer: Minimalne/maksimalne vrednosti več polj

Primer cURL: Minimalne/maksimalne vrednosti

Copy

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

Odgovor:

Odgovor: Minimalne/maksimalne vrednosti

Copy

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

Primer: Štetje unikatnih vrednosti več polj

Primer cURL: Štetje edinstvenih vrednosti

Copy

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

Odgovor:

Odgovor: Štetje edinstvenih vrednosti

Copy

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

Primer: Primer ustvarjanja poizvedbe

Primer cURL: Ustvarjanje poizvedbe

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: Ustvarjanje poizvedbe

Copy

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

Primer: Štetje komentarjev, ki čakajo na pregled

Primer cURL: Štetje komentarjev, ki čakajo na pregled

Copy

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

Odgovor:

Odgovor: Štetje komentarjev, ki čakajo na pregled

Copy

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

Primer: Razčlenitev odobrenih, pregledanih in spam komentarjev

Primer cURL: Razčlenitev komentarjev

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: Razčlenitev komentarjev

Copy

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

Strukture

Struktura zahteve za agregacijo

Copy

export type AggregationOpType = 'sum' | 'countDistinct' | 'distinct' | 'avg' | 'min' | 'max' | 'count';
/** Operacija, ki bo uporabljena na polju */
export interface AggregationOperation {
    /** Polje, na katerem se bo izvajala operacija */
    field: string;
    /** Vrsta operacije */
    op: AggregationOpType;
    /** Izbiren vzdevek (alias) za izhod; če ni naveden, se izračuna privzeti vzdevek */
    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 agregacijo

Copy

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

Naslednje vire je mogoče 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 revizijskega dnevnika

An AuditLog je objekt, ki predstavlja revidiran dogodek za najemnike, ki imajo dostop do te funkcije.

Struktura objekta AuditLog je naslednja:

Struktura objekta 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 dnevnik je nespremenljiv. Vanj poleg tega ni mogoče pisati ročno. FastComments.com lahko odloča le, kdaj zapisati v revizijski dnevnik. Vendar ga lahko berete prek tega API-ja.

Dogodki v revizijskem dnevniku potečejo po dveh letih.

GET /api/v1/audit-logs

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

Ta API uporablja straničenje, ki ga zagotavljata parametra skip, before in after. AuditLogi se vračajo v straneh po 1000, razvrščeni po when in id.

Pridobivanje vsakih 1000 zapisov stane 10 kreditov.

Privzeto boste prejeli seznam z najnovejšimi elementi na vrhu. Na ta način lahko začnete z skip=0 in straničite, dokler ne najdete zadnjega zapisa, ki ste ga že obdelali.

Alternativno lahko razvrstite najprej najstarejše in straničite, dokler ne bo več zapisov.

Razvrščanje lahko izvedete tako, da nastavite order na ASC ali DESC. Privzeto je ASC.

Poizvedovanje po datumu je mogoče z before in after kot časovnimi žigi v milisekundah. before in after nista vključujoča.

Primer cURL zahteve 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 zahteve za AuditLog

Copy

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

Struktura odgovora za AuditLog

Copy

interface CommentsResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Dnevniki! **/
    auditLogs: AuditLog[]
}

Struktura komentarja

Objekt Comment predstavlja komentar, ki ga je pustil uporabnik.

Razmerje med nadrejenimi in potomskimi komentarji je določeno z parentId.

Struktura objekta Comment je naslednja:

Struktura komentarja

Copy

interface Comment {
    /** READONLY: Nastavljeno na true, če je protivspamski mehanizem ocenil, da je komentar spam. **/
    aiDeterminedSpam?: boolean
    /** Ali je komentar odobren za prikaz. Ob shranjevanju komentarja nastavljeno na true, sicer bo skrit. **/
    approved?: boolean
    /** Avatar uporabnika. **/
    avatarSrc?: string
    /** Potomski komentarji. V vseh scenarijih niso vedno napolnjeni. Uporablja se, ko je preko API-ja asTree nastavljen na true. **/
    children: Comment[]
    /** Izviren komentar avtorja. **/
    comment: string
    /** READONLY: Komentar avtorja, pretvorjen v HTML. **/
    commentHTML?: string
    /** E-pošta avtorja. Obvezna, če je anonimno komentiranje onemogočeno. **/
    commenterEmail?: string
    /** Povezava avtorja (npr. njihov blog). **/
    commenterLink?: string
    /** Ime avtorja komentarja. Vedno zahtevano. Če ni na voljo, nastavite nekaj, kot je "Anonymous". **/
    commenterName: string
    /** Datum, kdaj je bil komentar objavljen, v UTC epoch obliki. **/
    date: number
    /** "Prikazna oznaka" za komentar - na primer "Admin", "Moderator", ali nekaj kot "VIP User". **/
    displayLabel?: string
    /** Domena, na kateri je bil komentar objavljen. **/
    domain?: string
    /** READONLY: Število krat, ko je bil komentar prijavljen (flag). **/
    flagCount?: number
    /** #hashtag-i zapisani v komentarju, ki so bili uspešno razčlenjeni. Hashtage lahko tudi ročno dodate za poizvedovanje, vendar se ti ne bodo samodejno prikazali v besedilu komentarja. **/
    hashTags?: CommentHashTag[]
    /** READONLY: Ali komentar vsebuje slike? **/
    hasImages?: boolean
    /** READONLY: Ali komentar vsebuje povezave? **/
    hasLinks?: boolean
    /** READONLY: Edinstveni id komentarja. **/
    id: string
    /** Samo ob ustvarjanju! To je zgoščeno (hashed) za shranjevanje. **/
    ip?: string
    /** READONLY: Ali je trenutni uporabnik blokiral uporabnika, ki je napisal ta komentar? **/
    isBlocked?: boolean
    /** READONLY: Ali je komentar avtorjev admin? Samodejno nastavljeno glede na userId. **/
    isByAdmin?: boolean
    /** READONLY: Ali je komentar avtorjev moderator? Samodejno nastavljeno glede na userId. **/
    isByModerator?: boolean
    /** Nastavljeno na true, če je bil komentar mehko izbrisan (mora ostati priponka zaradi določene konfiguracije). **/
    isDeleted?: boolean
    /** Nastavljeno na true, če je bil uporabniški račun izbrisan in je bilo treba komentar obdržati. **/
    isDeletedUser?: boolean
    /** READONLY: Ali je komentar prijavljen (flag) s strani trenutno prijavljenega uporabnika (contextUserId)? **/
    isFlagged?: boolean
    /** Ali je komentar pripet (pinned)? **/
    isPinned?: boolean
    /** Ali je komentar zaklenjen za nove odgovore (moderatorji lahko še vedno odgovarjajo)? **/
    isLocked?: boolean
    /** Ali je komentar spam? **/
    isSpam?: boolean
    /** READONLY: Ali je komentar za trenutnega uporabnika (contextUserId) ocenjeno navzdol? **/
    isVotedDown?: boolean
    /** READONLY: Ali je komentar za trenutnega uporabnika (contextUserId) ocenjeno navzgor? **/
    isVotedUp?: boolean
    /** Jeziki komentarja. Če ni podano, bo izpeljano iz HTTP glave language accept. **/
    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: @omembe, zapisane v komentarju, ki so bile uspešno razčlenjene. **/
    mentions?: CommentUserMention[]
    /** Neobvezni metapodatki povezani s komentarjem. **/
    meta?: Record<string, string | number | boolean>
    /** Neobvezni seznam id-jev moderacijskih skupin, povezanih s tem komentarjem. **/
    moderationGroupIds?: string[]|null
    /** READONLY: Id objekta glasovanja, ki ustreza glasu trenutnega uporabnika (contextUserId) za ta komentar. **/
    myVoteId?: string
    /** Ali so bila za ta komentar poslana obvestila komentatorjem. Da preprečite pošiljanje obvestil pri uvozih, nastavite na true. **/
    notificationSentForParent?: boolean
    /** Ali so bila za ta komentar poslana obvestila uporabnikom najemnika. Da preprečite pošiljanje obvestil pri uvozih, nastavite na true. **/
    notificationSentForParentTenant?: boolean
    /** Naslov strani, na kateri je bil komentar. **/
    pageTitle?: string
    /** Če odgovarjamo na komentar, je to ID komentarja, na katerega odgovarjamo. **/
    parentId?: string|null
    /** Ali je komentar označen kot pregledan. **/
    reviewed: boolean
    /** Id najemnika (tenant), kjer komentar pripada. **/
    tenantId: string
    /** Uporabnik, ki je napisal komentar. Ustvarjen samodejno ob shranjevanju komentarja z imenom/e-pošto. **/
    userId?: string|null
    /** URL lokacije, kjer je komentar viden, na primer objava na blogu. **/
    url: string
    /** "Očiščena" različica urlId, ki ste jo poslali. Pri shranjevanju določite to polje, a ko pridobite komentar nazaj, bo to "očiščeno" in vaša originalna vrednost premaknjena v "urlIdRaw". **/
    urlId: string
    /** READONLY: Izvirni urlId, ki ste nam ga poslali. **/
    urlIdRaw?: string
    /** Ali sta uporabnik in ta komentar preverjena? **/
    verified: boolean
    /** Število glasov za. **/
    votesUp?: number
    /** Število glasov proti. **/
    votesDown?: number
    /** "Karma" komentarja (= votes up - votes down). **/
    votes?: number
}

Nekatera od teh polj so označena kot READONLY - ta so vrnjena s strani API-ja, vendar jih ni mogoče nastaviti.

Struktura besedila komentarja

Komentarji so napisani v FastComments različici markdowna, kar je preprosto markdown plus tradicionalne bbcode sloga oznake za slike, na primer [img]path[/img].

Besedilo se shranjuje v dveh poljih. Besedilo, ki ga je uporabnik vnesel, je shranjeno nespremenjeno v polju comment. To se upodobi in shrani v polju commentHTML.

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

Priporočeno je upodabljanje HTML-ja, saj gre za zelo majhen podnabor HTML-ja, zato je izgradnja rendererja precej preprosta. Na voljo je več knjižnic za React Native in Flutter, na primer, ki pri tem pomagajo.

Lahko se odločite tudi za upodabljanje ne-normalizirane vrednosti polja comment. Primer parserja je tukaj..

Primer parserja bi lahko prilagodili tudi za delo s HTML-jem in pretvorbo HTML oznak v pričakovane elemente za upodabljanje na vaši platformi.

Označevanje

Ko so uporabniki označeni v komentarju, je informacija shranjena v seznamu imenovanem mentions. Vsak objekt v tem seznamu ima naslednjo strukturo.

Objekt omemb komentarja

Copy

Run

interface CommentUserMention {
    /** Id uporabnika. Pri SSO uporabnikih bo temu predponan vaš tenant id. **/
    id: string
    /** Končni @mention tag besedila, vključno z znakom @. **/
    tag: string
    /** Izvirni @mention tag besedila, vključno z znakom @. **/
    rawTag: string
    /** Kakšen tip uporabnika je bil označen. user = FastComments.com račun. sso = SSOUser. **/
    type: 'user'|'sso'
    /** Če se uporabnik odjavi od obvestil, bo to še vedno nastavljeno na true. **/
    sent: boolean
}

Hashtagi

Ko so hashtagi uporabljeni in uspešno razčlenjeni, je informacija shranjena v seznamu imenovanem hashTags. Vsak objekt v tem seznamu ima naslednjo strukturo. Hashtage je mogoče tudi ročno dodati v polje hashTags komentarja za poizvedovanje, če je retain nastavljen.

Objekt hash-tagov komentarja

Copy

Run

interface CommentHashTag {
    /** Id hashtaga. **/
    id: string
    /** Končni #hashtag tag besedila, vključno z znakom #. **/
    tag: string
    /** Če je hashtag povezan z lastnim URL-jem, bo to definirano. **/
    url?: string
    /** Če naj hashtag obdržimo, tudi če ob posodobitvi komentarja ni prisoten v besedilu. Uporabno za označevanje komentarjev brez spreminjanja besedila komentarja. **/
    retain?: boolean
}

GET /api/v1/comments

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

Ta API se uporablja za pridobivanje komentarjev za prikaz uporabniku. Na primer, samodejno filtrira neodobrene ali neželene (spam) komentarje.

Straničenje

Straničenje je mogoče izvesti na enega od dveh načinov, odvisno od zahtev glede zmogljivosti in primera uporabe:

Najhitrejše: Vnaprej izračunano straničenje:
1. Tako FastComments deluje, ko uporabljate naše vnaprej izdelane widgete in odjemalce.
2. Klik na "next" preprosto poveča števec strani.
3. To lahko razumete kot pridobitev iz ključ-vrednost shrambe.
4. Na ta način preprosto določite parameter page, ki se začne pri 0, in smer razvrščanja kot direction.
5. Velikosti strani je mogoče prilagoditi preko pravil prilagoditve.
Najbolj prilagodljivo: Fleksibilno straničenje:
1. Na ta način lahko določite po meri limit in skip parametra. Ne pošiljajte page.
2. Podprta je tudi smer razvrščanja direction.
3. limit je skupno število, ki ga vrnemo po uporabi skip.
  - Primer: nastavite skip = 200, limit = 100, ko je page size = 100 in page = 2.
4. Otroški komentarji se še vedno štejejo v straničenju. To lahko zaobidete z uporabo opcije asTree.
  - Otroke lahko straničite z limitChildren in skipChildren.
  - Globino vrnjenih niti lahko omejite z maxTreeDepth.

Niti

Ko uporabljate Precalculated Pagination, so komentarji združeni po strani in komentarji v nitih vplivajo na celotno stran.
1. Tako se niti lahko določijo na odjemalcu glede na parentId.
2. Na primer, na strani z enim vrhnjim komentarjem in 29 odgovori, in če v API nastavite page=0 - boste dobili samo vrhnji komentar in 29 otrok.
3. Primer slike tukaj, ki prikazuje več strani.
Ko uporabljate Flexible Pagination, lahko določite parameter parentId.
1. Nastavite ga na null, da dobite samo vrhnje komentarje.
2. Nato za ogled niti pokličite API znova in posredujte parentId.
3. Pogosta rešitev je, da naredite API klic za vrhnje komentarje in nato vzporedne API klice za pridobitev komentarjev za otroke vsakega komentarja.
NOVO od februarja 2023! Pridobite kot drevo z uporabo &asTree=true.
1. To lahko razumete kot Fleksibilno straničenje kot drevo.
2. Samo vrhnji komentarji štejejo v straničenju.
3. Nastavite parentId=null, da začnete drevo na korenu (mora biti nastavljen parentId).
4. Nastavite skip in limit za straničenje.
5. Nastavite asTree na true.
6. Cena v kreditih se poveča za 2x, saj mora naš backend v tem scenariju opraviti veliko več dela.
7. Nastavite maxTreeDepth, limitChildren in skipChildren po želji.

Drevesa pojasnjena

Ko uporabljate asTree, je lahko težko razmišljati o straničenju. Tukaj je priročna grafika:

Diagram straničenja dreves

Pridobivanje komentarjev v kontekstu uporabnika

API /comments se lahko uporablja v dveh kontekstih, za različne primere uporabe:

Za vračanje komentarjev, razvrščenih in označenih z informacijami za izdelavo vašega lastnega odjemalca.
- V tem primeru določite parameter poizvedbe contextUserId.
Za pridobivanje komentarjev iz vašega backenda za prilagojene integracije.
- Platforma bo to privzeto uporabila, če contextUserId ni podan.

Komentarji - vnaprej izračunano straničenje

Copy

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

Komentarji - fleksibilno straničenje

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'

Komentarji - fleksibilno straničenje v uporabniškem kontekstu

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'

Komentarji - fleksibilno straničenje v uporabniškem kontekstu samo za vrhnje komentarje

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'

Pridobitev komentarjev kot drevo

Možno je vrniti komentarje kot drevo, pri čemer straničenje upošteva samo vrhnje komentarje.

Komentarji kot drevo v uporabniškem kontekstu

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 pridobiti samo vrhnje komentarje in neposredne otroke? Tukaj je en način:

Komentarji kot drevo z največjo globino

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'

Vendar boste v svojem UI morda morali vedeti, ali prikazati gumb "prikaži odgovore" pri vsakem komentarju. Ko pridobivate komentarje kot drevo, imajo komentarji, kjer je primerno, lastnost hasChildren.

Pridobitev komentarjev kot drevo, iskanje po hashtagih

Možno je iskati po hashtagih z uporabo API-ja, po celotnem vašem najemniku (ne omejeno na eno stran ali urlId).

V tem primeru izpustimo urlId in iščemo po več hashtagih. API bo vrnil samo komentarje, ki vsebujejo vse zahtevane hashtage.

Komentarji kot drevo v uporabniškem kontekstu, po hashtagih

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'

Vsi parametri zahteve

Struktura zahteve za komentarje

Copy

interface CommentsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** urlId (URL strani ali ID članka), s katerim so komentarji povezani. **/
    urlId?: string
    /** Omejite komentarje, ki jih vrne ta uporabnik. **/
    userId?: string
    /** Uporabite to za iskanje po hashtagih. Če želite zožiti iskanje na presečišče več hashtagov, uporabite &hashTag=a&hashTag=b. **/
    hashTag?: string
    /** Smer razvrščanja. Privzeto je MR (Najbolj relevantno). Druge možnosti so OF (Najstarejši prvi) in NF (Najnovejši prvi). **/
    direction?: 'MR' | 'OF' | 'NF'
    /** Vnaprej izračunano straničenje: Stran za pridobitev, začetek pri 0. Za vse komentarje (do 250) uporabite -1. **/
    page?: number
    /** Fleksibilno straničenje: Koliko komentarjev naj vrnemo? **/
    limit?: number
    /** Fleksibilno straničenje: Koliko otroških komentarjev naj vrnemo za vsakega starša? **/
    limitChildren?: number
    /** Fleksibilno straničenje: Koliko komentarjev naj preskočimo? **/
    skip?: number
    /** Fleksibilno straničenje: Koliko otroških komentarjev naj preskočimo za vsakega starša? **/
    skipChildren?: number
    /** Za določanje blokiranih in prijavljenih komentarjev. **/
    contextUserId?: string
    /** Za določanje blokiranih in prijavljenih komentarjev. **/
    anonUserId?: string
    /** Za pridobivanje otroških komentarjev. **/
    parentId?: string
    /** Za pridobitev kot drevo. **/
    asTree?: boolean
    /** Kako globoko v drevo naj vrnemo podatke? 0 ne vrne otrok. 1 vrne neposredne otroke itd. **/
    maxTreeDepth?: number
}

Odgovor

Struktura odgovora za komentarje

Copy

interface CommentsResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Komentarji! **/
    comments: Comment[]
}

Koristni nasveti

URL ID

Verjetno boste želeli uporabiti API Comment s parametrom urlId. Najprej lahko pokličete API Pages, da vidite, kako izgledajo razpoložljive vrednosti urlId.

Anonimna dejanja

Za anonimno komentiranje boste verjetno želeli podati anonUserId pri pridobivanju komentarjev in pri prijavljanju in blokiranju.

(!) To je zahtevano pri mnogih trgovinah z aplikacijami, saj mora uporabnik lahko prijavi vsebino, ki jo je ustvaril uporabnik in ki jo vidi, tudi če ni prijavljen. Neupoštevanje tega lahko povzroči, da bo vaša aplikacija odstranjena iz navedene trgovine.

Komentarji se ne vračajo

Preverite, ali so vaši komentarji odobreni in niso neželeni (spam).

GET /api/v1/comments/:id

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

Ta API omogoča pridobitev posameznega komentarja po ID-ju.

Primer cURL zahteve za pridobitev komentarja po ID-ju

Copy

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

Struktura zahteve za pridobitev komentarja po ID-ju

Copy

interface CommentsGetByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za pridobitev komentarja po ID-ju

Copy

interface CommentGetByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno v primeru napake. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'missing-id'
    /** Vključeno v primeru napake. **/
    reason?: string
    /** Komentar! **/
    comment?: Comment
}

POST /api/v1/comments

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

Ta končna točka API omogoča ustvarjanje komentarjev.

Pogoste uporabe so prilagojeni uporabniški vmesniki, integracije ali uvozi.

Opombe:

Ta API lahko po želji posodobi prikazovalnik komentarjev "v živo" (to poveča creditsCost z 1 na 2).
Ta API bo samodejno ustvaril objekte uporabnikov v našem sistemu, če je podan e-poštni naslov.
Poskus shranjevanja dveh komentarjev z različnimi e-poštnimi naslovi, vendar istim uporabniškim imenom, bo pri drugem komentarju povzročil napako.
Če določite parentId, in ima otroški komentar notificationSentForParent nastavljen na false, bomo poslali obvestila za starševski komentar. To se izvaja vsako uro (obvestila zbiramo skupaj, da zmanjšamo število poslanih e-poštnih sporočil).
Če želite poslati dobrodošla e-poštna sporočila ob ustvarjanju uporabnikov ali e-poštna sporočila za preverjanje komentarjev, v poizvedbenih parametrih nastavite sendEmails na true.
Komentarji ustvarjeni preko tega API se bodo prikazali na straneh Analitike in Moderacije v administrativni aplikaciji.
"bad words" so še vedno zastrti v imenih komentatorjev in besedilu komentarjev, če je nastavitev vklopljena.
Komentarje ustvarjene preko tega API-ja je mogoče še vedno preveriti za neželeno pošto, če želite.
Konfiguracija, kot je največja dolžina komentarja, če je nastavljena preko strani pravil za prilagoditev (Customization Rule) v administraciji, se uporabi tukaj.

Najmanjši podatki, potrebni za oddajo in prikaz v pripomočku za komentarje, so naslednji:

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

Bolj realističen primer zahteve je:

Primer POST cURL 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 zahtevka za komentar

Copy

interface CommentPostQueryParams {
    tenantId: string
    API_KEY: string
    doSpamCheck?: 'true' | 'false'
    /** Ali naj se komentar prikaže "v živo" uporabnikom, ki si ogledajo primere pripomočka za komentarje z istim urlId. OPOZORILO: Podvoji strošek kreditov s 1 na 2. **/
    isLive?: 'true' | 'false'
    sendEmails?: 'true' | 'false'
    populateNotifications?: 'true' | 'false'
}

Struktura odgovora POST za komentar

Copy

interface CommentPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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';
    /** Vključeno ob napaki. **/
    reason?: string
    /** Ustvarjeni komentar. **/
    comment?: Comment
    /** Povezani uporabnik, ki je morda že obstajal ali pa še ne. **/
    user?: User
}

PATCH /api/v1/comments/:id

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

Ta API endpoint omogoča posodobitev enega komentarja.

Notes:

Ta API lahko po želji posodobi pripomoček za komentarje "live" (to poveča osnovni creditsCost z 1 na 2).
- To omogoča, da je migracija komentarjev med stranmi "v živo" (spreminjanje urlId).
- Migracije stanejo dodatne 2 kredite, saj se strani predizračunajo in je to intenzivno za CPU.
V nasprotju z API-jem za ustvarjanje, ta API NE bo samodejno ustvaril uporabniških objektov v našem sistemu, če je naveden e-poštni naslov.
Komentarje posodobljene preko tega API-ja je mogoče po želji še vedno preveriti na neželeno pošto (spam).
Konfiguracije, kot je največja dolžina komentarja, če so nastavljene prek strani za upravljanje pravil prilagoditve (Customization Rule), bodo veljale tudi tu.
Da omogočite uporabnikom, da posodobijo besedilo komentarja, lahko v telesu zahteve preprosto navedete comment. Mi bomo ustvarili ustrezen commentHTML.
- Če določite oba comment in commentHTML, HTML ne bomo samodejno ustvarili.
- Če uporabnik v novo besedilo doda omembe ali oznake, bo to še vedno obdelano enako kot pri POST API-ju.
Ko posodabljate commenterEmail pri komentarju, je najbolje, da prav tako navedete userId. V nasprotnem primeru morate zagotoviti, da uporabnik s tem e-poštnim naslovom pripada vašemu tenant, sicer bo zahteva neuspešna.

Minimalen primer PATCH cURL zahteve 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 zahteve za PATCH komentarja

Copy

interface CommentPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Uporabnik, ki izvaja posodobitev. Po želji se lahko uporabi za preverjanje, ali lahko ureja komentar.  **/
    contextUserId?: string
    /** Ali naj preverimo, ali nov komentar izgleda kot spam?  **/
    doSpamCheck?: 'true' | 'false'
    /** Ali naj se komentar prikaže "v živo" uporabnikom, ki gledajo instance pripomočka za komentarje z istim urlId. OPOMBA: Podvoji strošek kreditov s 1 na 2. **/
    isLive?: 'true' | 'false'
}

Struktura odgovora PATCH komentarja

Copy

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

DELETE /api/v1/comments/:id

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

Ta API endpoint omogoča brisanje komentarja.

Opombe:

Ta API lahko po želji posodobi pripomoček za komentarje "v živo" (to poveča creditsCost s 1 na 2).
Ta API bo izbrisal vse podrejene komentarje.

Primer cURL zahteve za brisanje komentarja

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 zahteve za brisanje komentarja

Copy

interface CommentDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** Uporabnik, ki izvaja posodobitev. Po želji se lahko uporabi za preverjanje, ali lahko izbriše komentar. **/
    contextUserId?: string
    /** Ali naj bo komentar izbrisan "v živo" za uporabnike, ki si ogledujejo primerke pripomočka za komentarje z enakim urlId. OPOMBA: Podvoji strošek kreditov s 1 na 2. **/
    isLive?: 'true' | 'false'
}

Struktura odgovora za brisanje komentarja

Copy

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

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

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

Ta API endpoint omogoča prijavo (flag) komentarja za določenega uporabnika.

Opombe:

Ta klic mora biti vedno izveden v kontekstu uporabnika. Uporabnik je lahko FastComments.com uporabnik, SSO uporabnik ali uporabnik najemnika.
Če je nastavljen flag-to-hide threshold, bo komentar samodejno skrit v živo, potem ko je bil prijavljen tolikokrat, kot je določeno.
Ko je samodejno preklican (skrit) — komentar lahko ponovno potrdi le skrbnik ali moderator. Odstranitev oznake (un-flagging) komentarja ga ne bo ponovno potrdila.

Primer cURL zahteve za označitev komentarja

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 prijavo moramo določiti anonUserId. To je lahko ID, ki predstavlja anonimno sejo, ali naključni UUID. To nam omogoča podporo prijavljanja in odstranjevanja prijav komentarjev tudi, če uporabnik ni prijavljen. Tako je lahko komentar označen kot prijavljen, ko se komentarji pridobijo z istim anonUserId.

Primer cURL zahteve za anonimno označitev komentarja

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 zahteve za označitev komentarja

Copy

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

Struktura odgovora za označitev komentarja

Copy

interface CommentFlagResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Ali je bil komentar samodejno preklican (skrit) zaradi prevelikega števila prijav? **/
    wasUnapproved?: boolean;
}

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

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

Ta končna točka API-ja omogoča odstranitev zastavice (un-flag) iz komentarja za določenega uporabnika.

Opombe:

Klic mora biti vedno izveden v kontekstu uporabnika. Uporabnik je lahko FastComments.com User, SSO User, ali Tenant User.
Ko je komentar samodejno zavrnjen (skrit) - komentar lahko ponovno odobri le administrator ali moderator. Odznačitev zastavice ne bo ponovno odobrila komentarja.

Primer cURL za odznačitev komentarja

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čevanje z zastavico moramo navesti anonUserId. To je lahko ID, ki predstavlja anonimno sejo, ali naključni UUID.

Primer cURL za anonimno odznačitev komentarja

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 zahtevka za odznačitev komentarja

Copy

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

Struktura odgovora za odznačitev komentarja

Copy

interface CommentUnFlagResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id'
    /** Vključeno ob neuspehu. **/
    reason?: string
}

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

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

Ta API endpoint omogoča blokiranje uporabnika, ki je napisal določen komentar. Podpira blokiranje komentarjev, napisanih s strani FastComments.com uporabnikov, SSO uporabnikov in najemniških uporabnikov.

Podpira telo parameter commentIdsToCheck, s katerim se preveri, ali je treba po tej akciji kateri koli drug potencialno viden komentar na odjemalcu blokirati/odblokirati.

Opombe:

Ta klic mora biti vedno izveden v kontekstu uporabnika. Uporabnik je lahko FastComments.com uporabnik, SSO uporabnik ali najemniški uporabnik.
V zahtevi userId označuje uporabnika, ki izvaja blokiranje. Na primer: User A želi blokirati User B. Posredujte userId=User A in ID komentarja, ki ga je napisal User B.
Popolnoma anonimnih komentarjev (brez ID uporabnika, brez e-pošte) ni mogoče blokirati in bo vrnjena napaka.

Primer cURL zahteve za blokiranje komentarja

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 en anonUserId. To je lahko ID, ki predstavlja anonimno sejo, ali naključen UUID. To nam omogoča podporo blokiranja komentarjev tudi, če uporabnik ni prijavljen, saj se komentarji pridobijo z istim anonUserId.

Primer cURL za blokiranje anonimnega komentarja

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 zahteve za blokiranje komentarja

Copy

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

Struktura odgovora za blokiranje komentarja

Copy

interface CommentBlockResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'missing-user-id' | 'missing-anon-user-id' | 'comment-cannot-be-blocked'
    /** Vključeno ob neuspehu. **/
    reason?: string
    /** Če je commentIdsToCheck definirano, so vnosi v tem zemljevidu z vrednostjo true prav tako blokirani. **/
    commentStatuses?: Record<string, boolean>;
}

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

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

Ta API konecna točka omogoča odblokiranje uporabnika, ki je napisal določen komentar. Podpira odblokiranje komentarjev, napisanih s strani uporabnikov FastComments.com, SSO uporabnikov in najemniških uporabnikov.

Podpira parametru v telesu zahteve commentIdsToCheck, s katerim se preveri, ali je treba tudi druge morebitno vidne komentarje na odjemalcu po tej akciji blokirati/odblokirati.

Opombe:

Ta klic mora biti vedno izveden v kontekstu uporabnika. Uporabnik je lahko uporabnik FastComments.com, SSO uporabnik ali najemniški uporabnik.
V zahtevku userId označuje uporabnika, ki izvaja odblokiranje. Na primer: User A želi odblokirati User B. Posredujte userId=User A in ID komentarja, ki ga je napisal User B.
Popolnoma anonimnih komentarjev (brez ID uporabnika, brez e-pošte) ni mogoče blokirati in bo vrnjena napaka.

Primer cURL zahteve za odblokiranje komentarja

Copy

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

Primer cURL zahteve za odblokiranje anonimnega komentarja

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 zahteve za odblokiranje komentarja

Copy

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

Struktura odgovora za odblokiranje komentarja

Copy

interface CommentUnBlockResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Če je `commentIdsToCheck` določen, so vnosi v tem zemljevidu z vrednostjo true še vedno blokirani. Če false, boste morda želeli komentare ponovno prikazati uporabniku, da se mu ni treba osveževati. **/
    commentStatuses?: Record<string, boolean>;
}

Struktura e-poštne predloge

Objekt EmailTemplate predstavlja konfiguracijo za prilagojen e-poštni predlog za najemnika.

Sistem bo izbral e-poštni predlog na podlagi:

Njegovega identifikatorja vrste, imenovanega emailTemplateId. To so konstante.
domain. Najprej bomo poskusili najti predlog za domeno, s katero je povezan ustrezni objekt (na primer Comment), in če ujemanja ne najdemo, bomo poiskali predlog, kjer je domain null ali *.

Struktura objekta EmailTemplate je naslednja:

Struktura e-poštnega predloga

Copy

interface EmailTemplate {
    id: string
    tenantId: string
    emailTemplateId: string
    displayName: string
    /** SAMO ZA BRANJE **/
    createdAt: string
    /** SAMO ZA BRANJE **/
    updatedAt: string
    /** SAMO ZA BRANJE **/
    updatedByUserId: string
    /** Domena, s katero naj bo predlog povezan. **/
    domain?: string | '*' | null
    /** Vsebina e-poštnega predloga v sintaksi EJS. **/
    ejs: string
    /** Preslikava prepisanih prevodnih ključev na vrednosti za vsako podprto lokalizacijo. **/
    translationOverridesByLocale: Record<string, Record<string, string>>
    /** Objekt, ki predstavlja kontekst za izris predloga. **/
    testData: object
}

Opombe

Veljavne vrednosti emailTemplateId lahko pridobite prek končne točke /definitions.
Končna točka /definitions vsebuje tudi privzete prevode in testne podatke.
Predlogi se ne bodo shranili, če je struktura ali testni podatki neveljavni.

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

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

Posamezne EmailTemplate lahko pridobite z njihovim ustreznim id (NE emailTemplateId).

Primer cURL za EmailTemplate po ID-ju

Copy

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

Struktura zahteve za EmailTemplate po ID-ju

Copy

interface EmailTemplatesByIdRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za EmailTemplate po ID-ju

Copy

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

GET /api/v1/email-templates

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

Ta API uporablja straničenje, ki ga zagotavlja poizvedni parameter page. EmailTemplates so vrnjeni po straneh po 100, urejeni po createdAt in nato id.

Primer cURL za EmailTemplate

Copy

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

Struktura zahteve za EmailTemplate

Copy

interface EmailTemplatesRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Stran za pridobitev, začne se z 0. **/
    page: number
}

Struktura odgovora za EmailTemplate

Copy

interface EmailTemplatesResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    emailTemplates: EmailTemplate[]
}

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

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

Ta API endpoint omogoča posodobitev e-poštne predloge z navedbo samo id in atributov, ki jih želite posodobiti.

Upoštevajte, da veljajo enake preveritve kot pri ustvarjanju predloge, na primer:

Predloga se mora pravilno upodobiti. To se preveri pri vsaki posodobitvi.
Ne morete imeti podvojenih predlog za isto domeno (v nasprotnem primeru bi bila ena prezreta brez obvestila).

Primer cURL zahteve za EmailTemplate PATCH

Copy

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

Struktura zahteve za EmailTemplate PATCH

Copy

interface EmailTemplatePatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za EmailTemplate PATCH

Copy

interface EmailTemplatePatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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';  
    /** Vključeno ob neuspehu. **/
    reason?: string
    /** Posodobljena e-poštna predloga. **/
    emailTemplate?: EmailTemplate
}

POST /api/v1/email-templates

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

Ta API vmesnik omogoča ustvarjanje predlog e-pošte.

Opombe:

Ne morete imeti več predlog z istim emailTemplateId za isto domeno.
Vendar pa lahko imate univerzalno (wildcard) predlogo (domain = *) in domensko specifično predlogo za isti emailTemplateId.
Določitev domain je pomembna le, če imate različne domene ali želite uporabiti specifične predloge za testiranje (npr. domain nastavljena na localhost).
Če določite domain, mora ta ustrezati DomainConfig. V primeru napake je na voljo seznam veljavnih domen.
Sintaksa predloge je EJS in se upodablja z omejitvijo 500ms. P99 za upodabljanje je <5ms, zato, če dosežete 500ms, je nekaj narobe.
Vaša predloga se mora upodabljati z danimi testData, da se shrani. Napake pri upodabljanju se združujejo in poročajo na nadzorni plošči (kmalu na voljo tudi prek API).

Najmanj podatkov, potrebnih za dodajanje predloge, je naslednjih:

Minimalni primer cURL POST za EmailTemplate

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 %>."
}'

Morda boste želeli imeti predloge za vsako spletno mesto posebej; v tem primeru določite domain:

Primer cURL POST za EmailTemplate

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 POST zahteve za EmailTemplate

Copy

interface EmailTemplatePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za EmailTemplate

Copy

interface EmailTemplatePostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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';
    /** Vključeno ob neuspehu. **/
    reason?: string
    /** Ustvarjena predloga. **/
    emailTemplate?: EmailTemplate
}

POST /api/v1/email-templates/render

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

Ta API končna točka omogoča predogled e-poštnih predlog.

Minimalni cURL primer POST za predogled 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 zahteve za EmailTemplate

Copy

interface EmailTemplatePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za EmailTemplate

Copy

interface EmailTemplatePostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'unauthorized' | 'unexpected-param' | 'does-not-render';
    /** Vključeno ob napaki. **/
    reason?: string
    /** Upodobljen HTML ob uspehu. **/
    html?: string
}

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

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

Ta končna točka omogoča odstranitev posameznega EmailTemplate po id.

Primer cURL za odstranitev EmailTemplate

Copy

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

Struktura zahtevka za odstranitev EmailTemplate

Copy

interface EmailTemplateRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev EmailTemplate

Copy

interface EmailTemplateDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno v primeru napake. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized'
    /** Vključeno v primeru napake. **/
    reason?: string
}

Struktura hashtagov

Objekt HashTag predstavlja oznako, ki jo lahko pusti uporabnik. HashTags se lahko uporabijo za povezavo na zunanjo vsebino ali za povezovanje sorodnih komentarjev.

The structure for the HashTag object is as follows:

Struktura HashTag

Copy

interface HashTag {
    /** Naj se začne z "#" ali želenim znakom. **/
    tag: string
    /** Izbiren URL, na katerega lahko kaže hashtag. Namesto filtriranja komentarjev po hashtagu bo uporabniški vmesnik ob kliku preusmeril na ta URL. **/
    url?: string
    /** LE ZA BRANJE **/
    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

To API uporablja straničenje, ki ga zagotavlja poizvedni parameter page. Hashtagi se vrnejo v straneh po 100, urejeni po tag.

cURL primer za HashTag

Copy

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

Struktura zahteve za HashTag

Copy

interface HashTagsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Stran za pridobitev, začne se pri 0. **/
    page: number
}

Struktura odgovora za HashTag

Copy

interface HashTagsResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Hashtagi! **/
    hashTags: HashTag[]
}

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

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

Ta končna točka omogoča posodobitev enega HashTag.

Primer cURL zahteve za posodobitev HashTag

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 zahtevka za posodobitev HashTag

Copy

interface HashTagPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za posodobitev HashTag

Copy

interface HashTagPatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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'
    /** Vključeno ob neuspehu. **/
    reason?: string
    hashTag?: HashTag; // Vrne popolnoma posodobljen hashTag ob uspehu.
}

POST /api/v1/hash-tags

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

Ta pot omogoča dodajanje posameznega HashTag.

Primer cURL zahteve za ustvarjanje HashTag

Copy

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

Struktura zahteve za ustvarjanje HashTag

Copy

interface HashTagPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ustvarjanje HashTag

Copy

interface HashTagPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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'
    /** Vključeno ob napaki. **/
    reason?: string
    hashTag?: HashTag; // Ob uspehu vrnemo popoln ustvarjeni HashTag.
}

POST /api/v1/hash-tags/bulk

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

Ta pot omogoča dodajanje do 100 HashTag objektov hkrati.

Primer cURL za množično ustvarjanje HashTag

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 zahteve za množično ustvarjanje HashTag

Copy

interface HashTagPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za množično ustvarjanje HashTag

Copy

interface HashTagBulkPostResponse {
    status: 'success' | 'failed'
    /** Vključeno v primeru napake. **/
    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'
    /** Vključeno v primeru napake. **/
    reason?: string
    results?: HashTagPostResponse[]; // Vrne se seznam objektov HashTagPostResponse za vsak podani tag.
}

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

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

Ta ruta omogoča odstranitev uporabnika HashTag z navedenim tagom.

Upoštevajte, da če samodejno ustvarjanje HashTag ni onemogočeno, lahko uporabniki ponovno ustvarijo hashtage tako, da pri komentiranju vnesejo hashtag.

Primer cURL zahteve za odstranitev HashTag

Copy

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

Struktura zahteve za odstranitev HashTag

Copy

interface HashTagDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev HashTag

Copy

interface HashTagDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-hash-tag' | 'tag-does-not-exist'
    /** Vključeno ob neuspehu. **/
    reason?: string
}

Struktura moderatorja

Objekt Moderator predstavlja konfiguracijo za moderatorja.

Obstajajo trije tipi moderatorjev:

Administrator users that have the isCommentModeratorAdmin flag.
SSO Users with the isCommentModeratorAdmin flag.
Regular commenters, or FastComments.com users, that are invited as Moderators.

Struktura Moderator se uporablja za predstavitev stanja moderacije pri primeru uporabe 3.

Če želite preko API-ja povabiti uporabnika, da postane moderator, uporabite Moderator API tako, da ustvarite Moderator in jih inviting.

Če uporabnik nima računa FastComments.com, mu bo povabilo po e-pošti pomagalo pri nastavitvi. Če že ima račun, mu bo dodeljen dostop za moderiranje do vašega tenant-a in lastnost userId objekta Moderator bo posodobljena, da kaže na njihovega uporabnika. Nimali boste API dostopa do njihovega uporabnika, saj v tem primeru pripada njim in ga upravlja FastComments.com.

Če potrebujete popolno upravljanje računa uporabnika, priporočamo uporabo SSO ali pa ga dodajte kot Tenant User in nato dodajte objekt Moderator za sledenje njihovim statistikam.

Strukturo Moderator je mogoče uporabiti kot mehanizem za sledenje statistik v primerih uporabe 1 in 2. Po ustvarjanju uporabnika dodajte objekt Moderator z določenim userId in njihove statistike se bodo spremljale na Comment Moderators Page.

Struktura objekta Moderator je naslednja:

Struktura Moderatorja

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

Ta klic vrne enega moderatorja po njihovem id.

Primer cURL zahteve za moderatorja po id

Copy

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

Struktura zahteve za moderatorja

Copy

interface ModeratorByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za moderatorja

Copy

interface ModeratorByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno v primeru napake. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Vključeno v primeru napake. **/
    reason?: string
    moderator?: Moderator
}

GET /api/v1/moderators

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

Ta API uporablja straničenje, ki ga zagotavlja poizvedni parameter skip. Moderatorji se vračajo po straneh po 100, urejeni po createdAt in id.

Stroški so odvisni od števila vrnjenih moderatorjev: 1 credit per 10 vrnjenih moderatorjev.

Primer cURL poizvedbe za Moderator

Copy

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

Struktura zahteve za Moderator

Copy

interface ModeratorsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Število moderatorjev, ki jih je treba preskočiti za straničenje. **/
    skip?: number
}

Struktura odgovora za Moderator

Copy

interface ModeratorsResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    moderators?: Moderator[]
}

PATCH /api/v1/moderators/:id

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

Ta API končna točka omogoča posodobitev Moderator po id.

Posodabljanje Moderator ima naslednje omejitve:

Pri posodabljanju Moderator ni dovoljeno posredovati naslednjih vrednosti:
- acceptedInvite
- markReviewedCount
- deletedCount
- markedSpamCount
- approvedCount
- editedCount
- bannedCount
- verificationId
- createdAt
Če je naveden userId, mora ta uporabnik obstajati.
Če je naveden userId, mora pripadati istemu tenantId, navedenemu v parametrih poizvedbe.
Dva moderatorja v istem najemniku ne moreta biti dodana z istim email.
Ne smete spremeniti tenantId, povezanega z Moderator.

Primer cURL zahteve za Moderator PATCH

Copy

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

Struktura zahteve PATCH za Moderator

Copy

interface ModeratorPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora PATCH za Moderator

Copy

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

POST /api/v1/moderators

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

Ta ruta omogoča dodajanje enega samega Moderator.

Ustvarjanje Moderator ima naslednje omejitve:

Vedno morate navesti name in email. userId je izbiren.
Pri ustvarjanju Moderator ni dovoljeno navesti naslednjih vrednosti:
- acceptedInvite
- markReviewedCount
- deletedCount
- markedSpamCount
- approvedCount
- editedCount
- bannedCount
- verificationId
- createdAt
Če je naveden userId, ta uporabnik mora obstajati.
Če je naveden userId, mora pripadati istemu tenantId, navedenemu v parametrkih poizvedbe.
Dva moderatorja v istem najemniku ne moreta imeti istega email.

Ustvarimo lahko Moderator za uporabnika, o katerem poznamo samo e-poštni naslov:

Ustvarjanje Moderatorja prek e-pošte — primer cURL

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

Lahko pa ustvarimo Moderator za uporabnika, ki pripada našemu najemniku, da spremljamo njegove statistike moderiranja:

Ustvarjanje Moderatorja prek uporabnika najemnika — primer cURL

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 zahtevka za ustvarjanje Moderatorja

Copy

interface ModeratorPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ustvarjanje Moderatorja

Copy

interface ModeratorPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'name-required' | 'email-required' | 'unexpected-param' | 'not-found'
    /** Vključeno ob neuspehu. **/
    reason?: string
    moderator?: Moderator; // Ob uspehu vrnemo popolnoma ustvarjenega moderatorja.
}

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

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

Ta ruta omogoča povabilo enega samega Moderator.

The following restrictions exist to send an invite email to a Moderator:

Moderator mora že obstajati.
fromName ne sme biti daljši od 100 characters.

Opombe:

Če uporabnik z navedenim e-poštnim naslovom že obstaja, bo povabljen, da moderira komentarje vašega najemnika.
Če uporabnik z navedenim e-poštnim naslovom ne obstaja bo povezava za povabilo vodila skozi postopek ustvarjanja njihovega računa.
Povabilo poteče po 30 days.

Lahko ustvarimo Moderator za uporabnika, katerega poznamo le po e-poštnem naslovu:

Primer cURL povabila moderatorja

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'

To bo poslalo e-pošto, kot je Bob at TenantName is inviting you to be a moderator...

Struktura zahteve za povabilo moderatorja

Copy

interface ModeratorSendInviteQueryParams {
    tenantId: string
    API_KEY: string
    /** E-pošta, poslana uporabniku, se bo prikazovala, kot da je poslana iz tega imena. **/
    fromName: string
}

Struktura odgovora na povabilo moderatorja

Copy

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

DELETE /api/v1/moderators/:id

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

Ta pot omogoča odstranitev Moderator po id.

Primer cURL zahteve za odstranitev Moderator

Copy

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

Struktura zahteve za odstranitev Moderator

Copy

interface ModeratorDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora ob odstranitvi Moderator

Copy

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

Struktura števila obvestil

Objekt NotificationCount predstavlja število neprebranih obvestil in metapodatke za uporabnika.

Če ni neprebranih obvestil, za uporabnika ne bo NotificationCount.

Objekti NotificationCount se ustvarijo samodejno in jih ni mogoče ustvariti prek API-ja. Prav tako potečejo po enem letu.

Število neprebranih obvestil uporabnika lahko počistite z izbrisom njihovega NotificationCount.

Struktura objekta NotificationCount je naslednja:

Struktura NotificationCount

Copy

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

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

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

Ta pot vrne en sam NotificationCount po ID-ju uporabnika. Pri SSO je ID uporabnika v obliki <tenant id>:<user id>.

Če ni nobenih neprebranih obvestil, NotificationCount ne bo — zato boste prejeli 404.

To se razlikuje od notifications/count, ker je veliko hitrejše, vendar ne dopušča filtriranja.

Primer cURL za NotificationCount po ID

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 zahteve za NotificationCount

Copy

interface NotificationCountGetQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za NotificationCount

Copy

interface NotificationCountGetResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'not-found'
    /** Vključeno ob neuspehu. **/
    reason?: string
    data?: NotificationCount
}

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

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

Ta ruta izbriše en sam NotificationCount glede na ID uporabnika. Pri SSO je ID uporabnika v obliki <tenant id>:<user id>.

To bo počistilo število neprebranih obvestil uporabnika (rdeči zvonček v widgetu za komentarje bo zbledel in števec bo izginil).

Primer cURL za DELETE NotificationCount

Copy

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

Struktura zahteve za odstranitev NotificationCount

Copy

interface NotificationCountDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora ob odstranitvi NotificationCount

Copy

interface NotificationCountDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'not-found'
    /** Vključeno ob napaki. **/
    reason?: string
}

Struktura obvestila

Objekt Notification predstavlja obvestilo za uporabnika.

Objekti Notification se ustvarijo samodejno in jih ni mogoče ustvariti prek API-ja. Prav tako potečejo po enem letu. Obvestil ni mogoče izbrisati. Lahko pa se posodobijo, tako da nastavite viewed na false, in lahko poizvedujete po viewed.

Uporabnik se lahko tudi odjavi od obvestil za določen komentar tako, da v obvestilu nastavi optedOut na true. Ponovno se lahko prijavite tako, da nastavite optedOut na false.

Obstajajo različne vrste obvestil - preverite relatedObjectType in type.

Načini ustvarjanja obvestil so precej prilagodljivi in jih lahko sprožijo številni scenariji (glejte NotificationType).

Trenutno prisotnost Notification ne pomeni nujno, da je bilo ali bi moralo biti poslano e-poštno sporočilo. Namesto tega se obvestila uporabljajo za feed obvestil in sorodne integracije.

Struktura za objekt Notification je naslednja:

Struktura obvestila

Copy

enum NotificationObjectType {
    Comment = 0,
    Profile = 1,
    Tenant = 2
}
enum NotificationType {
    /** Če vam je nekdo odgovoril. **/
    RepliedToMe = 0,
    /** Če je nekdo odgovoril kjerkoli v niti (tudi otroci otrok) niti, kjer ste komentirali. **/
    RepliedTransientChild = 1,
    /** Če je bil vaš komentar podprt z glasom gor (up-voted). **/
    VotedMyComment = 2,
    /** Če je na korenu strani, na katero ste naročeni, objavljen nov komentar. **/
    SubscriptionReplyRoot = 3,
    /** Če je nekdo komentiral vaš profil. **/
    CommentedOnProfile = 4,
    /** Če imate zasebno sporočilo (DM). **/
    DirectMessage = 5,
    /** TrialLimits je namenjen samo uporabnikom najemnika. **/
    TrialLimits = 6,
    /** Če ste bili omenjeni z @. **/
    Mentioned = 7
}
interface Notification {
    id: string
    tenantId: string
    /** Pri SSO je uporabniški id v formatu `<tenant id>:<user id>`. **/
    userId?: string
    /** Pri delu s SSO vas zanima samo `userId`. **/
    anonUserId?: string
    /** urlId je skoraj vedno določen. To je opcijsko samo za obvestila na ravni najemnika, ki so redka. **/
    urlId?: string
    /** URL je predpomnjen za hitro navigacijo do vira obvestila. **/
    url?: string
    /** Naslov strani je predpomnjen za hitro branje vira obvestila. **/
    pageTitle?: string
    relatedObjectType: NotificationObjectType
    /** Na primer, id komentarja. **/
    relatedObjectId: string
    viewed: boolean
    createdAt: string // niz datuma
    type: NotificationType
    fromCommentId?: string
    fromVoteId?: string
    /** fromUserName and fromUserAvatarSrc so tukaj predpomnjena za hitro prikazovanje obvestila. Posodobita se, ko se uporabnik posodobi. **/
    fromUserName: string
    fromUserId: string
    fromUserAvatarSrc?: string
    /** Nastavite to na true, da prenehate prejemati obvestila za ta objekt. **/
    optedOut?: boolean
}

GET /api/v1/notifications

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

Ta pot vrne do 30 Notification objektov, razvrščenih po createdAt, najnovejši prvi.

Lahko filtrirate po userId. Pri SSO je ID uporabnika v formatu <tenant id>:<user id>.

Primer cURL: neprebrana obvestila uporabnika

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 zahteve za obvestila

Copy

interface NotificationsGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Straničenje s preskočitvijo zapisov. **/
    skip?: number
    /** Filtriraj po uporabniku. **/
    userId?: string
    /** Filtriraj po urlId. **/
    urlId?: string
    /** Filtriraj po izvorni komentar. **/
    fromCommentId?: string
    /** Filtriraj po prebranem/neprebranem. **/
    viewed?: 'true' | 'false'
    /** Filtriraj po tipu. **/
    type?: NotificationType
}

Struktura odgovora za obvestila

Copy

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

GET /api/v1/notifications/count

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

Ta ruta vrača objekt, ki vsebuje število obvestil v parametru count.

Je počasnejša od /notification-count/ in stane dvakrat več kreditov, vendar omogoča filtriranje po več dimenzijah.

Filtrirate lahko z istimi parametri kot pri končni točki /notifications, na primer userId. Pri SSO je ID uporabnika v formatu <tenant id>:<user id>.

Primer cURL zahteve za število neprebranih obvestil uporabnika

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'

Primer cURL zahteve za število neprebranih obvestil uporabnika za določeno stran

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 zahteve za število obvestil

Copy

interface NotificationCountGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Filtriraj po uporabniku. **/
    userId?: string
    /** Filtriraj po urlId. **/
    urlId?: string
    /** Filtriraj po izvirnem komentarju. **/
    fromCommentId?: string
    /** Filtriraj po prebrano/neprebrano. **/
    viewed?: 'true' | 'false'
    /** Filtriraj po tipu. **/
    type?: NotificationType
}

Struktura odgovora za število obvestil

Copy

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

PATCH /api/v1/notifications/:id

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

Ta končna točka API omogoča posodobitev Notification po id.

Posodabljanje Notification ima naslednje omejitve:

Posodobiti lahko le naslednja polja:
- viewed
- optedOut

Primer cURL PATCH 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 zahteve PATCH za Notification

Copy

interface NotificationPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora PATCH za Notification

Copy

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

Struktura strani

Objekt Page predstavlja stran, kateremu lahko pripada več komentarjev. Ta povezava je določena z urlId.

Objekt Page hrani informacije, kot so naslov strani, število komentarjev in urlId.

Struktura objekta Page je naslednja:

Struktura strani

Copy

interface Page {
    id: string
    urlId: string
    url: string
    title?: string
    createdAt: string
    commentCount: number
    rootCommentCount: number
    /** Nastavitev na null pomeni, da lahko stran vidijo vsi SSO uporabniki. Prazen seznam pomeni, da je zaprt za vse uporabnike. **/
    accessibleByGroupIds?: string[] | null
    /** Je ta stran zaprta za nove komentarje? **/
    isClosed?: boolean
}

GET /api/v1/pages

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

Trenutno lahko pridobite le vse strani (ali posamezno stran preko /by-url-id) povezanih z vašim računom. Če želite bolj natančno iskanje, kontaktirajte nas.

Primer cURL zahtevka za strani

Copy

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

Struktura zahtevka za strani

Copy

interface PagesRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za strani

Copy

interface PagesResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    pages: Page[]
}

Koristen nasvet

API Comment zahteva urlId. Najprej lahko pokličete API Pages, da vidite, kako izgledajo vrednosti urlId, ki so vam na voljo.

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

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

Posamezne strani lahko pridobite po njihovem ustreznem urlId. To je lahko uporabno pri iskanju naslovov strani ali števila komentarjev.

Primer cURL zahteve za stran po URL ID

Copy

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

Struktura zahteve za stran po URL ID

Copy

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

Struktura odgovora za stran po URL ID

Copy

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

Koristen nasvet

Ne pozabite kodirati vrednosti za URI, kot je urlId.

PATCH /api/v1/pages/:id

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

Ta ruta omogoča posodobitev ene Page. Ustrezni komentarji bodo posodobljeni.

Primer cURL zahteve za posodobitev strani

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 zahteve za posodobitev strani

Copy

interface PagePatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora posodobitve strani

Copy

interface PagePatchResponse {
    status: 'success' | 'failed'
    /** Vključen ob napaki. **/
    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'
    /** Vključen ob napaki. **/
    reason?: string
    user?: Page; // Na uspeh vrnemo popolnoma posodobljeno stran.
}

Opomba

Nekateri parametri v objektu Page se samodejno posodobijo. To so atributi za števce in naslov. Števcev ni mogoče posodobiti prek API-ja, saj so izračunane vrednosti. Naslov strani title je mogoče nastaviti prek API-ja, vendar bo prepisan, če je gradnik za komentarje uporabljen na strani z istim urlId in drugačnim naslovom strani.

POST /api/v1/pages

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

Ta končna točka API-ja omogoča ustvarjanje strani.

Pogosta uporaba je nadzor dostopa.

Opombe:

Če ste komentirali v nit komentarjev, ali poklicali API za ustvarjanje Comment, ste že ustvarili objekt Page! Poskusite ga pridobiti prek Page poti /by-url-id, tako da posredujete isti urlId, ki je bil posredovan gradniku za komentarje.
Struktura Page vsebuje nekaj izračunanih vrednosti. Trenutno so to commentCount in rootCommentCount. Te vrednosti se napolnijo samodejno in jih API ne dovoljuje nastaviti. Poskus nastavitev bo povzročil, da bo API vrnil napako.

Primer cURL zahteve 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 zahteve za Page

Copy

interface PagePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za Page

Copy

interface PagePostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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';  
    /** Vključeno ob neuspehu. **/
    reason?: string
    /** Ustvarjena stran. **/
    page?: Page
}

DELETE /api/v1/pages/:id

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

Ta pot omogoča odstranitev posamezne strani po id.

Upoštevajte, da bo interakcija z vtičnikom za komentarje za stran z istim urlId preprosto brezhibno ponovno ustvarila Page.

Primer cURL zahteve za odstranitev strani

Copy

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

Struktura zahteve za odstranitev strani

Copy

interface PageDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev strani

Copy

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

Struktura čakajočega webhook dogodka

Objekt PendingWebhookEvent predstavlja webhook dogodek v čakalni vrsti.

Objekti PendingWebhookEvent se ustvarijo samodejno in jih ni mogoče ročno ustvariti prek API. Potečejo tudi po enem letu. Lahko jih izbrišete, kar odstrani nalogo iz vrste.

Obstajajo različne vrste dogodkov - preverite eventType (OutboundSyncEventType) in type (OutboundSyncType).

Pogost primer uporabe tega API-ja je implementacija prilagojenega nadzora. Morda boste želeli občasno klicati /count končno točko za poizvedovanje o številu nerešenih primerov za določene filtre.

Struktura objekta PendingWebhookEvent je naslednja:

Struktura PendingWebhookEvent

Copy

enum OutboundSyncEventType {
    Create: 0,
    Delete: 1,
    Update: 2
}
enum OutboundSyncType {
    /** Naloga sinhronizacije specifična za WordPress. **/
    WP: 0,
    Webhook: 1
}
interface PendingWebhookEvent {
    id: string
    /** ID komentarja, povezanega z dogodkom. **/
    commentId: string
    /** Objekt komentarja za dogodek ob času dogodka. Začeli smo jih dodajati novembra 2023. **/
    comment: Comment
    /** Zunanji ID, ki je lahko povezan s komentarjem. **/
    externalId: string | null
    createdAt: Date
    tenantId: string
    attemptCount: number
    /** Nastavljeno pred prvim poskusom in po vsaki napaki. **/
    nextAttemptAt: Date
    /** Ali gre za dogodek ustvarjanja, brisanja ali posodobitve... **/
    eventType: OutboundSyncEventType
    /** Vrsta sinhronizacije, ki jo je treba izvesti (WordPress, klic API, itd.). **/
    type: OutboundSyncType
    /** Domena, ki se je ujemala s komentarjem. To domeno uporabimo za izbiro API ključa. **/
    domain: string
    /** Zadnja nastala napaka. Ta tip ni tipiziran in je "dump" tega, kar se je zgodilo. Običajno vsebuje objekt s statusCode, body, in mapo headers. **/
    lastError: object | null
}

GET /api/v1/pending-webhook-events

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

Ta pot vrne seznam čakajočih webhook dogodkov v parametru pendingWebhookEvents.

Ta API uporablja paginacijo, ki jo določa parameter skip. PendingWebhookEvents so vrnjeni po straneh po 100, urejeni po createdAt od najnovejših naprej.

Primer cURL za PendingWebhookEvent

Copy

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

Struktura zahteve PendingWebhookEvent

Copy

interface PendingWebhookEventsGetQueryParams {
    tenantId: string
    API_KEY: string
    commentId?: string
    externalId?: string
    eventType?: OutboundSyncEventType
    type?: OutboundSyncType
    domain?: string
    /** Poizvedba za dogodke s številom poskusov večjim od navedenega. **/
    attemptCountGT?: number
}

Struktura odgovora PendingWebhookEvent

Copy

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

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

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

Ta pot vrne objekt, ki vsebuje število čakajočih webhook dogodkov v parametru count.

Lahko filtrirate z istimi parametri kot na končni točki /pending-webhook-events

Primer cURL zahtevka za štetje PendingWebhookEvent

Copy

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

Struktura zahteve za štetje PendingWebhookEvent

Copy

interface PendingWebhookEventsCountQueryParams {
    tenantId: string
    API_KEY: string
    commentId?: string
    externalId?: string
    eventType?: OutboundSyncEventType
    type?: OutboundSyncType
    domain?: string
    /** Poizvedba za dogodke, katerih število poskusov je večje od navedenega. **/
    attemptCountGT?: number
}

Struktura odgovora za štetje PendingWebhookEvent

Copy

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

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

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

Ta končna točka omogoča izbris enega PendingWebhookEvent.

Če potrebujete množični izbris, pokličite GET API s paginacijo in nato to API pokličite zaporedoma.

Primer cURL zahteve za DELETE PendingWebhookEvent

Copy

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

Struktura zahteve za brisanje PendingWebhookEvent

Copy

interface PendingWebhookEventDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za brisanje PendingWebhookEvent

Copy

interface PendingWebhookEventDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Vključeno ob napaki. **/
    reason?: string
}

Struktura SSO uporabnika

FastComments zagotavlja enostavno rešitev SSO. Posodabljanje informacij o uporabniku z integracijo, ki temelji na HMAC, je tako preprosto, kot če uporabnik naloži stran s posodobljenim podatkovnim paketom.

Vendar je včasih zaželeno upravljati z uporabnikom izven tega toka, da izboljšate doslednost vaše aplikacije.

SSO User API omogoča ustvarjanje, branje, posodabljanje in brisanje objektov, ki jim pravimo SSOUsers. Ti objekti se razlikujejo od običajnih Users in so ločeni zaradi tipne varnosti.

The structure for the SSOUser object is as follows:

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 // Skrbniška pravica - SSO uporabniki s to zastavico so zaračunani kot SSO Admini (ločeno od običajnih SSO uporabnikov)
    isAdminAdmin?: boolean // Skrbniška pravica - SSO uporabniki s to zastavico so zaračunani kot SSO Admini (ločeno od običajnih SSO uporabnikov)
    isCommentModeratorAdmin?: boolean // Moderatorska pravica - SSO uporabniki s to zastavico so zaračunani kot SSO Moderatorji (ločeno od običajnih SSO uporabnikov)
    /** Če je null, Access Control ne bo uporabljen za uporabnika. Če je seznam prazen, ta uporabnik ne bo mogel videti nobenih strani ali @omeniti drugih uporabnikov. **/
    groupIds?: string[] | null
    createdFromSimpleSSO?: boolean
    /** Ne dovolite drugim uporabnikom videti dejavnosti tega uporabnika, vključno s komentarji, na njegovem profilu. Privzeto je true, da privzeto zagotavlja varne profile. **/
    isProfileActivityPrivate?: boolean
    /** Ne dovolite drugim uporabnikom puščati komentarjev na uporabnikovem profilu ali videti obstoječih komentarjev profila. Privzeto false. **/
    isProfileCommentsPrivate?: boolean
    /** Ne dovolite drugim uporabnikom pošiljati neposrednih sporočil temu uporabniku. Privzeto false. **/
    isProfileDMDisabled?: boolean
    karma?: number
    /** Neobvezna konfiguracija za značke uporabnika. **/
    badgeConfig?: {
        /** Polje ID-jev značk za dodelitev uporabniku. Omejeno na 30 značk. Red je ohranjen. **/
        badgeIds: string[]
        /** Če je true, zamenja vse obstoječe prikazane značke s podanimi. Če je false ali izpuščeno, doda podane značke k obstoječim. **/
        override?: boolean
        /** Če je true, posodobi lastnosti prikaza značk iz konfiguracije najemnika. **/
        update?: boolean
    }
}

Billing for SSO Users

SSO uporabniki se zaračunavajo različno glede na njihove zastavice dovoljenj:

Regular SSO Users: Uporabniki brez skrbniških ali moderatorskih dovoljenj se zaračunavajo kot običajni SSO uporabniki
SSO Admins: Uporabniki z zastavicami isAccountOwner ali isAdminAdmin se zaračunavajo ločeno kot SSO Admini (enaka stopnja kot običajni najemniški skrbniki)
SSO Moderators: Uporabniki z zastavico isCommentModeratorAdmin se zaračunavajo ločeno kot SSO Moderatorji (enaka stopnja kot običajni moderatorji)

Pomembno: Da bi preprečili dvojno zaračunavanje, sistem samodejno odstrani podvojene SSO uporabnike glede na običajne najemniške uporabnike in moderatorje po e-poštnem naslovu. Če ima SSO uporabnik isti e-poštni naslov kot običajni najemniški uporabnik ali moderator, ne bo zaračunan dvakrat.

Access Control

Uporabnike je mogoče razdeliti v skupine. Za to služi polje groupIds in je neobvezno.

@Mentions

Privzeto bodo @mentions uporabili username za iskanje drugih SSO uporabnikov, ko je vnesen znak @. Če se uporablja displayName, bodo rezultati, ki se ujemajo z username, prezrti, kadar obstaja ujemanje za displayName, in rezultati iskanja @omenjanja bodo uporabili displayName.

Subscriptions

Pri FastComments se lahko uporabniki naročijo na stran tako, da kliknejo ikono zvonca v komentarni vtičnik in izberejo Subscribe.

Pri običajnem uporabniku jim pošljemo obvestilna e-poštna sporočila glede na njihove nastavitve obvestil.

Pri SSO uporabnikih to razdelimo zaradi združljivosti nazaj. Uporabniki bodo prejeli ta dodatna obvestilna e-poštna sporočila o naročilih le, če nastavite optedInSubscriptionNotifications na true.

Badges

Značke lahko dodelite SSO uporabnikom z uporabo lastnosti badgeConfig. Značke so vizualni pokazatelji, ki se prikažejo zraven imena uporabnika pri komentarjih.

badgeIds - Polje ID-jev značk, ki jih je treba dodeliti uporabniku. Ti morajo biti veljavni ID-ji značk, ustvarjeni v vašem FastComments računu. Omejeno na 30 značk.
override - Če je true, bodo vse obstoječe značke, prikazane pri komentarjih, zamenjane s podanimi. Če je false ali izpuščeno, bodo podane značke dodane k obstoječim značkam.
update - Če je true, bodo lastnosti prikaza značk posodobljene iz konfiguracije najemnika vsakič, ko se uporabnik prijavi.

GET /api/v1/sso-users

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

Ta ruta vrača SSO uporabnike po 100 na stran. Straničenje je zagotovljeno z parametrom skip. Uporabniki so razvrščeni po njihovem signUpDate in id.

Primer cURL zahteve za SSOUsers

Copy

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

Struktura zahteve SSOUsers

Copy

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

Struktura odgovora SSOUsers

Copy

interface SSOUsersResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    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

Ta pot vrne enega SSO uporabnika po njihovem id.

Primer cURL za SSOUser po id

Copy

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

Struktura zahteve SSOUser

Copy

interface SSOUserRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora SSOUser

Copy

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

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

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

Ta pot vrne enega SSO uporabnika glede na njihov e-poštni naslov.

Primer cURL zahteve SSOUser po e-pošti

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 zahteve SSOUser

Copy

interface SSOUserRequestByEmailQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora SSOUser

Copy

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

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

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

This route provides the ability to update a single SSO user.

Primer cURL zahteve za posodobitev 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 zahteve za posodobitev SSOUser

Copy

interface SSOUserPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Ko se spremeni e-poštni naslov ali uporabniško ime, lahko nastavite to na true, da posodobite tudi uporabnikove komentarje. To bo podvojilo strošek kreditov. **/
    updateComments: 'true' | 'false'
}

Struktura odgovora za posodobitev SSOUser

Copy

interface SSOUserPatchResponse {
    status: 'success' | 'failed'
    /** Included on failure. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'invalid-input' | 'missing-id' | 'user-does-not-exist'
    /** Vključeno ob neuspehu. **/
    reason?: string
    user?: SSOUser; // Ob uspehu vrnemo popolnoma posodobljenega uporabnika.
}

POST /api/v1/sso-users

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

Ta končna točka omogoča ustvarjanje enega SSO uporabnika.

Poskus ustvarjanja dveh uporabnikov z istim ID bo povzročil napako.

Primer cURL zahteve za ustvarjanje 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"]
}'

V tem primeru določimo groupIds za nadzor dostopa, vendar je to izbirno.

Struktura zahteve za ustvarjanje SSOUser

Copy

interface SSOUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ustvarjanje SSOUser

Copy

interface SSOUserPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'invalid-input' | 'missing-id' | 'user-exists'
    /** Vključeno ob napaki. **/
    reason?: string
    user?: SSOUser; // Na uspeh vrnemo ustvarjenega uporabnika.
}

Opomba o integraciji

Podatke, poslane preko API-ja, je mogoče preglasiti preprosto tako, da posredujete drugačen SSO User HMAC payload. Na primer, če nastavite uporabniško ime prek API-ja, a nato ob nalaganju strani skozi SSO tok posredujete drugačno, bomo samodejno posodobili njihovo uporabniško ime.

V tem toku ne bomo posodabljali uporabniških parametrov, razen če jih izrecno določite ali nastavite na null (ne undefined).

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

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

Ta končna točka omogoča posodobitev enega SSO uporabnika.

Primer cURL za posodobitev SSOUser

Copy

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

V tem primeru navedemo groupIds za nadzor dostopa, vendar je to neobvezno.

Struktura zahtevka za posodobitev SSOUser

Copy

interface SSOUserPutQueryParams {
    tenantId: string
    API_KEY: string
    /** Ko se spremeni e-pošta ali uporabniško ime, lahko to nastavite na true, da posodobite tudi komentarje uporabnika. To bo podvojilo porabo kreditov. **/
    updateComments: 'true' | 'false'
}

Struktura odgovora za posodobitev SSOUser

Copy

interface SSOUserPutResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'invalid-input' | 'missing-id' | 'user-exists'
    /** Vključeno ob napaki. **/
    reason?: string
    user?: SSOUser; // Na uspeh vrnemo posodobljenega uporabnika.
}

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

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

This route provides the removal of a single SSO user by their id.

Note that loading the comment widget again with a payload for this user will simply recreate the user seamlessly.

Deleting the user's comments is possible via the deleteComments query parameter. Note that if this is true:

All the user's comments will be deleted live.
All child (now orphan) comments will be deleted or anonymized based on each comment's associated page configuration. For example if thread deletion mode is "anonymize", then replies will remain, and the user's comments will be anonymized. This only applies when commentDeleteMode is Remove (the default value).
The creditsCost becomes 2.

Anonymized Comments

You can retain the user's comments but simply anonymize them by setting commentDeleteMode=1.

If the user's comments are anonymized then the following values are set to null:

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

isDeleted and isDeletedUser is set to true.

When rendering, the comment widget will use DELETED_USER_PLACEHOLDER (privzeto: "[deleted]") for the user's name and DELETED_CONTENT_PLACEHOLDER for the comment. These can be customized via the Widget Customization UI.

Examples

Primer cURL zahteve za odstranitev SSOUser

Copy

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

Struktura zahteve za odstranitev SSOUser

Copy

enum SSOUserCommentDeleteMode {
    Remove = 0, // privzeto
    Anonymize = 1
}
interface SSOUsersDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** Nastavite to na 'true', če želite tudi izbrisati komentarje uporabnika. To bo podvojilo strošek kreditov. **/
    deleteComments?: 'true' | 'false'
    /** Nastavite to po želji, da določite, kako ravnati s komentarji uporabnika. **/
    commentDeleteMode?: SSOUserCommentDeleteMode
}

Struktura odgovora za odstranitev SSOUser

Copy

interface SSOUsersResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'user-does-not-exist'
    /** Vključeno ob napaki. **/
    reason?: string
    user?: SSOUser; // Ob uspehu vrnemo odstranjenega uporabnika.
}

Struktura naročnine

Objekt Subscription predstavlja naročnino za uporabnika.

Subscription objekti se ustvarijo, ko uporabnik klikne zvonček za obvestila v pripomočku za komentarje in izbere "Naroči se na to stran".

Naročnine je mogoče ustvariti tudi prek API-ja.

Prisotnost objekta Subscription povzroči ustvarjanje objektov Notification in pošiljanje e-poštnih sporočil, ko so na korenu povezane strani za katero je Subscription, objavljeni novi komentarji. Pošiljanje e-pošte je odvisno od tipa uporabnika. Pri običajnih uporabnikih to določa optedInNotifications. Pri SSO uporabnikih to določa optedInSubscriptionNotifications. Upoštevajte, da nekateri programi morda nimajo koncepta spletno dostopne strani, v tem primeru preprosto nastavite urlId na id elementa, na katerega se naročate (isto vrednost za urlId, ki bi jo posredovali v pripomoček za komentarje).

Struktura objekta Subscription je naslednja:

Struktura objekta Subscription

Copy

interface Subscription {
    id: string
    tenantId: string
    /** Pri SSO je uporabniški id v formatu `<tenant id>:<user id>`. **/
    userId: string
    anonUserId?: string
    urlId: string
    url?: string
    pageTitle?: string
    createdAt: string // niz datuma
}

GET /api/v1/subscriptions/:id

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

Ta končna točka vrne do 30 objektov Subscription urejenih po createdAt, najnovejši prvi.

Filtrirate lahko po userId. Pri SSO je uporabniški id v formatu <tenant id>:<user id>.

Primer cURL za naročnine uporabnika

Copy

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

Struktura zahteve za naročnine

Copy

interface SubscriptionsGetQueryParams {
    tenantId: string
    API_KEY: string
    /** Straničenje s preskakovanjem zapisov. **/
    skip?: number
    /** Filtriraj po uporabniku. **/
    userId?: string
}

Struktura odgovora za naročnine

Copy

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

POST /api/v1/subscriptions

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

Ta API končna točka omogoča ustvarjanje Subscription. Upoštevajte, da ima lahko uporabnik samo eno naročnino na stran, saj je več odvečno, in poskus ustvariti več kot eno naročnino za istega uporabnika na isti strani bo povzročil napako.

Ustvarjanje naročnine bo povzročilo ustvarjanje objektov Notification, ko je na korenu naročenega urlId objavljen nov komentar (ko je parentId komentarja null).

Primer cURL POST za Subscription

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 POST zahtevka za Subscription

Copy

interface SubscriptionPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za Subscription

Copy

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

DELETE /api/v1/subscriptions/:id

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

Ta končna točka izbriše posamezen objekt Subscription po id-ju.

Primer cURL zahteve za odstranitev naročnine

Copy

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

Struktura zahteve za odstranitev naročnine

Copy

interface SubscriptionsDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora pri odstranitvi naročnine

Copy

interface SubscriptionDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'unauthorized' | 'unexpected-param' | 'not-found'
    /** Vključeno ob neuspehu. **/
    reason?: string
}

Struktura dnevne porabe najemnika

Objekt TenantDailyUsage predstavlja porabo za najemnika na določen dan. Če ni bilo dejavnosti za določenega najemnika na določen dan, ta dan ne bo imel objekta TenantDailyUsage.

Objekt TenantDailyUsage ni v realnem času in je lahko za dejansko porabo zamaknjen za nekaj minut.

Struktura objekta TenantDailyUsage je naslednja:

Struktura objekta 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
    /** Prezrto pri obračunu. **/
    ignored: boolean
}

GET /api/v1/tenant-daily-usage

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

Ta pot omogoča iskanje uporabe najemnika po letu, mesecu in dnevu. Vrne se lahko do 365 objektov, cena pa je 1 api credit na 10 objektov.

Objekti v odgovoru so razvrščeni po datumu ustvarjanja (najstarejši prvi).

Primer cURL poizvedbe 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 zahteve TenantDailyUsage

Copy

interface TenantDailyUsageQueryParams {
    tenantId: string
    API_KEY: string
    /** Glede na UTC. **/
    yearNumber?: number
    /** Indeksirano od 0. Glede na UTC. **/
    monthNumber?: number
    /** Indeksirano od 1. Glede na UTC. **/
    dayNumber?: number
}

Struktura odgovora TenantDailyUsage

Copy

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

Struktura najemnika

Tenant predstavlja stranko FastComments.com. Ustvarijo jih lahko preko API-ja najemniki z dostopom za white-labeling. Najemniki z white-labelingom ne morejo ustvarjati drugih najemnikov z white-labelingom (dovoljena je le ena raven gnezdenja).

Struktura objekta Tenant je naslednja:

Struktura objekta `Tenant`

Copy

export enum SiteType {
    Unknown = 0,
    WordPress = 1
}
/** To je mogoče tudi upravljati preko DomainConfig API-ja. **/
export interface TenantDomainConfig {
    domain: string
    emailFromName?: string
    emailFromEmail?: string
    createdAt?: string,
    siteType?: FastCommentsSiteType, // verjetno želite Unknown
    logoSrc?: string, // neobdelana pot do slike
    logoSrc100px?: string, // spremenjeno 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; // number zaradi "legacy" razlogov
    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čunano glede na packageId. **/
    hasFlexPricing?: boolean
    /** @readonly **/
    flexLastBilledAmount?: number
    /** @readonly - Izračunano glede na packageId. **/
    hasAuditing?: boolean
    /** Z najemnikom lahko shranite par ključ-vrednost, ki ga lahko uporabite za poizvedovanje. Ključi ne smejo vsebovati "." ali "$", niti biti daljši od 100 znakov. Vrednosti ne smejo biti daljše od 2k znakov. **/
    meta?: Record<string, string | null>
}

GET /api/v1/tenants/:id

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

Ta pot vrne posamezen Tenant glede na id.

Primer cURL zahteve za Tenant po ID

Copy

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

Struktura zahteve za Tenant

Copy

interface TenantByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora Tenant

Copy

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

GET /api/v1/tenants

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

Ta API vrne tenants, ki jih upravlja vaš tenant.

Paginacija se izvaja z parametrom poizvedbe skip. Tenants so vrnjeni v straneh po 100, urejeni po signUpDate in id.

Strošek je odvisen od števila vrnjenih tenants in znaša 1 credit per 10 vrnjenih tenants.

Primer cURL zahtevka za Tenant

Copy

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

Na objektih Tenant lahko določite parametre meta in poizvedujete po ujemajočih se tenants. Na primer, za ključ someKey in vrednost meta some-value, lahko sestavimo JSON objekt s tem parom ključ/vrednost in ga nato URI-enkodiramo kot parametar poizvedbe za filtriranje:

Primer cURL poizvedbe 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 zahtevka Tenant

Copy

interface TenantsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Število tenants, ki jih je treba preskočiti za paginacijo. **/
    skip?: number
    /** Filtriraj po meta parametrih. **/
    meta?: string
}

Struktura odgovora Tenant

Copy

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

POST /api/v1/tenants

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

Ta ruta omogoča dodajanje enega Tenant.

Ustvarjanje Tenant ima naslednje omejitve:

Polje name je obvezno.
domainConfiguration je obvezno.
Naslednjih vrednosti ni dovoljeno posredovati pri ustvarjanju Tenant:
- hasFlexPricing
- lastBillingIssueReminderDate
- flexLastBilledAmount
Datum signUpDate ne sme biti v prihodnosti.
Ime name ne sme biti daljše od 200 characters.
Elektronski naslov email ne sme biti daljši od 300 characters.
Elektronski naslov email mora biti unikaten med vsemi najemniki na FastComments.com.
Ne smete ustvarjati najemnikov, če nadrejeni najemnik nima veljavnega TenantPackage.
- Če je vaš najemnik ustvarjen preko FastComments.com, to ne bi smelo povzročati težav.
Ne smete ustvariti več najemnikov, kot je določeno v maxWhiteLabeledTenants v vašem paketu.
Obvezno morate določiti poizvedbeni parameter tenantId, ki je id vašega parent tenant z omogočenim white labelingom.

Za ustvarjanje Tenant potrebujemo le nekaj parametrov:

Primer cURL zahteve za ustvarjanje najemnika

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 zahteve za ustvarjanje najemnika

Copy

interface TenantPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ustvarjanje najemnika

Copy

interface TenantPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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'
    /** Vključeno ob napaki. **/
    reason?: string
    tenant?: Tenant; // Ob uspehu vrnemo popolnoma ustvarjenega najemnika.
}

PATCH /api/v1/tenants/:id

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

Ta API endpoint omogoča posodobitev Tenant po id.

Pri posodabljanju Tenant veljajo naslednje omejitve:

Naslednje vrednosti ni mogoče posodobiti:
- hasFlexPricing
- lastBillingIssueReminderDate
- flexLastBilledAmount
- managedByTenantId
signUpDate ne sme biti v prihodnosti.
name ne sme presegati dolžine 200 characters.
email ne sme presegati dolžine 300 characters.
email mora biti unikaten za vse FastComments.com tenants.
Ko nastavite billingInfoValid na true, mora biti billingInfo priložen v istem zahtevku.
Ne smete posodobiti packageId, povezanega z vašim tenantom.
Ne smete posodobiti paymentFrequency, povezanega z vašim tenantom.

Primer cURL PATCH zahteve 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 zahtevka za Tenant

Copy

interface TenantPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura PATCH odgovora za Tenant

Copy

interface TenantPatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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'; 
    /** Vključeno ob napaki. **/
    reason?: string
}

DELETE /api/v1/tenants/:id

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

Ta pot omogoča odstranitev Tenant in vseh povezanih podatkov (uporabniki, komentarji itd.) po id-ju.

The following restrictions exist around removing tenants:

Najemnik mora biti vaš ali najemnik z belo etiketo, ki ga upravljate.
Poizvedbeni parameter sure mora biti nastavljen na true.

Primer cURL zahtevka za odstranitev najemnika

Copy

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

Struktura zahtevka za odstranitev najemnika

Copy

interface TenantDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev najemnika

Copy

interface TenantDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'not-found' | 'unauthorized' | 'unsure'
    /** Vključeno ob napaki. **/
    reason?: string
}

Struktura paketa najemnika

The TenantPackage določa informacije o paketu, ki so na voljo Tenant-u. Tenant lahko ima na voljo več paketov, vendar je hkrati lahko v uporabi le en.

Tenant ne more uporabljati nobenih izdelkov, dokler njegov packageId ne kaže na veljaven TenantPackage.

Obstajata dve vrsti objektov TenantPackage:

Paketi s fiksno ceno - kjer je hasFlexPricing false.
Fleksibilno pricevanje - kjer je hasFlexPricing true.

V obeh primerih so omejitve določene na računu, ki uporablja paket, vendar pri Flex najemnika zaračunamo osnovno ceno plus porabo, določeno z flex* parametri.

Tenant lahko ima več paketov in lahko spremeni paket sam na Billing Info Page.

Če boste sami urejali obračunavanje za najemnike, boste še vedno morali določiti paket za vsakega najemnika, da definirate njihove omejitve. Preprosto nastavite billingHandledExternally na true na Tenant in ne bodo mogli sami spreminjati svojih podatkov o obračunavanju ali aktivnega paketa.

Ne smete ustvarjati paketov z višjimi omejitvami kot ima nadrejeni tenant.

Struktura objekta TenantPackage je naslednja:

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 // Strošek na običajnega SSO uporabnika (brez administratorskih/moderatorskih dovoljenj)
    flexSSOUserUnit?: null
    flexAPICreditCostCents?: null
    flexAPICreditUnit?: null
    flexModeratorCostCents?: null
    flexModeratorUnit?: null
    flexAdminCostCents?: null
    flexAdminUnit?: null
    flexDomainCostCents?: null
    flexDomainUnit?: null
    flexSSOAdminCostCents?: null // Strošek na SSO uporabnika z administratorskimi dovoljenji (flagi isAccountOwner ali isAdminAdmin)
    flexSSOAdminUnit?: null
    flexSSOModeratorCostCents?: null // Strošek na SSO uporabnika z moderatorskimi dovoljenji (z zastavico isCommentModeratorAdmin)
    flexSSOModeratorUnit?: null
    flexMinimumCostCents?: null
}

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

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

Ta pot vrne en Tenant Package glede na id.

Primer cURL zahteve za TenantPackage po ID

Copy

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

Struktura zahteve TenantPackage

Copy

interface TenantPackageByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora TenantPackage

Copy

interface TenantPackageByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Vključeno ob napaki. **/
    reason?: string
    tenantPackage: TenantPackage
}

GET /api/v1/tenant-packages

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

Ta API uporablja paginacijo, ki jo zagotavlja poizvedni parameter skip. TenantPackages se vrnejo po 100 na stran, razvrščene po createdAt in id.

Stroški so odvisni od števila vrnjenih tenant packages; znaša 1 credit per 10 vrnjenih tenant packages.

Primer cURL zahteve za TenantPackage

Copy

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

Struktura zahteve TenantPackage

Copy

interface TenantPackagesRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Število tenant packages, ki jih je treba preskočiti pri paginaciji. **/
    skip?: number
}

Struktura odgovora TenantPackage

Copy

interface TenantPackagesResponse {
    status: 'success' | 'failed'
    /** Vključeno v primeru napake. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno v primeru napake. **/
    reason?: string
    tenantPackages?: TenantPackage[]
}

POST /api/v1/tenant-packages

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

Ta ruta omogoča dodajanje posameznega TenantPackage.

Ustvarjanje TenantPackage ima naslednje omejitve:

Naslednji parametri so obvezni:
- name
- tenantId
- monthlyCostUSD - Can be null.
- yearlyCostUSD - Can be null.
- maxMonthlyPageLoads
- maxMonthlyAPICredits
- maxMonthlyComments
- maxConcurrentUsers
- maxTenantUsers
- maxSSOUsers
- maxModerators
- maxDomains
- hasDebranding
- forWhoText
- featureTaglines
- hasFlexPricing - If true, then all flex* parameters are required.
The name may not be longer than 50 characters.
Vsak element forWhoText ne sme biti daljši od 200 characters.
Vsak element featureTaglines ne sme biti daljši od 100 characters.
TenantPackage mora biti "manjši" od nadrejenega najemnika. Na primer, vsi max* parametri morajo imeti nižje vrednosti kot pri nadrejenem najemniku.
White-label najemnik lahko ima največ pet paketov.
Samo najemniki z dostopom do white-label lahko ustvarijo TenantPackage.
Paketov ne smete dodajati svojemu najemniku. :)

TenantPackage lahko ustvarimo na naslednji način:

Primer cURL zahteve za ustvarjanje TenantPackage prek 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 zahteve za ustvarjanje TenantPackage

Copy

interface TenantPackagePostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ustvarjanje TenantPackage

Copy

interface TenantPackagePostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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'
    /** Vključeno ob neuspehu. **/
    reason?: string
    tenantPackage?: TenantPackage; // Na uspeh vrnemo popoln ustvarjen paket najemnika.
}

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

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

Ta API endpoint omogoča posodobitev TenantPackage po id.

Posodabljanje TenantPackage ima naslednje omejitve:

Če nastavite hasFlexPricing na true, so vsi parametri flex* obvezni v istem zahtevku.
name ne sme biti daljše od 50 characters.
Vsak element forWhoText ne sme biti daljši od 200 characters.
Vsak element featureTaglines ne sme biti daljši od 100 characters.
TenantPackage mora biti "manjši" od nadrejenega najemnika. Na primer, vsi max* parametri morajo imeti nižje vrednosti kot pri nadrejenem najemniku.
Ne smete spremeniti tenantId, povezanega z TenantPackage.

Primer cURL PATCH za TenantPackage

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 PATCH zahtevka za TenantPackage

Copy

interface TenantPackagePatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora PATCH za TenantPackage

Copy

interface TenantPackagePatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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'; 
    /** Vključeno ob napaki. **/
    reason?: string
}

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

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

Ta končna točka omogoča odstranitev TenantPackage po id-ju.

Ne smete odstraniti TenantPackage, ki je v uporabi (tenantov packageId kaže na paket). Najprej posodobite Tenant.

Primer cURL zahteve za odstranitev TenantPackage

Copy

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

Struktura zahteve za odstranitev TenantPackage

Copy

interface TenantPackageDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev TenantPackage

Copy

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

Struktura uporabnika najemnika

TenantUser definira User, ki ga upravlja določen tenant. Njihov račun je popolnoma pod nadzorom tenanta, s katerim so povezani, in njihov račun lahko tenant posodobi ali izbriše preko UI ali API.

Uporabniki tenanta so lahko skrbniki z vsemi dovoljenji in dostopom do Tenant, ali pa so omejeni na določena dovoljenja za moderiranje komentarjev, dostop do API ključev itd.

Struktura za objekt TenantUser je naslednja:

Struktura objekta TenantUser

Copy

/** To je za obvestila. **/
export enum UserDigestEmailFrequency {
    Disabled = -1,
    Daily = 0,
    Weekly = 1,
    Monthly = 2
}
export interface TenantUser {
    id: string
    tenantId: string
    username: string
    /** Na primer povezava do komentatorjevega bloga. **/
    websiteUrl?: string
    email: string
    signUpDate: number
    createdFromUrlId: string
    createdFromTenantId: string
    verified: boolean
    loginCount: number
    optedInNotifications: boolean
    optedInTenantNotifications: boolean
    hideAccountCode: boolean
    avatarSrc?: string
    /** Ali uporabnik prejema zahteve za pomoč od komentatorjev? **/
    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

Ta pot vrne enega TenantUser glede na id.

Primer cURL za TenantUser po ID

Copy

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

Struktura zahteve za TenantUser

Copy

interface TenantUserByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za TenantUser

Copy

interface TenantUserByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Vključeno ob neuspehu. **/
    reason?: string
    tenantUser?: TenantUser
}

GET /api/v1/tenant-users

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

Ta API uporablja paginacijo, ki jo zagotavlja poizvedni parameter skip. TenantUsers se vračajo v straneh po 100, urejeni po signUpDate, username in id.

Cena je odvisna od števila vrnjenih tenant uporabnikov; znaša 1 credit per 10 vrnjenih tenant uporabnikov.

Primer cURL zahteve za TenantUser

Copy

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

Struktura zahteve TenantUser

Copy

interface TenantUsersRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Število tenant uporabnikov, ki jih je treba preskočiti pri paginaciji. **/
    skip?: number
}

Struktura odgovora TenantUser

Copy

interface TenantUsersResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    tenantUsers?: TenantUser[]
}

POST /api/v1/tenant-users

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

Ta končna točka omogoča dodajanje enega TenantUser.

Ustvarjanje TenantUser ima naslednje omejitve:

username je zahtevan.
email je zahtevan.
signUpDate ne sme biti v prihodnosti.
locale mora biti na seznamu Podprte lokalne nastavitve.
username mora biti edinstven na celotnem FastComments.com. Če to predstavlja težavo, priporočamo uporabo SSO.
email mora biti edinstven na celotnem FastComments.com. Če to predstavlja težavo, priporočamo uporabo SSO.
Ne smete ustvariti več uporabnikov najemnika, kot je določeno v maxTenantUsers v vašem paketu.

TenantUser lahko ustvarite na naslednji način

Primer cURL zahteve za ustvarjanje 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 zahtevka za ustvarjanje TenantUser

Copy

interface TenantUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za ustvarjanje TenantUser

Copy

interface TenantUserPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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'
    /** Vključeno ob neuspehu. **/
    reason?: string
    tenantUser?: TenantUser; // Ob uspehu vrnemo popolnoma ustvarjenega uporabnika najemnika.
}

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

Ta ruta omogoča pošiljanje prijavne povezave enemu TenantUser.

Uporabno pri množičnem ustvarjanju uporabnikov, ko jim ni treba navodila za prijavo na FastComments.com. To jim pošlje le "čarobno povezavo" za prijavo, ki poteče po 30 days.

Naslednje omejitve veljajo za pošiljanje prijavne povezave TenantUser:

TenantUser mora že obstajati.
Morate imeti dostop do upravljanja Tenant, kateremu pripada TenantUser.

Prijavno povezavo TenantUser lahko pošljemo na naslednji način:

Primer cURL zahtevka za prijavno povezavo TenantUser

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'

To bo poslalo e-pošto, kot na primer Bob at TenantName is inviting you to be a moderator...

Struktura zahteve za prijavno povezavo TenantUser

Copy

interface TenantUserPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za prijavno povezavo TenantUser

Copy

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

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

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

Ta pot omogoča posodobitev posameznega TenantUser.

Posodabljanje TenantUser ima naslednje omejitve:

signUpDate ne sme biti v prihodnosti.
locale mora biti na seznamu Podprte lokalizacije.
username mora biti edinstven po celotnem FastComments.com. Če je to težava, priporočamo uporabo SSO.
email mora biti edinstven po celotnem FastComments.com. Če je to težava, priporočamo uporabo SSO.
Ne morete posodobiti tenantId uporabnika.

Ustvarimo lahko TenantUser na naslednji način

Primer cURL zahtevka za posodobitev 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 zahteve za posodobitev TenantUser

Copy

interface TenantUserPatchQueryParams {
    tenantId: string
    API_KEY: string
    /** Ko se spremeni email ali uporabniško ime, lahko to nastavite na true, da posodobite tudi uporabnikove komentarje. To bo podvojilo strošek kreditov. **/
    updateComments: 'true' | 'false'
}

Struktura odgovora za posodobitev TenantUser

Copy

interface TenantUserPatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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'
    /** Vključeno ob neuspehu. **/
    reason?: string
}

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

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

Ta ruta omogoča odstranitev TenantUser po id.

Brisanje komentarjev uporabnika je možno preko poizvedbenega parametra deleteComments. Upoštevajte, da če je to true:

Vsi komentarji uporabnika bodo takoj izbrisani.
Vsi child (sedaj osiroteli) komentarji bodo izbrisani ali anonimizirani glede na konfiguracijo strani, povezane z vsakim komentarjem. Na primer, če je thread deletion mode "anonymize", bodo odgovori ostali, komentatorjevi komentarji pa bodo anonimizirani. To velja samo, ko je commentDeleteMode nastavljeno na Remove (privzeta vrednost).
Vrednost creditsCost postane 2.

Anonimizirani komentarji

Komentarje uporabnika lahko obdržite, vendar jih preprosto anonimizirate tako, da nastavite commentDeleteMode=1.

Če so komentarji uporabnika anonimizirani, se naslednje vrednosti nastavijo na null:

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

isDeleted and isDeletedUser sta nastavljena na true.

Pri upodabljanju bo komentarni pripomoček za ime uporabnika uporabil DELETED_USER_PLACEHOLDER (privzeto: "[deleted]") in DELETED_CONTENT_PLACEHOLDER za vsebino komentarja. To je mogoče prilagoditi prek uporabniškega vmesnika za prilagajanje widgeta.

Primeri

Primer cURL za odstranitev TenantUser

Copy

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

Struktura zahteve za odstranitev TenantUser

Copy

enum TenantUserCommentDeleteMode {
    Remove = 0, // privzeto
    Anonymize = 1
}
interface TenantUserDeleteQueryParams {
    tenantId: string
    API_KEY: string
    /** To lahko nastavite na true, da prav tako izbrišete komentarje uporabnika. To bo podvojilo strošek kreditov. **/
    deleteComments?: 'true' | 'false'
    /** To lahko nastavite po želji, da določite, kako ravnati s komentarji uporabnika. **/
    commentDeleteMode?: TenantUserCommentDeleteMode
}

Struktura odgovora za odstranitev TenantUser

Copy

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

Struktura uporabnika

User je objekt, ki predstavlja najpogostejši skupni imenovalec vseh uporabnikov.

Upoštevajte, da imamo pri FastComments več različnih primerov uporabe uporabnikov:

Secure SSO
Simple SSO
Uporabniki najemnika (na primer: skrbniki)
Komentatorji

Ta API je namenjen Komentatorjem in uporabnikom, ustvarjenim z Simple SSO. Praktično vsak uporabnik, ustvarjen prek vaše strani, je dostopen preko tega API-ja. Uporabniki najemnika so prav tako dostopni na ta način, vendar boste več informacij dobili pri interakciji z API-jem /tenant-users/.

Za Secure SSO uporabite API /sso-users/.

Te vrste uporabnikov ne morete posodobiti. Ustvarili so svoj račun preko vaše strani, zato nudimo osnovni dostop samo za branje, vendar ne morete narediti sprememb. Če želite imeti takšen potek, morate nastaviti Secure SSO.

Struktura objekta User je naslednja:

Struktura uporabnika

Copy

export interface User {
    /** To je tudi id, uporabljen kot userId na objektih komentarjev. **/
    id: string
    username: string
    /** Na primer, povezava do bloga komentatorja. **/
    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

Ta endpoint vrne posameznega User po id.

Primer cURL zahteve za User po ID

Copy

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

Struktura zahteve za User

Copy

interface UserByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za User

Copy

interface UserByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found' | 'unauthorized'
    /** Vključeno ob neuspehu. **/
    reason?: string
    user?: User
}

Struktura glasu

Objekt Vote predstavlja glas, ki ga je oddal uporabnik.

Razmerje med komentarji in glasovi je določeno preko commentId.

Struktura za objekt Vote je naslednja:

Struktura glasovanja

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 je treba pridobiti po urlId.

Vrste glasov

Obstajajo tri vrste glasov:

Avtentificirani glasovi, ki se uporabljajo za ustrezen komentar. Te lahko ustvarite preko tega API-ja.
Avtentificirani glasovi, ki so v postopku preverjanja, in zato še niso uporabljeni za komentar. Ti se ustvarijo, ko uporabnik uporabi mehanizem FastComments.com prijava za glasovanje.
Anonimni glasovi, ki se uporabljajo za ustrezen komentar. Ti se ustvarijo skupaj z anonimnim komentiranjem.

V API-ju so ti vrnjeni v ločenih seznamih, da se zmanjša zmeda.

Primer cURL zahteve za glasove

Copy

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

Struktura zahteve za glasove

Copy

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

Struktura odgovora za glasove

Copy

interface VotesResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Pooblaščeni, preverjeni glasovi, uporabljeni za ustrezne komentarje. **/
    appliedAuthorizedVotes: Vote[]
    /** Anonimni glasovi, uporabljeni za ustrezne komentarje. **/
    appliedAnonymousVotes: Vote[]
    /** Glasovi v postopku preverjanja, še niso uporabljeni za ustrezne komentarje. **/
    pendingVotes: Vote[]
}

Opombe o anonimnih glasovih

Upoštevajte, da se bodo anonimni glasovi, ustvarjeni preko tega API-ja, pojavili v seznamu appliedAuthorizedVotes. Štejemo jih za pooblaščene, saj so bili ustvarjeni preko API-ja z API ključem.

Struktura appliedAnonymousVotes je za glasove, ustvarjene brez 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

Omogoča pridobivanje glasov, ki jih je uporabnik oddal za določen urlId. Sprejme userId, ki je lahko katerikoli FastComments.com ali SSO User.

To je uporabno, če želite prikazati, ali je uporabnik glasoval pri komentarju. Pri pridobivanju komentarjev preprosto pokličite to API istočasno za uporabnika z istim urlId.

Če uporabljate anonimno glasovanje, boste namesto tega želeli posredovati anonUserId.

Primer cURL zahteve za glasove uporabnika

Copy

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

Primer cURL zahteve za anonimnega uporabnika

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'

Upoštevajte, da se bodo anonimni glasovi pojavili v seznamu appliedAuthorizedVotes. Štejemo jih za pooblaščene, saj so bili ustvarjeni preko API z API ključem.

Struktura zahteve za glasove uporabnika

Copy

interface VotesForUserRequestQueryParams {
    tenantId: string
    API_KEY: string
    urlId: string
    userId?: string
    anonUserId?: string
}

Struktura odgovora za glasove uporabnika

Copy

interface VotesForUserResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-url-id' | 'invalid-user-id'
    /** Vključeno ob neuspehu. **/
    reason?: string
    /** Pooblaščeni, preverjeni glasovi, uporabljeni pri pripadajočih komentarjih. **/
    appliedAuthorizedVotes: Vote[]
    /** Glasovi, ki čakajo na preverjanje, še niso uporabljeni pri pripadajočih komentarjih. **/
    pendingVotes: Vote[]
}

POST /api/v1/votes

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

Ta pot omogoča dodajanje enega pooblaščenega Vote. Glasovi so lahko up (+1) ali down (-1).

Primer cURL zahteve za ustvarjanje glasu

Copy

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

Primer cURL zahteve za ustvarjanje anonimnega glasu

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 zahteve za ustvarjanje glasu

Copy

interface VotePostQueryParams {
    tenantId: string
    API_KEY: string
    userId?: string
    anonUserId?: string
    commentId: string
    direction: 'up' | 'down'
}

Struktura odgovora za ustvarjanje glasu

Copy

interface VotePostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    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'
    /** Vključeno ob neuspehu. **/
    reason?: string
    voteId?: string
}

Ustvarjanje anonimnih glasov

Anonimne glasove lahko ustvarite tako, da v parametrih poizvedbe nastavite anonUserId namesto userId.

Ta id ne rabi ustrezati nobenemu uporabniškemu objektu nikjer (od tod anonimno). To je preprosto identifikator za sejo, tako da lahko v isti seji ponovno pridobite glasove, da preverite, ali je bil komentar glasovan.

Če nimate česa takega kot "anonymous sessions", kot jih ima FastComments - lahko preprosto to nastavite na naključen ID, na primer UUID (čeprav cenimo krajše identifikatorje zaradi prihranka prostora).

Druge opombe

Ta API upošteva nastavitve na ravni najemnika. Na primer, če onemogočite glasovanje za določeno stran, in poskusite ustvariti glas preko API-ja, bo spodletelo s kodo napake voting-disabled.
Ta API je privzeto aktiven.
Ta API bo posodobil votes ustreznega Comment.

DELETE /api/v1/votes/:id

Resource: Vote as DELETE /api/v1/votes/:id Credit Cost: 1

Ta ruta omogoča brisanje posameznega Vote.

Primer cURL zahteve za brisanje glasu

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 zahteve za brisanje glasu

Copy

interface VoteDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora pri brisanju glasu

Copy

interface VoteDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno v primeru napake. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id'
    /** Vključeno v primeru napake. **/
    reason?: string
}

Opombe:

Ta API upošteva nastavitve na ravni najemnika. Na primer, če onemogočite glasovanje za določeno stran in poskušate ustvariti glas prek API-ja, bo to neuspešno in se bo vrnila koda napake voting-disabled.
Ta API je privzeto aktiven.
Ta API bo posodobil votes ustreznega Comment.

Struktura konfiguracije domene

A DomainConfig object represents configuration for a domain for a tenant.

The structure for the DomainConfig object is as follows:

Struktura konfiguracije domene

Copy

interface DomainConfig {
    /** Domena, ne URL, na primer "fastcomments.com" ali "www.example.com". Lahko vključuje poddomeno, če želite omejiti na poddomeno. Največ 1000 znakov. **/
    domain: string
    /** Ime pošiljatelja (From-Name), uporabljeno pri pošiljanju e-pošte. **/
    emailFromName?: string
    /** E-pošta pošiljatelja (From-Email), uporabljena pri pošiljanju e-pošte. Poskrbite, da je SPF nastavljen tako, da dovoljuje mail.fastcomments.com pošiljanje e-pošte v imenu domene, uporabljene v tem atributu. **/
    emailFromEmail?: string
    /** SAMO ZA BRANJE. Kdaj je bil objekt ustvarjen. **/
    createdAt: string
    /** Logotip povezan s to domeno. Uporablja se v e-poštnih sporočilih. Uporabite HTTPS. **/
    logoSrc?: string
    /** Manjši logotip povezan s to domeno. Uporabite HTTPS. **/
    logoSrc100px?: string
    /** SAMO SSO. URL uporabljen v nogi vsakega poslanega e-poštnega sporočila. Podpira spremenljivko "[userId]". **/
    footerUnsubscribeURL?: string
    /** SAMO SSO. Glave, uporabljene v vsakem poslanem e-poštnem sporočilu. Na primer uporabno za nastavitev glav, povezanih z odjavo, za izboljšanje dostave. Vnos List-Unsubscribe v tem zapisu, če obstaja, podpira spremenljivko "[userId]". **/
    emailHeaders?: Record<string, string>
    /** Onemogoči vse povezave za odjavo. Ni priporočljivo, lahko poslabša stopnje dostave. **/
    disableUnsubscribeLinks?: boolean
    /** DKIM konfiguracija. **/
    dkim?: DomainConfigDKIM
}

Struktura DKIM konfiguracije

Copy

interface DomainConfigDKIM {
    /** Ime domene v vašem DKIM zapisu. **/
    domainName: string
    /** Selektor DKIM ključa, ki ga je treba uporabiti. **/
    keySelector: string
    /** Vaš zasebni ključ. Začne se z -----BEGIN PRIVATE KEY----- in konča z -----END PRIVATE KEY----- **/
    privateKey: string
}

Za avtentikacijo

Konfiguracija domen se uporablja za določanje, kateri spletni mesti lahko gostijo vtičnik FastComments za vaš račun. To je osnovna oblika avtentikacije, kar pomeni, da lahko dodajanje ali odstranjevanje katere koli konfiguracije domene vpliva na razpoložljivost vaše namestitve FastComments v produkcijskem okolju.

Ne odstranjujte ali ne spreminjajte lastnosti domain v Domain Config za domeno, ki se trenutno uporablja, razen če nameravate to domeno onemogočiti.

To ima enako vedenje kot odstranitev domene iz /auth/my-account/configure-domains.

Upoštevajte tudi, da bo odstranitev domene iz uporabniškega vmesnika My Domains odstranila tudi ustrezno konfiguracijo za to domeno, ki je bila morda dodana prek tega vmesnika.

Za prilagajanje e-pošte

Povezavo za odjavo v nogi e-poštnega sporočila in funkcijo enoklikne odjave, ki jo ponuja veliko e-poštnih odjemalcev, je mogoče konfigurirati prek tega API-ja z nastavitvijo footerUnsubscribeURL oziroma emailHeaders.

Za DKIM

Po opredelitvi vaših DKIM DNS zapisov preprosto posodobite DomainConfig z vašo DKIM konfiguracijo, pri čemer uporabite zgoraj določeno strukturo.

GET /api/v1/domain-configs

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

Ta API omogoča pridobitev vseh DomainConfig objektov za najemnika.

Primer cURL zahteve za DomainConfig GET

Copy

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

Struktura GET zahteve DomainConfig

Copy

interface GetDomainConfigsRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odziva GET za DomainConfig

Copy

interface GetDomainConfigsResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    /** Konfiguracije! **/
    configurations: DomainConfig[] | null
}

GET /api/v1/domain-configs/:domain

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

Posamezne DomainConfigs je mogoče pridobiti po ustrezni domain.

Primer cURL zahteve za konfiguracijo domene

Copy

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

Struktura zahteve za konfiguracijo domene

Copy

interface DomainConfigsByDomainRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za konfiguracijo domene

Copy

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

POST /api/v1/domain-configs

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

Ta API endpoint omogoča ustvarjanje konfiguracij domen.

Dodajanje konfiguracije za domeno pooblasti to domeno za račun FastComments.

Pogoste rabe tega API-ja so začetna nastavitev, če je želja dodati več domen, ali prilagojena konfiguracija za pošiljanje e-pošte.

Primer cURL zahteve za DomainConfig POST

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 zahteve za DomainConfig

Copy

interface DomainConfigPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora POST za DomainConfig

Copy

interface DomainConfigPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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';  
    /** Vključeno ob napaki. **/
    reason?: string
    /** Ustvarjena konfiguracija. **/
    configuration?: DomainConfig
}

PATCH /api/v1/domain-configs/:domain

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

Ta API končna točka omogoča posodobitev konfiguracije domene z navedbo samo domene in atributa, ki ga želite posodobiti.

Primer cURL 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 zahteve DomainConfig PATCH

Copy

interface DomainConfigPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora DomainConfig PATCH

Copy

interface DomainConfigPatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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';  
    /** Vključeno ob napaki. **/
    reason?: string
    /** Posodobljena konfiguracija. **/
    configuration?: DomainConfig
}

PUT /api/v1/domain-configs/:domain

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

Ta API končna točka omogoča zamenjavo konfiguracije domene.

Primer cURL za DomainConfig PUT

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

Struktura PUT zahtevka za DomainConfig

Copy

interface DomainConfigPutQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora PUT za DomainConfig

Copy

interface DomainConfigPutResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    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';  
    /** Vključeno ob napaki. **/
    reason?: string
    /** Posodobljena konfiguracija. **/
    configuration?: DomainConfig
}

DELETE /api/v1/domain-configs/:domain

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

Ta pot omogoča odstranitev enega DomainConfig po ID-ju.

Note: Odstranitev DomainConfig bo preklicala dovoljenje tej domeni za uporabo FastComments.
Note: Ponovno dodajanje domene prek uporabniškega vmesnika bo znova ustvarilo objekt (z izpolnjeno samo lastnostjo domain).

Primer cURL zahteve za odstranitev DomainConfig

Copy

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

Struktura zahteve za odstranitev DomainConfig

Copy

interface DomainConfigRequestQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev DomainConfig

Copy

interface DomainConfigDeleteResponse {
    status: 'success' | 'failed'
    /** Vključeno ob neuspehu. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-domain' | 'domain-config-does-not-exist'
    /** Vključeno ob neuspehu. **/
    reason?: string
}

Struktura konfiguracije vprašanja

FastComments nudi način za sestavljanje vprašanj in združevanje njihovih rezultatov. Primer vprašanja (v nadaljevanju imenovan QuestionConfig) je lahko ocena z zvezdicami, drsnik ali NPS vprašanje (določeno z type).

Podatke o vprašanjih je mogoče združevati posamično, skupaj, skozi čas, na splošno, po strani itd.

Okvir ima vse zmogljivosti, potrebne za izdelavo odjemalskih vtičnikov (z vašim strežnikom pred tem API-jem), nadzornih plošč za skrbnike in orodij za poročanje.

Najprej moramo definirati QuestionConfig. Struktura je naslednja:

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 BRANJE - poveča se za vsak nov odgovor. **/
    usedCount: number
    /** Niz datuma, kdaj je bila konfiguracija nazadnje uporabljena (ko je bil oddan 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

Ta ruta vrne do 100 QuestionConfig objektov naenkrat, paginirano. Strošek je 1 za vsakih 100 objektov. Razvrščeni so po besedilu vprašanja naraščajoče (question field).

Primer QuestionConfig

Copy

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

Struktura zahteve za QuestionConfig

Copy

interface QuestionConfigRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
    /** Za paginacijo. Začne se pri 0. **/
    skip?: number
}

Struktura odgovora za QuestionConfig

Copy

interface QuestionConfigByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    questionConfigs: QuestionConfig[]
}

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

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

Ta endpoint vrne en QuestionConfig po njegovem id.

Primer cURL za QuestionConfig po ID

Copy

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

Struktura zahteve za QuestionConfig

Copy

interface QuestionConfigRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za QuestionConfig

Copy

interface QuestionConfigByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Vključeno ob napaki. **/
    reason?: string
    questionConfig?: QuestionConfig
}

POST /api/v1/question-configs

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

Ta API endpoint omogoča ustvarjanje QuestionConfig.

Primer cURL POST za QuestionConfig

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/question-configs?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "name": "Some name that shows on reports.",
    "question": "how much do you like this api?",
    "type": 'slider',
    "reportingOrder": 0,
    "min": 0,
    "max": 10
}'

Struktura POST zahteve za QuestionConfig

Copy

interface QuestionConfigPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za QuestionConfig

Copy

interface QuestionConfigPostResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'empty-request' | 'internal' | 'invalid-input';  
    /** Vključeno ob napaki. **/
    reason?: string
    /** Ustvarjen objekt. **/
    questionConfig?: QuestionConfig
}

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

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

Ta končna točka omogoča posodobitev posamezne QuestionConfig.

Naslednja struktura predstavlja vse vrednosti, ki jih je mogoče spremeniti:

Struktura QuestionConfig

Copy

interface QuestionConfigPatchBody {
    name?: string
    question?: string
    helpText?: string
    /** Pazite! Sprememba type lahko izkrivi poročanje, če sta min/max različna. **/
    type?: QuestionConfigType
    numStars?: number
    min?: number
    max?: number
    defaultValue?: number
    labelNegative?: string
    labelPositive?: string
    subQuestionIds?: string[]
    alwaysShowSubQuestions?: boolean
    reportingOrder?: number
}

Primer cURL posodobitve 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 zahtevka za posodobitev QuestionConfig

Copy

interface QuestionConfigPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za posodobitev QuestionConfig

Copy

interface QuestionConfigPatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'unauthorized' | 'missing-api-key' | 'missing-id' | 'not-found' | 'empty-request' | 'invalid-input'
    /** Vključeno ob napaki. **/
    reason?: string
}

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

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

Ta ruta omogoča odstranitev QuestionConfig po ID-ju.

To bo izbrisalo vse ustrezne rezultate vprašanj (ne pa komentarjev). To je del visoke porabe kreditov.

Primer cURL za odstranitev QuestionConfig

Copy

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

Struktura zahteve za odstranitev QuestionConfig

Copy

interface QuestionConfigDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora pri odstranitvi QuestionConfig

Copy

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

Struktura rezultata vprašanja

Da shranite rezultate za vprašanja, ustvarite QuestionResult. Nato lahko združite rezultate vprašanj in jih povežete s komentarji za namene poročanja.

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

Ta ruta vrne do 1000 QuestionResults objektov naenkrat, paginirano. Strošek je 1 za vsakih 100 objektov. Razvrščeni so po createdAt, naraščajoče. Lahko filtrirate po različnih parametrih.

Primer QuestionResults

Copy

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

Struktura zahteve QuestionResults

Copy

interface QuestionResultsRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Za straničenje. Začne se pri 0. **/
    skip?: number
    /** Za straničenje. **/
    limit?: number
    /** Pridobi rezultate s določene strani. **/
    urlId?: string
    /** Pridobi rezultate določenega uporabnika. **/
    userId?: string
    startDate?: string | number
    questionId?: string | string[]
}

Struktura odgovora QuestionResults

Copy

interface QuestionResultsResponse {
    status: 'success' | 'failed'
    /** Vključen ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključen ob napaki. **/
    reason?: string
    questionResults: QuestionResults[]
}

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

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

Ta končna točka vrne posamezen QuestionResult po njegovem id.

Primer cURL za QuestionResult po id-ju

Copy

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

Struktura zahtevka za QuestionResult

Copy

interface QuestionResultRequestByIdQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za QuestionResult

Copy

interface QuestionResultByIdResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Vključeno ob napaki. **/
    reason?: string
    questionResult?: QuestionResult
}

POST /api/v1/question-results

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

Ta API endpoint omogoča ustvarjanje QuestionResult.

Primer POST cURL zahteve za QuestionResult

Copy

curl --request POST \
  --url 'https://fastcomments.com/api/v1/question-results?tenantId=demo&API_KEY=DEMO_API_SECRET' \
  --header 'Content-Type: application/json' \
  --data '{
    "urlId": "some-page-id",
    "anonUserId": 'anon-0',
    "userId": 'user-0',
    "value": 10,
    "questionId": "some-question-id",
    "meta": [
        {
            name: "example",
            values: ["value-1", "value-2"]
        }
    ]
}'

Struktura POST zahteve za QuestionResult

Copy

interface QuestionResultPostQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura POST odgovora za QuestionResult

Copy

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

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

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

Ta končna točka omogoča posodobitev enega QuestionResult.

Naslednja struktura predstavlja vse vrednosti, ki jih je mogoče spremeniti:

Struktura QuestionResult

Copy

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

Primer cURL za posodobitev 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 zahtevka za posodobitev QuestionResult

Copy

interface QuestionResultPatchQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za posodobitev QuestionResult

Copy

interface QuestionResultPatchResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'unauthorized' | 'missing-api-key' | 'missing-id' | 'not-found' | 'empty-request' | 'invalid-input'
    /** Vključeno ob napaki. **/
    reason?: string
}

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

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

Ta končna točka omogoča odstranitev QuestionResult glede na id.

Primer cURL zahteve za odstranitev QuestionResult

Copy

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

Struktura zahteve za odstranitev QuestionResult

Copy

interface QuestionResultDeleteQueryParams {
    tenantId: string
    API_KEY: string
}

Struktura odgovora za odstranitev QuestionResult

Copy

interface QuestionResultResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key' | 'missing-id' | 'not-found'
    /** Vključeno ob napaki. **/
    reason?: string
}

GET /api/v1/question-results-aggregate

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

Tukaj poteka agregacija rezultatov.

Struktura odziva agregacije je naslednja:

Struktura QuestionResultsAggregationResult

Copy

interface QuestionResultDataPoint {
    /** Mapa vrednosti v število pojavitev te vrednosti za trenutno podatkovno točko (časovni segment ali stran). **/
    v: Map<ValueAsString, number>
    total: number
}
interface QuestionResultsAggregationResult {
    /** Opomba - je null, ko timeBucket ni naveden. **/
    dataByDateBucket?: Map<DateString, QuestionResultDataPoint>
    dataByUrlId?: Map<URLIdString, QuestionResultDataPoint>
    countsByValue?: Map<ValueAsString, number>
    /** Skupno število agregiranih rezultatov. **/
    total: number
    /** Izračunan tehtani povpreček. Gre za plavajoče število (float), običajno z največ dvema decimalnima mestoma. **/
    average: number
    /** Niz datuma, ki predstavlja, kdaj so bili ti podatki izračunani, saj so lahko iz predpomnilnika. **/
    createdAt: string
}

Tu so razpoložljivi parametri poizvedbe za agregacijo:

Struktura zahteve QuestionResultsAggregation

Copy

interface QuestionResultsAggregateRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Lahko agregirate rezultate za eno ali več vprašanj. **/
    questionId: string | string[]
    startDate?: string | number
    timeBucket?: 'day' | 'month' | 'year'
    /** Agregiraj za določeno stran. **/
    urlId?: string
    /** Agregiraj za določenega uporabnika. **/
    userId?: string
    /** Prisili ponovno izračunanje zdaj in posodobi predpomnilnik. **/
    forceRecalculate?: boolean
}

Primer zahteve:

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

Primer odziva:

Primer odziva 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 odziva QuestionResultsAggregation

Copy

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

Opombe o zmogljivosti

Pri neujemajočem predpomnilniku (cache miss) agregacije običajno trajajo pet sekund na milijon rezultatov.
V nasprotnem primeru so zahtevki v konstantnem času.

Opombe o predpomnjenju in stroških

Ko je forceRecalculate določen, je strošek vedno 10, namesto običajnih 2.
Če predpomnilnik poteče in se podatki ponovno izračunajo, je strošek še vedno konstanten 2, če forceRecalculate ni naveden. Predpomnilnik poteče glede na velikost agregiranega nabora podatkov (lahko se giblje med 30 sekundami in 5 minutami).
To spodbuja uporabo predpomnilnika.

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

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

Tukaj se izvaja združevanje rezultatov s komentarji. Uporabno na primer za ustvarjanje "nedavni pozitivni in negativni komentarji" grafikona za izdelek.

Iskanje lahko izvedete po razponu vrednosti (vključno), za eno ali več vprašanj in po začetnem datumu (vključno).

Struktura odgovora je naslednja:

Struktura QuestionResultsCombinedWithCommentsResponse

Copy

interface SimpleComment {
    id: string
    commenterName: string
    userId?: string
    date: string
    commentHTML: string
}
interface SimpleQuestionResult {
    id: string
    value: number
}
interface CommentAndResult {
    comment: SimpleComment
    result: SimpleQuestionResult
}
interface QuestionResultsCombinedWithCommentsResponse {
    /** Niz z datumom, ki označuje, kdaj so bili ti podatki izračunani, saj lahko izhajajo iz predpomnilnika. **/
    createdAt: string
    results: CommentAndResult[]
}

Spodaj so parametri poizvedbe, ki so na voljo za agregacijo:

Struktura zahtevka QuestionResultsCombineComments

Copy

interface QuestionResultsAggregateRequestQueryParams {
    tenantId: string
    API_KEY: string
    /** Rezultate lahko agregirate za eno ali več vprašanj. **/
    questionId: string | string[]
    startDate?: string | number
    urlId?: string
    minValue: number
    maxValue: number
    limit?: number
    forceRecalculate?: boolean
}

Tu je primer zahteve:

Primer zahteve QuestionResultsCombineComments

Copy

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

Primer odgovora:

Primer odgovora QuestionResultsCombineComments

Copy

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

Struktura odgovora QuestionResultsCombineComments

Copy

interface QuestionResultsCombineCommentsResponse {
    status: 'success' | 'failed'
    /** Vključeno ob napaki. **/
    code?: 'missing-tenant-id' | 'invalid-tenant-id' | 'invalid-api-key' | 'missing-api-key'
    /** Vključeno ob napaki. **/
    reason?: string
    data: QuestionResultsCombinedWithCommentsResponse
}

Opombe o predpomnjenju in stroških

Ko je določen forceRecalculate, je strošek vedno 10, namesto običajnega 2.
Če predpomnilnik poteče in so podatki ponovno izračunani, je strošek še vedno konstanten 2, če forceRecalculate ni določen.
To je namenjeno spodbujanju uporabe predpomnilnika.

Struktura uporabniške značke

UserBadge je objekt, ki predstavlja značko, dodeljeno uporabniku v sistemu FastComments.

Značke se lahko uporabnikom dodelijo samodejno na podlagi njihove aktivnosti (kot so število komentarjev, čas odgovora, status veterana) ali ročno s strani skrbnikov spletnega mesta.

Struktura objekta UserBadge je naslednja:

Struktura objekta UserBadge

Copy

export interface UserBadge {
    /** Enoličen identifikator te dodelitve uporabniške značke */
    id: string
    /** ID uporabnika, kateremu je ta značka dodeljena */
    userId: string
    /** ID definicije značke iz kataloga značk najemnika */
    badgeId: string
    /** ID najemnika, ki je ustvaril/dodelil to značko */
    fromTenantId: string
    /** Kdaj je bila ta značka ustvarjena (milisekunde od epohe) */
    createdAt?: number
    /** Kdaj je ta značka prejeta s strani uporabnika (milisekunde od epohe) */
    receivedAt?: number
    /** 
     * Tip značke: 
     * 0=CommentCount, 1=CommentUpVotes, 2=CommentReplies, 3=CommentsPinned, 
     * 4=Veteran, 5=NightOwl, 6=FastReplyTime, 7=ModeratorCommentsDeleted,
     * 8=ModeratorCommentsApproved, 9=ModeratorCommentsUnapproved, 10=ModeratorCommentsReviewed,
     * 11=ModeratorCommentsMarkedSpam, 12=ModeratorCommentsMarkedNotSpam, 13=RepliedToSpecificPage,
     * 14=Manual
     */
    type: number
    /** Za značke, ki temeljijo na pragih, vrednost praga */
    threshold?: number
    /** Ime/oznaka značke */
    name?: string
    /** Podroben opis značke */
    description?: string
    /** Besedilo, prikazano na znački */
    displayLabel?: string
    /** URL do slike, prikazane na znački */
    displaySrc?: string
    /** Barva ozadja značke (heksadecimalna koda) */
    backgroundColor?: string
    /** Barva obrobe značke (heksadecimalna koda) */
    borderColor?: string
    /** Barva besedila značke (heksadecimalna koda) */
    textColor?: string
    /** Dodatna CSS razred za stiliranje */
    cssClass?: string
    /** Za veteranske značke, časovni prag v milisekundah */
    veteranUserThresholdMillis?: number
    /** Ali se ta značka prikazuje ob uporabnikovih komentarjih */
    displayedOnComments: boolean
    /** Vrstni red prikaza značke */
    order?: number
}

GET /api/v1/user-badges

Ta končna točka vam omogoča pridobivanje značk uporabnikov na podlagi različnih kriterijev.

Example Request:

Primer GET zahteve

Copy

Run

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

You can add various query parameters to filter the results:

userId - Pridobi značke za določenega uporabnika
badgeId - Pridobi primere določene značke
type - Filtriraj po tipu značke (0=CommentCount, 1=CommentUpVotes, 2=CommentReplies, etc. Glejte strukturo UserBadge za celoten seznam)
displayedOnComments - Filtriraj glede na to, ali je značka prikazana pri komentarjih (true/false)
limit - Največje število značk za vrniti (privzeto 30, max 200)
skip - Število značk za preskočiti (za pagination)

Example Response:

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

Possible Error Responses:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Neveljaven limit

Copy

{
  "status": "failed",
  "code": "invalid-limit",
  "reason": "The limit (query param: limit) is too large (> 200)."
}

GET /api/v1/user-badges/:id

Ta končna točka omogoča pridobitev določene uporabniške značke po njenem edinstvenem ID-ju.

Primer zahteve:

Primer GET zahteve

Copy

Run

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

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadge": {
    "id": "badge123",
    "userId": "user456",
    "badgeId": "badgeDef789",
    "fromTenantId": "tenant001",
    "createdAt": 1650532511000,
    "receivedAt": 1650532511000,
    "type": 14,
    "name": "Special Contributor",
    "description": "Awarded to special contributors to our community",
    "displayLabel": "Special",
    "backgroundColor": "#4a5568",
    "textColor": "#ffffff",
    "displayedOnComments": true,
    "order": 1
  }
}

Možni odgovori z napako:

Napaka: Manjkajoč ID najemnika

Copy

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

Napaka: Ni najdeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge badge123 was not found."
}

POST /api/v1/user-badges

This endpoint allows you to create a new user badge assignment.

Example Request:

Primer POST zahtevka

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

The request body must contain the following parameters:

userId (required) - The ID of the user to assign the badge to
badgeId (required) - The ID of the badge to assign
displayedOnComments (optional) - Whether the badge should be displayed on the user's comments (defaults to true)

Important Notes:

The badge must exist and be enabled in your tenant's badge catalog
You can only assign badges to users who belong to your tenant or have commented on your site

Example Response:

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

Possible Error Responses:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Manjkajoči ID uporabnika

Copy

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

Napaka: Manjkajoči ID značke

Copy

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

Napaka: Značka ni bila najdena

Copy

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

Napaka: Nepooblaščen uporabnik

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

Ta končna točka vam omogoča posodobitev dodelitve uporabniške značke.

Trenutno je edina lastnost, ki jo je mogoče posodobiti, displayedOnComments, ki določa, ali se značka prikazuje pri komentarjih uporabnika.

Primer zahteve:

Primer PUT zahteve

Copy

Run

curl -X PUT "https://fastcomments.com/api/v1/user-badges/badge123?tenantId=demo&API_KEY=DEMO_API_SECRET" \
-H "Content-Type: application/json" \
-d '{
  "displayedOnComments": false
}'

Primer odgovora:

Odgovor

Copy

{
  "status": "success"
}

Možni odgovori z napako:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Manjkajoči ID

Copy

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

Napaka: Ni najdeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge badge123 was not found."
}

DELETE /api/v1/user-badges/:id

Ta končna točka omogoča brisanje dodelitve uporabniške značke.

Example Request:

Primer DELETE zahteve

Copy

Run

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

Example Response:

Odgovor

Copy

{
  "status": "success"
}

Possible Error Responses:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Manjkajoči ID

Copy

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

Napaka: Ni najdeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge badge123 was not found."
}

Struktura napredka uporabniške značke

UserBadgeProgress je objekt, ki predstavlja napredek uporabnika pri pridobivanju različnih značk v sistemu FastComments.

To sledenje pomaga določiti, kdaj naj uporabniki prejmejo samodejne značke glede na njihovo dejavnost in sodelovanje v vaši skupnosti.

Struktura objekta UserBadgeProgress je naslednja:

Struktura UserBadgeProgress

Copy

export interface UserBadgeProgress {
    /** Enolični identifikator tega zapisa o napredku */
    id: string
    /** ID najemnika, kateremu pripada ta zapis o napredku */
    tenantId: string
    /** ID uporabnika, katerega ta zapis o napredku spremlja */
    userId: string
    /** ID prvega komentarja uporabnika v sistemu */
    firstCommentId?: string
    /** Datum prvega komentarja uporabnika (milisekunde od epohe) */
    firstCommentDate?: number
    /** Samodejno izračunan faktor zaupanja na podlagi dejavnosti uporabnika */
    autoTrustFactor?: number
    /** Ročno nastavljen faktor zaupanja s strani skrbnikov */
    manualTrustFactor?: number
    /** Podroben objekt napredka z različnimi metrikami, ključi ustrezajo BadgeType enum */
    progress: {
        /** 0: CommentCount - Število komentarjev, ki jih je uporabnik napisal */
        '0'?: number
        /** 1: CommentUpVotes - Število všečkov, ki jih je uporabnik prejel */
        '1'?: number
        /** 2: CommentReplies - Število odgovorov, ki jih je uporabnik napisal */
        '2'?: number
        /** 3: CommentsPinned - Število pripetih komentarjev, ki jih ima uporabnik */
        '3'?: number
        /** 4: Veteran - Starost uporabniškega računa */
        '4'?: number
        /** 5: NightOwl - Število objav uporabnika med nočnimi urami */
        '5'?: number
        /** 6: FastReplyTime - Povprečni čas odgovora v milisekundah */
        '6'?: number
        /** 7: ModeratorCommentsDeleted - Za moderatorjske značke, število izbrisanih komentarjev */
        '7'?: number
        /** 8: ModeratorCommentsApproved - Za moderatorjske značke, število odobrenih komentarjev */
        '8'?: number
        /** 9: ModeratorCommentsUnapproved - Za moderatorjske značke, število neodobrenih komentarjev */
        '9'?: number
        /** 10: ModeratorCommentsReviewed - Za moderatorjske značke, število pregledanih komentarjev */
        '10'?: number
        /** 11: ModeratorCommentsMarkedSpam - Za moderatorjske značke, število komentarjev označenih kot spam */
        '11'?: number
        /** 12: ModeratorCommentsMarkedNotSpam - Za moderatorjske značke, število komentarjev označenih kot ne-spam */
        '12'?: number
        /** 13: RepliedToSpecificPage - Za vsako stran, število odgovorov */
        '13'?: Record<string, number>
    }
}

---

GET /api/v1/user-badge-progress

Ta končna točka vam omogoča pridobitev zapisov o napredku uporabniških značk na podlagi različnih kriterijev.

Primer zahteve:

Primer GET zahteve

Copy

Run

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

Lahko dodate različne parametre poizvedbe za filtriranje rezultatov:

userId - Pridobi napredek za določenega uporabnika
limit - Največje število zapisov za vrnitev (privzeto 30, največ 200)
skip - Število zapisov za preskočitev (za straničenje)

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadgeProgresses": [
    {
      "id": "progress123",
      "tenantId": "tenant001",
      "userId": "user456",
      "firstCommentId": "comment789",
      "firstCommentDate": 1650532511000,
      "autoTrustFactor": 0.75,
      "progress": {
        "0": 42,
        "1": 120,
        "2": 15,
        "3": 3,
        "5": 5,
        "6": 1800000,
        "8": 0,
        "7": 0
      }
    },
    {
      "id": "progress124",
      "tenantId": "tenant001",
      "userId": "user789",
      "firstCommentId": "comment790",
      "firstCommentDate": 1650532598000,
      "autoTrustFactor": 0.5,
      "progress": {
        "0": 12,
        "1": 15,
        "2": 4
      }
    }
  ]
}

Možni odgovori z napako:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Neveljaven limit

Copy

{
  "status": "failed",
  "code": "invalid-limit",
  "reason": "The limit (query param: limit) is too large (> 200)."
}

---

GET /api/v1/user-badge-progress/:id

Ta končna točka vam omogoča pridobiti določen zapis napredka uporabnikove značke po njegovem edinstvenem ID-ju.

Example Request:

Primer GET zahteve

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:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Ni najdeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "The user badge progress progress123 was not found."
}

GET /api/v1/user-badge-progress/user/:userId

Ta končna točka omogoča pridobitev zapisa o napredku značk uporabnika na podlagi ID-ja uporabnika.

Primer zahteve:

Primer GET zahteve

Copy

Run

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

Primer odgovora:

Odgovor

Copy

{
  "status": "success",
  "userBadgeProgress": {
    "id": "progress123",
    "tenantId": "tenant001",
    "userId": "user456",
    "firstCommentId": "comment789",
    "firstCommentDate": 1650532511000,
    "autoTrustFactor": 0.75,
    "progress": {
      "0": 42,
      "1": 120,
      "2": 15,
      "3": 3,
      "5": 5,
      "6": 1800000,
      "8": 0,
      "7": 0
    }
  }
}

Možni odgovori z napako:

Napaka: Manjkajoči ID najemnika

Copy

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

Napaka: Manjkajoči ID uporabnika

Copy

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

Napaka: Ni najdeno

Copy

{
  "status": "failed",
  "code": "not-found",
  "reason": "No badge progress found for user user456 in tenant tenant001."
}

Zaključek

Upamo, da se vam je naša dokumentacija API zdela izčrpna in enostavna za razumevanje. Če opazite kakšne vrzeli, nam jih sporočite spodaj.

Jezik 🇸🇮 Slovenščina

Viri API

Agregacije

Revizijski dnevniki

Komentarji

E-poštne predloge

Hashtagi

Moderatorji

Število obvestil

Obvestila

Strani

Čakajoči webhook dogodki

SSO uporabniki

Naročnine

Dnevna poraba najemnika

Najemniki

Paketi najemnikov

Uporabniki najemnikov

Uporabniki

Glasovi

Konfiguracije domen

Konfiguracije vprašanj

Rezultati vprašanj

Agregacija rezultatov vprašanj

Uporabniške značke

Napredek uporabniške značke