FastComments Go SDK

Ovo je zvanični Go SDK za FastComments.

Zvanični Go SDK za FastComments API

Repozitorijum

Instalacija

go get github.com/fastcomments/fastcomments-go

Korišćenje API klijenta

Javni API (Bez autentifikacije)

PublicAPI omogućava neautentifikovan pristup javnim krajnjim tačkama:

package main

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

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

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

Podrazumevani API (Zahteva API ključ)

DefaultAPI zahteva autentifikaciju korišćenjem vašeg API ključa:

package main

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

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

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

    // Preuzmi komentare koristeći autentifikovani 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)
}

Moderacioni API (Moderator kontrolna tabla)

ModerationAPI pruža opsežan skup live i brzih moderacionih API-ja. Sve metode moderacije prihvataju sso parametar i mogu se autentifikovati putem SSO‑a ili FastComments.com sesijske kolačiće:

package main

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

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

    // Navedi komentare za moderaciju 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

Jednostavan SSO

package main

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

func main() {
    // Kreiraj Simple 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)

    // Iskoristi SSO token za autentifikovani 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)
}

Siguran SSO

package main

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

func main() {
    // Kreiraj Secure 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)

    // Iskoristi SSO token za autentifikovani 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)
}

Agregat

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

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
parentTenantId	string	query	No
includeStats	boolean	query	No

Odgovor

Vraća: AggregateResponse

Primer

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

DohvatiAuditLogove

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

Primer

Primer 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 |  (opciono)
	skip := float64(1.2) // float64 |  (opciono)
	order := openapiclient.SORT_DIR("ASC") // SORTDIR |  (opciono)
	after := float64(1.2) // float64 |  (opciono)
	before := float64(1.2) // float64 |  (opciono)
	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)
}

OdjavaJavni

Odgovor

Vraća: APIEmptyResponse

Primer

Primer za LogoutPublic

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

BlokirajIzKomentaraJavno

Parametri

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

Odgovor

Vraća: BlockSuccess

Primer

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

DeblokirajKomentarJavno

Parametri

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

Odgovor

Vraća: UnblockSuccess

Primer

Primer UnBlockCommentPublic

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 |  (opciono)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.PublicAPI.UnBlockCommentPublic(context.Background(), commentId).TenantId(tenantId).PublicBlockFromCommentParams(publicBlockFromCommentParams).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UnBlockCommentPublic``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `UnBlockCommentPublic`: UnblockSuccess
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnBlockCommentPublic`: %v\n", resp)
}

ProvereniKomentariZaBlokirane

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Yes
commentIds	string	query	Yes	Lista ID-jeva komentara razdvojenih zarezom.
sso	string	query	No

Odgovor

Vraća: CheckBlockedCommentsResponse

Primer

Primer 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 | Lista ID-jeva komentara razdvojenih 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)
}

BlokirajKorisnikaIzKomentara

Parametri

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

Odgovor

Vraća: BlockSuccess

Primer

Primer 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 |  (opciono)
	anonUserId := "anonUserId_example" // string |  (opciono)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.BlockUserFromComment(context.Background(), id).TenantId(tenantId).BlockFromCommentParams(blockFromCommentParams).UserId(userId).AnonUserId(anonUserId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.BlockUserFromComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `BlockUserFromComment`: BlockSuccess
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.BlockUserFromComment`: %v\n", resp)
}

KreirajKomentarJavno

Parametri

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

Odgovor

Vraća: SaveCommentsResponseWithPresence

Primer

Primer CreateCommentPublic

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šiKomentar

Parametri

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

Odgovor

Vraća: DeleteCommentResult

Primer

Primer DeleteComment

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 |  (opciono)
	isLive := true // bool |  (opciono)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.DeleteComment(context.Background(), id).TenantId(tenantId).ContextUserId(contextUserId).IsLive(isLive).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `DeleteComment`: DeleteCommentResult
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteComment`: %v\n", resp)
}

ObrišiKomentarJavno

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

Primer

Primer 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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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šiGlasZaKomentar

Parametri

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

Odgovor

Vraća: VoteDeleteResponse

Primer

Primer 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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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čiKomentar

Parametri

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

Odgovor

Vraća: FlagCommentResponse

Primer

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

DohvatiKomentar

Parametri

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

Odgovor

Vraća: APIGetCommentResponse

Primer

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

DohvatiKomentare

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

Primer

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

DohvatiKomentareJavno

req tenantId urlId

Parametri

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

Odgovor

Vraća: GetCommentsResponseWithPresencePublicComment

Primer

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

DohvatiTekstKomentara

Parametri

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

Response

Vraća: PublicAPIGetCommentTextResponse

Primer

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

DohvatiImenaKorisnikaGlasaliZaKomentar

Parametri

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

Odgovor

Vraća: GetCommentVoteUserNamesSuccessResponse

Primer

Primer za GetCommentVoteUserNames

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

ZaključaKomentar

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

Primer

Primer LockComment poziva

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

PrikvačiKomentar

Parametri

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

Odgovor

Vraća: ChangeCommentPinStatusResponse

Primer

Primer 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 |  (opciono)
	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)
	}
	// response from `PinComment`: ChangeCommentPinStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.PinComment`: %v\n", resp)
}

SačuvajKomentar

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

Primer

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

SačuvajVišeKomentara

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
isLive	boolean	query	No
doSpamCheck	boolean	query	No
sendEmails	boolean	query	No
populateNotifications	boolean	query	No

Odgovor

Vraća: []SaveCommentsBulkResponse

Primer

Primer 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 |  (opciono)
	doSpamCheck := true // bool |  (opciono)
	sendEmails := true // bool |  (opciono)
	populateNotifications := true // bool |  (opciono)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.SaveCommentsBulk(context.Background()).TenantId(tenantId).CreateCommentParams(createCommentParams).IsLive(isLive).DoSpamCheck(doSpamCheck).SendEmails(sendEmails).PopulateNotifications(populateNotifications).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.SaveCommentsBulk``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `SaveCommentsBulk`: []SaveCommentsBulkResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveCommentsBulk`: %v\n", resp)
}

PostaviTekstKomentara

Parametri

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

Odgovor

Vraća: PublicAPISetCommentTextResponse

Primer

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

DeblokirajKorisnikaIzKomentara

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

Primer

Primer UnBlockUserFromComment

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

UkloniOznakuKomentara

Parametri

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

Odgovor

Vraća: FlagCommentResponse

Primer

Primer 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čajKomentar

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

OtkačiKomentar

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

Primer

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

AžurirajKomentar

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

Primer

Primer UpdateComment

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 |  (opciono)
	doSpamCheck := true // bool |  (opciono)
	isLive := true // bool |  (opciono)
	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 od `UpdateComment`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateComment`: %v\n", resp)
}

GlasajZaKomentar

Parametri

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

Odgovor

Vraća: VoteResponse

Primer

Primer glasanja komentara

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

DohvatiKomentareZaKorisnika

Parametri

Ime	Tip	Lokacija	Obavezno
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

Primer

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

DodajDomainKonfiguraciju

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: AddDomainConfigResponse

Primer

Primer 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šiDomainKonfiguraciju

Parametri

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

Odgovor

Vraća: DeleteDomainConfigResponse

Primer

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

DohvatiDomainKonfiguraciju

Parametri

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

Odgovor

Vraća: GetDomainConfigResponse

Primer

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

DohvatiDomainKonfiguracije

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetDomainConfigsResponse

Primer

Primer 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žurirajDomainKonfiguraciju

Parametri

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

Odgovor

Vraća: PatchDomainConfigResponse

Primer

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

PostaviDomainKonfiguraciju

Parametri

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

Odgovor

Vraća: PutDomainConfigResponse

Primer

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

KreirajEmailŠablon

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateEmailTemplateResponse

Primer

Primer 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šiEmailŠablon

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer DeleteEmailTemplate

Copy

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

ObrišiGreškuRenderovanjaEmailŠablona

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

DohvatiEmailŠablon

Parametri

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

Odgovor

Vraća: GetEmailTemplateResponse

Primer

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

DohvatiDefinicijeEmailŠablona

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetEmailTemplateDefinitionsResponse

Primer

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

DohvatiGreškeRenderovanjaEmailŠablona

Parametri

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

Odgovor

Vraća: GetEmailTemplateRenderErrorsResponse

Primer

Primer 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 |  (opciono)
	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)
}

DohvatiEmailŠablone

Parametri

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

Odgovor

Vraća: GetEmailTemplatesResponse

Primer

Primer GetEmailTemplates

Copy

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

RenderujEmailŠablon

Parametri

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

Odgovor

Vraća: RenderEmailTemplateResponse

Primer

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

AžurirajEmailŠablon

Parameters

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer UpdateEmailTemplate

Copy

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

DohvatiDnevnikDogadjaja

req tenantId urlId userIdWS

Parametri

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

Odgovor

Vraća: GetEventLogResponse

Primer

Primer GetEventLog

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

DohvatiGlobalniDnevnikDogadjaja

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

Primer

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

KreirajFeedObjavu

Parametri

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

Odgovor

Vraća: CreateFeedPostsResponse

Primer

Primer CreateFeedPost

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

KreirajFeedObjavuJavno

Parametri

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

Odgovor

Vraća: CreateFeedPostResponse

Primer

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

ObrišiFeedObjavuJavno

Parametri

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

Odgovor

Vraća: DeleteFeedPostPublicResponse

Primer

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

DohvatiFeedObjave

zahtev tenantId afterId

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
afterId	string	query	Ne
limit	integer	query	Ne
tags	array	query	Ne

Odgovor

Vraća: GetFeedPostsResponse

Primer

Primer 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 |  (opciono)
	limit := int32(56) // int32 |  (opciono)
	tags := []string{"Inner_example"} // []string |  (opciono)
	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)
}

DohvatiFeedObjaveJavno

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

Primer

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

DohvatiStatistikuFeedObjava

Parametri

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

Odgovor

Vraća: FeedPostsStatsResponse

Primer

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

DohvatiReakcijeKorisnikaJavno

Parametri

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

Odgovor

Vraća: UserReactsResponse

Primer

GetUserReactsPublic Primer

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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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 od `GetUserReactsPublic`: UserReactsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserReactsPublic`: %v\n", resp)
}

ReagujNaFeedObjavuJavno

Parametri

Name	Type	Location	Required
tenantId	string	path	Da
postId	string	path	Da
isUndo	boolean	query	Ne
broadcastId	string	query	Ne
sso	string	query	Ne

Odgovor

Vraća: ReactFeedPostResponse

Primer

Primer 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žurirajFeedObjavu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

AžurirajFeedObjavuJavno

Parametri

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

Odgovor

Vraća: CreateFeedPostResponse

Primer

Primer 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čiKomentarJavno

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

DohvatiVelikiGif

Parametri

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

Odgovor

Vraća: GifGetLargeResponse

Primer

GetGifLarge Primer

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

PretragaGifova

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

Primer

Primer 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 |  (opciono)
	rating := "rating_example" // string |  (opciono)
	page := float64(1.2) // float64 |  (opciono)
	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)
}

DohvatiPopularneGifove

Parametri

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

Odgovor

Vraća: GetGifsTrendingResponse

Primer

Primer za 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 od `GetGifsTrending`: GetGifsTrendingResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetGifsTrending`: %v\n", resp)
}

DodajHashTag

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateHashTagResponse

Primer

AddHashTag Primer

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

MasovnoDodavanjeHashTagova

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Yes

Odgovor

Vraća: BulkCreateHashTagsResponse

Primer

AddHashTagsBulk Primer

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

ObrišiHashTag

Parameters

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

Response

Returns: APIEmptyResponse

Example

DeleteHashTag Primer

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

DohvatiHashTagove

Parametri

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

Odgovor

Vraća: GetHashTagsResponse

Primer

Primer GetHashTags

Copy

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

AžurirajHashTag

Parametri

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

Odgovor

Vraća: UpdateHashTagResponse

Primer

Primer PatchHashTag

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 pri pozivanju `DefaultAPI.PatchHashTag``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PatchHashTag`: UpdateHashTagResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `DefaultAPI.PatchHashTag`: %v\n", resp)
}

ObrišiModeracioniGlas

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

Primer

Primer 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 |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	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, "Greška pri pozivanju `ModerationAPI.DeleteModerationVote``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor iz `DeleteModerationVote`: VoteDeleteResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.DeleteModerationVote`: %v\n", resp)
}

DohvatiApiKomentare

Parametri

Ime	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

Primer

GetApiComments Primer

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 |  (optional)
	count := float64(1.2) // float64 |  (optional)
	textSearch := "textSearch_example" // string |  (optional)
	byIPFromComment := "byIPFromComment_example" // string |  (optional)
	filters := "filters_example" // string |  (optional)
	searchFilters := "searchFilters_example" // string |  (optional)
	sorts := "sorts_example" // string |  (optional)
	demo := true // bool |  (optional)
	sso := "sso_example" // string |  (optional)
	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, "Greška pri pozivanju `ModerationAPI.GetApiComments``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Ceo HTTP odgovor: %v\n", r)
	}
	// odgovor od `GetApiComments`: ModerationAPIGetCommentsResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.GetApiComments`: %v\n", resp)
}

DohvatiStatusApiEksporta

Parameters

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

Odgovor

Vraća: ModerationExportStatusResponse

Primer

GetApiExportStatus Primer

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 pozivanju `ModerationAPI.GetApiExportStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `GetApiExportStatus`: ModerationExportStatusResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.GetApiExportStatus`: %v\n", resp)
}

DohvatiApiIdije

Parametri

Ime	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

Primer

GetApiIds Primer

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)
	afterId := "afterId_example" // string |  (opcionalno)
	demo := true // bool |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	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(sso).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 od `GetApiIds`: ModerationAPIGetCommentIdsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetApiIds`: %v\n", resp)
}

DohvatiBlokiraneKorisnikeIzKomentara

Parametri

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

Odgovor

Vraća: GetBannedUsersFromCommentResponse

Primer

Primer GetBanUsersFromComment

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

DohvatiStatusBlokadeKomentara

Parametri

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

Odgovor

Vraća: GetCommentBanStatusResponse

Primer

GetCommentBanStatus Primer

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

DohvatiDetuKomentara

Parametri

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

Odgovor

Vraća: ModerationAPIChildCommentsResponse

Primer

Primer GetCommentChildren

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, "Error when calling `ModerationAPI.GetCommentChildren``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetCommentChildren`: ModerationAPIChildCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetCommentChildren`: %v\n", resp)
}

DohvatiBroj

Parameters

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

Response

Vraća: ModerationAPICountCommentsResponse

Example

Primer GetCount

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

DohvatiBrojeve

Parameters

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

Response

Vraća: GetBannedUsersCountResponse

Example

Primer 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 |  (opcionalno)
	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)
}

DohvatiLogove

Parametri

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

Odgovor

Vraća: ModerationAPIGetLogsResponse

Primer

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

DohvatiRučnoDodeljeneBedževe

Parametri

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

Odgovor

Vraća: GetTenantManualBadgesResponse

Primer

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

DohvatiRučnoDodeljeneBedževeZaKorisnika

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

Primer

GetManualBadgesForUser Primer

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

DohvatiModeracioniKomentar

Parametri

Naziv	Tip	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

Primer

GetModerationComment Primer

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, "Greška prilikom pozivanja `ModerationAPI.GetModerationComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Pun HTTP odgovor: %v\n", r)
	}
	// odgovor od `GetModerationComment`: ModerationAPICommentResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.GetModerationComment`: %v\n", resp)
}

DohvatiModeracioniTekstKomentara

Parametri

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

Odgovor

Vraća: GetCommentTextResponse

Primer

Primer GetModerationCommentText

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

DohvatiPreBanRezime

Parametri

Naziv	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

Primer

Primer GetPreBanSummary

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, "Error when calling `ModerationAPI.GetPreBanSummary``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetPreBanSummary`: PreBanSummary
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetPreBanSummary`: %v\n", resp)
}

DohvatiRezimePretrageKomentara

Parametri

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

Odgovor

Vraća: ModerationCommentSearchResponse

Primer

GetSearchCommentsSummary Primer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	value := "value_example" // string |  (opciono)
	filters := "filters_example" // string |  (opciono)
	searchFilters := "searchFilters_example" // string |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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 od `GetSearchCommentsSummary`: ModerationCommentSearchResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetSearchCommentsSummary`: %v\n", resp)
}

DohvatiPretrageStranica

Parametri

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

Odgovor

Vraća: ModerationPageSearchResponse

Primer

Primer 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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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)
}

DohvatiPretrageSajtova

Parametri

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

Odgovor

Vraća: ModerationSiteSearchResponse

Primer

GetSearchSites Primer

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, "Greška prilikom poziva `ModerationAPI.GetSearchSites``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `GetSearchSites`: ModerationSiteSearchResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.GetSearchSites`: %v\n", resp)
}

DohvatiPretraguSugestija

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
text-search	string	query	No
sso	string	query	No

Odgovor

Vraća: ModerationSuggestResponse

Primer

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

DohvatiPretraguKorisnika

Parametri

Ime	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
value	string	query	No
sso	string	query	No

Odgovor

Returns: ModerationUserSearchResponse

Primer

GetSearchUsers Primer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	value := "value_example" // string |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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)
}

DohvatiFaktorPoverenja

Parameters

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

Response

Returns: GetUserTrustFactorResponse

Example

Primer 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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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)
}

DohvatiPodešavanjaBanovanjaKorisnika

Parametri

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

Odgovor

Vraća: APIModerateGetUserBanPreferencesResponse

Primer

GetUserBanPreference Primer

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	sso := "sso_example" // string |  (opciono)
	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 iz `GetUserBanPreference`: APIModerateGetUserBanPreferencesResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.GetUserBanPreference`: %v\n", resp)
}

DohvatiInterniProfilKorisnika

Parametri

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

Odgovor

Vraća: GetUserInternalProfileResponse

Primer

GetUserInternalProfile Primer

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(smo).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)
}

PrilagodiGlasoveZaKomentare

Parameters

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

Response

Vraća: AdjustVotesResponse

Primer

Primer PostAdjustCommentVotes

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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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 od `PostAdjustCommentVotes`: AdjustVotesResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostAdjustCommentVotes`: %v\n", resp)
}

ApiEksport

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

Primer

Primer 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 |  (optional)
	byIPFromComment := "byIPFromComment_example" // string |  (optional)
	filters := "filters_example" // string |  (optional)
	searchFilters := "searchFilters_example" // string |  (optional)
	sorts := "sorts_example" // string |  (optional)
	sso := "sso_example" // string |  (optional)
	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 od `PostApiExport`: ModerationExportResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostApiExport`: %v\n", resp)
}

BanujKorisnikaIzKomentara

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

Primer

PostBanUserFromComment Primer

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 |  (opciono)
	banEmailDomain := true // bool |  (opciono)
	banIP := true // bool |  (opciono)
	deleteAllUsersComments := true // bool |  (opciono)
	bannedUntil := "bannedUntil_example" // string |  (opciono)
	isShadowBan := true // bool |  (opciono)
	updateId := "updateId_example" // string |  (opciono)
	banReason := "banReason_example" // string |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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, "Greška pri pozivu `ModerationAPI.PostBanUserFromComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostBanUserFromComment`: BanUserFromCommentResult
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostBanUserFromComment`: %v\n", resp)
}

PoništiBanovanjeKorisnika

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

PostBanUserUndo Primer

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 |  (opciono)
	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, "Greška pri pozivanju `ModerationAPI.PostBanUserUndo``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostBanUserUndo`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Odgovor iz `ModerationAPI.PostBanUserUndo`: %v\n", resp)
}

MasovniPreBanRezime

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

Primer

PostBulkPreBanSummary Primer

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 |  (optional)
	includeByIP := true // bool |  (optional)
	includeByEmailDomain := true // bool |  (optional)
	sso := "sso_example" // string |  (optional)
	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)
	}
	// odgovor od `PostBulkPreBanSummary`: BulkPreBanSummary
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostBulkPreBanSummary`: %v\n", resp)
}

KomentariPoIdJevima

Parametri

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

Odgovor

Vraća: ModerationAPIChildCommentsResponse

Primer

PostCommentsByIds Primer

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 |  (opciono)
	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, "Error when calling `ModerationAPI.PostCommentsByIds``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `PostCommentsByIds`: ModerationAPIChildCommentsResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostCommentsByIds`: %v\n", resp)
}

OznačiKomentarModeracija

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

PostFlagComment Primer

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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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, "Error when calling `ModerationAPI.PostFlagComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `PostFlagComment`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostFlagComment`: %v\n", resp)
}

UkloniKomentar

Parametri

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

Odgovor

Vraća: PostRemoveCommentApiResponse

Primer

PostRemoveComment Primer

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.PostRemoveComment(context.Background(), commentId).TenantId(tenantId).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `ModerationAPI.PostRemoveComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `PostRemoveComment`: PostRemoveCommentApiResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostRemoveComment`: %v\n", resp)
}

PovratiObrisaniKomentar

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

PostRestoreDeletedComment Primer

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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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, "Greška prilikom poziva `ModerationAPI.PostRestoreDeletedComment``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostRestoreDeletedComment`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostRestoreDeletedComment`: %v\n", resp)
}

PostaviStatusOdobravanjaKomentara

Parameters

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

Response

Vraća: SetCommentApprovedResponse

Example

Primer PostSetCommentApprovalStatus

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, "Greška prilikom pozivanja `ModerationAPI.PostSetCommentApprovalStatus``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Ceo HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostSetCommentApprovalStatus`: SetCommentApprovedResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostSetCommentApprovalStatus`: %v\n", resp)
}

PostaviStatusPregledaKomentara

Parameters

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

Odgovor

Vraća: APIEmptyResponse

Primer

PostSetCommentReviewStatus Primer

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 |  (opcionalno)
	broadcastId := "broadcastId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	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)
	}
	// odgovor od `PostSetCommentReviewStatus`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PostSetCommentReviewStatus`: %v\n", resp)
}

PostaviStatusSpamaKomentara

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

PostSetCommentSpamStatus Primer

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

PostaviTekstKomentaraModeracija

Parameters

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

Response

Vraća: SetCommentTextResponse

Example

Primer PostSetCommentText

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 |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PostSetCommentText`: SetCommentTextResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PostSetCommentText`: %v\n", resp)
}

PoništiOznakuKomentaraModeracija

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

PostUnFlagComment Primer

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

GlasajModeracija

Parametri

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

Odgovor

Returns: VoteResponse

Primer

PostVote Primer

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 |  (opcionalno)
	broadcastId := "broadcastId_example" // string |  (opcionalno)
	sso := "sso_example" // string |  (opcionalno)
	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)
}

DodeliBedž

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

Primer

PutAwardBadge Primer

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

ZatvoriTemu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer PutCloseThread

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 |  (opcionalno)
	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, "Error when calling `ModerationAPI.PutCloseThread``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor iz `PutCloseThread`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `ModerationAPI.PutCloseThread`: %v\n", resp)
}

UkloniBedž

Parametri

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

Primer

PutRemoveBadge Primer

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.PutRemoveBadge(context.Background()).TenantId(tenantId).BadgeId(badgeId).UserId(userId).CommentId(commentId).BroadcastId(broadcastId).Sso(sso).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Greška pri pozivu `ModerationAPI.PutRemoveBadge``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Ceo HTTP odgovor: %v\n", r)
	}
	// response from `PutRemoveBadge`: RemoveUserBadgeResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PutRemoveBadge`: %v\n", resp)
}

PonovoOtvoriTemu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

PutReopenThread Primer

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 |  (opcionalno)
	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, "Greška prilikom pozivanja `ModerationAPI.PutReopenThread``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Puni HTTP odgovor: %v\n", r)
	}
	// odgovor od `PutReopenThread`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Odgovor od `ModerationAPI.PutReopenThread`: %v\n", resp)
}

PostaviFaktorPoverenja

Parametri

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

Odgovor

Vraća: SetUserTrustFactorResponse

Primer

Primer SetTrustFactor

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

KreirajModeratora

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateModeratorResponse

Primer

Primer CreateModerator

Copy

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

ObrišiModeratora

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer brisanja moderatora

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

DohvatiModeratora

Parametri

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

Odgovor

Vraća: GetModeratorResponse

Primer

Primer GetModerator

Copy

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

DohvatiModeratore

Parametri

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

Odgovor

Vraća: GetModeratorsResponse

Primer

GetModerators Primer

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 |  (opciono)
	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šaljiPozivnicu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer slanja pozivnice

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žurirajModeratora

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer UpdateModerator

Copy

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

ObrišiBrojNotifikacija

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

DohvatiKeširaniBrojNotifikacija

Parametri

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

Odgovor

Vraća: GetCachedNotificationCountResponse

Primer

Primer GetCachedNotificationCount

Copy

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

DohvatiBrojNotifikacija

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

Primer

GetNotificationCount Primer

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

DohvatiNotifikacije

Parametri

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

Odgovor

Vraća: GetNotificationsResponse

Primer

Primer 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 |  (opciono)
	urlId := "urlId_example" // string |  (opciono)
	fromCommentId := "fromCommentId_example" // string |  (opciono)
	viewed := true // bool |  (opciono)
	type_ := "type__example" // string |  (opciono)
	skip := float64(1.2) // float64 |  (opciono)
	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žurirajNotifikaciju

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

KreirajV1ReakcijuStranice

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	path	Da
urlId	string	query	Da
title	string	query	Ne

Odgovor

Vraća: CreateV1PageReact

Primer

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

KreirajV2ReakcijuStranice

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

Primer

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

ObrišiV1ReakcijuStranice

Parametri

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

Odgovor

Vraća: CreateV1PageReact

Primer

DeleteV1PageReact Primer

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

ObrišiV2ReakcijuStranice

Parametri

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

Odgovor

Vraća: CreateV1PageReact

Primer

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

DohvatiV1StranicaLajkove

Parametri

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

Vraća

Vraća: GetV1PageLikes

Primer

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

DohvatiV2ReakcijeStranice

Parametri

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

Odgovor

Vraća: GetV2PageReacts

Primer

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

DohvatiV2KorisnikeReakcijeStranice

Parametri

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

Odgovor

Vraća: GetV2PageReactUsersResponse

Primer

GetV2PageReactUsers Primer

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

DodajStranicu

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: AddPageAPIResponse

Primer

Primer 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šiStranicu

Parametri

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

Odgovor

Vraća: DeletePageAPIResponse

Primer

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

DohvatiOfflineKorisnike

Prethodni komentatori na stranici koji trenutno NISU online. Sortirano po displayName. Koristite ovo nakon što iscrpite /users/online da biste prikazali sekciju "Members". Kursor-paginacija po commenterName: server prolazi delimični {tenantId, urlId, commenterName} indeks od afterName unapred preko $gt, bez troška $skip.

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Da
urlId	string	query	Da	Identifikator URL stranice (očišćen na serverskoj strani).
afterName	string	query	Ne	Kursor: prosledite nextAfterName iz prethodnog odgovora.
afterUserId	string	query	Ne	Kursor za razrešavanje izjednačenja: prosledite nextAfterUserId iz prethodnog odgovora. Obavezno kada je afterName postavljen kako unosi sa istim imenom ne bi bili izostavljeni.

Odgovor

Vraća: PageUsersOfflineResponse

Primer

Primer 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 stranice (očišćen na serverskoj strani).
	afterName := "afterName_example" // string | Kursor: prosledite nextAfterName iz prethodnog odgovora. (opciono)
	afterUserId := "afterUserId_example" // string | Kursor za razrešavanje izjednačenja: prosledite nextAfterUserId iz prethodnog odgovora. Obavezno kada je afterName postavljen kako unosi sa istim imenom ne bi bili izostavljeni. (opciono)
	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)
	}
	// response from `GetOfflineUsers`: PageUsersOfflineResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetOfflineUsers`: %v\n", resp)
}

DohvatiOnlineKorisnike

Trenutno online gledaoci stranice: osobe čija je websocket sesija trenutno pretplaćena na stranicu. Vraća anonCount + totalCount (pretplatnici u okviru sobe, uključujući anonimne posetioce koje ne nabrajamo).

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	path	Da
urlId	string	query	Da	Identifikator URL stranice (očišćen na serverskoj strani).
afterName	string	query	Ne	Kursor: pošaljite nextAfterName iz prethodnog odgovora.
afterUserId	string	query	Ne	Kursor za razrešavanje izjednačenja: pošaljite nextAfterUserId iz prethodnog odgovora. Obavezno kada je afterName postavljen kako bi se unosi sa istim imenom ne bi izostavili.

Odgovor

Vraća: PageUsersOnlineResponse

Primer

Primer 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 stranice (očišćen na serverskoj strani).
	afterName := "afterName_example" // string | Kursor: pošaljite nextAfterName iz prethodnog odgovora. (opciono)
	afterUserId := "afterUserId_example" // string | Kursor za razrešavanje izjednačenja: pošaljite nextAfterUserId iz prethodnog odgovora. Obavezno kada je afterName postavljen kako bi se unosi sa istim imenom ne bi izostavili. (opciono)
	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)
}

DohvatiStranicuPoURLIdiju

Parametri

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

Odgovor

Vraća: GetPageByURLIdAPIResponse

Primer

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

DohvatiStranice

Parametri

Ime	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: GetPagesAPIResponse

Primer

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

DohvatiStraniceJavno

Lista stranica za tenant. Koristi se od strane FChat desktop klijenta za popunjavanje njegove liste soba. Zahteva da enableFChat bude true na razrešenom prilagođenom podešavanju za svaku stranicu. Stranice koje zahtevaju SSO filtriraju se u skladu sa pristupom grupa korisnika koji šalje zahtev.

Parametri

Name	Type	Location	Required	Description
tenantId	string	path	Yes
cursor	string	query	No	Neprozirni kursor paginacije koji se vraća kao `nextCursor` iz prethodnog zahteva. Povezan sa istim `sortBy`.
limit	integer	query	No	1..200, podrazumevano 50
q	string	query	No	Opcioni prefiks filter naslova koji nije osetljiv na veličinu slova.
sortBy	string	query	No	Redosled sortiranja. `updatedAt` (podrazumevano, najnoviji prvi), `commentCount` (najviše komentara prvi), ili `title` (alfabetički).
hasComments	boolean	query	No	Ako je true, vrati samo stranice sa najmanje jednim komentarom.

Odgovor

Vraća: GetPublicPagesResponse

Primer

Primer 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 kursor paginacije koji se vraća kao `nextCursor` iz prethodnog zahteva. Povezan sa istim `sortBy`. (optional)
	limit := int32(56) // int32 | 1..200, podrazumevano 50 (optional)
	q := "q_example" // string | Opcioni prefiks-filter naslova koji nije osetljiv na veličinu slova. (optional)
	sortBy := openapiclient.PagesSortBy("updatedAt") // PagesSortBy | Redosled sortiranja. `updatedAt` (podrazumevano, najnoviji prvi), `commentCount` (najviše komentara prvi), ili `title` (alfabetički). (optional)
	hasComments := true // bool | Ako je true, vrati samo stranice sa najmanje jednim komentarom. (optional)
	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)
	}
	// odgovor iz `GetPagesPublic`: GetPublicPagesResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetPagesPublic`: %v\n", resp)
}

DohvatiInformacijeOKorisnicima

Grupne informacije o korisnicima za tenant. Za zadate userIds, vrati prikazne informacije iz User / SSOUser. Koristi comment widget da obogati korisnike koji su se upravo pojavili putem presence događaja. Nema konteksta stranice: privatnost se primenjuje jednako (privatni profili su maskirani).

Parameters

Name	Type	Location	Required	Description
tenantId	string	path	Da
ids	string	query	Da	userIds odvojeni zarezima.

Response

Vraća: PageUsersInfoResponse

Example

Primer za 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 | userIds odvojeni zarezima.
	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 od `GetUsersInfo`: PageUsersInfoResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUsersInfo`: %v\n", resp)
}

AžurirajStranicu

Parametri

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

Odgovor

Vraća: PatchPageAPIResponse

Primer

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

ObrišiZakađenWebhookDogađaj

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

DeletePendingWebhookEvent Primer

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

DohvatiBrojZakađenihWebhookDogađ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

Primer

Primer 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 |  (opcionalno)
	externalId := "externalId_example" // string |  (opcionalno)
	eventType := "eventType_example" // string |  (opcionalno)
	type_ := "type__example" // string |  (opcionalno)
	domain := "domain_example" // string |  (opcionalno)
	attemptCountGT := float64(1.2) // float64 |  (opcionalno)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.GetPendingWebhookEventCount(context.Background()).TenantId(tenantId).CommentId(commentId).ExternalId(externalId).EventType(eventType).Type_(type_).Domain(domain).AttemptCountGT(attemptCountGT).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetPendingWebhookEventCount``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `GetPendingWebhookEventCount`: GetPendingWebhookEventCountResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEventCount`: %v\n", resp)
}

DohvatiZakađeneWebhookDogađ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

Primer

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

KreirajPitanjeKonfiguracija

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: CreateQuestionConfigResponse

Primer

Primer 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šiPitanjeKonfiguraciju

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

DohvatiPitanjeKonfiguraciju

Parametri

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

Odgovor

Vraća: GetQuestionConfigResponse

Primer

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

DohvatiPitanjaKonfiguracije

Parametri

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

Odgovor

Vraća: GetQuestionConfigsResponse

Primer

Primer GetQuestionConfigs

Copy

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

AžurirajPitanjeKonfiguraciju

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

KreirajRezultatPitanja

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateQuestionResultResponse

Primer

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

ObrišiRezultatPitanja

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer DeleteQuestionResult

Copy

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

DohvatiRezultatPitanja

Parametri

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

Odgovor

Vraća: GetQuestionResultResponse

Primer

GetQuestionResult Primer

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

DohvatiRezultatePitanja

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

Primer

Primer 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žurirajRezultatPitanja

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

AgregirajRezultatePitanja

Parametri

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

Odgovor

Vraća: AggregateQuestionResultsResponse

Primer

Primer 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 |  (opciono)
	questionIds := []string{"Inner_example"} // []string |  (opciono)
	urlId := "urlId_example" // string |  (opciono)
	timeBucket := openapiclient.AggregateTimeBucket("day") // AggregateTimeBucket |  (opciono)
	startDate := time.Now() // time.Time |  (opciono)
	forceRecalculate := true // bool |  (opciono)
	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)
	}
	// response from `AggregateQuestionResults`: AggregateQuestionResultsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AggregateQuestionResults`: %v\n", resp)
}

MasovnaAgregacijaRezultataPitanja

Parametri

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

Odgovor

Vraća: BulkAggregateQuestionResultsResponse

Primer

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

KombinujKomentareSaRezultatimaPitanja

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

Primer

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

DodajSSOKorisnika

Parameters

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Response

Vraća: AddSSOUserAPIResponse

Primer

Primer 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šiSSOKorisnika

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

Primer

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

DohvatiSSOKorisnikaPoEmailu

Parametri

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

Odgovor

Vraća: GetSSOUserByEmailAPIResponse

Primer

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

DohvatiSSOKorisnikaPoId

Parametri

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

Odgovor

Vraća: GetSSOUserByIdAPIResponse

Primer

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

DohvatiSSOKorisnike

Parametri

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

Odgovor

Vraća: GetSSOUsersResponse

Primer

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

IzmeniSSOKorisnika

Parametri

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

Odgovor

Vraća: PatchSSOUserAPIResponse

Primer

PatchSSOUser Primer

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

PostaviSSOKorisnika

Parametri

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

Odgovor

Vraća: PutSSOUserAPIResponse

Primer

PutSSOUser Primer

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

NapraviPretplatu

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateSubscriptionAPIResponse

Primer

Primer 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šiPretplatu

Parametri

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

Odgovor

Vraća: DeleteSubscriptionAPIResponse

Primer

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

DohvatiPretplate

Parametri

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

Odgovor

Vraća: GetSubscriptionsAPIResponse

Primer

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

AžurirajPretplatu

Parametri

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

Odgovor

Vraća: UpdateSubscriptionAPIResponse

Primer

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

DnevnoKorišćenjeZakupca

Parametri

Name	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

Primer

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

KreirajPaketZakupca

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantPackageResponse

Primer

Primer CreateTenantPackage

Copy

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

ObrišiPaketZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer DeleteTenantPackage

Copy

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

DohvatiPaketZakupca

Parametri

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

Odgovor

Vraća: GetTenantPackageResponse

Primer

Primer GetTenantPackage

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

DohvatiPaketeZakupca

Parametri

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

Odgovor

Vraća: GetTenantPackagesResponse

Primer

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

ZameniPaketZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer ReplaceTenantPackage

Copy

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

AžurirajPaketZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

KreirajKorisnikaZakupca

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantUserResponse

Primer

Primer 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šiKorisnikaZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

DohvatiKorisnikaZakupca

Parametri

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

Odgovor

Vraća: GetTenantUserResponse

Primer

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

DohvatiKorisnikeZakupca

Parametri

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

Odgovor

Vraća: GetTenantUsersResponse

Primer

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

ZameniKorisnikaZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer ReplaceTenantUser

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	replaceTenantUserBody := *openapiclient.NewReplaceTenantUserBody("Username_example", "Email_example") // ReplaceTenantUserBody | 
	updateComments := "updateComments_example" // string |  (opciono)
	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 od `ReplaceTenantUser`: APIEmptyResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.ReplaceTenantUser`: %v\n", resp)
}

PošaljiLinkZaPrijavu

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

AžurirajKorisnikaZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

Primer UpdateTenantUser

Copy

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

KreirajZakupca

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: CreateTenantResponse

Primer

Primer 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šiZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

DohvatiZakupca

Parametri

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

Odgovor

Vraća: GetTenantResponse

Primer

Primer GetTenant

Copy

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

DohvatiZakupce

Parametri

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

Odgovor

Vraća: GetTenantsResponse

Primer

Primer 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 |  (opciono)
	skip := float64(1.2) // float64 |  (opciono)
	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žurirajZakupca

Parametri

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

Odgovor

Vraća: APIEmptyResponse

Primer

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

PromeniStatusTiketa

Parametri

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

Odgovor

Vraća: ChangeTicketStateResponse

Primer

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

KreirajTiket

Parametri

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

Odgovor

Vraća: CreateTicketResponse

Primer

Primer CreateTicket zahteva

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

DohvatiTiket

Parametri

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

Odgovor

Vraća: GetTicketResponse

Primer

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

DohvatiTikete

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

Primer

Primer 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 |  (opciono)
	state := float64(1.2) // float64 |  (opciono)
	skip := float64(1.2) // float64 |  (opciono)
	limit := float64(1.2) // float64 |  (opciono)
	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 od `GetTickets`: GetTicketsResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTickets`: %v\n", resp)
}

DohvatiPrevode

Parametri

Naziv	Tip	Lokacija	Obavezno
namespace	string	path	Da
component	string	path	Da
locale	string	query	Ne
useFullTranslationIds	boolean	query	Ne

Odgovor

Vraća: GetTranslationsResponse

Primer

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

OtpremiSliku

Otpremi i promeni veličinu slike

Parametri

Name	Type	Location	Required	Description
tenantId	string	path	Da
sizePreset	string	query	Ne	Prednastavka veličine: "Default" (1000x1000px) ili "CrossPlatform" (kreira veličine za popularne uređaje)
urlId	string	query	Ne	ID stranice sa koje se otpremanje vrši, za konfiguraciju

Odgovor

Vraća: UploadImageResponse

Primer

Primer 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 | Prednastavka veličine: \"Default\" (1000x1000px) ili \"CrossPlatform\" (kreira veličine za popularne uređaje) (opcionalno)
	urlId := "urlId_example" // string | ID stranice sa koje se otpremanje vrši, 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)
	}
	// response from `UploadImage`: UploadImageResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UploadImage`: %v\n", resp)
}

DohvatiNapredakBedžaKorisnikaPoId-u

Parametri

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

Odgovor

Vraća: APIGetUserBadgeProgressResponse

Primer

GetUserBadgeProgressById Primer

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

DohvatiNapredakBedžaKorisnikaPoUserId-u

Parametri

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

Odgovor

Vraća: APIGetUserBadgeProgressResponse

Primer

GetUserBadgeProgressByUserId Primer

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

DohvatiListuNapretkaBedžaKorisnika

Parametri

Naziv	Tip	Lokacija	Obavezno
tenantId	string	query	Yes
userId	string	query	No
limit	number	query	No
skip	number	query	No

Odgovor

Vraća: APIGetUserBadgeProgressListResponse

Primer

Primer 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 |  (opciono)
	limit := float64(1.2) // float64 |  (opciono)
	skip := float64(1.2) // float64 |  (opciono)
	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)
}

KreirajBedžKorisnika

Parametri

Name	Type	Location	Required	Description
tenantId	string	query	Da

Odgovor

Vraća: APICreateUserBadgeResponse

Primer

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

ObrišiBedžKorisnika

Parametri

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

Odgovor

Vraća: APIEmptySuccessResponse

Primer

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

DohvatiBedžKorisnika

Parametri

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

Odgovor

Vraća: APIGetUserBadgeResponse

Primer

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

DohvatiBedževeKorisnika

Parametri

Ime	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

Primer

Primer 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žurirajBedžKorisnika

Parametri

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

Odgovor

Vraća: APIEmptySuccessResponse

Primer

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

DohvatiBrojNotifikacijaKorisnika

Parametri

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

Odgovor

Vraća: GetUserNotificationCountResponse

Primer

Primer za 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 |  (opciono)
	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 od `GetUserNotificationCount`: GetUserNotificationCountResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotificationCount`: %v\n", resp)
}

DohvatiNotifikacijeKorisnika

Parametri

Naziv	Tip	Lokacija	Obavezno	Opis
tenantId	string	query	Da
urlId	string	query	Ne	Koristi se za utvrđivanje da li je 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

Primer

Primer 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 utvrđivanje da li je trenutna stranica pretplaćena. (opciono)
	pageSize := int32(56) // int32 |  (opciono)
	afterId := "afterId_example" // string |  (opciono)
	includeContext := true // bool |  (opciono)
	afterCreatedAt := int64(789) // int64 |  (opciono)
	unreadOnly := true // bool |  (opciono)
	dmOnly := true // bool |  (opciono)
	noDm := true // bool |  (opciono)
	includeTranslations := true // bool |  (opciono)
	includeTenantNotifications := true // bool |  (opciono)
	sso := "sso_example" // string |  (opciono)
	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 od `GetUserNotifications`: GetMyNotificationsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotifications`: %v\n", resp)
}

ResetujBrojNotifikacijaKorisnika

Parametri

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

Odgovor

Vraća: ResetUserNotificationsResponse

Primer

Primer 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 |  (opciono)
	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 iz `ResetUserNotificationCount`: ResetUserNotificationsResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ResetUserNotificationCount`: %v\n", resp)
}

ResetujNotifikacijeKorisnika

Parametri

Ime	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

Primer

Primer ResetUserNotifications

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žurirajStatusPretplateNaKomentareUNotifikacijama

Omogućavanje ili onemogućavanje notifikacija za određeni komentar.

Parametri

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

Odgovor

Vraća: UpdateUserNotificationCommentSubscriptionStatusResponse

Primer

Primer 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žurirajStatusPretplateNaStranicuUNotifikacijama

Omogućavanje ili onemogućavanje notifikacija za stranicu. Kada su korisnici pretplaćeni na stranicu, notifikacije se kreiraju za nove root komentare, i takođe

Parametri

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

Primer

Primer UpdateUserNotificationPageSubscriptionStatus

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

AžurirajStatusNotifikacijeKorisnika

Parametri

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

Odgovor

Vraća: UpdateUserNotificationStatusResponse

Primer

UpdateUserNotificationStatus Primer

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 sa `UpdateUserNotificationStatus`: UpdateUserNotificationStatusResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationStatus`: %v\n", resp)
}

DohvatiStatusPrisustvaKorisnika

Parametri

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

Odgovor

Vraća: GetUserPresenceStatusesResponse

Primer

Primer 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žiKorisnike

Parametri

Ime	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

Primer

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

DohvatiKorisnika

Parametri

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

Odgovor

Vraća: GetUserResponse

Primer

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

KreirajGlas

Parametri

Name	Type	Location	Required
tenantId	string	query	Da
commentId	string	query	Da
direction	string	query	Da
userId	string	query	Ne
anonUserId	string	query	Ne

Odgovor

Vraća: VoteResponse

Primer

Primer 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 |  (opciono)
	anonUserId := "anonUserId_example" // string |  (opciono)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.CreateVote(context.Background()).TenantId(tenantId).CommentId(commentId).Direction(direction).UserId(userId).AnonUserId(anonUserId).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CreateVote``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// odgovor od `CreateVote`: VoteResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateVote`: %v\n", resp)
}

ObrišiGlas

Parametri

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

Odgovor

Vraća: VoteDeleteResponse

Primer

Primer brisanja glasa

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

DohvatiGlasove

Parametri

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

Odgovor

Vraća: GetVotesResponse

Primer

GetVotes primer

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

DohvatiGlasoveZaKorisnika

Parametri

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

Odgovor

Vraća: GetVotesForUserResponse

Primer

Primer 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 od `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 u vezi Go SDK, molimo:

Doprinosi

Doprinosi su dobrodošli! Molimo posetite GitHub repozitorijum za smernice za doprinos.

Jezik 🇷🇸 Srpski (Latinica)

Početak

Upotreba

Agregat

Audit Logovi

Autentifikacija

Blokiranje iz komentara

Proveri blokirane komentare

Komentari

Komentari za korisnika

Domen Konfiguracije

Email Šabloni

Dnevnik Dogadjaja

Objave u feedu

Označi komentar

Gifovi

Hash Tagovi

Moderacija

Moderatori

Broj Notifikacija

Notifikacije

Reakcije na stranici

Stranice

Zakađeni Webhook Događaji

Konfiguracije pitanja

Rezultati pitanja

Agregacija rezultata pitanja

SSO Korisnici

Pretplate

Dnevno korišćenje zakupca

Paketi zakupca

Korisnici zakupca

Zakupci

Tiketi

Prevodi

Otpremanje slike

Napredak bedža korisnika

Bedževi korisnika

Korisničke notifikacije

Status Prisustva Korisnika

Pretraga korisnika

Korisnici

Glasovi

FastComments Go SDK

Repozitorijum

Instalacija

Korišćenje API klijenta

Javni API (Bez autentifikacije)

Podrazumevani API (Zahteva API ključ)

Moderacioni API (Moderator kontrolna tabla)

Upotreba

Jednostavan SSO

Siguran SSO

Agregat

Parametri

Odgovor

Primer

DohvatiAuditLogove

Parametri

Odgovor

Primer

OdjavaJavni

Odgovor

Primer

BlokirajIzKomentaraJavno

Parametri

Odgovor

Primer

DeblokirajKomentarJavno

Parametri

Odgovor

Primer

ProvereniKomentariZaBlokirane

Parametri

Odgovor

Primer

BlokirajKorisnikaIzKomentara

Parametri

Odgovor

Primer