FastComments Go SDK

Ovo je službeni Go SDK za FastComments.

Službeni Go SDK za FastComments API

Repozitorij

AI programski agenti

Dajte svom programskom agentu FastComments kontekst koji mu je potreban - widgete, konfiguraciju, Secure SSO, REST API i SDK‑ove:

npx skills add fastcomments/skills

Radi s Claude Code, Codex, Cursor, Copilot, Gemini i svakim drugim agentom koji podržava skills CLI.

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)

    // Dohvati komentare koristeći 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)

    // Stvori autentificirani kontekst s API ključem
    auth := context.WithValue(
        context.Background(),
        client.ContextAPIKeys,
        map[string]client.APIKey{
            "api_key": {Key: "your-api-key-here"},
        },
    )

    // Dohvati komentare koristeći autentificirani 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)
}

Moderacijski API (Nadzorna ploča moderatora)

ModerationAPI pruža opsežan skup API-ja za moderiranje uživo i brzo moderiranje. Sve metode moderiranja prihvaćaju parametar sso i mogu se autentificirati putem SSO-a ili kolačića sesije FastComments.com:

package main

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

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

    // Navedi komentare za moderiranje koristeći ModerationAPI
    response, httpResp, err := apiClient.ModerationAPI.GetApiComments(
        context.Background(),
    ).Sso("your-sso-token").Execute()

    if err != nil {
        panic(err)
    }

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

Upotreba

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

Agregacija

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

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
parentTenantId	string	query	Ne
includeStats	boolean	query	Ne

Odgovor

Vraća: AggregateResponse

Primjer

Primjer agregacije

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// odgovor od `Aggregate`: AggregateResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.Aggregate`: %v\n", resp)
}

Dohvati audit zapise

Parametri

Ime	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: GetAuditLogsResponse

Primjer

Primjer GetAuditLogs

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `GetAuditLogs`: GetAuditLogsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetAuditLogs`: %v\n", resp)
}

Odjava javna

Odgovor

Vraća: APIEmptyResponse

Primjer

LogoutPublic Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.LogoutPublic(context.Background()).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.LogoutPublic``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `LogoutPublic`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.LogoutPublic`: %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: BlockSuccess

Primjer

Primjer BlockFromCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// response from `BlockFromCommentPublic`: BlockSuccess
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.BlockFromCommentPublic`: %v\n", resp)
}

Odblokiraj komentar (javno)

Parametri

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

Odgovor

Vraća: UnblockSuccess

Primjer

UnBlockCommentPublic Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// response from `UnBlockCommentPublic`: UnblockSuccess
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnBlockCommentPublic`: %v\n", resp)
}

Provjereni komentari za blokirane

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
commentIds	string	query	Da	Popis ID-jeva komentara odvojenih zarezom.
sso	string	query	Ne

Odgovor

Vraća: CheckBlockedCommentsResponse

Primjer

Primjer CheckedCommentsForBlocked

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentIds := "commentIds_example" // string | Popis ID-jeva komentara odvojenih zarezom.
	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`: CheckBlockedCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CheckedCommentsForBlocked`: %v\n", resp)
}

Blokiraj korisnika iz komentara

Parametri

Naziv	Tip	Lokacija	Obvezno
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Odgovor

Vraća: BlockSuccess

Primjer

Primjer BlockUserFromComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// response from `BlockUserFromComment`: BlockSuccess
	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: SaveCommentsResponseWithPresence

Primjer

CreateCommentPublic Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// odgovor od `CreateCommentPublic`: SaveCommentsResponseWithPresence
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateCommentPublic`: %v\n", resp)
}

Obriš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: DeleteCommentResult

Primjer

DeleteComment 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 | 
	contextUserId := "contextUserId_example" // string |  (neobvezno)
	isLive := true // bool |  (neobvezno)
	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)
	}
	// response from `DeleteComment`: DeleteCommentResult
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteComment`: %v\n", resp)
}

Obriši komentar javno

Parametri

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

Odgovor

Vraća: PublicAPIDeleteCommentResponse

Primjer

Primjer DeleteCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `DeleteCommentPublic`: PublicAPIDeleteCommentResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteCommentPublic`: %v\n", resp)
}

Obriš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: VoteDeleteResponse

Primjer

Primjer DeleteCommentVote

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: VoteDeleteResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteCommentVote`: %v\n", resp)
}

Označi 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: FlagCommentResponse

Primjer

Primjer FlagComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: FlagCommentResponse
	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: APIGetCommentResponse

Primjer

Primjer GetComment

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.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 iz `GetComment`: APIGetCommentResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetComment`: %v\n", resp)
}

Dohvati komentare

Parametri

Name	Type	Location	Required
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
fromDate	integer	query	Ne
toDate	integer	query	Ne

Odgovor

Vraća: APIGetCommentsResponse

Primjer

Primjer GetComments

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	fromDate := int64(789) // int64 |  (neobavezno)
	toDate := int64(789) // int64 |  (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).FromDate(fromDate).ToDate(toDate).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 od `GetComments`: APIGetCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetComments`: %v\n", resp)
}

Dohvati komentare javno

req tenantId urlId

Parametri

Naziv	Tip	Lokacija	Obavezno
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: GetCommentsResponseWithPresencePublicComment

Primjer

Primjer GetCommentsPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: GetCommentsResponseWithPresencePublicComment
	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: PublicAPIGetCommentTextResponse

Primjer

Primjer GetCommentText

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: PublicAPIGetCommentTextResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentText`: %v\n", resp)
}

Dohvati korisnička imena glasova za komentar

Parametri

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

Odgovor

Vraća: GetCommentVoteUserNamesSuccessResponse

Primjer

GetCommentVoteUserNames Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: GetCommentVoteUserNamesSuccessResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentVoteUserNames`: %v\n", resp)
}

Zaključaj komentar

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer LockComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	sso := "sso_example" // string |  (neobvezno)
	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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.LockComment`: %v\n", resp)
}

Prikvači komentar

Parametri

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

Odgovor

Vraća: ChangeCommentPinStatusResponse

Primjer

Primjer PinComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: ChangeCommentPinStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.PinComment`: %v\n", resp)
}

Spremi komentar

Parametri

Ime	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: APISaveCommentResponse

Primjer

Primjer SaveComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: APISaveCommentResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveComment`: %v\n", resp)
}

Spremi komentare u grupi

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: []SaveCommentsBulkResponse

Primjer

Primjer SaveCommentsBulk

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `SaveCommentsBulk`: []SaveCommentsBulkResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveCommentsBulk`: %v\n", resp)
}

Postavi tekst komentara

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: PublicAPISetCommentTextResponse

Primjer

Primjer SetCommentText

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `SetCommentText`: PublicAPISetCommentTextResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SetCommentText`: %v\n", resp)
}

Odblokiraj 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: UnblockSuccess

Primjer

UnBlockUserFromComment 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 | 
	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)
	}
	// response from `UnBlockUserFromComment`: UnblockSuccess
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UnBlockUserFromComment`: %v\n", resp)
}

Ukloni oznaku 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: FlagCommentResponse

Primjer

Primjer za UnFlagComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: FlagCommentResponse
	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: APIEmptyResponse

Primjer

Primjer UnLockComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnLockComment`: %v\n", resp)
}

Ukloni prikvačeni komentar

Parametri

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

Odgovor

Vraća: ChangeCommentPinStatusResponse

Primjer

Primjer UnPinComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	sso := "sso_example" // string |  (neobvezno)
	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`: ChangeCommentPinStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnPinComment`: %v\n", resp)
}

Ažuriraj komentar

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
id	string	path	Da
contextUserId	string	query	Ne
doSpamCheck	boolean	query	Ne
isLive	boolean	query	Ne

Odgovor

Vraća: APIEmptyResponse

Primjer

UpdateComment 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 | 
	updatableCommentParams := *openapiclient.NewUpdatableCommentParams() // UpdatableCommentParams | 
	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).UpdatableCommentParams(updatableCommentParams).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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateComment`: %v\n", resp)
}

Glasaj za komentar

Parametri

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

Odgovor

Vraća: VoteResponse

Primjer

Primjer VoteComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: VoteResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.VoteComment`: %v\n", resp)
}

Dohvati komentare za korisnika

Parametri

Name	Type	Location	Required
userId	string	query	Ne
direction	string	query	Ne
repliesToUserId	string	query	Ne
page	number	query	Ne
includei10n	boolean	query	Ne
locale	string	query	Ne
isCrawler	boolean	query	Ne

Odgovor

Vraća: GetCommentsForUserResponse

Primjer

Primjer GetCommentsForUser

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	userId := "userId_example" // string |  (neobavezno)
	direction := openapiclient.SortDirections("OF") // SortDirections |  (neobavezno)
	repliesToUserId := "repliesToUserId_example" // string |  (neobavezno)
	page := float64(1.2) // float64 |  (neobavezno)
	includei10n := true // bool |  (neobavezno)
	locale := "locale_example" // string |  (neobavezno)
	isCrawler := true // bool |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetCommentsForUser(context.Background()).UserId(userId).Direction(direction).RepliesToUserId(repliesToUserId).Page(page).Includei10n(includei10n).Locale(locale).IsCrawler(isCrawler).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetCommentsForUser``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetCommentsForUser`: GetCommentsForUserResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentsForUser`: %v\n", resp)
}

Dodaj konfiguraciju domena

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: AddDomainConfigResponse

Primjer

Primjer AddDomainConfig

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `AddDomainConfig`: AddDomainConfigResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddDomainConfig`: %v\n", resp)
}

Obriši konfiguraciju domena

Parametri

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

Odgovor

Vraća: DeleteDomainConfigResponse

Primjer

Primjer DeleteDomainConfig

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `DeleteDomainConfig`: DeleteDomainConfigResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteDomainConfig`: %v\n", resp)
}

Dohvati konfiguraciju domena

Parametri

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

Odgovor

Vraća: GetDomainConfigResponse

Primjer

Primjer GetDomainConfig

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: GetDomainConfigResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetDomainConfig`: %v\n", resp)
}

Dohvati konfiguracije domena

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetDomainConfigsResponse

Primjer

Primjer GetDomainConfigs

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.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 od `GetDomainConfigs`: GetDomainConfigsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetDomainConfigs`: %v\n", resp)
}

Ažuriraj konfiguraciju domena

Parametri

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

Odgovor

Vraća: PatchDomainConfigResponse

Primjer

Primjer PatchDomainConfig

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: PatchDomainConfigResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PatchDomainConfig`: %v\n", resp)
}

Postavi konfiguraciju domena

Parametri

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

Odgovor

Vraća: PutDomainConfigResponse

Primjer

Primjer PutDomainConfig

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: PutDomainConfigResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PutDomainConfig`: %v\n", resp)
}

Kreiraj email predložak

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateEmailTemplateResponse

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)
	}
	// odgovor od `CreateEmailTemplate`: CreateEmailTemplateResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateEmailTemplate`: %v\n", resp)
}

Obriši email predložak

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 iz `DeleteEmailTemplate`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteEmailTemplate`: %v\n", resp)
}

Obriši grešku renderiranja email predloška

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer DeleteEmailTemplateRenderError

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 od `DeleteEmailTemplateRenderError`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteEmailTemplateRenderError`: %v\n", resp)
}

Dohvati email predložak

Parametri

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

Odgovor

Vraća: GetEmailTemplateResponse

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`: GetEmailTemplateResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplate`: %v\n", resp)
}

Dohvati definicije email predloška

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetEmailTemplateDefinitionsResponse

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 od `GetEmailTemplateDefinitions`: GetEmailTemplateDefinitionsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplateDefinitions`: %v\n", resp)
}

Dohvati greške renderiranja email predloška

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
id	string	putanja	Da
skip	number	query	Ne

Odgovor

Vraća: GetEmailTemplateRenderErrorsResponse

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 od `GetEmailTemplateRenderErrors`: GetEmailTemplateRenderErrorsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplateRenderErrors`: %v\n", resp)
}

Dohvati email predloške

Parametri

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

Odgovor

Vraća: GetEmailTemplatesResponse

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 iz `GetEmailTemplates`: GetEmailTemplatesResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplates`: %v\n", resp)
}

Renderiraj email predložak

Parametri

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

Odgovor

Vraća: RenderEmailTemplateResponse

Primjer

Primjer 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`: RenderEmailTemplateResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.RenderEmailTemplate`: %v\n", resp)
}

Ažuriraj email predložak

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 od `UpdateEmailTemplate`: APIEmptyResponse
	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	Ne

Odgovor

Vraća: GetEventLogResponse

Primjer

GetEventLog Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	userIdWS := "userIdWS_example" // string | 
	startTime := int64(789) // int64 | 
	endTime := int64(789) // int64 |  (neobavezno)
	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`: GetEventLogResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetEventLog`: %v\n", resp)
}

Dohvati globalni 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	Ne

Odgovor

Vraća: GetEventLogResponse

Primjer

Primjer GetGlobalEventLog

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	userIdWS := "userIdWS_example" // string | 
	startTime := int64(789) // int64 | 
	endTime := int64(789) // int64 |  (neobavezno)
	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 od `GetGlobalEventLog`: GetEventLogResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetGlobalEventLog`: %v\n", resp)
}

Kreiraj objavu u feedu

Parametri

Ime	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: CreateFeedPostsResponse

Primjer

CreateFeedPost Example

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `CreateFeedPost`: CreateFeedPostsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateFeedPost`: %v\n", resp)
}

Kreiraj objavu u feedu javno

Parametri

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

Odgovor

Vraća: CreateFeedPostResponse

Primjer

Primjer CreateFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: CreateFeedPostResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateFeedPostPublic`: %v\n", resp)
}

Obriši objavu u feedu javno

Parametri

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

Odgovor

Vraća: DeleteFeedPostPublicResponse

Primjer

Primjer DeleteFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `DeleteFeedPostPublic`: DeleteFeedPostPublicResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteFeedPostPublic`: %v\n", resp)
}

Dohvati objave u feedu

req tenantId afterId

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
afterId	string	query	Ne
limit	integer	query	Ne
tags	array	query	Ne

Odgovor

Vraća: GetFeedPostsResponse

Primjer

Primjer GetFeedPosts

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: GetFeedPostsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetFeedPosts`: %v\n", resp)
}

Dohvati objave u feedu 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: PublicFeedPostsResponse

Primjer

Primjer GetFeedPostsPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: PublicFeedPostsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsPublic`: %v\n", resp)
}

Dohvati statistiku objava u feedu

Parametri

Ime	Tip	Lokacija	Obvezno
tenantId	string	path	Da
postIds	array	query	Da
sso	string	query	Ne

Odgovor

Vraća: FeedPostsStatsResponse

Primjer

Primjer GetFeedPostsStats

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: FeedPostsStatsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsStats`: %v\n", resp)
}

Dohvati reakcije korisnika javno

Parametri

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

Odgovor

Vraća: UserReactsResponse

Primjer

Primjer GetUserReactsPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// odgovor iz `GetUserReactsPublic`: UserReactsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserReactsPublic`: %v\n", resp)
}

Reagiraj na objavu u feedu javno

Parametri

Ime	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: ReactFeedPostResponse

Primjer

Primjer ReactFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: ReactFeedPostResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ReactFeedPostPublic`: %v\n", resp)
}

Ažuriraj objavu u feedu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer UpdateFeedPost

Copy

package main
import (
	"context"
	"fmt"
	"os"
    "time"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `UpdateFeedPost`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateFeedPost`: %v\n", resp)
}

Ažuriraj objavu u feedu 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: CreateFeedPostResponse

Primjer

Primjer UpdateFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// odgovor od `UpdateFeedPostPublic`: CreateFeedPostResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateFeedPostPublic`: %v\n", resp)
}

Označi komentar javno

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer FlagCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.FlagCommentPublic`: %v\n", resp)
}

Dohvati veliki gif

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	putanja	Da
largeInternalURLSanitized	string	upit	Da

Odgovor

Vraća: GifGetLargeResponse

Primjer

Primjer GetGifLarge

Copy

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

Pretraži gifove

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
search	string	query	Da
locale	string	query	Ne
rating	string	query	Ne
page	number	query	Ne

Odgovor

Vraća: GetGifsSearchResponse

Primjer

Primjer GetGifsSearch

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	search := "search_example" // string | 
	locale := "locale_example" // string |  (neobavezno)
	rating := "rating_example" // string |  (neobavezno)
	page := float64(1.2) // float64 |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetGifsSearch(context.Background(), tenantId).Search(search).Locale(locale).Rating(rating).Page(page).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetGifsSearch``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetGifsSearch`: GetGifsSearchResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetGifsSearch`: %v\n", resp)
}

Dohvati popularne gifove

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	putanja	Da
locale	string	upit	Ne
rating	string	upit	Ne
page	number	upit	Ne

Odgovor

Vraća: GetGifsTrendingResponse

Primjer

Primjer GetGifsTrending

Copy

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

Dodaj hashtag

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateHashTagResponse

Primjer

Primjer AddHashTag

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	createHashTagBody := *openapiclient.NewCreateHashTagBody("Tag_example") // CreateHashTagBody |  (opcionalno)
	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 iz `AddHashTag`: CreateHashTagResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddHashTag`: %v\n", resp)
}

Dodaj hashtagove u grupi

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Yes

Odgovor

Vraća: BulkCreateHashTagsResponse

Primjer

Primjer AddHashTagsBulk

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	bulkCreateHashTagsBody := *openapiclient.NewBulkCreateHashTagsBody([]openapiclient.BulkCreateHashTagsBodyTagsInner{*openapiclient.NewBulkCreateHashTagsBodyTagsInner("Tag_example")}) // BulkCreateHashTagsBody |  (opcionalno)
	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`: BulkCreateHashTagsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddHashTagsBulk`: %v\n", resp)
}

Obriši hashtag

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer DeleteHashTag

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	tag := "tag_example" // string | 
	deleteHashTagRequestBody := *openapiclient.NewDeleteHashTagRequestBody() // DeleteHashTagRequestBody |  (optional)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.DeleteHashTag(context.Background(), tag).TenantId(tenantId).DeleteHashTagRequestBody(deleteHashTagRequestBody).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 od `DeleteHashTag`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteHashTag`: %v\n", resp)
}

Dohvati hashtagove

Parametri

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

Odgovor

Vraća: GetHashTagsResponse

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 iz `GetHashTags`: GetHashTagsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetHashTags`: %v\n", resp)
}

Ažuriraj hashtag

Parametri

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

Odgovor

Vraća: UpdateHashTagResponse

Primjer

PatchHashTag Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	tag := "tag_example" // string | 
	updateHashTagBody := *openapiclient.NewUpdateHashTagBody() // UpdateHashTagBody |  (opcionalno)
	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, "Greška prilikom pozivanja `DefaultAPI.PatchHashTag``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor iz `PatchHashTag`: UpdateHashTagResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `DefaultAPI.PatchHashTag`: %v\n", resp)
}

Obriši moderacijski glas

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
voteId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Odgovor

Vraća: VoteDeleteResponse

Primjer

Primjer DeleteModerationVote

Copy

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

Dohvati API komentare

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
page	number	query	No
count	number	query	No
text-search	string	query	No
byIPFromComment	string	query	No
filters	string	query	No
searchFilters	string	query	No
sorts	string	query	No
demo	boolean	query	No
sso	string	query	No

Odgovor

Vraća: ModerationAPIGetCommentsResponse

Primjer

Primjer GetApiComments

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 |  (opcionalno)
	count := float64(1.2) // float64 |  (opcionalno)
	textSearch := "textSearch_example" // string |  (opcionalno)
	byIPFromComment := "byIPFromComment_example" // string |  (opcionalno)
	filters := "filters_example" // string |  (opcionalno)
	searchFilters := "searchFilters_example" // string |  (opcionalno)
	sorts := "sorts_example" // string |  (opcionalno)
	demo := true // bool |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetApiComments(context.Background()).TenantId(tenantId).Page(page).Count(count).TextSearch(textSearch).ByIPFromComment(byIPFromComment).Filters(filters).SearchFilters(searchFilters).Sorts(sorts).Demo(demo).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetApiComments``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetApiComments`: ModerationAPIGetCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetApiComments`: %v\n", resp)
}

Dohvati status API izvoza

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
batchJobId	string	query	No
sso	string	query	No

Odgovor

Vraća: ModerationExportStatusResponse

Primjer

Primjer GetApiExportStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	batchJobId := "batchJobId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetApiExportStatus(context.Background()).TenantId(tenantId).BatchJobId(batchJobId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška pri pozivu `ModerationAPI.GetApiExportStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Cjeli HTTP odgovor: %v\n", r)
	}
	// odgovor od `GetApiExportStatus`: ModerationExportStatusResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.GetApiExportStatus`: %v\n", resp)
}

Dohvati API ID-e

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Da
text-search	string	query	Ne
byIPFromComment	string	query	Ne
filters	string	query	Ne
searchFilters	string	query	Ne
afterId	string	query	Ne
demo	boolean	query	Ne
sso	string	query	Ne

Odgovor

Vraća: ModerationAPIGetCommentIdsResponse

Primjer

GetApiIds Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	textSearch := "textSearch_example" // string | (neobavezno)
	byIPFromComment := "byIPFromComment_example" // string | (neobavezno)
	filters := "filters_example" // string | (neobavezno)
	searchFilters := "searchFilters_example" // string | (neobavezno)
	afterId := "afterId_example" // string | (neobavezno)
	demo := true // bool | (neobavezno)
	sso := "sso_example" // string | (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetApiIds(context.Background()).TenantId(tenantId).TextSearch(textSearch).ByIPFromComment(byIPFromComment).Filters(filters).SearchFilters(searchFilters).AfterId(afterId).Demo(demo).Sso(sno).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetApiIds``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetApiIds`: ModerationAPIGetCommentIdsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetApiIds`: %v\n", resp)
}

Dohvati zabranjene korisnike iz komentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Odgovor

Vraća: GetBannedUsersFromCommentResponse

Primjer

GetBanUsersFromComment Primjer

Copy

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

Dohvati status zabrane komentara

Parameters

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Odgovor

Vraća: GetCommentBanStatusResponse

Primjer

Primjer GetCommentBanStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetCommentBanStatus(context.Background(), commentId).TenantId(tenantId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška prilikom poziva `ModerationAPI.GetCommentBanStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Cijeli HTTP odgovor: %v\n", r)
	}
	// odgovor iz `GetCommentBanStatus`: GetCommentBanStatusResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.GetCommentBanStatus`: %v\n", resp)
}

Dohvati podkomentare

Parametri

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

Odgovor

Vraća: ModerationAPIChildCommentsResponse

Primjer

GetCommentChildren Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetCommentChildren(context.Background(), commentId).TenantId(tenantId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška prilikom poziva `ModerationAPI.GetCommentChildren``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Pun HTTP odgovor: %v\n", r)
	}
	// odgovor iz `GetCommentChildren`: ModerationAPIChildCommentsResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.GetCommentChildren`: %v\n", resp)
}

Dohvati broj

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
text-search	string	query	No
byIPFromComment	string	query	No
filter	string	query	No
searchFilters	string	query	No
demo	boolean	query	No
sso	string	query	No

Odgovor

Vraća: ModerationAPICountCommentsResponse

Primjer

GetCount Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	textSearch := "textSearch_example" // string |  (opcionalno)
	byIPFromComment := "byIPFromComment_example" // string |  (opcionalno)
	filter := "filter_example" // string |  (opcionalno)
	searchFilters := "searchFilters_example" // string |  (opcionalno)
	demo := true // bool |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetCount(context.Background()).TenantId(tenantId).TextSearch(textSearch).ByIPFromComment(byIPFromComment).Filter(filter).SearchFilters(searchFilters).Demo(demo).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetCount``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetCount`: ModerationAPICountCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetCount`: %v\n", resp)
}

Dohvati brojeve

Parameters

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

Response

Vraća: GetBannedUsersCountResponse

Primjer

Primjer GetCounts

Copy

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

Dohvati zapise

Parameters

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Odgovor

Vraća: ModerationAPIGetLogsResponse

Primjer

Primjer GetLogs

Copy

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

Dohvati ručne značke

Parametri

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

Odgovor

Vraća: GetTenantManualBadgesResponse

Primjer

Primjer GetManualBadges

Copy

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

Dohvati ručne značke za korisnika

Parametri

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

Odgovor

Vraća: GetUserManualBadgesResponse

Primjer

Primjer GetManualBadgesForUser

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	badgesUserId := "badgesUserId_example" // string |  (opcionalno)
	commentId := "commentId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetManualBadgesForUser(context.Background()).TenantId(tenantId).BadgesUserId(badgesUserId).CommentId(commentId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetManualBadgesForUser``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `GetManualBadgesForUser`: GetUserManualBadgesResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetManualBadgesForUser`: %v\n", resp)
}

Dohvati moderacijski komentar

Parametri

Naziv	Vrsta	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
includeEmail	boolean	query	No
includeIP	boolean	query	No
sso	string	query	No

Odgovor

Vraća: ModerationAPICommentResponse

Primjer

Primjer GetModerationComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	includeEmail := true // bool |  (opcionalno)
	includeIP := true // bool |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetModerationComment(context.Background(), commentId).TenantId(tenantId).IncludeEmail(includeEmail).IncludeIP(includeIP).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetModerationComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetModerationComment`: ModerationAPICommentResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetModerationComment`: %v\n", resp)
}

Dohvati tekst moderacijskog komentara

Parametri

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

Odgovor

Vraća: GetCommentTextResponse

Primjer

GetModerationCommentText Primjer

Copy

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

Dohvati sažetak pre zabrane

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Da
commentId	string	path	Da
includeByUserIdAndEmail	boolean	query	Ne
includeByIP	boolean	query	Ne
includeByEmailDomain	boolean	query	Ne
sso	string	query	Ne

Odgovor

Vraća: PreBanSummary

Primjer

GetPreBanSummary Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	includeByUserIdAndEmail := true // bool |  (opcionalno)
	includeByIP := true // bool |  (opcionalno)
	includeByEmailDomain := true // bool |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetPreBanSummary(context.Background(), commentId).TenantId(tenantId).IncludeByUserIdAndEmail(includeByUserIdAndEmail).IncludeByIP(includeByIP).IncludeByEmailDomain(includeByEmailDomain).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška prilikom poziva `ModerationAPI.GetPreBanSummary``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor iz `GetPreBanSummary`: PreBanSummary
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.GetPreBanSummary`: %v\n", resp)
}

Dohvati sažetak pretrage komentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
value	string	query	No
filters	string	query	No
searchFilters	string	query	No
sso	string	query	No

Odgovor

Vraća: ModerationCommentSearchResponse

Primjer

GetSearchCommentsSummary Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	value := "value_example" // string |  (opcionalno)
	filters := "filters_example" // string |  (opcionalno)
	searchFilters := "searchFilters_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetSearchCommentsSummary(context.Background()).TenantId(tenantId).Value(value).Filters(filters).SearchFilters(searchFilters).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetSearchCommentsSummary``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetSearchCommentsSummary`: ModerationCommentSearchResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetSearchCommentsSummary`: %v\n", resp)
}

Dohvati stranice pretrage

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Da
value	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: ModerationPageSearchResponse

Primjer

Primjer GetSearchPages

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	value := "value_example" // string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetSearchPages(context.Background()).TenantId(tenantId).Value(value).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetSearchPages``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetSearchPages`: ModerationPageSearchResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetSearchPages`: %v\n", resp)
}

Dohvati sajtove pretrage

Parameters

Naziv	Tip	Lokacija	Potrebno
tenantId	string	query	Da
value	string	query	Ne
sso	string	query	Ne

Response

Vraća: ModerationSiteSearchResponse

Example

GetSearchSites Primjer

Copy

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

Dohvati prijedloge pretrage

Parametri

Ime	Vrsta	Lokacija	Obavezno
tenantId	string	query	Da
text-search	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: ModerationSuggestResponse

Primjer

Primjer GetSearchSuggest

Copy

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

Dohvati korisnike pretrage

Parametri

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

Odgovor

Vraća: ModerationUserSearchResponse

Primjer

Primjer GetSearchUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	value := "value_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetSearchUsers(context.Background()).TenantId(tenantId).Value(value).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetSearchUsers``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetSearchUsers`: ModerationUserSearchResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetSearchUsers`: %v\n", resp)
}

Dohvati faktor povjerenja

Parametri

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

Odgovor

Vraća: GetUserTrustFactorResponse

Primjer

Primjer GetTrustFactor

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetTrustFactor(context.Background()).TenantId(tenantId).UserId(userId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetTrustFactor``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetTrustFactor`: GetUserTrustFactorResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetTrustFactor`: %v\n", resp)
}

Dohvati preferenciju zabrane korisnika

Parametri

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

Odgovor

Vraća: APIModerateGetUserBanPreferencesResponse

Primjer

Primjer GetUserBanPreference

Copy

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

Dohvati internu profil korisnika

Parametri

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

Odgovor

Vraća: GetUserInternalProfileResponse

Primjer

Primjer GetUserInternalProfile

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | (opcionalno)
	sso := "sso_example" // string | (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.GetUserInternalProfile(context.Background()).TenantId(tenantId).CommentId(commentId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.GetUserInternalProfile``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetUserInternalProfile`: GetUserInternalProfileResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetUserInternalProfile`: %v\n", resp)
}

Objavi prilagodi glasove za komentar

Parameters

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

Odgovor

Vraća: AdjustVotesResponse

Primjer

PostAdjustCommentVotes Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	adjustCommentVotesParams := *openapiclient.NewAdjustCommentVotesParams(float64(123)) // AdjustCommentVotesParams | 
	broadcastId := "broadcastId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostAdjustCommentVotes(context.Background(), commentId).TenantId(tenantId).AdjustCommentVotesParams(adjustCommentVotesParams).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostAdjustCommentVotes``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `PostAdjustCommentVotes`: AdjustVotesResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostAdjustCommentVotes`: %v\n", resp)
}

Objavi API izvoz

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
text-search	string	query	No
byIPFromComment	string	query	No
filters	string	query	No
searchFilters	string	query	No
sorts	string	query	No
sso	string	query	No

Odgovor

Vraća: ModerationExportResponse

Primjer

Primjer PostApiExport

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	textSearch := "textSearch_example" // string |  (opcionalno)
	byIPFromComment := "byIPFromComment_example" // string |  (opcionalno)
	filters := "filters_example" // string |  (opcionalno)
	searchFilters := "searchFilters_example" // string |  (opcionalno)
	sorts := "sorts_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostApiExport(context.Background()).TenantId(tenantId).TextSearch(textSearch).ByIPFromComment(byIPFromComment).Filters(filters).SearchFilters(searchFilters).Sorts(sorts).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostApiExport``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `PostApiExport`: ModerationExportResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostApiExport`: %v\n", resp)
}

Objavi zabranu korisnika iz komentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
banEmail	boolean	query	No
banEmailDomain	boolean	query	No
banIP	boolean	query	No
deleteAllUsersComments	boolean	query	No
bannedUntil	string	query	No
isShadowBan	boolean	query	No
updateId	string	query	No
banReason	string	query	No
sso	string	query	No

Odgovor

Vraća: BanUserFromCommentResult

Primjer

PostBanUserFromComment Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	banEmail := true // bool |  (opcionalno)
	banEmailDomain := true // bool |  (opcionalno)
	banIP := true // bool |  (opcionalno)
	deleteAllUsersComments := true // bool |  (opcionalno)
	bannedUntil := "bannedUntil_example" // string |  (opcionalno)
	isShadowBan := true // bool |  (opcionalno)
	updateId := "updateId_example" // string |  (opcionalno)
	banReason := "banReason_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostBanUserFromComment(context.Background(), commentId).TenantId(tenantId).BanEmail(banEmail).BanEmailDomain(banEmailDomain).BanIP(banIP).DeleteAllUsersComments(deleteAllUsersComments).BannedUntil(bannedUntil).IsShadowBan(isShadowBan).UpdateId(updateId).BanReason(banReason).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostBanUserFromComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `PostBanUserFromComment`: BanUserFromCommentResult
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostBanUserFromComment`: %v\n", resp)
}

Objavi poništi zabranu korisnika

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

PostBanUserUndo Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	banUserUndoParams := *openapiclient.NewBanUserUndoParams(*openapiclient.NewAPIBanUserChangeLog()) // BanUserUndoParams | 
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostBanUserUndo(context.Background()).TenantId(tenantId).BanUserUndoParams(banUserUndoParams).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Pogreška pri pozivu `ModerationAPI.PostBanUserUndo``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Cijeli HTTP odgovor: %v\n", r)
	}
	// odgovor iz `PostBanUserUndo`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.PostBanUserUndo`: %v\n", resp)
}

Objavi grupni sažetak pre zabrane

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
includeByUserIdAndEmail	boolean	query	No
includeByIP	boolean	query	No
includeByEmailDomain	boolean	query	No
sso	string	query	No

Odgovor

Vraća: BulkPreBanSummary

Primjer

PostBulkPreBanSummary Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	bulkPreBanParams := *openapiclient.NewBulkPreBanParams([]string{"CommentIds_example"}) // BulkPreBanParams | 
	includeByUserIdAndEmail := true // bool |  (opcionalno)
	includeByIP := true // bool |  (opcionalno)
	includeByEmailDomain := true // bool |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostBulkPreBanSummary(context.Background()).TenantId(tenantId).BulkPreBanParams(bulkPreBanParams).IncludeByUserIdAndEmail(includeByUserIdAndEmail).IncludeByIP(includeByIP).IncludeByEmailDomain(includeByEmailDomain).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostBulkPreBanSummary``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `PostBulkPreBanSummary`: BulkPreBanSummary
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostBulkPreBanSummary`: %v\n", resp)
}

Objavi komentare po ID-ovima

Parametri

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

Odgovor

Vraća: ModerationAPIChildCommentsResponse

Primjer

Primjer PostCommentsByIds

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentsByIdsParams := *openapiclient.NewCommentsByIdsParams([]string{"Ids_example"}) // CommentsByIdsParams | 
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostCommentsByIds(context.Background()).TenantId(tenantId).CommentsByIdsParams(commentsByIdsParams).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška pri pozivu `ModerationAPI.PostCommentsByIds``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Potpun HTTP odgovor: %v\n", r)
	}
	// odgovor iz `PostCommentsByIds`: ModerationAPIChildCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostCommentsByIds`: %v\n", resp)
}

Objavi označi komentar

Parameters

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Odgovor

Vraća: APIEmptyResponse

Primjer

PostFlagComment Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	broadcastId := "broadcastId_example" // string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostFlagComment(context.Background(), commentId).TenantId(tenantId).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška pri pozivu `ModerationAPI.PostFlagComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Cjeloviti HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostFlagComment`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostFlagComment`: %v\n", resp)
}

Objavi ukloni komentar

Parameters

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

Response

Vraća: PostRemoveCommentApiResponse

Example

PostRemoveComment Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	broadcastId := "broadcastId_example" // string |  (optional)
	sso := "sso_example" // string |  (optional)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostRemoveComment(context.Background(), commentId).TenantId(tenantId).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Pogreška pri pozivu `ModerationAPI.PostRemoveComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Cjelokupni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostRemoveComment`: PostRemoveCommentApiResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostRemoveComment`: %v\n", resp)
}

Objavi obnovi obrisani komentar

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Odgovor

Vraća: APIEmptyResponse

Primjer

PostRestoreDeletedComment primjer

Copy

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

Objavi postavi status odobrenja komentara

Parametri

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

Odgovor

Vraća: SetCommentApprovedResponse

Primjer

PostSetCommentApprovalStatus Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	approved := true // bool | (opcionalno)
	broadcastId := "broadcastId_example" // string | (opcionalno)
	sso := "sso_example" // string | (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostSetCommentApprovalStatus(context.Background(), commentId).TenantId(tenantId).Approved(approved).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostSetCommentApprovalStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `PostSetCommentApprovalStatus`: SetCommentApprovedResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostSetCommentApprovalStatus`: %v\n", resp)
}

Objavi postavi status pregleda komentara

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
commentId	string	path	Yes
reviewed	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Response

Returns: APIEmptyResponse

Example

PostSetCommentReviewStatus Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	reviewed := true // bool |  (optional)
	broadcastId := "broadcastId_example" // string |  (optional)
	sso := "sso_example" // string |  (optional)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostSetCommentReviewStatus(context.Background(), commentId).TenantId(tenantId).Reviewed(reviewed).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostSetCommentReviewStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `PostSetCommentReviewStatus`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostSetCommentReviewStatus`: %v\n", resp)
}

Objavi postavi status spama komentara

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

PostSetCommentSpamStatus Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	spam := true // bool |  (neobavezno)
	permNotSpam := true // bool |  (neobavezno)
	broadcastId := "broadcastId_example" // string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostSetCommentSpamStatus(context.Background(), commentId).TenantId(tenantId).Spam(spam).PermNotSpam(permNotSpam).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostSetCommentSpamStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `PostSetCommentSpamStatus`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostSetCommentSpamStatus`: %v\n", resp)
}

Objavi postavi tekst komentara

Parametri

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

Odgovor

Vraća: SetCommentTextResponse

Primjer

PostSetCommentText Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	setCommentTextParams := *openapiclient.NewSetCommentTextParams("Comment_example") // SetCommentTextParams | 
	broadcastId := "broadcastId_example" // string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostSetCommentText(context.Background(), commentId).TenantId(tenantId).SetCommentTextParams(setCommentTextParams).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška pri pozivu `ModerationAPI.PostSetCommentText``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Cijeli HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostSetCommentText`: SetCommentTextResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostSetCommentText`: %v\n", resp)
}

Objavi ukloni oznaku komentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
commentId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer PostUnFlagComment

Copy

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

Objavi glas

Parametri

Name	Type	Location	Required
tenantId	string	query	Yes
commentId	string	path	Yes
direction	string	query	No
broadcastId	string	query	No
sso	string	query	No

Odgovor

Returns: VoteResponse

Primjer

PostVote Primjer

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 |  (neobavezno)
	broadcastId := "broadcastId_example" // string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PostVote(context.Background(), commentId).TenantId(tenantId).Direction(direction).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostVote``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `PostVote`: VoteResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostVote`: %v\n", resp)
}

Postavi nagradu značku

Parametri

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

Odgovor

Vraća: AwardUserBadgeResponse

Primjer

PutAwardBadge Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	badgeId := "badgeId_example" // string | 
	userId := "userId_example" // string |  (opcionalno)
	commentId := "commentId_example" // string |  (opcionalno)
	broadcastId := "broadcastId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PutAwardBadge(context.Background()).TenantId(tenantId).BadgeId(badgeId).UserId(userId).CommentId(commentId).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PutAwardBadge``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `PutAwardBadge`: AwardUserBadgeResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PutAwardBadge`: %v\n", resp)
}

Zatvori temu

Parameters

Naziv	Tip	Lokacija	Obavezno
tenantId	string	upit	Da
urlId	string	upit	Da
sso	string	upit	Ne

Response

Returns: APIEmptyResponse

Example

PutCloseThread Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PutCloseThread(context.Background()).TenantId(tenantId).UrlId(urlId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Pogreška prilikom pozivanja `ModerationAPI.PutCloseThread``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PutCloseThread`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.PutCloseThread`: %v\n", resp)
}

Ukloni značku

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
badgeId	string	query	Yes
userId	string	query	No
commentId	string	query	No
broadcastId	string	query	No
sso	string	query	No

Odgovor

Vraća: RemoveUserBadgeResponse

Primjer

PutRemoveBadge Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	badgeId := "badgeId_example" // string | 
	userId := "userId_example" // string |  (neobavezno)
	commentId := "commentId_example" // string |  (neobavezno)
	broadcastId := "broadcastId_example" // string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.PutRemoveBadge(context.Background()).TenantId(tenantId).BadgeId(badgeId).UserId(userId).CommentId(commentId).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PutRemoveBadge``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `PutRemoveBadge`: RemoveUserBadgeResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PutRemoveBadge`: %v\n", resp)
}

Ponovo otvori temu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

PutReopenThread Primjer

Copy

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

Postavi faktor povjerenja

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
userId	string	query	No
trustFactor	string	query	No
sso	string	query	No

Odgovor

Vraća: SetUserTrustFactorResponse

Primjer

SetTrustFactor Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (opcionalno)
	trustFactor := "trustFactor_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.ModerationAPI.SetTrustFactor(context.Background()).TenantId(tenantId).UserId(userId).TrustFactor(trustFactor).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.SetTrustFactor``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `SetTrustFactor`: SetUserTrustFactorResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.SetTrustFactor`: %v\n", resp)
}

Kreiraj moderatora

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateModeratorResponse

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 iz `CreateModerator`: CreateModeratorResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateModerator`: %v\n", resp)
}

Obriši moderatora

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 od `DeleteModerator`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteModerator`: %v\n", resp)
}

Dohvati moderatora

Parametri

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

Odgovor

Vraća: GetModeratorResponse

Primjer

GetModerator 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.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 iz `GetModerator`: GetModeratorResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetModerator`: %v\n", resp)
}

Dohvati moderatore

Parametri

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

Odgovor

Vraća: GetModeratorsResponse

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 iz `GetModerators`: GetModeratorsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetModerators`: %v\n", resp)
}

Pošalji poziv

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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`: APIEmptyResponse
	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: APIEmptyResponse

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)
	}
	// response from `UpdateModerator`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateModerator`: %v\n", resp)
}

Obriši broj obavijesti

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteNotificationCount`: %v\n", resp)
}

Dohvati keširani broj obavijesti

Parametri

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

Odgovor

Vraća: GetCachedNotificationCountResponse

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)
	}
	// response from `GetCachedNotificationCount`: GetCachedNotificationCountResponse
	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: GetNotificationCountResponse

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`: GetNotificationCountResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetNotificationCount`: %v\n", resp)
}

Dohvati obavijesti

Parametri

Ime	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: GetNotificationsResponse

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 od `GetNotifications`: GetNotificationsResponse
	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: APIEmptyResponse

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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateNotification`: %v\n", resp)
}

Kreiraj V1 reakciju stranice

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
urlId	string	query	Da
title	string	query	Ne

Odgovor

Vraća: CreateV1PageReact

Primjer

Primjer CreateV1PageReact

Copy

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

Kreiraj V2 reakciju stranice

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
urlId	string	query	Da
id	string	query	Da
title	string	query	Ne

Odgovor

Vraća: CreateV1PageReact

Primjer

Primjer CreateV2PageReact

Copy

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

Obriši V1 reakciju stranice

Parametri

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

Odgovor

Vraća: CreateV1PageReact

Primjer

DeleteV1PageReact Primjer

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.PublicAPI.DeleteV1PageReact(context.Background(), tenantId).UrlId(urlId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.DeleteV1PageReact``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `DeleteV1PageReact`: CreateV1PageReact
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteV1PageReact`: %v\n", resp)
}

Obriši V2 reakciju stranice

Parametri

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

Odgovor

Vraća: CreateV1PageReact

Primjer

Primjer DeleteV2PageReact

Copy

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

Dohvati V1 lajkove stranice

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Yes
urlId	string	query	Yes

Odgovor

Vraća: GetV1PageLikes

Primjer

Primjer GetV1PageLikes

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.PublicAPI.GetV1PageLikes(context.Background(), tenantId).UrlId(urlId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetV1PageLikes``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetV1PageLikes`: GetV1PageLikes
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetV1PageLikes`: %v\n", resp)
}

Dohvati V2 reakcije stranice

Parametri

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

Odgovor

Vraća: GetV2PageReacts

Primjer

Primjer GetV2PageReacts

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.PublicAPI.GetV2PageReacts(context.Background(), tenantId).UrlId(urlId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetV2PageReacts``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetV2PageReacts`: GetV2PageReacts
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetV2PageReacts`: %v\n", resp)
}

Dohvati korisnike V2 reakcija stranice

Parametri

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

Odgovor

Vraća: GetV2PageReactUsersResponse

Primjer

Primjer GetV2PageReactUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	id := "id_example" // string | 
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetV2PageReactUsers(context.Background(), tenantId).UrlId(urlId).Id(id).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetV2PageReactUsers``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetV2PageReactUsers`: GetV2PageReactUsersResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetV2PageReactUsers`: %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)
}

Obriš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 korisnike izvan mreže

Prošli komentatori na stranici koji trenutno NISU online. Sortirano po displayName. Koristite ovo nakon iscrpljenja /users/online kako biste prikazali odjeljak "Članovi". Paginacija kursorom po commenterName: server prolazi djelomični {tenantId, urlId, commenterName} indeks od afterName naprijed putem $gt, bez troška $skip.

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Da
urlId	string	query	Da	Identifikator URL-a stranice (očisti se na strani poslužitelja).
afterName	string	query	Ne	Kursor: pošaljite nextAfterName iz prethodnog odgovora.
afterUserId	string	query	Ne	Kursor za rješavanje jednakih imena: pošaljite nextAfterUserId iz prethodnog odgovora. Obavezno kada je afterName postavljen kako unosi s istim imenom ne bi bili izostavljeni.

Odgovor

Vraća: PageUsersOfflineResponse

Primjer

Primjer GetOfflineUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | Identifikator URL-a stranice (očisti se na strani poslužitelja).
	afterName := "afterName_example" // string | Kursor: pošaljite nextAfterName iz prethodnog odgovora. (opcionalno)
	afterUserId := "afterUserId_example" // string | Kursor za rješavanje jednakih imena: pošaljite nextAfterUserId iz prethodnog odgovora. Obavezno kada je afterName postavljen kako unosi s istim imenom ne bi bili izostavljeni. (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetOfflineUsers(context.Background(), tenantId).UrlId(urlId).AfterName(afterName).AfterUserId(afterUserId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetOfflineUsers``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetOfflineUsers`: PageUsersOfflineResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetOfflineUsers`: %v\n", resp)
}

Dohvati korisnike na mreži

Trenutno online gledatelji stranice: osobe čija je websocket sesija trenutno pretplaćena na tu stranicu. Vraća anonCount + totalCount (pretplatnici na razini sobe, uključujući anonimne gledatelje koje ne navodimo).

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Da
urlId	string	query	Da	Identifikator URL-a stranice (očišćen na strani poslužitelja).
afterName	string	query	Ne	Kursor: pošaljite nextAfterName iz prethodnog odgovora.
afterUserId	string	query	Ne	Kursor (tiebreaker): pošaljite nextAfterUserId iz prethodnog odgovora. Potrebno kada je afterName postavljen kako se unosi s istim imenom ne bi izostavili.

Odgovor

Vraća: PageUsersOnlineResponse

Primjer

Primjer GetOnlineUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | Identifikator URL-a stranice (očišćen na strani poslužitelja).
	afterName := "afterName_example" // string | Kursor: pošaljite nextAfterName iz prethodnog odgovora. (neobavezno)
	afterUserId := "afterUserId_example" // string | Kursor (tiebreaker): pošaljite nextAfterUserId iz prethodnog odgovora. Potrebno kada je afterName postavljen kako se unosi s istim imenom ne bi izostavili. (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetOnlineUsers(context.Background(), tenantId).UrlId(urlId).AfterName(afterName).AfterUserId(afterUserId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetOnlineUsers``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetOnlineUsers`: PageUsersOnlineResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetOnlineUsers`: %v\n", resp)
}

Dohvati stranicu po URL ID

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

Dohvati stranice javno

Popis stranica za tenant. Koristi ga FChat desktop klijent za popunjavanje svog popisa soba. Zahtijeva da je enableFChat postavljen na true u razriješenoj prilagođenoj konfiguraciji za svaku stranicu. Stranice koje zahtijevaju SSO filtriraju se prema grupnom pristupu korisnika koji šalje zahtjev.

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Yes
cursor	string	query	No	Neprozirni paginacijski kursor vraćen kao `nextCursor` iz prethodnog zahtjeva. Veže se uz isti `sortBy`.
limit	integer	query	No	1..200, zadano 50
q	string	query	No	Opcionalni prefiks filtriranja naslova koji nije osjetljiv na velika/mala slova.
sortBy	string	query	No	Redoslijed sortiranja. `updatedAt` (zadano, najnovije prvo), `commentCount` (najviše komentara prvo), ili `title` (abecedno).
hasComments	boolean	query	No	Ako je true, vraća samo stranice s najmanje jednim komentarom.

Odgovor

Vraća: GetPublicPagesResponse

Primjer

Primjer GetPagesPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	cursor := "cursor_example" // string | Neprozirni paginacijski kursor vraćen kao `nextCursor` iz prethodnog zahtjeva. Veže se uz isti `sortBy`. (neobavezno)
	limit := int32(56) // int32 | 1..200, zadano 50 (neobavezno)
	q := "q_example" // string | Opcionalni prefiks filtriranja naslova koji nije osjetljiv na velika/mala slova. (neobavezno)
	sortBy := openapiclient.PagesSortBy("updatedAt") // PagesSortBy | Redoslijed sortiranja. `updatedAt` (zadano, najnovije prvo), `commentCount` (najviše komentara prvo), ili `title` (abecedno). (neobavezno)
	hasComments := true // bool | Ako je true, vraća samo stranice s najmanje jednim komentarom. (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetPagesPublic(context.Background(), tenantId).Cursor(cursor).Limit(limit).Q(q).SortBy(sortBy).HasComments(hasComments).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetPagesPublic``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `GetPagesPublic`: GetPublicPagesResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetPagesPublic`: %v\n", resp)
}

Dohvati informacije korisnika

Skupne informacije o korisnicima za tenant. Za zadane userIds vraća prikazne informacije iz User / SSOUser. Koristi se u widgetu komentara za obogaćivanje korisnika koji su se upravo pojavili putem događaja prisutnosti. Bez konteksta stranice: privatnost se provodi jednako (privatni profili su maskirani).

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Yes
ids	string	query	Yes	ID-ovi korisnika odvojeni zarezom.

Odgovor

Vraća: PageUsersInfoResponse

Primjer

Primjer GetUsersInfo

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	ids := "ids_example" // string | ID-ovi korisnika odvojeni zarezom.
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetUsersInfo(context.Background(), tenantId).Ids(ids).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetUsersInfo``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetUsersInfo`: PageUsersInfoResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUsersInfo`: %v\n", resp)
}

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

Obriši nedovršeni webhook događaj

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeletePendingWebhookEvent`: %v\n", resp)
}

Dohvati broj nedovršenih webhook događaja

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: GetPendingWebhookEventCountResponse

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)
	}
	// response from `GetPendingWebhookEventCount`: GetPendingWebhookEventCountResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEventCount`: %v\n", resp)
}

Dohvati nedovršene webhook događaje

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
skip	number	query	Ne

Odgovor

Vraća: GetPendingWebhookEventsResponse

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)
	}
	// odgovor iz `GetPendingWebhookEvents`: GetPendingWebhookEventsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEvents`: %v\n", resp)
}

Kreiraj konfiguraciju pitanja

Parametri

Naziv	Tip	Lokacija	Obvezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateQuestionConfigResponse

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 od `CreateQuestionConfig`: CreateQuestionConfigResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateQuestionConfig`: %v\n", resp)
}

Obriši konfiguraciju pitanja

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteQuestionConfig`: %v\n", resp)
}

Dohvati konfiguraciju pitanja

Parametri

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

Odgovor

Vraća: GetQuestionConfigResponse

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)
	}
	// odgovor iz `GetQuestionConfig`: GetQuestionConfigResponse
	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: GetQuestionConfigsResponse

Primjer

GetQuestionConfigs Primjer

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)
	}
	// response from `GetQuestionConfigs`: GetQuestionConfigsResponse
	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: APIEmptyResponse

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)
	}
	// response from `UpdateQuestionConfig`: APIEmptyResponse
	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: CreateQuestionResultResponse

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 iz `CreateQuestionResult`: CreateQuestionResultResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateQuestionResult`: %v\n", resp)
}

Obriši rezultat pitanja

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 iz `DeleteQuestionResult`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteQuestionResult`: %v\n", resp)
}

Dohvati rezultat pitanja

Parametri

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

Odgovor

Vraća: GetQuestionResultResponse

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 od `GetQuestionResult`: GetQuestionResultResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionResult`: %v\n", resp)
}

Dohvati rezultate pitanja

Parametri

Name	Type	Location	Required
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: GetQuestionResultsResponse

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 od `GetQuestionResults`: GetQuestionResultsResponse
	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: APIEmptyResponse

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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateQuestionResult`: %v\n", resp)
}

Agregiraj rezultate pitanja

Parametri

Name	Type	Location	Required
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: AggregateQuestionResultsResponse

Primjer

Primjer AggregateQuestionResults

Copy

package main
import (
	"context"
	"fmt"
	"os"
    "time"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `AggregateQuestionResults`: AggregateQuestionResultsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AggregateQuestionResults`: %v\n", resp)
}

Grupna agregacija rezultata pitanja

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da
forceRecalculate	boolean	query	Ne

Odgovor

Vraća: BulkAggregateQuestionResultsResponse

Primjer

Primjer BulkAggregateQuestionResults

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `BulkAggregateQuestionResults`: BulkAggregateQuestionResultsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.BulkAggregateQuestionResults`: %v\n", resp)
}

Kombiniraj komentare sa 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: CombineQuestionResultsWithCommentsResponse

Primjer

Primjer CombineCommentsWithQuestionResults

Copy

package main
import (
	"context"
	"fmt"
	"os"
    "time"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// response from `CombineCommentsWithQuestionResults`: CombineQuestionResultsWithCommentsResponse
	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)
}

Obriš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 emailu

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

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: GetSSOUsersResponse

Primjer

Primjer GetSSOUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// response from `GetSSOUsers`: GetSSOUsersResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSSOUsers`: %v\n", resp)
}

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

Obriš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)
}

Ažuriraj pretplatu

Parametri

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

Odgovor

Vraća: UpdateSubscriptionAPIResponse

Primjer

Primjer UpdateSubscription

Copy

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

Dohvati dnevnu upotrebu najmodavca

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: GetTenantDailyUsagesResponse

Primjer

Primjer 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)
	}
	// odgovor iz `GetTenantDailyUsages`: GetTenantDailyUsagesResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantDailyUsages`: %v\n", resp)
}

Kreiraj paket najmodavca

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantPackageResponse

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 iz `CreateTenantPackage`: CreateTenantPackageResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateTenantPackage`: %v\n", resp)
}

Obriši paket najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

Primjer brisanja paketa zakupnika

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 od `DeleteTenantPackage`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenantPackage`: %v\n", resp)
}

Dohvati paket najmodavca

Parametri

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

Odgovor

Vraća: GetTenantPackageResponse

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`: GetTenantPackageResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantPackage`: %v\n", resp)
}

Dohvati pakete najmodavca

Parametri

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

Odgovor

Vraća: GetTenantPackagesResponse

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`: GetTenantPackagesResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantPackages`: %v\n", resp)
}

Zamijeni paket najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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)
	}
	// response from `ReplaceTenantPackage`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.ReplaceTenantPackage`: %v\n", resp)
}

Ažuriraj paket najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 iz `UpdateTenantPackage`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenantPackage`: %v\n", resp)
}

Kreiraj korisnika najmodavca

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantUserResponse

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 od `CreateTenantUser`: CreateTenantUserResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateTenantUser`: %v\n", resp)
}

Obriši korisnika najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 od `DeleteTenantUser`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenantUser`: %v\n", resp)
}

Dohvati korisnika najmodavca

Parametri

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

Odgovor

Vraća: GetTenantUserResponse

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`: GetTenantUserResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantUser`: %v\n", resp)
}

Dohvati korisnike najmodavca

Parametri

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

Odgovor

Vraća: GetTenantUsersResponse

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`: GetTenantUsersResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantUsers`: %v\n", resp)
}

Zamijeni korisnika najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primjer

ReplaceTenantUser 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 | 
	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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.ReplaceTenantUser`: %v\n", resp)
}

Pošalji link za prijavu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SendLoginLink`: %v\n", resp)
}

Ažuriraj korisnika najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 iz `UpdateTenantUser`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenantUser`: %v\n", resp)
}

Kreiraj najmodavca

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantResponse

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)
	}
	// odgovor od `CreateTenant`: CreateTenantResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateTenant`: %v\n", resp)
}

Obriši najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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)
	}
	// odgovor od `DeleteTenant`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenant`: %v\n", resp)
}

Dohvati najmodavca

Parameters

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

Odgovor

Vraća: GetTenantResponse

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 iz `GetTenant`: GetTenantResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenant`: %v\n", resp)
}

Dohvati najmodavce

Parametri

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

Odgovor

Vraća: GetTenantsResponse

Primjer

Primjer GetTenants

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 od `GetTenants`: GetTenantsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenants`: %v\n", resp)
}

Ažuriraj najmodavca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

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 iz `UpdateTenant`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenant`: %v\n", resp)
}

Promijeni stanje tiketa

Parametri

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

Odgovor

Vraća: ChangeTicketStateResponse

Primjer

Primjer ChangeTicketState

Copy

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

Kreiraj tiketu

Parametri

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

Odgovor

Vraća: CreateTicketResponse

Primjer

Primjer CreateTicket

Copy

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

Dohvati tiketu

Parametri

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

Odgovor

Vraća: GetTicketResponse

Primjer

Primjer GetTicket

Copy

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

Dohvati tikete

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
userId	string	query	Ne
state	number	query	Ne
skip	number	query	Ne
limit	number	query	Ne

Odgovor

Vraća: GetTicketsResponse

Primjer

Primjer GetTickets

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)
	state := float64(1.2) // float64 |  (neobavezno)
	skip := float64(1.2) // float64 |  (neobavezno)
	limit := float64(1.2) // float64 |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.GetTickets(context.Background()).TenantId(tenantId).UserId(userId).State(state).Skip(skip).Limit(limit).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTickets``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `GetTickets`: GetTicketsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTickets`: %v\n", resp)
}

Dohvati prijevode

Parametri

Name	Type	Location	Required
namespace	string	path	Da
component	string	path	Da
locale	string	query	Ne
useFullTranslationIds	boolean	query	Ne

Odgovor

Vraća: GetTranslationsResponse

Primjer

Primjer GetTranslations

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	namespace := "namespace_example" // string | 
	component := "component_example" // string | 
	locale := "locale_example" // string |  (neobavezno)
	useFullTranslationIds := true // bool |  (neobavezno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.GetTranslations(context.Background(), namespace, component).Locale(locale).UseFullTranslationIds(useFullTranslationIds).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetTranslations``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetTranslations`: GetTranslationsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetTranslations`: %v\n", resp)
}

Učitaj 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

Parametri

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

Odgovor

Vraća: APIGetUserBadgeProgressResponse

Primjer

Primjer GetUserBadgeProgressById

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.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 od `GetUserBadgeProgressById`: APIGetUserBadgeProgressResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressById`: %v\n", resp)
}

Dohvati napredak značke korisnika po korisničkom ID

Parametri

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

Odgovor

Vraća: APIGetUserBadgeProgressResponse

Primjer

Primjer GetUserBadgeProgressByUserId

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: APIGetUserBadgeProgressResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressByUserId`: %v\n", resp)
}

Dohvati popis napretka značaka 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: APIGetUserBadgeProgressListResponse

Primjer

Primjer GetUserBadgeProgressList

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)
	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 od `GetUserBadgeProgressList`: APIGetUserBadgeProgressListResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressList`: %v\n", resp)
}

Kreiraj korisničku značku

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: APICreateUserBadgeResponse

Primjer

Primjer CreateUserBadge

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// odgovor iz `CreateUserBadge`: APICreateUserBadgeResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateUserBadge`: %v\n", resp)
}

Obriši korisničku značku

Parametri

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

Odgovor

Vraća: APIEmptySuccessResponse

Primjer

Primjer DeleteUserBadge

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.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 iz `DeleteUserBadge`: APIEmptySuccessResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteUserBadge`: %v\n", resp)
}

Dohvati korisničku značku

Parametri

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

Odgovor

Vraća: APIGetUserBadgeResponse

Primjer

Primjer GetUserBadge

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.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`: APIGetUserBadgeResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadge`: %v\n", resp)
}

Dohvati korisničke značke

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: APIGetUserBadgesResponse

Primjer

Primjer GetUserBadges

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)
	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 iz `GetUserBadges`: APIGetUserBadgesResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadges`: %v\n", resp)
}

Ažuriraj korisničku značku

Parametri

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

Odgovor

Vraća: APIEmptySuccessResponse

Primjer

Primjer UpdateUserBadge

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 iz `UpdateUserBadge`: APIEmptySuccessResponse
	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: GetUserNotificationCountResponse

Primjer

Primjer GetUserNotificationCount

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: GetUserNotificationCountResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotificationCount`: %v\n", resp)
}

Dohvati obavijesti korisnika

Parametri

Name	Type	Location	Obavezno	Opis
tenantId	string	query	Da
urlId	string	query	Ne	Koristi se za određivanje je li trenutna stranica pretplaćena.
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
includeTenantNotifications	boolean	query	Ne
sso	string	query	Ne

Odgovor

Vraća: GetMyNotificationsResponse

Primjer

Primjer GetUserNotifications

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | Koristi se za određivanje je li trenutna stranica pretplaćena. (neobavezno)
	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)
	includeTenantNotifications := 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).UrlId(urlId).PageSize(pageSize).AfterId(afterId).IncludeContext(includeContext).AfterCreatedAt(afterCreatedAt).UnreadOnly(unreadOnly).DmOnly(dmOnly).NoDm(noDm).IncludeTranslations(includeTranslations).IncludeTenantNotifications(includeTenantNotifications).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)
	}
	// odgovor iz `GetUserNotifications`: GetMyNotificationsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotifications`: %v\n", resp)
}

Resetiraj broj obavijesti korisnika

Parametri

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

Odgovor

Vraća: ResetUserNotificationsResponse

Primjer

Primjer ResetUserNotificationCount

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// odgovor od `ResetUserNotificationCount`: ResetUserNotificationsResponse
	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: ResetUserNotificationsResponse

Primjer

ResetUserNotifications Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: ResetUserNotificationsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ResetUserNotifications`: %v\n", resp)
}

Ažuriraj status pretplate na komentare obavijesti korisnika

Omogućite ili onemogućite obavijesti za određeni komentar.

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: UpdateUserNotificationCommentSubscriptionStatusResponse

Primjer

Primjer UpdateUserNotificationCommentSubscriptionStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `UpdateUserNotificationCommentSubscriptionStatus`: UpdateUserNotificationCommentSubscriptionStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationCommentSubscriptionStatus`: %v\n", resp)
}

Ažuriraj status pretplate na stranice obavijesti korisnika

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

Parametri

Ime	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: UpdateUserNotificationPageSubscriptionStatusResponse

Primjer

UpdateUserNotificationPageSubscriptionStatus Primjer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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)
	}
	// response from `UpdateUserNotificationPageSubscriptionStatus`: UpdateUserNotificationPageSubscriptionStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationPageSubscriptionStatus`: %v\n", resp)
}

Ažuriraj status obavijesti korisnika

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
notificationId	string	path	Da
newStatus	string	path	Da
sso	string	query	Ne

Odgovor

Vraća: UpdateUserNotificationStatusResponse

Primjer

Primjer UpdateUserNotificationStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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 od `UpdateUserNotificationStatus`: UpdateUserNotificationStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationStatus`: %v\n", resp)
}

Dohvati status prisustva korisnika

Parametri

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

Odgovor

Vraća: GetUserPresenceStatusesResponse

Primjer

Primjer GetUserPresenceStatuses

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/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`: GetUserPresenceStatusesResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserPresenceStatuses`: %v\n", resp)
}

Pretraži korisnike

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
urlId	string	query	Da
usernameStartsWith	string	query	Ne
mentionGroupIds	array	query	Ne
sso	string	query	Ne
searchSection	string	query	Ne

Odgovor

Vraća: SearchUsersResult

Primjer

Primjer SearchUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	usernameStartsWith := "usernameStartsWith_example" // string |  (neobavezno)
	mentionGroupIds := []string{"Inner_example"} // []string |  (neobavezno)
	sso := "sso_example" // string |  (neobavezno)
	searchSection := "searchSection_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).SearchSection(searchSection).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)
	}
	// response from `SearchUsers`: SearchUsersResult
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SearchUsers`: %v\n", resp)
}

Dohvati korisnika

Parametri

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

Odgovor

Vraća: GetUserResponse

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`: GetUserResponse
	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: VoteResponse

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 |  (neobvezno)
	anonUserId := "anonUserId_example" // string |  (neobvezno)
	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 iz `CreateVote`: VoteResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateVote`: %v\n", resp)
}

Obriši glas

Parametri

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

Odgovor

Vraća: VoteDeleteResponse

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`: VoteDeleteResponse
	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: GetVotesResponse

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)
	}
	// odgovor iz `GetVotes`: GetVotesResponse
	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: GetVotesForUserResponse

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 |  (neobavezno)
	anonUserId := "anonUserId_example" // string |  (neobavezno)
	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`: GetVotesForUserResponse
	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

Dokumentacija

Početak

Upotreba

Agregacija

Audit zapisi

Autentikacija

Blokiranje iz komentara

Provjeri blokirane komentare

Komentari

Komentari za korisnika

Konfiguracije domena

Email predlošci

Dnevnik događaja

Objave u feedu

Označi komentar

Gifovi

Hashtagovi

Moderacija

Moderatori

Broj obavijesti

Obavijesti

Reakcije na stranicu

Stranice

Nedovršeni webhook događaji

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

SSO korisnici

Pretplate

Dnevna upotreba najmodavca

Paketi najmodavca

Korisnici najmodavca

Najmodavci

Tiketi

Prijevodi

Učitaj sliku

Napredak korisničkih značaka

Korisničke značke

Obavijesti korisnika

Status prisustva korisnika

Pretraga korisnika

Korisnici

Glasovi

FastComments Go SDK

Repozitorij

AI programski agenti

Instalacija

Korištenje API klijenta

Javni API (Bez autentifikacije)

Zadani API (Zahtijeva API ključ)

Moderacijski API (Nadzorna ploča moderatora)

Upotreba

Jednostavni SSO

Sigurni SSO

Agregacija

Parametri

Odgovor

Primjer

Dohvati audit zapise

Parametri

Odgovor

Primjer

Odjava javna

Odgovor

Primjer

Blokiraj iz komentara (javno)

Parametri

Odgovor

Primjer

Odblokiraj komentar (javno)

Parametri

Odgovor

Primjer

Provjereni komentari za blokirane

Parametri

Odgovor

Primjer

Blokiraj korisnika iz komentara

Parametri