FastComments Go SDK

Ovo je službeni Go SDK za FastComments.

Službeni Go SDK za FastComments API

Repozitorij

Instalacija

go get github.com/fastcomments/fastcomments-go

Korištenje API klijenta

Javni API (bez autentifikacije)

PublicAPI omogućuje neautentificiran pristup javnim krajnjim točkama:

package main

import (
    "context"
    "fmt"
    "github.com/fastcomments/fastcomments-go/client"
)

func main() {
    config := client.NewConfiguration()
    apiClient := client.NewAPIClient(config)

    // Get comments using PublicAPI
    response, httpResp, err := apiClient.PublicAPI.GetCommentsPublic(
        context.Background(),
        "your-tenant-id",
    ).UrlId("your-page-url-id").Execute()

    if err != nil {
        panic(err)
    }

    fmt.Printf("Status: %d\n", httpResp.StatusCode)
    fmt.Printf("Comments: %+v\n", response)
}

Zadani API (zahtijeva API ključ)

DefaultAPI zahtijeva autentifikaciju koristeći vaš API ključ:

package main

import (
    "context"
    "fmt"
    "github.com/fastcomments/fastcomments-go/client"
)

func main() {
    config := client.NewConfiguration()
    apiClient := client.NewAPIClient(config)

    // Create authenticated context with API key
    auth := context.WithValue(
        context.Background(),
        client.ContextAPIKeys,
        map[string]client.APIKey{
            "api_key": {Key: "your-api-key-here"},
        },
    )

    // Get comments using authenticated DefaultAPI
    response, httpResp, err := apiClient.DefaultAPI.GetComments(auth).
        TenantId("your-tenant-id").
        UrlId("your-page-url-id").
        Execute()

    if err != nil {
        panic(err)
    }

    fmt.Printf("Status: %d\n", httpResp.StatusCode)
    fmt.Printf("Comments: %+v\n", response)
}

Korištenje

Jednostavni SSO

package main

import (
    "context"
    "fmt"
    "github.com/fastcomments/fastcomments-go/client"
    "github.com/fastcomments/fastcomments-go/sso"
)

func main() {
    // Kreirajte Jednostavni SSO token
    user := &sso.SimpleSSOUserData{
        UserID: "user-123",
        Email:  "user@example.com",
        Avatar: "https://example.com/avatar.jpg",
    }

    ssoInstance := sso.NewSimple(user)
    token, err := ssoInstance.CreateToken()
    if err != nil {
        panic(err)
    }

    fmt.Println("SSO Token:", token)

    // Upotrijebite SSO token za autentificirani API poziv
    config := client.NewConfiguration()
    apiClient := client.NewAPIClient(config)

    response, httpResp, err := apiClient.PublicAPI.GetCommentsPublic(
        context.Background(),
        "your-tenant-id",
    ).UrlId("your-page-url-id").Sso(token).Execute()

    if err != nil {
        panic(err)
    }

    fmt.Printf("Status: %d\n", httpResp.StatusCode)
    fmt.Printf("Comments: %+v\n", response)
}

Sigurni SSO

package main

import (
    "context"
    "fmt"
    "github.com/fastcomments/fastcomments-go/client"
    "github.com/fastcomments/fastcomments-go/sso"
)

func main() {
    // Kreirajte Sigurni SSO token
    user := &sso.SecureSSOUserData{
        UserID:   "user-123",
        Email:    "user@example.com",
        Username: "johndoe",
        Avatar:   "https://example.com/avatar.jpg",
    }

    apiKey := "your-api-key"
    ssoInstance, err := sso.NewSecure(apiKey, user)
    if err != nil {
        panic(err)
    }

    token, err := ssoInstance.CreateToken()
    if err != nil {
        panic(err)
    }

    fmt.Println("Secure SSO Token:", token)

    // Upotrijebite SSO token za autentificirani API poziv
    config := client.NewConfiguration()
    apiClient := client.NewAPIClient(config)

    response, httpResp, err := apiClient.PublicAPI.GetCommentsPublic(
        context.Background(),
        "your-tenant-id",
    ).UrlId("your-page-url-id").Sso(token).Execute()

    if err != nil {
        panic(err)
    }

    fmt.Printf("Status: %d\n", httpResp.StatusCode)
    fmt.Printf("Comments: %+v\n", response)
}

Agregiranje

Agregira dokumente grupiranjem (ako je groupBy zadano) i primjenom više operacija. Podržane su različite operacije (npr. sum, countDistinct, avg, itd.).

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
parentTenantId	string	query	Ne
includeStats	boolean	query	Ne

Odgovor

Vraća: AggregationResponse

Primjer

Primjer agregacije

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    aggregationRequest := *openapiclient.NewAggregationRequest("ResourceName_example", []openapiclient.AggregationOperation{*openapiclient.NewAggregationOperation("Field_example", openapiclient.AggregationOpType("sum"))}) // AggregationRequest | 
    parentTenantId := "parentTenantId_example" // string |  (neobavezno)
    includeStats := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.Aggregate(context.Background()).TenantId(tenantId).AggregationRequest(aggregationRequest).ParentTenantId(parentTenantId).IncludeStats(includeStats).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.Aggregate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `Aggregate`: AggregationResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.Aggregate`: %v\n", resp)
}

Dohvati dnevnike revizije

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
limit	number	query	Ne
skip	number	query	Ne
order	string	query	Ne
after	number	query	Ne
before	number	query	Ne

Odgovor

Vraća: GetAuditLogs200Response

Primjer

Primjer GetAuditLogs

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    limit := float64(1.2) // float64 |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    order := openapiclient.SORT_DIR("ASC") // SORTDIR |  (neobavezno)
    after := float64(1.2) // float64 |  (neobavezno)
    before := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetAuditLogs(context.Background()).TenantId(tenantId).Limit(limit).Skip(skip).Order(order).After(after).Before(before).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetAuditLogs``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetAuditLogs`: GetAuditLogs200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetAuditLogs`: %v\n", resp)
}

Blokiraj iz komentara (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
commentId	string	path	Da
sso	string	query	Ne

Odgovor

Vraća: BlockFromCommentPublic200Response

Primjer

Primjer BlockFromCommentPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    publicBlockFromCommentParams := *openapiclient.NewPublicBlockFromCommentParams([]string{"CommentIds_example"}) // PublicBlockFromCommentParams | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.BlockFromCommentPublic(context.Background(), commentId).TenantId(tenantId).PublicBlockFromCommentParams(publicBlockFromCommentParams).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.BlockFromCommentPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `BlockFromCommentPublic`: BlockFromCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.BlockFromCommentPublic`: %v\n", resp)
}

Poništi blokadu komentara (javno)

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
commentId	string	path	Da
sso	string	query	Ne

Odgovor

Vraća: UnBlockCommentPublic200Response

Primjer

Primjer UnBlockCommentPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    publicBlockFromCommentParams := *openapiclient.NewPublicBlockFromCommentParams([]string{"CommentIds_example"}) // PublicBlockFromCommentParams | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UnBlockCommentPublic(context.Background(), commentId).TenantId(tenantId).PublicBlockFromCommentParams(publicBlockFromCommentParams).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UnBlockCommentPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UnBlockCommentPublic`: UnBlockCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnBlockCommentPublic`: %v\n", resp)
}

Provjeri komentare za blokirane

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
commentIds	string	query	Da	Zarezom odvojen popis ID-eva komentara.
sso	string	query	Ne

Odgovor

Vraća: CheckedCommentsForBlocked200Response

Primjer

CheckedCommentsForBlocked Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentIds := "commentIds_example" // string | Zarezom odvojen popis ID-eva komentara.
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.CheckedCommentsForBlocked(context.Background()).TenantId(tenantId).CommentIds(commentIds).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.CheckedCommentsForBlocked``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `CheckedCommentsForBlocked`: CheckedCommentsForBlocked200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CheckedCommentsForBlocked`: %v\n", resp)
}

Blokiraj korisnika iz komentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: BlockFromCommentPublic200Response

Primjer

Primjer BlockUserFromComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    blockFromCommentParams := *openapiclient.NewBlockFromCommentParams() // BlockFromCommentParams | 
    userId := "userId_example" // string |  (neobavezno)
    anonUserId := "anonUserId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.BlockUserFromComment(context.Background(), id).TenantId(tenantId).BlockFromCommentParams(blockFromCommentParams).UserId(userId).AnonUserId(anonUserId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.BlockUserFromComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `BlockUserFromComment`: BlockFromCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.BlockUserFromComment`: %v\n", resp)
}

Kreiraj komentar (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
urlId	string	query	Da
broadcastId	string	query	Da
sessionId	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: CreateCommentPublic200Response

Primjer

Primjer CreateCommentPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    commentData := *openapiclient.NewCommentData("CommenterName_example", "Comment_example", "Url_example", "UrlId_example") // CommentData | 
    sessionId := "sessionId_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.CreateCommentPublic(context.Background(), tenantId).UrlId(urlId).BroadcastId(broadcastId).CommentData(commentData).SessionId(sessionId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.CreateCommentPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateCommentPublic`: CreateCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateCommentPublic`: %v\n", resp)
}

Izbriši komentar

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
contextUserId	string	query	Ne
isLive	boolean	query	Ne

Odgovor

Vraća: DeleteComment200Response

Primjer

Primjer DeleteComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    contextUserId := "contextUserId_example" // string |  (neobavezno)
    isLive := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteComment(context.Background(), id).TenantId(tenantId).ContextUserId(contextUserId).IsLive(isLive).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteComment`: DeleteComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteComment`: %v\n", resp)
}

Izbriši komentar (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
commentId	string	path	Da
broadcastId	string	query	Da
editKey	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: DeleteCommentPublic200Response

Primjer

DeleteCommentPublic Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    editKey := "editKey_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.DeleteCommentPublic(context.Background(), tenantId, commentId).BroadcastId(broadcastId).EditKey(editKey).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.DeleteCommentPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeleteCommentPublic`: DeleteCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteCommentPublic`: %v\n", resp)
}

Izbriši glas za komentar

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
commentId	string	path	Da
voteId	string	path	Da
urlId	string	query	Da
broadcastId	string	query	Da
editKey	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: DeleteCommentVote200Response

Primjer

Primjer DeleteCommentVote

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    voteId := "voteId_example" // string | 
    urlId := "urlId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    editKey := "editKey_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.DeleteCommentVote(context.Background(), tenantId, commentId, voteId).UrlId(urlId).BroadcastId(broadcastId).EditKey(editKey).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.DeleteCommentVote``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteCommentVote`: DeleteCommentVote200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteCommentVote`: %v\n", resp)
}

Prijavi komentar

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: FlagComment200Response

Primjer

Primjer FlagComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    anonUserId := "anonUserId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.FlagComment(context.Background(), id).TenantId(tenantId).UserId(userId).AnonUserId(anonUserId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.FlagComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `FlagComment`: FlagComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.FlagComment`: %v\n", resp)
}

Dohvati komentar

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetComment200Response

Primjer

Primjer GetComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetComment(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetComment`: GetComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetComment`: %v\n", resp)
}

Dohvati komentare

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
page	integer	query	Ne
limit	integer	query	Ne
skip	integer	query	Ne
asTree	boolean	query	Ne
skipChildren	integer	query	Ne
limitChildren	integer	query	Ne
maxTreeDepth	integer	query	Ne
urlId	string	query	Ne
userId	string	query	Ne
anonUserId	string	query	Ne
contextUserId	string	query	Ne
hashTag	string	query	Ne
parentId	string	query	Ne
direction	string	query	Ne

Odgovor

Vraća: GetComments200Response

Primjer

GetComments Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    page := int32(56) // int32 |  (neobavezno)
    limit := int32(56) // int32 |  (neobavezno)
    skip := int32(56) // int32 |  (neobavezno)
    asTree := true // bool |  (neobavezno)
    skipChildren := int32(56) // int32 |  (neobavezno)
    limitChildren := int32(56) // int32 |  (neobavezno)
    maxTreeDepth := int32(56) // int32 |  (neobavezno)
    urlId := "urlId_example" // string |  (neobavezno)
    userId := "userId_example" // string |  (neobavezno)
    anonUserId := "anonUserId_example" // string |  (neobavezno)
    contextUserId := "contextUserId_example" // string |  (neobavezno)
    hashTag := "hashTag_example" // string |  (neobavezno)
    parentId := "parentId_example" // string |  (neobavezno)
    direction := openapiclient.SortDirections("OF") // SortDirections |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetComments(context.Background()).TenantId(tenantId).Page(page).Limit(limit).Skip(skip).AsTree(asTree).SkipChildren(skipChildren).LimitChildren(limitChildren).MaxTreeDepth(maxTreeDepth).UrlId(urlId).UserId(userId).AnonUserId(anonUserId).ContextUserId(contextUserId).HashTag(hashTag).ParentId(parentId).Direction(direction).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetComments``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetComments`: GetComments200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetComments`: %v\n", resp)
}

Dohvati komentare (javno)

zahtjev tenantId urlId

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
urlId	string	query	Da
page	integer	query	Ne
direction	string	query	Ne
sso	string	query	Ne
skip	integer	query	Ne
skipChildren	integer	query	Ne
limit	integer	query	Ne
limitChildren	integer	query	Ne
countChildren	boolean	query	Ne
fetchPageForCommentId	string	query	Ne
includeConfig	boolean	query	Ne
countAll	boolean	query	Ne
includei10n	boolean	query	Ne
locale	string	query	Ne
modules	string	query	Ne
isCrawler	boolean	query	Ne
includeNotificationCount	boolean	query	Ne
asTree	boolean	query	Ne
maxTreeDepth	integer	query	Ne
useFullTranslationIds	boolean	query	Ne
parentId	string	query	Ne
searchText	string	query	Ne
hashTags	array	query	Ne
userId	string	query	Ne
customConfigStr	string	query	Ne
afterCommentId	string	query	Ne
beforeCommentId	string	query	Ne

Odgovor

Vraća: GetCommentsPublic200Response

Primjer

Primjer GetCommentsPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    page := int32(56) // int32 |  (neobavezno)
    direction := openapiclient.SortDirections("OF") // SortDirections |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    skip := int32(56) // int32 |  (neobavezno)
    skipChildren := int32(56) // int32 |  (neobavezno)
    limit := int32(56) // int32 |  (neobavezno)
    limitChildren := int32(56) // int32 |  (neobavezno)
    countChildren := true // bool |  (neobavezno)
    fetchPageForCommentId := "fetchPageForCommentId_example" // string |  (neobavezno)
    includeConfig := true // bool |  (neobavezno)
    countAll := true // bool |  (neobavezno)
    includei10n := true // bool |  (neobavezno)
    locale := "locale_example" // string |  (neobavezno)
    modules := "modules_example" // string |  (neobavezno)
    isCrawler := true // bool |  (neobavezno)
    includeNotificationCount := true // bool |  (neobavezno)
    asTree := true // bool |  (neobavezno)
    maxTreeDepth := int32(56) // int32 |  (neobavezno)
    useFullTranslationIds := true // bool |  (neobavezno)
    parentId := "parentId_example" // string |  (neobavezno)
    searchText := "searchText_example" // string |  (neobavezno)
    hashTags := []string{"Inner_example"} // []string |  (neobavezno)
    userId := "userId_example" // string |  (neobavezno)
    customConfigStr := "customConfigStr_example" // string |  (neobavezno)
    afterCommentId := "afterCommentId_example" // string |  (neobavezno)
    beforeCommentId := "beforeCommentId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetCommentsPublic(context.Background(), tenantId).UrlId(urlId).Page(page).Direction(direction).Sso(sso).Skip(skip).SkipChildren(skipChildren).Limit(limit).LimitChildren(limitChildren).CountChildren(countChildren).FetchPageForCommentId(fetchPageForCommentId).IncludeConfig(includeConfig).CountAll(countAll).Includei10n(includei10n).Locale(locale).Modules(modules).IsCrawler(isCrawler).IncludeNotificationCount(includeNotificationCount).AsTree(asTree).MaxTreeDepth(maxTreeDepth).UseFullTranslationIds(useFullTranslationIds).ParentId(parentId).SearchText(searchText).HashTags(hashTags).UserId(userId).CustomConfigStr(customConfigStr).AfterCommentId(afterCommentId).BeforeCommentId(beforeCommentId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetCommentsPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetCommentsPublic`: GetCommentsPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentsPublic`: %v\n", resp)
}

Dohvati tekst komentara

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
commentId	string	path	Da
editKey	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: GetCommentText200Response

Primjer

Primjer GetCommentText

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    editKey := "editKey_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetCommentText(context.Background(), tenantId, commentId).EditKey(editKey).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetCommentText``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetCommentText`: GetCommentText200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentText`: %v\n", resp)
}

Dohvati korisnička imena glasova komentara

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
commentId	string	path	Da
dir	integer	query	Da
sso	string	query	Ne

Odgovor

Vraća: GetCommentVoteUserNames200Response

Primjer

Primjer GetCommentVoteUserNames

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    dir := int32(56) // int32 | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetCommentVoteUserNames(context.Background(), tenantId, commentId).Dir(dir).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetCommentVoteUserNames``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetCommentVoteUserNames`: GetCommentVoteUserNames200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentVoteUserNames`: %v\n", resp)
}

Zaključaj komentar

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	path	Da
commentId	string	path	Da
broadcastId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: LockComment200Response

Primjer

Primjer LockComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.LockComment(context.Background(), tenantId, commentId).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.LockComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `LockComment`: LockComment200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.LockComment`: %v\n", resp)
}

Pričvrsti komentar

Parametri

Naziv	Tip	Lokacija	Obvezno
tenantId	string	path	Da
commentId	string	path	Da
broadcastId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: PinComment200Response

Primjer

Primjer PinComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.PinComment(context.Background(), tenantId, commentId).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.PinComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `PinComment`: PinComment200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.PinComment`: %v\n", resp)
}

Spremi komentar

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
isLive	boolean	query	Ne
doSpamCheck	boolean	query	Ne
sendEmails	boolean	query	Ne
populateNotifications	boolean	query	Ne

Odgovor

Vraća: SaveComment200Response

Primjer

Primjer SaveComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createCommentParams := *openapiclient.NewCreateCommentParams("CommenterName_example", "Comment_example", "Url_example", "UrlId_example", "Locale_example") // CreateCommentParams | 
    isLive := true // bool |  (neobavezno)
    doSpamCheck := true // bool |  (neobavezno)
    sendEmails := true // bool |  (neobavezno)
    populateNotifications := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.SaveComment(context.Background()).TenantId(tenantId).CreateCommentParams(createCommentParams).IsLive(isLive).DoSpamCheck(doSpamCheck).SendEmails(sendEmails).PopulateNotifications(populateNotifications).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.SaveComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `SaveComment`: SaveComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveComment`: %v\n", resp)
}

Spremi komentare u seriji

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
isLive	boolean	query	Ne
doSpamCheck	boolean	query	Ne
sendEmails	boolean	query	Ne
populateNotifications	boolean	query	Ne

Odgovor

Vraća: []SaveComment200Response

Primjer

Primjer SaveCommentsBulk

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createCommentParams := []openapiclient.CreateCommentParams{*openapiclient.NewCreateCommentParams("CommenterName_example", "Comment_example", "Url_example", "UrlId_example", "Locale_example")} // []CreateCommentParams | 
    isLive := true // bool |  (neobavezno)
    doSpamCheck := true // bool |  (neobavezno)
    sendEmails := true // bool |  (neobavezno)
    populateNotifications := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.SaveCommentsBulk(context.Background()).TenantId(tenantId).CreateCommentParams(createCommentParams).IsLive(isLive).DoSpamCheck(doSpamCheck).SendEmails(sendEmails).PopulateNotifications(populateNotifications).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.SaveCommentsBulk``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `SaveCommentsBulk`: []SaveComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveCommentsBulk`: %v\n", resp)
}

Postavi tekst komentara

Parametri

Name	Type	Location	Required
tenantId	string	putanja	Da
commentId	string	putanja	Da
broadcastId	string	upit	Da
editKey	string	upit	Ne
sso	string	upit	Ne

Odgovor

Vraća: SetCommentText200Response

Primjer

Primjer SetCommentText

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    commentTextUpdateRequest := *openapiclient.NewCommentTextUpdateRequest("Comment_example") // CommentTextUpdateRequest | 
    editKey := "editKey_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.SetCommentText(context.Background(), tenantId, commentId).BroadcastId(broadcastId).CommentTextUpdateRequest(commentTextUpdateRequest).EditKey(editKey).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.SetCommentText``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `SetCommentText`: SetCommentText200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SetCommentText`: %v\n", resp)
}

Deblokiraj korisnika iz komentara

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
id	string	path	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: UnBlockCommentPublic200Response

Primjer

Primjer UnBlockUserFromComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    unBlockFromCommentParams := *openapiclient.NewUnBlockFromCommentParams() // UnBlockFromCommentParams | 
    userId := "userId_example" // string |  (neobavezno)
    anonUserId := "anonUserId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UnBlockUserFromComment(context.Background(), id).TenantId(tenantId).UnBlockFromCommentParams(unBlockFromCommentParams).UserId(userId).AnonUserId(anonUserId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UnBlockUserFromComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UnBlockUserFromComment`: UnBlockCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UnBlockUserFromComment`: %v\n", resp)
}

Poništi prijavu komentara

Parametri

Naziv	Tip	Lokacija	Obvezno
tenantId	string	query	Da
id	string	path	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: FlagComment200Response

Primjer

Primjer UnFlagComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    anonUserId := "anonUserId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UnFlagComment(context.Background(), id).TenantId(tenantId).UserId(userId).AnonUserId(anonUserId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UnFlagComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UnFlagComment`: FlagComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UnFlagComment`: %v\n", resp)
}

Otključaj komentar

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
commentId	string	path	Da
broadcastId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: LockComment200Response

Primjer

Primjer UnLockComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UnLockComment(context.Background(), tenantId, commentId).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UnLockComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UnLockComment`: LockComment200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnLockComment`: %v\n", resp)
}

Ukloni pričvrćenje komentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
commentId	string	path	Da
broadcastId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: PinComment200Response

Primjer

Primjer UnPinComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UnPinComment(context.Background(), tenantId, commentId).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UnPinComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UnPinComment`: PinComment200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnPinComment`: %v\n", resp)
}

Ažuriraj komentar

Parametri

Naziv	Tip	Lokacija	Obvezno
tenantId	string	query	Da
id	string	path	Da
contextUserId	string	query	Ne
doSpamCheck	boolean	query	Ne
isLive	boolean	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    body := PickAPICommentUpdatableCommentFields(987) // PickAPICommentUpdatableCommentFields | 
    contextUserId := "contextUserId_example" // string |  (neobavezno)
    doSpamCheck := true // bool |  (neobavezno)
    isLive := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateComment(context.Background(), id).TenantId(tenantId).Body(body).ContextUserId(contextUserId).DoSpamCheck(doSpamCheck).IsLive(isLive).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateComment`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateComment`: %v\n", resp)
}

Glasaj za komentar

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	putanja	Da
commentId	string	putanja	Da
urlId	string	upit	Da
broadcastId	string	upit	Da
sessionId	string	upit	Ne
sso	string	upit	Ne

Odgovor

Vraća: VoteComment200Response

Primjer

Primjer VoteComment

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    urlId := "urlId_example" // string | 
    broadcastId := "broadcastId_example" // string | 
    voteBodyParams := *openapiclient.NewVoteBodyParams("CommenterEmail_example", "CommenterName_example", "VoteDir_example", "Url_example") // VoteBodyParams | 
    sessionId := "sessionId_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.VoteComment(context.Background(), tenantId, commentId).UrlId(urlId).BroadcastId(broadcastId).VoteBodyParams(voteBodyParams).SessionId(sessionId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.VoteComment``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `VoteComment`: VoteComment200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.VoteComment`: %v\n", resp)
}

Dodaj konfiguraciju domene

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: AddDomainConfig200Response

Primjer

Primjer za AddDomainConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    addDomainConfigParams := *openapiclient.NewAddDomainConfigParams("Domain_example") // AddDomainConfigParams | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AddDomainConfig(context.Background()).TenantId(tenantId).AddDomainConfigParams(addDomainConfigParams).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AddDomainConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `AddDomainConfig`: AddDomainConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddDomainConfig`: %v\n", resp)
}

Izbriši konfiguraciju domene

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
domain	string	path	Da

Odgovor

Vraća: DeleteDomainConfig200Response

Primjer

Primjer DeleteDomainConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    domain := "domain_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteDomainConfig(context.Background(), domain).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteDomainConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteDomainConfig`: DeleteDomainConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteDomainConfig`: %v\n", resp)
}

Dohvati konfiguraciju domene

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
domain	string	path	Da

Odgovor

Vraća: GetDomainConfig200Response

Primjer

Primjer GetDomainConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    domain := "domain_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetDomainConfig(context.Background(), domain).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetDomainConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetDomainConfig`: GetDomainConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetDomainConfig`: %v\n", resp)
}

Dohvati konfiguracije domene

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: GetDomainConfigs200Response

Primjer

Primjer GetDomainConfigs

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetDomainConfigs(context.Background()).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetDomainConfigs``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetDomainConfigs`: GetDomainConfigs200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetDomainConfigs`: %v\n", resp)
}

Djelomično ažuriraj konfiguraciju domene

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
domainToUpdate	string	path	Da

Odgovor

Vraća: GetDomainConfig200Response

Primjer

Primjer PatchDomainConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    domainToUpdate := "domainToUpdate_example" // string | 
    patchDomainConfigParams := *openapiclient.NewPatchDomainConfigParams() // PatchDomainConfigParams | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.PatchDomainConfig(context.Background(), domainToUpdate).TenantId(tenantId).PatchDomainConfigParams(patchDomainConfigParams).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.PatchDomainConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `PatchDomainConfig`: GetDomainConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PatchDomainConfig`: %v\n", resp)
}

Postavi konfiguraciju domene

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
domainToUpdate	string	path	Da

Odgovor

Vraća: GetDomainConfig200Response

Primjer

Primjer PutDomainConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    domainToUpdate := "domainToUpdate_example" // string | 
    updateDomainConfigParams := *openapiclient.NewUpdateDomainConfigParams("Domain_example") // UpdateDomainConfigParams | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.PutDomainConfig(context.Background(), domainToUpdate).TenantId(tenantId).UpdateDomainConfigParams(updateDomainConfigParams).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.PutDomainConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `PutDomainConfig`: GetDomainConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PutDomainConfig`: %v\n", resp)
}

Kreiraj predložak e-pošte

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateEmailTemplate200Response

Primjer

Primjer CreateEmailTemplate

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createEmailTemplateBody := *openapiclient.NewCreateEmailTemplateBody("EmailTemplateId_example", "DisplayName_example", "Ejs_example") // CreateEmailTemplateBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateEmailTemplate(context.Background()).TenantId(tenantId).CreateEmailTemplateBody(createEmailTemplateBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateEmailTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateEmailTemplate`: CreateEmailTemplate200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateEmailTemplate`: %v\n", resp)
}

Izbriši predložak e-pošte

Parametri

Naziv	Type	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteEmailTemplate

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteEmailTemplate(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteEmailTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeleteEmailTemplate`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteEmailTemplate`: %v\n", resp)
}

Izbriši pogrešku renderiranja predloška e-pošte

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
errorId	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

DeleteEmailTemplateRenderError Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    errorId := "errorId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteEmailTemplateRenderError(context.Background(), id, errorId).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteEmailTemplateRenderError``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteEmailTemplateRenderError`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteEmailTemplateRenderError`: %v\n", resp)
}

Dohvati predložak e-pošte

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetEmailTemplate200Response

Primjer

Primjer GetEmailTemplate

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetEmailTemplate(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetEmailTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetEmailTemplate`: GetEmailTemplate200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplate`: %v\n", resp)
}

Dohvati definicije predložaka e-pošte

Parametri

Naziv	Type	Location	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetEmailTemplateDefinitions200Response

Primjer

Primjer GetEmailTemplateDefinitions

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetEmailTemplateDefinitions(context.Background()).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetEmailTemplateDefinitions``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetEmailTemplateDefinitions`: GetEmailTemplateDefinitions200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplateDefinitions`: %v\n", resp)
}

Dohvati pogreške renderiranja predložaka e-pošte

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
id	string	path	Da
skip	number	query	Ne

Odgovor

Vraća: GetEmailTemplateRenderErrors200Response

Primjer

Primjer GetEmailTemplateRenderErrors

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetEmailTemplateRenderErrors(context.Background(), id).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetEmailTemplateRenderErrors``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetEmailTemplateRenderErrors`: GetEmailTemplateRenderErrors200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplateRenderErrors`: %v\n", resp)
}

Dohvati predloške e-pošte

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
skip	number	query	Ne

Odgovor

Vraća: GetEmailTemplates200Response

Primjer

Primjer GetEmailTemplates

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetEmailTemplates(context.Background()).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetEmailTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetEmailTemplates`: GetEmailTemplates200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplates`: %v\n", resp)
}

Renderiraj predložak e-pošte

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Yes
locale	string	query	No

Odgovor

Vraća: RenderEmailTemplate200Response

Primjer

Primjer za RenderEmailTemplate

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    renderEmailTemplateBody := *openapiclient.NewRenderEmailTemplateBody("EmailTemplateId_example", "Ejs_example") // RenderEmailTemplateBody | 
    locale := "locale_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.RenderEmailTemplate(context.Background()).TenantId(tenantId).RenderEmailTemplateBody(renderEmailTemplateBody).Locale(locale).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.RenderEmailTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `RenderEmailTemplate`: RenderEmailTemplate200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.RenderEmailTemplate`: %v\n", resp)
}

Ažuriraj predložak e-pošte

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateEmailTemplate

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateEmailTemplateBody := *openapiclient.NewUpdateEmailTemplateBody() // UpdateEmailTemplateBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateEmailTemplate(context.Background(), id).TenantId(tenantId).UpdateEmailTemplateBody(updateEmailTemplateBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateEmailTemplate``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateEmailTemplate`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateEmailTemplate`: %v\n", resp)
}

Dohvati dnevnik događaja

req tenantId urlId userIdWS

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
urlId	string	query	Da
userIdWS	string	query	Da
startTime	integer	query	Da
endTime	integer	query	Da

Odgovor

Vraća: GetEventLog200Response

Primjer

Primjer GetEventLog

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    userIdWS := "userIdWS_example" // string | 
    startTime := int64(789) // int64 | 
    endTime := int64(789) // int64 | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetEventLog(context.Background(), tenantId).UrlId(urlId).UserIdWS(userIdWS).StartTime(startTime).EndTime(endTime).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetEventLog``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetEventLog`: GetEventLog200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetEventLog`: %v\n", resp)
}

Dohvati globalni dnevnik događaja

req tenantId urlId userIdWS

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
urlId	string	query	Da
userIdWS	string	query	Da
startTime	integer	query	Da
endTime	integer	query	Da

Odgovor

Vraća: GetEventLog200Response

Primjer

Primjer GetGlobalEventLog

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    userIdWS := "userIdWS_example" // string | 
    startTime := int64(789) // int64 | 
    endTime := int64(789) // int64 | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetGlobalEventLog(context.Background(), tenantId).UrlId(urlId).UserIdWS(userIdWS).StartTime(startTime).EndTime(endTime).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetGlobalEventLog``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetGlobalEventLog`: GetEventLog200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetGlobalEventLog`: %v\n", resp)
}

Kreiraj objavu feeda

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
broadcastId	string	query	Ne
isLive	boolean	query	Ne
doSpamCheck	boolean	query	Ne
skipDupCheck	boolean	query	Ne

Odgovor

Vraća: CreateFeedPost200Response

Primjer

Primjer CreateFeedPost

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createFeedPostParams := *openapiclient.NewCreateFeedPostParams() // CreateFeedPostParams | 
    broadcastId := "broadcastId_example" // string |  (neobavezno)
    isLive := true // bool |  (neobavezno)
    doSpamCheck := true // bool |  (neobavezno)
    skipDupCheck := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateFeedPost(context.Background()).TenantId(tenantId).CreateFeedPostParams(createFeedPostParams).BroadcastId(broadcastId).IsLive(isLive).DoSpamCheck(doSpamCheck).SkipDupCheck(skipDupCheck).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateFeedPost``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `CreateFeedPost`: CreateFeedPost200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateFeedPost`: %v\n", resp)
}

Kreiraj objavu feeda (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
broadcastId	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: CreateFeedPostPublic200Response

Primjer

Primjer CreateFeedPostPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createFeedPostParams := *openapiclient.NewCreateFeedPostParams() // CreateFeedPostParams | 
    broadcastId := "broadcastId_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.CreateFeedPostPublic(context.Background(), tenantId).CreateFeedPostParams(createFeedPostParams).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.CreateFeedPostPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `CreateFeedPostPublic`: CreateFeedPostPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateFeedPostPublic`: %v\n", resp)
}

Izbriši objavu feeda (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
postId	string	path	Da
broadcastId	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: DeleteFeedPostPublic200Response

Primjer

Primjer DeleteFeedPostPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    postId := "postId_example" // string | 
    broadcastId := "broadcastId_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.DeleteFeedPostPublic(context.Background(), tenantId, postId).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.DeleteFeedPostPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeleteFeedPostPublic`: DeleteFeedPostPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteFeedPostPublic`: %v\n", resp)
}

Dohvati objave feeda

req tenantId afterId

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
afterId	string	query	No
limit	integer	query	No
tags	array	query	No

Odgovor

Vraća: GetFeedPosts200Response

Primjer

GetFeedPosts Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    afterId := "afterId_example" // string |  (neobavezno)
    limit := int32(56) // int32 |  (neobavezno)
    tags := []string{"Inner_example"} // []string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetFeedPosts(context.Background()).TenantId(tenantId).AfterId(afterId).Limit(limit).Tags(tags).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetFeedPosts``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetFeedPosts`: GetFeedPosts200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetFeedPosts`: %v\n", resp)
}

Dohvati objave feeda (javno)

req tenantId afterId

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
afterId	string	query	Ne
limit	integer	query	Ne
tags	array	query	Ne
sso	string	query	Ne
isCrawler	boolean	query	Ne
includeUserInfo	boolean	query	Ne

Odgovor

Vraća: GetFeedPostsPublic200Response

Primjer

Primjer GetFeedPostsPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    afterId := "afterId_example" // string |  (neobavezno)
    limit := int32(56) // int32 |  (neobavezno)
    tags := []string{"Inner_example"} // []string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    isCrawler := true // bool |  (neobavezno)
    includeUserInfo := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetFeedPostsPublic(context.Background(), tenantId).AfterId(afterId).Limit(limit).Tags(tags).Sso(sso).IsCrawler(isCrawler).IncludeUserInfo(includeUserInfo).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetFeedPostsPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetFeedPostsPublic`: GetFeedPostsPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsPublic`: %v\n", resp)
}

Dohvati statistiku objava feeda

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
postIds	array	query	Da
sso	string	query	Ne

Odgovor

Vraća: GetFeedPostsStats200Response

Primjer

GetFeedPostsStats Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    postIds := []string{"Inner_example"} // []string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetFeedPostsStats(context.Background(), tenantId).PostIds(postIds).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetFeedPostsStats``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetFeedPostsStats`: GetFeedPostsStats200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsStats`: %v\n", resp)
}

Dohvati reakcije korisnika (javno)

Parametri

Naziv	Type	Location	Obavezno
tenantId	string	path	Da
postIds	array	query	Ne
sso	string	query	Ne

Response

Vraća: GetUserReactsPublic200Response

Primjer

Primjer GetUserReactsPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    postIds := []string{"Inner_example"} // []string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetUserReactsPublic(context.Background(), tenantId).PostIds(postIds).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetUserReactsPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetUserReactsPublic`: GetUserReactsPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserReactsPublic`: %v\n", resp)
}

Reagiraj na objavu feeda (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
postId	string	path	Da
isUndo	boolean	query	Ne
broadcastId	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: ReactFeedPostPublic200Response

Primjer

ReactFeedPostPublic Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    postId := "postId_example" // string | 
    reactBodyParams := *openapiclient.NewReactBodyParams() // ReactBodyParams | 
    isUndo := true // bool |  (neobavezno)
    broadcastId := "broadcastId_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.ReactFeedPostPublic(context.Background(), tenantId, postId).ReactBodyParams(reactBodyParams).IsUndo(isUndo).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.ReactFeedPostPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `ReactFeedPostPublic`: ReactFeedPostPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ReactFeedPostPublic`: %v\n", resp)
}

Ažuriraj objavu feeda

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateFeedPost

Copy

package main
import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    feedPost := *openapiclient.NewFeedPost("Id_example", "TenantId_example", time.Now()) // FeedPost | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateFeedPost(context.Background(), id).TenantId(tenantId).FeedPost(feedPost).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateFeedPost``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateFeedPost`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateFeedPost`: %v\n", resp)
}

Ažuriraj objavu feeda (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
postId	string	path	Da
broadcastId	string	query	Ne
sso	string	query	Ne

Response

Vraća: CreateFeedPostPublic200Response

Primjer

Primjer UpdateFeedPostPublic

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    postId := "postId_example" // string | 
    updateFeedPostParams := *openapiclient.NewUpdateFeedPostParams() // UpdateFeedPostParams | 
    broadcastId := "broadcastId_example" // string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UpdateFeedPostPublic(context.Background(), tenantId, postId).UpdateFeedPostParams(updateFeedPostParams).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UpdateFeedPostPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateFeedPostPublic`: CreateFeedPostPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateFeedPostPublic`: %v\n", resp)
}

Prijavi komentar (javno)

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
commentId	string	path	Da
isFlagged	boolean	query	Da
sso	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

FlagCommentPublic Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    isFlagged := true // bool | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.FlagCommentPublic(context.Background(), commentId).TenantId(tenantId).IsFlagged(isFlagged).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.FlagCommentPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `FlagCommentPublic`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.FlagCommentPublic`: %v\n", resp)
}

Dodaj hashtag

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Ne

Odgovor

Vraća: AddHashTag200Response

Primjer

Primjer AddHashTag

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string |  (neobavezno)
    createHashTagBody := *openapiclient.NewCreateHashTagBody("Tag_example") // CreateHashTagBody |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AddHashTag(context.Background()).TenantId(tenantId).CreateHashTagBody(createHashTagBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AddHashTag``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `AddHashTag`: AddHashTag200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddHashTag`: %v\n", resp)
}

Dodaj hashtage u seriji

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Ne

Odgovor

Vraća: AddHashTagsBulk200Response

Primjer

Primjer AddHashTagsBulk

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string |  (neobavezno)
    bulkCreateHashTagsBody := *openapiclient.NewBulkCreateHashTagsBody([]openapiclient.BulkCreateHashTagsBodyTagsInner{*openapiclient.NewBulkCreateHashTagsBodyTagsInner("Tag_example")}) // BulkCreateHashTagsBody |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AddHashTagsBulk(context.Background()).TenantId(tenantId).BulkCreateHashTagsBody(bulkCreateHashTagsBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AddHashTagsBulk``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `AddHashTagsBulk`: AddHashTagsBulk200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddHashTagsBulk`: %v\n", resp)
}

Izbriši hashtag

Parametri

Name	Type	Location	Required	Description
tag	string	path	Da
tenantId	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteHashTag

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tag := "tag_example" // string | 
    tenantId := "tenantId_example" // string |  (neobavezno)
    deleteHashTagRequest := *openapiclient.NewDeleteHashTagRequest() // DeleteHashTagRequest |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteHashTag(context.Background(), tag).TenantId(tenantId).DeleteHashTagRequest(deleteHashTagRequest).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteHashTag``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteHashTag`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteHashTag`: %v\n", resp)
}

Dohvati hashtage

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
page	number	query	Ne

Odgovor

Vraća: GetHashTags200Response

Primjer

Primjer GetHashTags

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    page := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetHashTags(context.Background()).TenantId(tenantId).Page(page).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetHashTags``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetHashTags`: GetHashTags200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetHashTags`: %v\n", resp)
}

Djelomično ažuriraj hashtag

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tag	string	path	Da
tenantId	string	query	Ne

Odgovor

Vraća: PatchHashTag200Response

Primjer

Primjer PatchHashTag

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tag := "tag_example" // string | 
    tenantId := "tenantId_example" // string |  (neobavezno)
    updateHashTagBody := *openapiclient.NewUpdateHashTagBody() // UpdateHashTagBody |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.PatchHashTag(context.Background(), tag).TenantId(tenantId).UpdateHashTagBody(updateHashTagBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.PatchHashTag``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `PatchHashTag`: PatchHashTag200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PatchHashTag`: %v\n", resp)
}

Kreiraj moderatora

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: CreateModerator200Response

Primjer

Primjer CreateModerator

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createModeratorBody := *openapiclient.NewCreateModeratorBody("Name_example", "Email_example") // CreateModeratorBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateModerator(context.Background()).TenantId(tenantId).CreateModeratorBody(createModeratorBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateModerator``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `CreateModerator`: CreateModerator200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateModerator`: %v\n", resp)
}

Izbriši moderatora

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
sendEmail	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteModerator

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    sendEmail := "sendEmail_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteModerator(context.Background(), id).TenantId(tenantId).SendEmail(sendEmail).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteModerator``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteModerator`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteModerator`: %v\n", resp)
}

Dohvati moderatora

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetModerator200Response

Primjer

Primjer GetModerator

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetModerator(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetModerator``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetModerator`: GetModerator200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetModerator`: %v\n", resp)
}

Dohvati moderatore

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
skip	number	query	Ne

Odgovor

Vraća: GetModerators200Response

Primjer

Primjer GetModerators

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetModerators(context.Background()).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetModerators``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetModerators`: GetModerators200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetModerators`: %v\n", resp)
}

Pošalji pozivnicu

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
fromName	string	query	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer SendInvite

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    fromName := "fromName_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.SendInvite(context.Background(), id).TenantId(tenantId).FromName(fromName).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.SendInvite``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `SendInvite`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SendInvite`: %v\n", resp)
}

Ažuriraj moderatora

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateModerator

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateModeratorBody := *openapiclient.NewUpdateModeratorBody() // UpdateModeratorBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateModerator(context.Background(), id).TenantId(tenantId).UpdateModeratorBody(updateModeratorBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateModerator``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateModerator`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateModerator`: %v\n", resp)
}

Izbriši broj obavijesti

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteNotificationCount

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteNotificationCount(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteNotificationCount``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteNotificationCount`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteNotificationCount`: %v\n", resp)
}

Dohvati keširani broj obavijesti

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetCachedNotificationCount200Response

Primjer

Primjer GetCachedNotificationCount

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetCachedNotificationCount(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetCachedNotificationCount``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetCachedNotificationCount`: GetCachedNotificationCount200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetCachedNotificationCount`: %v\n", resp)
}

Dohvati broj obavijesti

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
userId	string	query	Ne
urlId	string	query	Ne
fromCommentId	string	query	Ne
viewed	boolean	query	Ne
type	string	query	Ne

Odgovor

Vraća: GetNotificationCount200Response

Primjer

Primjer GetNotificationCount

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    urlId := "urlId_example" // string |  (neobavezno)
    fromCommentId := "fromCommentId_example" // string |  (neobavezno)
    viewed := true // bool |  (neobavezno)
    type_ := "type__example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetNotificationCount(context.Background()).TenantId(tenantId).UserId(userId).UrlId(urlId).FromCommentId(fromCommentId).Viewed(viewed).Type_(type_).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetNotificationCount``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetNotificationCount`: GetNotificationCount200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetNotificationCount`: %v\n", resp)
}

Dohvati obavijesti

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
userId	string	query	Ne
urlId	string	query	Ne
fromCommentId	string	query	Ne
viewed	boolean	query	Ne
type	string	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetNotifications200Response

Primjer

Primjer GetNotifications

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    urlId := "urlId_example" // string |  (neobavezno)
    fromCommentId := "fromCommentId_example" // string |  (neobavezno)
    viewed := true // bool |  (neobavezno)
    type_ := "type__example" // string |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetNotifications(context.Background()).TenantId(tenantId).UserId(userId).UrlId(urlId).FromCommentId(fromCommentId).Viewed(viewed).Type_(type_).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetNotifications``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetNotifications`: GetNotifications200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetNotifications`: %v\n", resp)
}

Ažuriraj obavijest

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
id	string	path	Da
userId	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateNotification

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateNotificationBody := *openapiclient.NewUpdateNotificationBody() // UpdateNotificationBody | 
    userId := "userId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateNotification(context.Background(), id).TenantId(tenantId).UpdateNotificationBody(updateNotificationBody).UserId(userId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateNotification``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateNotification`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateNotification`: %v\n", resp)
}

Dodaj stranicu

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: AddPageAPIResponse

Primjer

Primjer AddPage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createAPIPageData := *openapiclient.NewCreateAPIPageData("Title_example", "Url_example", "UrlId_example") // CreateAPIPageData | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AddPage(context.Background()).TenantId(tenantId).CreateAPIPageData(createAPIPageData).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AddPage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `AddPage`: AddPageAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddPage`: %v\n", resp)
}

Izbriši stranicu

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: DeletePageAPIResponse

Primjer

Primjer DeletePage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeletePage(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeletePage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeletePage`: DeletePageAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeletePage`: %v\n", resp)
}

Dohvati stranicu po URL ID-u

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
urlId	string	query	Da

Odgovor

Vraća: GetPageByURLIdAPIResponse

Primjer

Primjer GetPageByURLId

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetPageByURLId(context.Background()).TenantId(tenantId).UrlId(urlId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetPageByURLId``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetPageByURLId`: GetPageByURLIdAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPageByURLId`: %v\n", resp)
}

Dohvati stranice

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetPagesAPIResponse

Primjer

Primjer GetPages

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetPages(context.Background()).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetPages``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetPages`: GetPagesAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPages`: %v\n", resp)
}

Djelomično ažuriraj stranicu

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: PatchPageAPIResponse

Primjer

Primjer PatchPage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateAPIPageData := *openapiclient.NewUpdateAPIPageData() // UpdateAPIPageData | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.PatchPage(context.Background(), id).TenantId(tenantId).UpdateAPIPageData(updateAPIPageData).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.PatchPage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `PatchPage`: PatchPageAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PatchPage`: %v\n", resp)
}

Izbriši webhook događaj na čekanju

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeletePendingWebhookEvent

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeletePendingWebhookEvent(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeletePendingWebhookEvent``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeletePendingWebhookEvent`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeletePendingWebhookEvent`: %v\n", resp)
}

Dohvati broj webhook događaja na čekanju

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
commentId	string	query	Ne
externalId	string	query	Ne
eventType	string	query	Ne
type	string	query	Ne
domain	string	query	Ne
attemptCountGT	number	query	Ne

Odgovor

Vraća: GetPendingWebhookEventCount200Response

Primjer

Primjer GetPendingWebhookEventCount

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string |  (neobavezno)
    externalId := "externalId_example" // string |  (neobavezno)
    eventType := "eventType_example" // string |  (neobavezno)
    type_ := "type__example" // string |  (neobavezno)
    domain := "domain_example" // string |  (neobavezno)
    attemptCountGT := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetPendingWebhookEventCount(context.Background()).TenantId(tenantId).CommentId(commentId).ExternalId(externalId).EventType(eventType).Type_(type_).Domain(domain).AttemptCountGT(attemptCountGT).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetPendingWebhookEventCount``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetPendingWebhookEventCount`: GetPendingWebhookEventCount200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEventCount`: %v\n", resp)
}

Dohvati webhook događaje na čekanju

Parametri

Naziv	Type	Location	Obavezno
tenantId	string	query	Da
commentId	string	query	Ne
externalId	string	query	Ne
eventType	string	query	Ne
type	string	query	Ne
domain	string	query	Ne
attemptCountGT	number	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetPendingWebhookEvents200Response

Primjer

Primjer GetPendingWebhookEvents

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string |  (neobavezno)
    externalId := "externalId_example" // string |  (neobavezno)
    eventType := "eventType_example" // string |  (neobavezno)
    type_ := "type__example" // string |  (neobavezno)
    domain := "domain_example" // string |  (neobavezno)
    attemptCountGT := float64(1.2) // float64 |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetPendingWebhookEvents(context.Background()).TenantId(tenantId).CommentId(commentId).ExternalId(externalId).EventType(eventType).Type_(type_).Domain(domain).AttemptCountGT(attemptCountGT).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetPendingWebhookEvents``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetPendingWebhookEvents`: GetPendingWebhookEvents200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEvents`: %v\n", resp)
}

Kreiraj konfiguraciju pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateQuestionConfig200Response

Primjer

Primjer CreateQuestionConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createQuestionConfigBody := *openapiclient.NewCreateQuestionConfigBody("Name_example", "Question_example", "Type_example", float64(123)) // CreateQuestionConfigBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateQuestionConfig(context.Background()).TenantId(tenantId).CreateQuestionConfigBody(createQuestionConfigBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateQuestionConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `CreateQuestionConfig`: CreateQuestionConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateQuestionConfig`: %v\n", resp)
}

Izbriši konfiguraciju pitanja

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteQuestionConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteQuestionConfig(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteQuestionConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteQuestionConfig`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteQuestionConfig`: %v\n", resp)
}

Dohvati konfiguraciju pitanja

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Yes
id	string	path	Yes

Odgovor

Vraća: GetQuestionConfig200Response

Primjer

Primjer GetQuestionConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetQuestionConfig(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetQuestionConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetQuestionConfig`: GetQuestionConfig200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionConfig`: %v\n", resp)
}

Dohvati konfiguracije pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
skip	number	query	Ne

Odgovor

Vraća: GetQuestionConfigs200Response

Primjer

Primjer GetQuestionConfigs

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetQuestionConfigs(context.Background()).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetQuestionConfigs``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetQuestionConfigs`: GetQuestionConfigs200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionConfigs`: %v\n", resp)
}

Ažuriraj konfiguraciju pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateQuestionConfig

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateQuestionConfigBody := *openapiclient.NewUpdateQuestionConfigBody() // UpdateQuestionConfigBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateQuestionConfig(context.Background(), id).TenantId(tenantId).UpdateQuestionConfigBody(updateQuestionConfigBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateQuestionConfig``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateQuestionConfig`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateQuestionConfig`: %v\n", resp)
}

Kreiraj rezultat pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateQuestionResult200Response

Primjer

Primjer CreateQuestionResult

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createQuestionResultBody := *openapiclient.NewCreateQuestionResultBody("UrlId_example", float64(123), "QuestionId_example") // CreateQuestionResultBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateQuestionResult(context.Background()).TenantId(tenantId).CreateQuestionResultBody(createQuestionResultBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateQuestionResult``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `CreateQuestionResult`: CreateQuestionResult200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateQuestionResult`: %v\n", resp)
}

Izbriši rezultat pitanja

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteQuestionResult

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteQuestionResult(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteQuestionResult``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeleteQuestionResult`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteQuestionResult`: %v\n", resp)
}

Dohvati rezultat pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetQuestionResult200Response

Primjer

Primjer GetQuestionResult

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetQuestionResult(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetQuestionResult``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetQuestionResult`: GetQuestionResult200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionResult`: %v\n", resp)
}

Dohvati rezultate pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
urlId	string	query	Ne
userId	string	query	Ne
startDate	string	query	Ne
questionId	string	query	Ne
questionIds	string	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetQuestionResults200Response

Primjer

Primjer GetQuestionResults

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string |  (neobavezno)
    userId := "userId_example" // string |  (neobavezno)
    startDate := "startDate_example" // string |  (neobavezno)
    questionId := "questionId_example" // string |  (neobavezno)
    questionIds := "questionIds_example" // string |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetQuestionResults(context.Background()).TenantId(tenantId).UrlId(urlId).UserId(userId).StartDate(startDate).QuestionId(questionId).QuestionIds(questionIds).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetQuestionResults``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetQuestionResults`: GetQuestionResults200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionResults`: %v\n", resp)
}

Ažuriraj rezultat pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateQuestionResult

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateQuestionResultBody := *openapiclient.NewUpdateQuestionResultBody() // UpdateQuestionResultBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateQuestionResult(context.Background(), id).TenantId(tenantId).UpdateQuestionResultBody(updateQuestionResultBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateQuestionResult``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateQuestionResult`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateQuestionResult`: %v\n", resp)
}

Agregiraj rezultate pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
questionId	string	query	Ne
questionIds	array	query	Ne
urlId	string	query	Ne
timeBucket	string	query	Ne
startDate	string	query	Ne
forceRecalculate	boolean	query	Ne

Odgovor

Vraća: AggregateQuestionResults200Response

Primjer

AggregateQuestionResults Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    questionId := "questionId_example" // string |  (neobavezno)
    questionIds := []string{"Inner_example"} // []string |  (neobavezno)
    urlId := "urlId_example" // string |  (neobavezno)
    timeBucket := openapiclient.AggregateTimeBucket("day") // AggregateTimeBucket |  (neobavezno)
    startDate := time.Now() // time.Time |  (neobavezno)
    forceRecalculate := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AggregateQuestionResults(context.Background()).TenantId(tenantId).QuestionId(questionId).QuestionIds(questionIds).UrlId(urlId).TimeBucket(timeBucket).StartDate(startDate).ForceRecalculate(forceRecalculate).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AggregateQuestionResults``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `AggregateQuestionResults`: AggregateQuestionResults200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AggregateQuestionResults`: %v\n", resp)
}

Masovna agregacija rezultata pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
forceRecalculate	boolean	query	Ne

Odgovor

Vraća: BulkAggregateQuestionResults200Response

Primjer

Primjer BulkAggregateQuestionResults

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    bulkAggregateQuestionResultsRequest := *openapiclient.NewBulkAggregateQuestionResultsRequest([]openapiclient.BulkAggregateQuestionItem{*openapiclient.NewBulkAggregateQuestionItem("AggId_example")}) // BulkAggregateQuestionResultsRequest | 
    forceRecalculate := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.BulkAggregateQuestionResults(context.Background()).TenantId(tenantId).BulkAggregateQuestionResultsRequest(bulkAggregateQuestionResultsRequest).ForceRecalculate(forceRecalculate).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.BulkAggregateQuestionResults``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `BulkAggregateQuestionResults`: BulkAggregateQuestionResults200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.BulkAggregateQuestionResults`: %v\n", resp)
}

Spoji komentare s rezultatima pitanja

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
questionId	string	query	Ne
questionIds	array	query	Ne
urlId	string	query	Ne
startDate	string	query	Ne
forceRecalculate	boolean	query	Ne
minValue	number	query	Ne
maxValue	number	query	Ne
limit	number	query	Ne

Odgovor

Vraća: CombineCommentsWithQuestionResults200Response

Primjer

Primjer CombineCommentsWithQuestionResults

Copy

package main
import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    questionId := "questionId_example" // string |  (neobavezno)
    questionIds := []string{"Inner_example"} // []string |  (neobavezno)
    urlId := "urlId_example" // string |  (neobavezno)
    startDate := time.Now() // time.Time |  (neobavezno)
    forceRecalculate := true // bool |  (neobavezno)
    minValue := float64(1.2) // float64 |  (neobavezno)
    maxValue := float64(1.2) // float64 |  (neobavezno)
    limit := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CombineCommentsWithQuestionResults(context.Background()).TenantId(tenantId).QuestionId(questionId).QuestionIds(questionIds).UrlId(urlId).StartDate(startDate).ForceRecalculate(forceRecalculate).MinValue(minValue).MaxValue(maxValue).Limit(limit).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CombineCommentsWithQuestionResults``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `CombineCommentsWithQuestionResults`: CombineCommentsWithQuestionResults200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CombineCommentsWithQuestionResults`: %v\n", resp)
}

Dodaj SSO korisnika

Parametri

Naziv	Tip	Lokacija	Obvezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: AddSSOUserAPIResponse

Primjer

Primjer AddSSOUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createAPISSOUserData := *openapiclient.NewCreateAPISSOUserData("Email_example", "Username_example", "Id_example") // CreateAPISSOUserData | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AddSSOUser(context.Background()).TenantId(tenantId).CreateAPISSOUserData(createAPISSOUserData).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AddSSOUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `AddSSOUser`: AddSSOUserAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddSSOUser`: %v\n", resp)
}

Izbriši SSO korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
deleteComments	boolean	query	Ne
commentDeleteMode	string	query	Ne

Odgovor

Vraća: DeleteSSOUserAPIResponse

Primjer

Primjer DeleteSSOUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    deleteComments := true // bool |  (neobavezno)
    commentDeleteMode := "commentDeleteMode_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteSSOUser(context.Background(), id).TenantId(tenantId).DeleteComments(deleteComments).CommentDeleteMode(commentDeleteMode).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteSSOUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeleteSSOUser`: DeleteSSOUserAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteSSOUser`: %v\n", resp)
}

Dohvati SSO korisnika po e-pošti

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
email	string	path	Da

Odgovor

Vraća: GetSSOUserByEmailAPIResponse

Primjer

Primjer GetSSOUserByEmail

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    email := "email_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetSSOUserByEmail(context.Background(), email).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetSSOUserByEmail``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetSSOUserByEmail`: GetSSOUserByEmailAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSSOUserByEmail`: %v\n", resp)
}

Dohvati SSO korisnika po ID-u

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetSSOUserByIdAPIResponse

Primjer

Primjer GetSSOUserById

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetSSOUserById(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetSSOUserById``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetSSOUserById`: GetSSOUserByIdAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSSOUserById`: %v\n", resp)
}

Dohvati SSO korisnike

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
skip	integer	query	Ne

Odgovor

Vraća: GetSSOUsers200Response

Primjer

Primjer GetSSOUsers

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    skip := int32(56) // int32 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetSSOUsers(context.Background()).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetSSOUsers``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetSSOUsers`: GetSSOUsers200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSSOUsers`: %v\n", resp)
}

Djelomično ažuriraj SSO korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
updateComments	boolean	query	Ne

Odgovor

Vraća: PatchSSOUserAPIResponse

Primjer

Primjer PatchSSOUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateAPISSOUserData := *openapiclient.NewUpdateAPISSOUserData() // UpdateAPISSOUserData | 
    updateComments := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.PatchSSOUser(context.Background(), id).TenantId(tenantId).UpdateAPISSOUserData(updateAPISSOUserData).UpdateComments(updateComments).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.PatchSSOUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `PatchSSOUser`: PatchSSOUserAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PatchSSOUser`: %v\n", resp)
}

Postavi/ zamijeni SSO korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
updateComments	boolean	query	Ne

Odgovor

Vraća: PutSSOUserAPIResponse

Primjer

Primjer PutSSOUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateAPISSOUserData := *openapiclient.NewUpdateAPISSOUserData() // UpdateAPISSOUserData | 
    updateComments := true // bool |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.PutSSOUser(context.Background(), id).TenantId(tenantId).UpdateAPISSOUserData(updateAPISSOUserData).UpdateComments(updateComments).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.PutSSOUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `PutSSOUser`: PutSSOUserAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PutSSOUser`: %v\n", resp)
}

Kreiraj pretplatu

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateSubscriptionAPIResponse

Primjer

Primjer CreateSubscription

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createAPIUserSubscriptionData := *openapiclient.NewCreateAPIUserSubscriptionData("UrlId_example") // CreateAPIUserSubscriptionData | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateSubscription(context.Background()).TenantId(tenantId).CreateAPIUserSubscriptionData(createAPIUserSubscriptionData).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateSubscription``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `CreateSubscription`: CreateSubscriptionAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateSubscription`: %v\n", resp)
}

Izbriši pretplatu

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
userId	string	query	Ne

Odgovor

Vraća: DeleteSubscriptionAPIResponse

Primjer

Primjer DeleteSubscription

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteSubscription(context.Background(), id).TenantId(tenantId).UserId(userId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteSubscription``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteSubscription`: DeleteSubscriptionAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteSubscription`: %v\n", resp)
}

Dohvati pretplate

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
userId	string	query	Ne

Odgovor

Vraća: GetSubscriptionsAPIResponse

Primjer

Primjer GetSubscriptions

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetSubscriptions(context.Background()).TenantId(tenantId).UserId(userId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetSubscriptions``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetSubscriptions`: GetSubscriptionsAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSubscriptions`: %v\n", resp)
}

Dohvati dnevne upotrebe tenant-a

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
yearNumber	number	query	Ne
monthNumber	number	query	Ne
dayNumber	number	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetTenantDailyUsages200Response

Primjer

Primjer za GetTenantDailyUsages

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    yearNumber := float64(1.2) // float64 |  (neobavezno)
    monthNumber := float64(1.2) // float64 |  (neobavezno)
    dayNumber := float64(1.2) // float64 |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenantDailyUsages(context.Background()).TenantId(tenantId).YearNumber(yearNumber).MonthNumber(monthNumber).DayNumber(dayNumber).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenantDailyUsages``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetTenantDailyUsages`: GetTenantDailyUsages200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantDailyUsages`: %v\n", resp)
}

Kreiraj paket za tenant-a

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantPackage200Response

Primjer

Primjer CreateTenantPackage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createTenantPackageBody := *openapiclient.NewCreateTenantPackageBody("Name_example", float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), false, "ForWhoText_example", []string{"FeatureTaglines_example"}, false) // CreateTenantPackageBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateTenantPackage(context.Background()).TenantId(tenantId).CreateTenantPackageBody(createTenantPackageBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateTenantPackage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `CreateTenantPackage`: CreateTenantPackage200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateTenantPackage`: %v\n", resp)
}

Izbriši paket tenant-a

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteTenantPackage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteTenantPackage(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteTenantPackage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteTenantPackage`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenantPackage`: %v\n", resp)
}

Dohvati paket tenant-a

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Yes
id	string	path	Yes

Odgovor

Vraća: GetTenantPackage200Response

Primjer

GetTenantPackage Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenantPackage(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenantPackage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetTenantPackage`: GetTenantPackage200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantPackage`: %v\n", resp)
}

Dohvati pakete tenant-a

Parametri

Naziv	Tip	Lokacija	Obvezno	Opis
tenantId	string	upit	Da
skip	number	upit	Ne

Odgovor

Vraća: GetTenantPackages200Response

Primjer

Primjer GetTenantPackages

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenantPackages(context.Background()).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenantPackages``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetTenantPackages`: GetTenantPackages200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantPackages`: %v\n", resp)
}

Zamijeni paket tenant-a

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer ReplaceTenantPackage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    replaceTenantPackageBody := *openapiclient.NewReplaceTenantPackageBody("Name_example", float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), float64(123), false, "ForWhoText_example", []string{"FeatureTaglines_example"}, false) // ReplaceTenantPackageBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.ReplaceTenantPackage(context.Background(), id).TenantId(tenantId).ReplaceTenantPackageBody(replaceTenantPackageBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.ReplaceTenantPackage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `ReplaceTenantPackage`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.ReplaceTenantPackage`: %v\n", resp)
}

Ažuriraj paket tenant-a

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateTenantPackage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateTenantPackageBody := *openapiclient.NewUpdateTenantPackageBody() // UpdateTenantPackageBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateTenantPackage(context.Background(), id).TenantId(tenantId).UpdateTenantPackageBody(updateTenantPackageBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateTenantPackage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UpdateTenantPackage`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenantPackage`: %v\n", resp)
}

Kreiraj tenant korisnika

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantUser200Response

Primjer

Primjer CreateTenantUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createTenantUserBody := *openapiclient.NewCreateTenantUserBody("Username_example", "Email_example") // CreateTenantUserBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateTenantUser(context.Background()).TenantId(tenantId).CreateTenantUserBody(createTenantUserBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateTenantUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `CreateTenantUser`: CreateTenantUser200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateTenantUser`: %v\n", resp)
}

Izbriši tenant korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
deleteComments	string	query	Ne
commentDeleteMode	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteTenantUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    deleteComments := "deleteComments_example" // string |  (neobavezno)
    commentDeleteMode := "commentDeleteMode_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteTenantUser(context.Background(), id).TenantId(tenantId).DeleteComments(deleteComments).CommentDeleteMode(commentDeleteMode).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteTenantUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteTenantUser`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenantUser`: %v\n", resp)
}

Dohvati tenant korisnika

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetTenantUser200Response

Primjer

Primjer GetTenantUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenantUser(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenantUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetTenantUser`: GetTenantUser200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantUser`: %v\n", resp)
}

Dohvati tenant korisnike

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
skip	number	query	Ne

Odgovor

Vraća: GetTenantUsers200Response

Primjer

Primjer GetTenantUsers

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenantUsers(context.Background()).TenantId(tenantId).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenantUsers``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetTenantUsers`: GetTenantUsers200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantUsers`: %v\n", resp)
}

Zamijeni tenant korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
updateComments	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer ReplaceTenantUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    replaceTenantUserBody := *openapiclient.NewReplaceTenantUserBody("Username_example", "Email_example") // ReplaceTenantUserBody | 
    updateComments := "updateComments_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.ReplaceTenantUser(context.Background(), id).TenantId(tenantId).ReplaceTenantUserBody(replaceTenantUserBody).UpdateComments(updateComments).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.ReplaceTenantUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `ReplaceTenantUser`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.ReplaceTenantUser`: %v\n", resp)
}

Pošalji poveznicu za prijavu

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
redirectURL	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer SendLoginLink

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    redirectURL := "redirectURL_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.SendLoginLink(context.Background(), id).TenantId(tenantId).RedirectURL(redirectURL).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.SendLoginLink``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `SendLoginLink`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SendLoginLink`: %v\n", resp)
}

Ažuriraj tenant korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
updateComments	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateTenantUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateTenantUserBody := *openapiclient.NewUpdateTenantUserBody() // UpdateTenantUserBody | 
    updateComments := "updateComments_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateTenantUser(context.Background(), id).TenantId(tenantId).UpdateTenantUserBody(updateTenantUserBody).UpdateComments(updateComments).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateTenantUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UpdateTenantUser`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenantUser`: %v\n", resp)
}

Kreiraj tenant

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateTenant200Response

Primjer

Primjer CreateTenant

Copy

package main
import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createTenantBody := *openapiclient.NewCreateTenantBody("Name_example", []openapiclient.APIDomainConfiguration{*openapiclient.NewAPIDomainConfiguration("Id_example", "Domain_example", time.Now())}) // CreateTenantBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateTenant(context.Background()).TenantId(tenantId).CreateTenantBody(createTenantBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateTenant``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateTenant`: CreateTenant200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateTenant`: %v\n", resp)
}

Izbriši tenant

Parametri

Naziv	Tip	Lokacija	Obvezno
tenantId	string	query	Da
id	string	path	Da
sure	string	query	Ne

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer DeleteTenant

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    sure := "sure_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteTenant(context.Background(), id).TenantId(tenantId).Sure(sure).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteTenant``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteTenant`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenant`: %v\n", resp)
}

Dohvati tenant

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetTenant200Response

Primjer

Primjer GetTenant

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenant(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenant``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetTenant`: GetTenant200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenant`: %v\n", resp)
}

Dohvati tenant-e

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
meta	string	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetTenants200Response

Primjer

GetTenants Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    meta := "meta_example" // string |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetTenants(context.Background()).TenantId(tenantId).Meta(meta).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTenants``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetTenants`: GetTenants200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenants`: %v\n", resp)
}

Ažuriraj tenant

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: FlagCommentPublic200Response

Primjer

Primjer UpdateTenant

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateTenantBody := *openapiclient.NewUpdateTenantBody() // UpdateTenantBody | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateTenant(context.Background(), id).TenantId(tenantId).UpdateTenantBody(updateTenantBody).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateTenant``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UpdateTenant`: FlagCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenant`: %v\n", resp)
}

Prenesi sliku

Učitajte i promijenite veličinu slike

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Yes
sizePreset	string	query	No	Preset veličine: "Default" (1000x1000px) ili "CrossPlatform" (stvara veličine za popularne uređaje)
urlId	string	query	No	ID stranice s koje se vrši učitavanje, za konfiguraciju

Odgovor

Vraća: UploadImageResponse

Primjer

Primjer UploadImage

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    file := os.NewFile(1234, "some_file") // *os.File | 
    sizePreset := openapiclient.SizePreset("Default") // SizePreset | Preset veličine: \"Default\" (1000x1000px) ili \"CrossPlatform\" (stvara veličine za popularne uređaje) (opcionalno)
    urlId := "urlId_example" // string | ID stranice s koje se vrši učitavanje, za konfiguraciju (opcionalno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UploadImage(context.Background(), tenantId).File(file).SizePreset(sizePreset).UrlId(urlId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UploadImage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UploadImage`: UploadImageResponse
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UploadImage`: %v\n", resp)
}

Dohvati napredak značke korisnika po ID-u

Parametri

Name	Type	Lokacija	Required	Description
tenantId	string	upit	Da
id	string	putanja	Da

Odgovor

Vraća: GetUserBadgeProgressById200Response

Primjer

Primjer GetUserBadgeProgressById

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetUserBadgeProgressById(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetUserBadgeProgressById``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetUserBadgeProgressById`: GetUserBadgeProgressById200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressById`: %v\n", resp)
}

Dohvati napredak značke po ID-u korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
userId	string	path	Da

Odgovor

Vraća: GetUserBadgeProgressById200Response

Primjer

Primjer GetUserBadgeProgressByUserId

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    userId := "userId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetUserBadgeProgressByUserId(context.Background(), userId).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetUserBadgeProgressByUserId``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetUserBadgeProgressByUserId`: GetUserBadgeProgressById200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressByUserId`: %v\n", resp)
}

Dohvati popis napretka znački korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
userId	string	query	Ne
limit	number	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetUserBadgeProgressList200Response

Primjer

Primjer GetUserBadgeProgressList

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    limit := float64(1.2) // float64 |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetUserBadgeProgressList(context.Background()).TenantId(tenantId).UserId(userId).Limit(limit).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetUserBadgeProgressList``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetUserBadgeProgressList`: GetUserBadgeProgressList200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressList`: %v\n", resp)
}

Kreiraj značku korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateUserBadge200Response

Primjer

Primjer CreateUserBadge

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    createUserBadgeParams := *openapiclient.NewCreateUserBadgeParams("UserId_example", "BadgeId_example") // CreateUserBadgeParams | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateUserBadge(context.Background()).TenantId(tenantId).CreateUserBadgeParams(createUserBadgeParams).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateUserBadge``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateUserBadge`: CreateUserBadge200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateUserBadge`: %v\n", resp)
}

Izbriši značku korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: UpdateUserBadge200Response

Primjer

Primjer DeleteUserBadge

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteUserBadge(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteUserBadge``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `DeleteUserBadge`: UpdateUserBadge200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteUserBadge`: %v\n", resp)
}

Dohvati značku korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetUserBadge200Response

Primjer

Primjer GetUserBadge

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetUserBadge(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetUserBadge``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetUserBadge`: GetUserBadge200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadge`: %v\n", resp)
}

Dohvati značke korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
userId	string	query	Ne
badgeId	string	query	Ne
type	number	query	Ne
displayedOnComments	boolean	query	Ne
limit	number	query	Ne
skip	number	query	Ne

Odgovor

Vraća: GetUserBadges200Response

Primjer

Primjer GetUserBadges

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    badgeId := "badgeId_example" // string |  (neobavezno)
    type_ := float64(1.2) // float64 |  (neobavezno)
    displayedOnComments := true // bool |  (neobavezno)
    limit := float64(1.2) // float64 |  (neobavezno)
    skip := float64(1.2) // float64 |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetUserBadges(context.Background()).TenantId(tenantId).UserId(userId).BadgeId(badgeId).Type_(type_).DisplayedOnComments(displayedOnComments).Limit(limit).Skip(skip).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetUserBadges``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetUserBadges`: GetUserBadges200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadges`: %v\n", resp)
}

Ažuriraj značku korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: UpdateUserBadge200Response

Primjer

Primjer UpdateUserBadge

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    updateUserBadgeParams := *openapiclient.NewUpdateUserBadgeParams() // UpdateUserBadgeParams | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.UpdateUserBadge(context.Background(), id).TenantId(tenantId).UpdateUserBadgeParams(updateUserBadgeParams).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.UpdateUserBadge``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `UpdateUserBadge`: UpdateUserBadge200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateUserBadge`: %v\n", resp)
}

Dohvati broj obavijesti korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: GetUserNotificationCount200Response

Primjer

Primjer GetUserNotificationCount

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetUserNotificationCount(context.Background()).TenantId(tenantId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetUserNotificationCount``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetUserNotificationCount`: GetUserNotificationCount200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotificationCount`: %v\n", resp)
}

Dohvati obavijesti korisnika

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Da
pageSize	integer	query	Ne
afterId	string	query	Ne
includeContext	boolean	query	Ne
afterCreatedAt	integer	query	Ne
unreadOnly	boolean	query	Ne
dmOnly	boolean	query	Ne
noDm	boolean	query	Ne
includeTranslations	boolean	query	Ne
sso	string	query	Ne

Odgovor

Vraća: GetUserNotifications200Response

Primjer

Primjer GetUserNotifications

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    pageSize := int32(56) // int32 |  (neobavezno)
    afterId := "afterId_example" // string |  (neobavezno)
    includeContext := true // bool |  (neobavezno)
    afterCreatedAt := int64(789) // int64 |  (neobavezno)
    unreadOnly := true // bool |  (neobavezno)
    dmOnly := true // bool |  (neobavezno)
    noDm := true // bool |  (neobavezno)
    includeTranslations := true // bool |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetUserNotifications(context.Background()).TenantId(tenantId).PageSize(pageSize).AfterId(afterId).IncludeContext(includeContext).AfterCreatedAt(afterCreatedAt).UnreadOnly(unreadOnly).DmOnly(dmOnly).NoDm(noDm).IncludeTranslations(includeTranslations).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetUserNotifications``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetUserNotifications`: GetUserNotifications200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotifications`: %v\n", resp)
}

Resetiraj broj obavijesti korisnika

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: ResetUserNotifications200Response

Primjer

Primjer ResetUserNotificationCount

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.ResetUserNotificationCount(context.Background()).TenantId(tenantId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.ResetUserNotificationCount``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ResetUserNotificationCount`: ResetUserNotifications200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ResetUserNotificationCount`: %v\n", resp)
}

Resetiraj obavijesti korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
afterId	string	query	Ne
afterCreatedAt	integer	query	Ne
unreadOnly	boolean	query	Ne
dmOnly	boolean	query	Ne
noDm	boolean	query	Ne
sso	string	query	Ne

Odgovor

Vraća: ResetUserNotifications200Response

Primjer

ResetUserNotifications Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    afterId := "afterId_example" // string |  (neobavezno)
    afterCreatedAt := int64(789) // int64 |  (neobavezno)
    unreadOnly := true // bool |  (neobavezno)
    dmOnly := true // bool |  (neobavezno)
    noDm := true // bool |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.ResetUserNotifications(context.Background()).TenantId(tenantId).AfterId(afterId).AfterCreatedAt(afterCreatedAt).UnreadOnly(unreadOnly).DmOnly(dmOnly).NoDm(noDm).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.ResetUserNotifications``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `ResetUserNotifications`: ResetUserNotifications200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ResetUserNotifications`: %v\n", resp)
}

Ažuriraj status pretplate korisnika na obavijesti o komentarima

Enable or disable notifications for a specific comment.

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
notificationId	string	path	Da
optedInOrOut	string	path	Da
commentId	string	query	Da
sso	string	query	Ne

Odgovor

Vraća: UpdateUserNotificationStatus200Response

Primjer

UpdateUserNotificationCommentSubscriptionStatus Primjer

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    notificationId := "notificationId_example" // string | 
    optedInOrOut := "optedInOrOut_example" // string | 
    commentId := "commentId_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UpdateUserNotificationCommentSubscriptionStatus(context.Background(), notificationId, optedInOrOut).TenantId(tenantId).CommentId(commentId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UpdateUserNotificationCommentSubscriptionStatus``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateUserNotificationCommentSubscriptionStatus`: UpdateUserNotificationStatus200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationCommentSubscriptionStatus`: %v\n", resp)
}

Ažuriraj status pretplate korisnika na obavijesti o stranicama

Omogućite ili onemogućite obavijesti za stranicu. Kada su korisnici pretplaćeni na stranicu, obavijesti se stvaraju za nove glavne komentare, i također

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
urlId	string	query	Da
url	string	query	Da
pageTitle	string	query	Da
subscribedOrUnsubscribed	string	path	Da
sso	string	query	Ne

Odgovor

Vraća: UpdateUserNotificationStatus200Response

Primjer

Primjer UpdateUserNotificationPageSubscriptionStatus

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    url := "url_example" // string | 
    pageTitle := "pageTitle_example" // string | 
    subscribedOrUnsubscribed := "subscribedOrUnsubscribed_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UpdateUserNotificationPageSubscriptionStatus(context.Background(), subscribedOrUnsubscribed).TenantId(tenantId).UrlId(urlId).Url(url).PageTitle(pageTitle).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UpdateUserNotificationPageSubscriptionStatus``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateUserNotificationPageSubscriptionStatus`: UpdateUserNotificationStatus200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationPageSubscriptionStatus`: %v\n", resp)
}

Ažuriraj status obavijesti korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
notificationId	string	path	Da
newStatus	string	path	Da
sso	string	query	Ne

Odgovor

Vraća: UpdateUserNotificationStatus200Response

Primjer

Primjer UpdateUserNotificationStatus

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    notificationId := "notificationId_example" // string | 
    newStatus := "newStatus_example" // string | 
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UpdateUserNotificationStatus(context.Background(), notificationId, newStatus).TenantId(tenantId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UpdateUserNotificationStatus``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `UpdateUserNotificationStatus`: UpdateUserNotificationStatus200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationStatus`: %v\n", resp)
}

Dohvati statuse prisutnosti korisnika

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Da
urlIdWS	string	query	Da
userIds	string	query	Da

Odgovor

Vraća: GetUserPresenceStatuses200Response

Primjer

Primjer GetUserPresenceStatuses

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlIdWS := "urlIdWS_example" // string | 
    userIds := "userIds_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetUserPresenceStatuses(context.Background()).TenantId(tenantId).UrlIdWS(urlIdWS).UserIds(userIds).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetUserPresenceStatuses``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `GetUserPresenceStatuses`: GetUserPresenceStatuses200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserPresenceStatuses`: %v\n", resp)
}

Pretraži korisnike

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
urlId	string	query	Da
usernameStartsWith	string	query	Da
mentionGroupIds	array	query	Ne
sso	string	query	Ne

Odgovor

Vraća: SearchUsers200Response

Primjer

Primjer SearchUsers

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    usernameStartsWith := "usernameStartsWith_example" // string | 
    mentionGroupIds := []string{"Inner_example"} // []string |  (neobavezno)
    sso := "sso_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.SearchUsers(context.Background(), tenantId).UrlId(urlId).UsernameStartsWith(usernameStartsWith).MentionGroupIds(mentionGroupIds).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.SearchUsers``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `SearchUsers`: SearchUsers200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SearchUsers`: %v\n", resp)
}

Dohvati korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
id	string	path	Da

Odgovor

Vraća: GetUser200Response

Primjer

Primjer GetUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetUser(context.Background(), id).TenantId(tenantId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetUser`: GetUser200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUser`: %v\n", resp)
}

Kreiraj glas

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
commentId	string	query	Da
direction	string	query	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: VoteComment200Response

Primjer

Primjer CreateVote

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    commentId := "commentId_example" // string | 
    direction := "direction_example" // string | 
    userId := "userId_example" // string |  (neobavezno)
    anonUserId := "anonUserId_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CreateVote(context.Background()).TenantId(tenantId).CommentId(commentId).Direction(direction).UserId(userId).AnonUserId(anonUserId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateVote``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor od `CreateVote`: VoteComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateVote`: %v\n", resp)
}

Izbriši glas

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	path	Da
editKey	string	query	Ne

Odgovor

Vraća: DeleteCommentVote200Response

Primjer

Primjer DeleteVote

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    id := "id_example" // string | 
    editKey := "editKey_example" // string |  (neobavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteVote(context.Background(), id).TenantId(tenantId).EditKey(editKey).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteVote``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `DeleteVote`: DeleteCommentVote200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteVote`: %v\n", resp)
}

Dohvati glasove

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
urlId	string	query	Da

Odgovor

Vraća: GetVotes200Response

Primjer

Primjer GetVotes

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetVotes(context.Background()).TenantId(tenantId).UrlId(urlId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetVotes``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetVotes`: GetVotes200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetVotes`: %v\n", resp)
}

Dohvati glasove za korisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
urlId	string	query	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: GetVotesForUser200Response

Primjer

Primjer GetVotesForUser

Copy

package main
import (
    "context"
    "fmt"
    "os"
    openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
    tenantId := "tenantId_example" // string | 
    urlId := "urlId_example" // string | 
    userId := "userId_example" // string |  (nije obavezno)
    anonUserId := "anonUserId_example" // string |  (nije obavezno)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.GetVotesForUser(context.Background()).TenantId(tenantId).UrlId(urlId).UserId(userId).AnonUserId(anonUserId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetVotesForUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // odgovor iz `GetVotesForUser`: GetVotesForUser200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetVotesForUser`: %v\n", resp)
}

Trebate pomoć?

Ako naiđete na bilo kakve probleme ili imate pitanja o Go SDK-u, molimo:

Doprinosi

Doprinosi su dobrodošli! Posjetite GitHub repository za smjernice za doprinos.

Jezik 🇭🇷 Hrvatski

Početak

Korištenje

Agregiranje

Dnevnici revizije

Blokiranje iz komentara

Provjera blokiranih komentara

Komentari

Konfiguracije domene

Predlošci e-pošte

Dnevnik događaja

Objave feeda

Prijavi komentar

Hashtagovi

Moderatori

Broj obavijesti

Obavijesti

Stranice

Webhook događaji na čekanju

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

SSO korisnici

Pretplate

Dnevna upotreba tenant-a

Paketi tenant-a

Tenant korisnici

Tenant-i

Prenesi sliku

Napredak značke korisnika

Značke korisnika

Obavijesti korisnika

Status prisutnosti korisnika

Pretraživanje korisnika

Korisnici

Glasovi

FastComments Go SDK

Repozitorij

Instalacija

Korištenje API klijenta

Javni API (bez autentifikacije)

Zadani API (zahtijeva API ključ)

Korištenje

Jednostavni SSO

Sigurni SSO

Agregiranje

Parametri

Odgovor

Primjer

Dohvati dnevnike revizije

Parametri

Odgovor

Primjer

Blokiraj iz komentara (javno)

Parametri

Odgovor

Primjer

Poništi blokadu komentara (javno)

Parametri

Odgovor

Primjer

Provjeri komentare za blokirane

Parametri

Odgovor

Primjer

Blokiraj korisnika iz komentara

Parametri

Odgovor

Primjer

Kreiraj komentar (javno)

Parametri

Odgovor

Primjer

Izbriši komentar

Parametri

Odgovor

Primjer

Izbriši komentar (javno)

Parametri

Odgovor