SDK FastComments para Go

Este é o SDK oficial em Go para o FastComments.

SDK oficial em Go para a API do FastComments

Repositório

Instalação

go get github.com/fastcomments/fastcomments-go

Usando o Cliente da API

PublicAPI (Sem Autenticação)

A PublicAPI permite acesso não autenticado a endpoints públicos:

package main

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

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

    // Obter comentários usando a 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)
}

DefaultAPI (Requer chave de API)

A DefaultAPI requer autenticação usando sua chave de API:

package main

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

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

    // Criar contexto autenticado com a chave de API
    auth := context.WithValue(
        context.Background(),
        client.ContextAPIKeys,
        map[string]client.APIKey{
            "api_key": {Key: "your-api-key-here"},
        },
    )

    // Obter comentários usando a DefaultAPI autenticada
    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)
}

Uso

SSO Simples

package main

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

func main() {
    // Criar token SSO simples
    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)

    // Use o token SSO para fazer uma chamada de API autenticada
    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)
}

SSO Seguro

package main

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

func main() {
    // Criar token SSO seguro
    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)

    // Use o token SSO para fazer uma chamada de API autenticada
    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)
}

Agregação

Agrega documentos agrupando-os (se groupBy for fornecido) e aplicando múltiplas operações. Diferentes operações (por exemplo sum, countDistinct, avg, etc.) são suportadas.

Parameters

Name	Type	Location	Required
tenantId	string	query	Sim
parentTenantId	string	query	Não
includeStats	boolean	query	Não

Response

Retorna: AggregationResponse

Example

Exemplo de Agregação

Copy

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

Obter Logs de Auditoria

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
limit	number	query	Não
skip	number	query	Não
order	string	query	Não
after	number	query	Não
before	number	query	Não

Resposta

Retorna: GetAuditLogs200Response

Exemplo

Exemplo de GetAuditLogs

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	limit := float64(1.2) // float64 |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	order := openapiclient.SORT_DIR("ASC") // SORTDIR |  (opcional)
	after := float64(1.2) // float64 |  (opcional)
	before := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetAuditLogs`: GetAuditLogs200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetAuditLogs`: %v\n", resp)
}

Bloquear a partir do Comentário (Público)

Parameters

Name	Type	Location	Required
tenantId	string	query	Sim
commentId	string	path	Sim
sso	string	query	Não

Response

Retorna: BlockFromCommentPublic200Response

Exemplo

Exemplo de BlockFromCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	publicBlockFromCommentParams := *openapiclient.NewPublicBlockFromCommentParams([]string{"CommentIds_example"}) // PublicBlockFromCommentParams | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `BlockFromCommentPublic`: BlockFromCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.BlockFromCommentPublic`: %v\n", resp)
}

Desbloquear Comentário (Público)

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
commentId	string	path	Sim
sso	string	query	Não

Resposta

Retorna: UnBlockCommentPublic200Response

Exemplo

Exemplo de UnBlockCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	publicBlockFromCommentParams := *openapiclient.NewPublicBlockFromCommentParams([]string{"CommentIds_example"}) // PublicBlockFromCommentParams | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `UnBlockCommentPublic`: UnBlockCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UnBlockCommentPublic`: %v\n", resp)
}

Verificar Comentários Bloqueados

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim
commentIds	string	query	Sim	Uma lista separada por vírgulas de IDs de comentários.
sso	string	query	Não

Resposta

Retorna: CheckedCommentsForBlocked200Response

Exemplo

Exemplo de CheckedCommentsForBlocked

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentIds := "commentIds_example" // string | Uma lista separada por vírgulas de IDs de comentários.
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `CheckedCommentsForBlocked`: CheckedCommentsForBlocked200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CheckedCommentsForBlocked`: %v\n", resp)
}

Bloquear Usuário a partir do Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não
anonUserId	string	query	Não

Resposta

Retorna: BlockFromCommentPublic200Response

Exemplo

Exemplo de BlockUserFromComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	blockFromCommentParams := *openapiclient.NewBlockFromCommentParams() // BlockFromCommentParams | 
	userId := "userId_example" // string |  (opcional)
	anonUserId := "anonUserId_example" // string |  (opcional)
	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)
	}
	// resposta de `BlockUserFromComment`: BlockFromCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.BlockUserFromComment`: %v\n", resp)
}

Criar Comentário (Público)

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
urlId	string	query	Sim
broadcastId	string	query	Sim
sessionId	string	query	Não
sso	string	query	Não

Resposta

Retorna: CreateCommentPublic200Response

Exemplo

Exemplo de CreateCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	commentData := *openapiclient.NewCommentData("CommenterName_example", "Comment_example", "Url_example", "UrlId_example") // CommentData | 
	sessionId := "sessionId_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `CreateCommentPublic`: CreateCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateCommentPublic`: %v\n", resp)
}

Excluir Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
contextUserId	string	query	Não
isLive	boolean	query	Não

Resposta

Retorna: DeleteComment200Response

Exemplo

Exemplo de DeleteComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	contextUserId := "contextUserId_example" // string |  (opcional)
	isLive := true // bool |  (opcional)
	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)
	}
	// resposta de `DeleteComment`: DeleteComment200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteComment`: %v\n", resp)
}

Excluir Comentário (Público)

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
commentId	string	path	Sim
broadcastId	string	query	Sim
editKey	string	query	Não
sso	string	query	Não

Resposta

Retorna: DeleteCommentPublic200Response

Exemplo

Exemplo de DeleteCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	editKey := "editKey_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `DeleteCommentPublic`: DeleteCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteCommentPublic`: %v\n", resp)
}

Excluir Voto de Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
commentId	string	path	Sim
voteId	string	path	Sim
urlId	string	query	Sim
broadcastId	string	query	Sim
editKey	string	query	Não
sso	string	query	Não

Resposta

Retorna: DeleteCommentVote200Response

Exemplo

Exemplo DeleteCommentVote

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	voteId := "voteId_example" // string | 
	urlId := "urlId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	editKey := "editKey_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `DeleteCommentVote`: DeleteCommentVote200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteCommentVote`: %v\n", resp)
}

Denunciar Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não
anonUserId	string	query	Não

Resposta

Retorna: FlagComment200Response

Exemplo

Exemplo de FlagComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	userId := "userId_example" // string |  (opcional)
	anonUserId := "anonUserId_example" // string |  (opcional)
	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)
	}
	// resposta de `FlagComment`: FlagComment200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.FlagComment`: %v\n", resp)
}

Obter Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetComment200Response

Exemplo

Exemplo de GetComment

Copy

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

Obter Comentários

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
page	integer	query	Não
limit	integer	query	Não
skip	integer	query	Não
asTree	boolean	query	Não
skipChildren	integer	query	Não
limitChildren	integer	query	Não
maxTreeDepth	integer	query	Não
urlId	string	query	Não
userId	string	query	Não
anonUserId	string	query	Não
contextUserId	string	query	Não
hashTag	string	query	Não
parentId	string	query	Não
direction	string	query	Não

Resposta

Retorna: GetComments200Response

Exemplo

Exemplo de GetComments

Copy

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

Obter Comentários (Público)

req tenantId urlId

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
urlId	string	query	Sim
page	integer	query	Não
direction	string	query	Não
sso	string	query	Não
skip	integer	query	Não
skipChildren	integer	query	Não
limit	integer	query	Não
limitChildren	integer	query	Não
countChildren	boolean	query	Não
fetchPageForCommentId	string	query	Não
includeConfig	boolean	query	Não
countAll	boolean	query	Não
includei10n	boolean	query	Não
locale	string	query	Não
modules	string	query	Não
isCrawler	boolean	query	Não
includeNotificationCount	boolean	query	Não
asTree	boolean	query	Não
maxTreeDepth	integer	query	Não
useFullTranslationIds	boolean	query	Não
parentId	string	query	Não
searchText	string	query	Não
hashTags	array	query	Não
userId	string	query	Não
customConfigStr	string	query	Não
afterCommentId	string	query	Não
beforeCommentId	string	query	Não

Resposta

Retorna: GetCommentsPublic200Response

Exemplo

Exemplo GetCommentsPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	page := int32(56) // int32 |  (opcional)
	direction := openapiclient.SortDirections("OF") // SortDirections |  (opcional)
	sso := "sso_example" // string |  (opcional)
	skip := int32(56) // int32 |  (opcional)
	skipChildren := int32(56) // int32 |  (opcional)
	limit := int32(56) // int32 |  (opcional)
	limitChildren := int32(56) // int32 |  (opcional)
	countChildren := true // bool |  (opcional)
	fetchPageForCommentId := "fetchPageForCommentId_example" // string |  (opcional)
	includeConfig := true // bool |  (opcional)
	countAll := true // bool |  (opcional)
	includei10n := true // bool |  (opcional)
	locale := "locale_example" // string |  (opcional)
	modules := "modules_example" // string |  (opcional)
	isCrawler := true // bool |  (opcional)
	includeNotificationCount := true // bool |  (opcional)
	asTree := true // bool |  (opcional)
	maxTreeDepth := int32(56) // int32 |  (opcional)
	useFullTranslationIds := true // bool |  (opcional)
	parentId := "parentId_example" // string |  (opcional)
	searchText := "searchText_example" // string |  (opcional)
	hashTags := []string{"Inner_example"} // []string |  (opcional)
	userId := "userId_example" // string |  (opcional)
	customConfigStr := "customConfigStr_example" // string |  (opcional)
	afterCommentId := "afterCommentId_example" // string |  (opcional)
	beforeCommentId := "beforeCommentId_example" // string |  (opcional)
	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)
	}
	// resposta de `GetCommentsPublic`: GetCommentsPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentsPublic`: %v\n", resp)
}

Obter Texto do Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
commentId	string	path	Sim
editKey	string	query	Não
sso	string	query	Não

Response

Retorna: GetCommentText200Response

Exemplo

Exemplo de GetCommentText

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	editKey := "editKey_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `GetCommentText`: GetCommentText200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentText`: %v\n", resp)
}

Obter Nomes de Usuários que Votaram no Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
commentId	string	path	Sim
dir	integer	query	Sim
sso	string	query	Não

Resposta

Retorna: GetCommentVoteUserNames200Response

Exemplo

Exemplo de GetCommentVoteUserNames

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	dir := int32(56) // int32 | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `GetCommentVoteUserNames`: GetCommentVoteUserNames200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentVoteUserNames`: %v\n", resp)
}

Bloquear Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
commentId	string	path	Sim
broadcastId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: LockComment200Response

Exemplo

Exemplo de LockComment

Copy

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

Fixar Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
commentId	string	path	Sim
broadcastId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: PinComment200Response

Exemplo

Exemplo de PinComment

Copy

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

Salvar Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
isLive	boolean	query	Não
doSpamCheck	boolean	query	Não
sendEmails	boolean	query	Não
populateNotifications	boolean	query	Não

Resposta

Retorna: SaveComment200Response

Exemplo

Exemplo de SaveComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	createCommentParams := *openapiclient.NewCreateCommentParams("CommenterName_example", "Comment_example", "Url_example", "UrlId_example", "Locale_example") // CreateCommentParams | 
	isLive := true // bool |  (opcional)
	doSpamCheck := true // bool |  (opcional)
	sendEmails := true // bool |  (opcional)
	populateNotifications := true // bool |  (opcional)
	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)
	}
	// resposta de `SaveComment`: SaveComment200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveComment`: %v\n", resp)
}

Salvar Comentários em Lote

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
isLive	boolean	query	Não
doSpamCheck	boolean	query	Não
sendEmails	boolean	query	Não
populateNotifications	boolean	query	Não

Resposta

Retorna: []SaveComment200Response

Exemplo

Exemplo de SaveCommentsBulk

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	createCommentParams := []openapiclient.CreateCommentParams{*openapiclient.NewCreateCommentParams("CommenterName_example", "Comment_example", "Url_example", "UrlId_example", "Locale_example")} // []CreateCommentParams | 
	isLive := true // bool |  (opcional)
	doSpamCheck := true // bool |  (opcional)
	sendEmails := true // bool |  (opcional)
	populateNotifications := true // bool |  (opcional)
	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)
	}
	// resposta de `SaveCommentsBulk`: []SaveComment200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveCommentsBulk`: %v\n", resp)
}

Definir Texto do Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
commentId	string	path	Sim
broadcastId	string	query	Sim
editKey	string	query	Não
sso	string	query	Não

Resposta

Retorna: SetCommentText200Response

Exemplo

Exemplo de SetCommentText

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	commentTextUpdateRequest := *openapiclient.NewCommentTextUpdateRequest("Comment_example") // CommentTextUpdateRequest | 
	editKey := "editKey_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `SetCommentText`: SetCommentText200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SetCommentText`: %v\n", resp)
}

Desbloquear Usuário do Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não
anonUserId	string	query	Não

Resposta

Retorna: UnBlockCommentPublic200Response

Exemplo

Exemplo de UnBlockUserFromComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	unBlockFromCommentParams := *openapiclient.NewUnBlockFromCommentParams() // UnBlockFromCommentParams | 
	userId := "userId_example" // string |  (opcional)
	anonUserId := "anonUserId_example" // string |  (opcional)
	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)
	}
	// resposta de `UnBlockUserFromComment`: UnBlockCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UnBlockUserFromComment`: %v\n", resp)
}

Remover Denúncia do Comentário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não
anonUserId	string	query	Não

Resposta

Retorna: FlagComment200Response

Exemplo

Exemplo de UnFlagComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	userId := "userId_example" // string |  (opcional)
	anonUserId := "anonUserId_example" // string |  (opcional)
	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)
	}
	// resposta de `UnFlagComment`: FlagComment200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UnFlagComment`: %v\n", resp)
}

Desbloquear Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
commentId	string	path	Sim
broadcastId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: LockComment200Response

Exemplo

Exemplo de UnLockComment

Copy

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

Desafixar Comentário

Parâmetros

Nome	Tipo	Location	Obrigatório
tenantId	string	path	Sim
commentId	string	path	Sim
broadcastId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: PinComment200Response

Exemplo

Exemplo de UnPinComment

Copy

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

Atualizar Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
contextUserId	string	query	Não
doSpamCheck	boolean	query	Não
isLive	boolean	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de UpdateComment

Copy

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

Votar em Comentário

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
commentId	string	path	Sim
urlId	string	query	Sim
broadcastId	string	query	Sim
sessionId	string	query	Não
sso	string	query	Não

Resposta

Retorna: VoteComment200Response

Exemplo

Exemplo de VoteComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	urlId := "urlId_example" // string | 
	broadcastId := "broadcastId_example" // string | 
	voteBodyParams := *openapiclient.NewVoteBodyParams("CommenterEmail_example", "CommenterName_example", "VoteDir_example", "Url_example") // VoteBodyParams | 
	sessionId := "sessionId_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `VoteComment`: VoteComment200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.VoteComment`: %v\n", resp)
}

Adicionar Configuração de Domínio

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Resposta

Retorna: AddDomainConfig200Response

Exemplo

Exemplo de AddDomainConfig

Copy

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

Excluir Configuração de Domínio

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
domain	string	path	Sim

Resposta

Retorna: DeleteDomainConfig200Response

Exemplo

Exemplo de DeleteDomainConfig

Copy

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

Obter Configuração de Domínio

Parâmetros

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

Resposta

Retorna: GetDomainConfig200Response

Exemplo

Exemplo de GetDomainConfig

Copy

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

Obter Configurações de Domínio

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim

Resposta

Retorna: GetDomainConfigs200Response

Exemplo

Exemplo de GetDomainConfigs

Copy

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

Patch em Configuração de Domínio

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
domainToUpdate	string	path	Sim

Resposta

Retorna: GetDomainConfig200Response

Exemplo

Exemplo de PatchDomainConfig

Copy

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

Substituir Configuração de Domínio (PUT)

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
domainToUpdate	string	path	Sim

Resposta

Retorna: GetDomainConfig200Response

Exemplo

Exemplo de PutDomainConfig

Copy

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

Criar Modelo de E-mail

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Response

Retorna: CreateEmailTemplate200Response

Exemplo

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

Excluir Modelo de E-mail

Parâmetros

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

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Excluir Erro de Renderização de Modelo de E-mail

Parâmetros

Nome	Tipo	Local	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
errorId	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Obter Modelo de E-mail

Parâmetros

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

Resposta

Retorna: GetEmailTemplate200Response

Exemplo

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

Obter Definições de Modelos de E-mail

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Response

Retorna: GetEmailTemplateDefinitions200Response

Exemplo

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

Obter Erros de Renderização de Modelos de E-mail

Parâmetros

Nome	Tipo	Local	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
skip	number	query	Não

Resposta

Retorna: GetEmailTemplateRenderErrors200Response

Exemplo

Exemplo de 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 |  (opcional)
	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)
	}
	// Resposta de `GetEmailTemplateRenderErrors`: GetEmailTemplateRenderErrors200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplateRenderErrors`: %v\n", resp)
}

Obter Modelos de E-mail

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
skip	number	query	Não

Resposta

Retorna: GetEmailTemplates200Response

Exemplo

Exemplo 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 |  (opcional)
	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)
	}
	// resposta de `GetEmailTemplates`: GetEmailTemplates200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetEmailTemplates`: %v\n", resp)
}

Renderizar Modelo de E-mail

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
locale	string	query	Não

Resposta

Retorna: RenderEmailTemplate200Response

Exemplo

Exemplo de 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 |  (opcional)
	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)
	}
	// resposta de `RenderEmailTemplate`: RenderEmailTemplate200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.RenderEmailTemplate`: %v\n", resp)
}

Atualizar Modelo de E-mail

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de 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)
	}
	// resposta de `UpdateEmailTemplate`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateEmailTemplate`: %v\n", resp)
}

Obter Registro de Eventos

req tenantId urlId userIdWS

Parâmetros

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

Resposta

Retorna: GetEventLog200Response

Exemplo

Exemplo de GetEventLog

Copy

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

Obter Registro Global de Eventos

req tenantId urlId userIdWS

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
urlId	string	query	Sim
userIdWS	string	query	Sim
startTime	integer	query	Sim
endTime	integer	query	Sim

Resposta

Retorna: GetEventLog200Response

Exemplo

Exemplo de GetGlobalEventLog

Copy

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

Criar Publicação do Feed

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
broadcastId	string	query	Não
isLive	boolean	query	Não
doSpamCheck	boolean	query	Não
skipDupCheck	boolean	query	Não

Resposta

Retorna: CreateFeedPost200Response

Exemplo

Exemplo de CreateFeedPost

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	createFeedPostParams := *openapiclient.NewCreateFeedPostParams() // CreateFeedPostParams | 
	broadcastId := "broadcastId_example" // string |  (opcional)
	isLive := true // bool |  (opcional)
	doSpamCheck := true // bool |  (opcional)
	skipDupCheck := true // bool |  (opcional)
	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)
	}
	// resposta de `CreateFeedPost`: CreateFeedPost200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateFeedPost`: %v\n", resp)
}

Criar Publicação do Feed (Pública)

Parâmetros

Nome	Tipo	Local	Obrigatório
tenantId	string	path	Sim
broadcastId	string	query	Não
sso	string	query	Não

Resposta

Retorna: CreateFeedPostPublic200Response

Exemplo

Exemplo CreateFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	createFeedPostParams := *openapiclient.NewCreateFeedPostParams() // CreateFeedPostParams | 
	broadcastId := "broadcastId_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `CreateFeedPostPublic`: CreateFeedPostPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateFeedPostPublic`: %v\n", resp)
}

Excluir Publicação do Feed (Pública)

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
postId	string	path	Sim
broadcastId	string	query	Não
sso	string	query	Não

Resposta

Retorna: DeleteFeedPostPublic200Response

Exemplo

Exemplo DeleteFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	postId := "postId_example" // string | 
	broadcastId := "broadcastId_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// response from `DeleteFeedPostPublic`: DeleteFeedPostPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.DeleteFeedPostPublic`: %v\n", resp)
}

Obter Publicações do Feed

req tenantId afterId

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
afterId	string	query	Não
limit	integer	query	Não
tags	array	query	Não

Resposta

Retorna: GetFeedPosts200Response

Exemplo

Exemplo de GetFeedPosts

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	afterId := "afterId_example" // string |  (opcional)
	limit := int32(56) // int32 |  (opcional)
	tags := []string{"Inner_example"} // []string |  (opcional)
	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)
	}
	// resposta de `GetFeedPosts`: GetFeedPosts200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetFeedPosts`: %v\n", resp)
}

Obter Publicações do Feed (Público)

req tenantId afterId

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
afterId	string	query	Não
limit	integer	query	Não
tags	array	query	Não
sso	string	query	Não
isCrawler	boolean	query	Não
includeUserInfo	boolean	query	Não

Resposta

Retorna: GetFeedPostsPublic200Response

Exemplo

Exemplo de GetFeedPostsPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	afterId := "afterId_example" // string |  (opcional)
	limit := int32(56) // int32 |  (opcional)
	tags := []string{"Inner_example"} // []string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	isCrawler := true // bool |  (opcional)
	includeUserInfo := true // bool |  (opcional)
	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)
	}
	// resposta de `GetFeedPostsPublic`: GetFeedPostsPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsPublic`: %v\n", resp)
}

Obter Estatísticas de Publicações do Feed

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
postIds	array	query	Sim
sso	string	query	Não

Resposta

Retorna: GetFeedPostsStats200Response

Exemplo

Exemplo de GetFeedPostsStats

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	postIds := []string{"Inner_example"} // []string | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `GetFeedPostsStats`: GetFeedPostsStats200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsStats`: %v\n", resp)
}

Obter Reações de Usuário (Público)

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
postIds	array	query	Não
sso	string	query	Não

Resposta

Retorna: GetUserReactsPublic200Response

Exemplo

Exemplo de GetUserReactsPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	postIds := []string{"Inner_example"} // []string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `GetUserReactsPublic`: GetUserReactsPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserReactsPublic`: %v\n", resp)
}

Reagir à Publicação do Feed (Pública)

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
postId	string	path	Sim
isUndo	boolean	query	Não
broadcastId	string	query	Não
sso	string	query	Não

Resposta

Retorna: ReactFeedPostPublic200Response

Exemplo

Exemplo de ReactFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	postId := "postId_example" // string | 
	reactBodyParams := *openapiclient.NewReactBodyParams() // ReactBodyParams | 
	isUndo := true // bool |  (opcional)
	broadcastId := "broadcastId_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `ReactFeedPostPublic`: ReactFeedPostPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ReactFeedPostPublic`: %v\n", resp)
}

Atualizar Publicação do Feed

Parâmetros

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

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de UpdateFeedPost

Copy

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

Atualizar Publicação do Feed (Pública)

Parâmetros

Name	Type	Location	Required
tenantId	string	path	Sim
postId	string	path	Sim
broadcastId	string	query	Não
sso	string	query	Não

Resposta

Retorna: CreateFeedPostPublic200Response

Exemplo

Exemplo de UpdateFeedPostPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	postId := "postId_example" // string | 
	updateFeedPostParams := *openapiclient.NewUpdateFeedPostParams() // UpdateFeedPostParams | 
	broadcastId := "broadcastId_example" // string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `UpdateFeedPostPublic`: CreateFeedPostPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateFeedPostPublic`: %v\n", resp)
}

Denunciar Comentário (Público)

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
commentId	string	path	Sim
isFlagged	boolean	query	Sim
sso	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de FlagCommentPublic

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	commentId := "commentId_example" // string | 
	isFlagged := true // bool | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `FlagCommentPublic`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.FlagCommentPublic`: %v\n", resp)
}

Adicionar Hashtag

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Não

Resposta

Retorna: AddHashTag200Response

Exemplo

Exemplo de AddHashTag

Copy

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

Adicionar Hashtags em Lote

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Não

Resposta

Retorna: AddHashTagsBulk200Response

Exemplo

Exemplo de AddHashTagsBulk

Copy

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

Excluir Hashtag

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tag	string	path	Sim
tenantId	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de DeleteHashTag

Copy

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

Obter Hashtags

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim
page	number	query	Não

Resposta

Retorna: GetHashTags200Response

Exemplo

Exemplo de 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 |  (opcional)
	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)
	}
	// resposta de `GetHashTags`: GetHashTags200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetHashTags`: %v\n", resp)
}

Patch em Hashtag

Parâmetros

Name	Type	Location	Required	Description
tag	string	path	Sim
tenantId	string	query	Não

Resposta

Retorna: PatchHashTag200Response

Exemplo

Exemplo de PatchHashTag

Copy

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

Criar Moderador

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim

Resposta

Retorna: CreateModerator200Response

Exemplo

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

Excluir Moderador

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
sendEmail	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de DeleteModerator

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	sendEmail := "sendEmail_example" // string |  (opcional)
	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)
	}
	// resposta de `DeleteModerator`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteModerator`: %v\n", resp)
}

Obter Moderador

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetModerator200Response

Exemplo

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

Obter Moderadores

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
skip	number	query	Não

Resposta

Retorna: GetModerators200Response

Exemplo

Exemplo de GetModerators

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetModerators`: GetModerators200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetModerators`: %v\n", resp)
}

Enviar Convite

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
fromName	string	query	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de SendInvite

Copy

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

Atualizar Moderador

Parâmetros

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

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Excluir Contagem de Notificações

Parâmetros

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

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Obter Contagem de Notificações em Cache

Parâmetros

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

Resposta

Retorna: GetCachedNotificationCount200Response

Exemplo

Exemplo de 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)
	}
	// resposta de `GetCachedNotificationCount`: GetCachedNotificationCount200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetCachedNotificationCount`: %v\n", resp)
}

Obter Contagem de Notificações

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
userId	string	query	Não
urlId	string	query	Não
fromCommentId	string	query	Não
viewed	boolean	query	Não
type	string	query	Não

Resposta

Retorna: GetNotificationCount200Response

Exemplo

Exemplo de GetNotificationCount

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (opcional)
	urlId := "urlId_example" // string |  (opcional)
	fromCommentId := "fromCommentId_example" // string |  (opcional)
	viewed := true // bool |  (opcional)
	type_ := "type__example" // string |  (opcional)
	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)
	}
	// resposta de `GetNotificationCount`: GetNotificationCount200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetNotificationCount`: %v\n", resp)
}

Obter Notificações

Parâmetros

Nome	Tipo	Location	Obrigatório
tenantId	string	query	Sim
userId	string	query	Não
urlId	string	query	Não
fromCommentId	string	query	Não
viewed	boolean	query	Não
type	string	query	Não
skip	number	query	Não

Resposta

Retorna: GetNotifications200Response

Exemplo

Exemplo de 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 |  (opcional)
	urlId := "urlId_example" // string |  (opcional)
	fromCommentId := "fromCommentId_example" // string |  (opcional)
	viewed := true // bool |  (opcional)
	type_ := "type__example" // string |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetNotifications`: GetNotifications200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetNotifications`: %v\n", resp)
}

Atualizar Notificação

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Adicionar Página

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: AddPageAPIResponse

Exemplo

Exemplo de 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)
	}
	// resposta de `AddPage`: AddPageAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddPage`: %v\n", resp)
}

Excluir Página

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: DeletePageAPIResponse

Exemplo

Exemplo de 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)
	}
	// resposta de `DeletePage`: DeletePageAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeletePage`: %v\n", resp)
}

Obter Página por URLId

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
urlId	string	query	Sim

Resposta

Retorna: GetPageByURLIdAPIResponse

Exemplo

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

Obter Páginas

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: GetPagesAPIResponse

Exemplo

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

Patch em Página

Parâmetros

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

Resposta

Retorna: PatchPageAPIResponse

Exemplo

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

Excluir Evento de Webhook Pendente

Parâmetros

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

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de DeletePendingWebhookEvent

Copy

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

Obter Contagem de Eventos de Webhook Pendentes

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
commentId	string	query	Não
externalId	string	query	Não
eventType	string	query	Não
type	string	query	Não
domain	string	query	Não
attemptCountGT	number	query	Não

Resposta

Retorna: GetPendingWebhookEventCount200Response

Exemplo

Exemplo de 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 |  (opcional)
	externalId := "externalId_example" // string |  (opcional)
	eventType := "eventType_example" // string |  (opcional)
	type_ := "type__example" // string |  (opcional)
	domain := "domain_example" // string |  (opcional)
	attemptCountGT := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetPendingWebhookEventCount`: GetPendingWebhookEventCount200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEventCount`: %v\n", resp)
}

Obter Eventos de Webhook Pendentes

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
commentId	string	query	Não
externalId	string	query	Não
eventType	string	query	Não
type	string	query	Não
domain	string	query	Não
attemptCountGT	number	query	Não
skip	number	query	Não

Resposta

Retorna: GetPendingWebhookEvents200Response

Exemplo

Exemplo de 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 |  (opcional)
	externalId := "externalId_example" // string |  (opcional)
	eventType := "eventType_example" // string |  (opcional)
	type_ := "type__example" // string |  (opcional)
	domain := "domain_example" // string |  (opcional)
	attemptCountGT := float64(1.2) // float64 |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetPendingWebhookEvents`: GetPendingWebhookEvents200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetPendingWebhookEvents`: %v\n", resp)
}

Criar Configuração de Pergunta

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: CreateQuestionConfig200Response

Exemplo

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

Excluir Configuração de Pergunta

Parâmetros

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

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Obter Configuração de Pergunta

Parâmetros

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

Resposta

Retorna: GetQuestionConfig200Response

Exemplo

Exemplo de 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)
	}
	// resposta de `GetQuestionConfig`: GetQuestionConfig200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionConfig`: %v\n", resp)
}

Obter Configurações de Perguntas

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim
skip	number	query	Não

Resposta

Retorna: GetQuestionConfigs200Response

Exemplo

Exemplo de 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 |  (opcional)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.GetQuestionConfigs(context.Background()).TenantId(tenantId).Skip(skip).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetQuestionConfigs``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// response from `GetQuestionConfigs`: GetQuestionConfigs200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionConfigs`: %v\n", resp)
}

Atualizar Configuração de Pergunta

Parâmetros

Nome	Tipo	Local	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de 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)
	}
	// resposta de `UpdateQuestionConfig`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateQuestionConfig`: %v\n", resp)
}

Criar Resultado de Pergunta

Parâmetros

Nome	Tipo	Local	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: CreateQuestionResult200Response

Exemplo

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

Excluir Resultado de Pergunta

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Obter Resultado de Pergunta

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetQuestionResult200Response

Exemplo

Exemplo de GetQuestionResult

Copy

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

Obter Resultados de Perguntas

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
urlId	string	query	Não
userId	string	query	Não
startDate	string	query	Não
questionId	string	query	Não
questionIds	string	query	Não
skip	number	query	Não

Resposta

Retorna: GetQuestionResults200Response

Exemplo

Exemplo de 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 |  (opcional)
	userId := "userId_example" // string |  (opcional)
	startDate := "startDate_example" // string |  (opcional)
	questionId := "questionId_example" // string |  (opcional)
	questionIds := "questionIds_example" // string |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetQuestionResults`: GetQuestionResults200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetQuestionResults`: %v\n", resp)
}

Atualizar Resultado de Pergunta

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Agregação de Resultados de Perguntas

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
questionId	string	query	Não
questionIds	array	query	Não
urlId	string	query	Não
timeBucket	string	query	Não
startDate	string	query	Não
forceRecalculate	boolean	query	Não

Resposta

Retorna: AggregateQuestionResults200Response

Exemplo

Exemplo de AggregateQuestionResults

Copy

package main
import (
	"context"
	"fmt"
	"os"
    "time"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	questionId := "questionId_example" // string |  (opcional)
	questionIds := []string{"Inner_example"} // []string |  (opcional)
	urlId := "urlId_example" // string |  (opcional)
	timeBucket := openapiclient.AggregateTimeBucket("day") // AggregateTimeBucket |  (opcional)
	startDate := time.Now() // time.Time |  (opcional)
	forceRecalculate := true // bool |  (opcional)
	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)
	}
	// resposta de `AggregateQuestionResults`: AggregateQuestionResults200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AggregateQuestionResults`: %v\n", resp)
}

Agregação em Lote de Resultados de Perguntas

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
forceRecalculate	boolean	query	Não

Resposta

Retorna: BulkAggregateQuestionResults200Response

Exemplo

Exemplo de BulkAggregateQuestionResults

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	bulkAggregateQuestionResultsRequest := *openapiclient.NewBulkAggregateQuestionResultsRequest([]openapiclient.BulkAggregateQuestionItem{*openapiclient.NewBulkAggregateQuestionItem("AggId_example")}) // BulkAggregateQuestionResultsRequest | 
	forceRecalculate := true // bool |  (opcional)
	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)
	}
	// resposta de `BulkAggregateQuestionResults`: BulkAggregateQuestionResults200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.BulkAggregateQuestionResults`: %v\n", resp)
}

Combinar Comentários com Resultados de Perguntas

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
questionId	string	query	Não
questionIds	array	query	Não
urlId	string	query	Não
startDate	string	query	Não
forceRecalculate	boolean	query	Não
minValue	number	query	Não
maxValue	number	query	Não
limit	number	query	Não

Resposta

Retorna: CombineCommentsWithQuestionResults200Response

Exemplo

Exemplo de CombineCommentsWithQuestionResults

Copy

package main
import (
	"context"
	"fmt"
	"os"
    "time"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	questionId := "questionId_example" // string |  (opcional)
	questionIds := []string{"Inner_example"} // []string |  (opcional)
	urlId := "urlId_example" // string |  (opcional)
	startDate := time.Now() // time.Time |  (opcional)
	forceRecalculate := true // bool |  (opcional)
	minValue := float64(1.2) // float64 |  (opcional)
	maxValue := float64(1.2) // float64 |  (opcional)
	limit := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `CombineCommentsWithQuestionResults`: CombineCommentsWithQuestionResults200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CombineCommentsWithQuestionResults`: %v\n", resp)
}

Adicionar Usuário SSO

Parâmetros

Nome	Tipo	Local	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: AddSSOUserAPIResponse

Exemplo

Exemplo de 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)
	}
	// resposta de `AddSSOUser`: AddSSOUserAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AddSSOUser`: %v\n", resp)
}

Excluir Usuário SSO

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
deleteComments	boolean	query	Não
commentDeleteMode	string	query	Não

Resposta

Retorna: DeleteSSOUserAPIResponse

Exemplo

Exemplo de 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 |  (opcional)
	commentDeleteMode := "commentDeleteMode_example" // string |  (opcional)
	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)
	}
	// resposta de `DeleteSSOUser`: DeleteSSOUserAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteSSOUser`: %v\n", resp)
}

Obter Usuário SSO por Email

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim
email	string	path	Sim

Resposta

Retorna: GetSSOUserByEmailAPIResponse

Exemplo

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

Obter Usuário SSO por Id

Parâmetros

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

Resposta

Retorna: GetSSOUserByIdAPIResponse

Exemplo

Exemplo de 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)
	}
	// resposta de `GetSSOUserById`: GetSSOUserByIdAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSSOUserById`: %v\n", resp)
}

Obter Usuários SSO

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
skip	integer	query	Não

Resposta

Retorna: GetSSOUsers200Response

Exemplo

Exemplo de GetSSOUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	skip := int32(56) // int32 |  (opcional)
	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)
	}
	// resposta de `GetSSOUsers`: GetSSOUsers200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSSOUsers`: %v\n", resp)
}

Patch em Usuário SSO

Parâmetros

Nome	Tipo	Local	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
updateComments	boolean	query	Não

Resposta

Retorna: PatchSSOUserAPIResponse

Exemplo

Exemplo PatchSSOUser

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	updateAPISSOUserData := *openapiclient.NewUpdateAPISSOUserData() // UpdateAPISSOUserData | 
	updateComments := true // bool |  (opcional)
	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)
	}
	// resposta de `PatchSSOUser`: PatchSSOUserAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PatchSSOUser`: %v\n", resp)
}

Substituir Usuário SSO (PUT)

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
updateComments	boolean	query	Não

Resposta

Retorna: PutSSOUserAPIResponse

Exemplo

Exemplo de PutSSOUser

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	updateAPISSOUserData := *openapiclient.NewUpdateAPISSOUserData() // UpdateAPISSOUserData | 
	updateComments := true // bool |  (opcional)
	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)
	}
	// response from `PutSSOUser`: PutSSOUserAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.PutSSOUser`: %v\n", resp)
}

Criar Assinatura

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: CreateSubscriptionAPIResponse

Exemplo

Exemplo de 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)
	}
	// resposta de `CreateSubscription`: CreateSubscriptionAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateSubscription`: %v\n", resp)
}

Excluir Assinatura

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não

Resposta

Retorna: DeleteSubscriptionAPIResponse

Exemplo

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

Obter Assinaturas

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim
userId	string	query	Não

Resposta

Retorna: GetSubscriptionsAPIResponse

Exemplo

Exemplo de 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 |  (opcional)
	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)
	}
	// resposta de `GetSubscriptions`: GetSubscriptionsAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSubscriptions`: %v\n", resp)
}

Atualizar Assinatura

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não

Resposta

Retorna: UpdateSubscriptionAPIResponse

Exemplo

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

Obter Uso Diário do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
yearNumber	number	query	Não
monthNumber	number	query	Não
dayNumber	number	query	Não
skip	number	query	Não

Resposta

Retorna: GetTenantDailyUsages200Response

Exemplo

Exemplo de 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 |  (opcional)
	monthNumber := float64(1.2) // float64 |  (opcional)
	dayNumber := float64(1.2) // float64 |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetTenantDailyUsages`: GetTenantDailyUsages200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenantDailyUsages`: %v\n", resp)
}

Criar Pacote do Tenant

Parâmetros

Nome	Tipo	Local	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: CreateTenantPackage200Response

Exemplo

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

Excluir Pacote do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Obter Pacote do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetTenantPackage200Response

Exemplo

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

Obter Pacotes do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
skip	number	query	Não

Resposta

Retorna: GetTenantPackages200Response

Exemplo

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

Substituir Pacote do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Atualizar Pacote do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Yes
id	string	path	Yes

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Criar Usuário do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim

Resposta

Retorna: CreateTenantUser200Response

Exemplo

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

Excluir Usuário do Tenant

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
deleteComments	string	query	Não
commentDeleteMode	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de 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 |  (opcional)
	commentDeleteMode := "commentDeleteMode_example" // string |  (opcional)
	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)
	}
	// resposta de `DeleteTenantUser`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenantUser`: %v\n", resp)
}

Obter Usuário do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetTenantUser200Response

Exemplo

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

Obter Usuários do Tenant

Parâmetros

Nome	Tipo	Local	Obrigatório	Descrição
tenantId	string	query	Sim
skip	number	query	Não

Resposta

Retorna: GetTenantUsers200Response

Exemplo

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

Substituir Usuário do Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
updateComments	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Enviar Link de Login

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
redirectURL	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Atualizar Usuário do Tenant

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
updateComments	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo de 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 |  (opcional)
	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)
	}
	// resposta de `UpdateTenantUser`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateTenantUser`: %v\n", resp)
}

Criar Tenant

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim

Resposta

Retorna: CreateTenant200Response

Exemplo

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

Excluir Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
sure	string	query	Não

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

Exemplo 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 |  (opcional)
	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)
	}
	// resposta de `DeleteTenant`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteTenant`: %v\n", resp)
}

Obter Tenant

Parâmetros

Nome	Tipo	Local	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetTenant200Response

Exemplo

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

Obter Tenants

Parâmetros

Nome	Tipo	Local	Obrigatório
tenantId	string	query	Sim
meta	string	query	Não
skip	number	query	Não

Resposta

Retorna: GetTenants200Response

Exemplo

Exemplo de 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 |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetTenants`: GetTenants200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTenants`: %v\n", resp)
}

Atualizar Tenant

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: FlagCommentPublic200Response

Exemplo

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

Alterar Estado do Ticket

Parâmetros

Nome	Tipo	Local	Obrigatório
tenantId	string	query	Sim
userId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: ChangeTicketState200Response

Exemplo

Exemplo de 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)
	}
	// resposta de `ChangeTicketState`: ChangeTicketState200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.ChangeTicketState`: %v\n", resp)
}

Criar Ticket

Parâmetros

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

Resposta

Retorna: CreateTicket200Response

Exemplo

Exemplo de CreateTicket

Copy

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

Obter Ticket

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
id	string	path	Sim
userId	string	query	Não

Resposta

Retorna: GetTicket200Response

Exemplo

Exemplo de 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 |  (opcional)
	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)
	}
	// resposta de `GetTicket`: GetTicket200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTicket`: %v\n", resp)
}

Obter Tickets

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
userId	string	query	Não
state	number	query	Não
skip	number	query	Não
limit	number	query	Não

Resposta

Retorna: GetTickets200Response

Exemplo

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

Enviar Imagem

Enviar e redimensionar uma imagem

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	path	Yes
sizePreset	string	query	No	Predefinição de tamanho: "Default" (1000x1000px) ou "CrossPlatform" (cria tamanhos para dispositivos populares)
urlId	string	query	No	ID da página de onde o upload está sendo feito, para configurar

Resposta

Retorna: UploadImageResponse

Exemplo

Exemplo de 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 | Predefinição de tamanho: \"Default\" (1000x1000px) ou \"CrossPlatform\" (cria tamanhos para dispositivos populares) (opcional)
	urlId := "urlId_example" // string | ID da página de onde o upload está sendo feito, para configurar (opcional)
	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)
	}
	// resposta de `UploadImage`: UploadImageResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UploadImage`: %v\n", resp)
}

Obter Progresso da Insígnia do Usuário por Id

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: GetUserBadgeProgressById200Response

Exemplo

Exemplo de GetUserBadgeProgressById

Copy

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

Obter Progresso da Insígnia por Id de Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
userId	string	path	Sim

Resposta

Retorna: GetUserBadgeProgressById200Response

Exemplo

Exemplo de GetUserBadgeProgressByUserId

Copy

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

Obter Lista de Progresso de Insígnias do Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
userId	string	query	Não
limit	number	query	Não
skip	number	query	Não

Resposta

Retorna: GetUserBadgeProgressList200Response

Exemplo

Exemplo de GetUserBadgeProgressList

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (opcional)
	limit := float64(1.2) // float64 |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// response from `GetUserBadgeProgressList`: GetUserBadgeProgressList200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadgeProgressList`: %v\n", resp)
}

Criar Insígnia de Usuário

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim

Resposta

Retorna: CreateUserBadge200Response

Exemplo

Exemplo de CreateUserBadge

Copy

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

Excluir Insígnia de Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
id	string	path	Sim

Resposta

Retorna: UpdateUserBadge200Response

Exemplo

Exemplo de DeleteUserBadge

Copy

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

Obter Insígnia de Usuário

Parâmetros

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

Resposta

Retorna: GetUserBadge200Response

Exemplo

Exemplo de GetUserBadge

Copy

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

Obter Insígnias de Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
userId	string	query	Não
badgeId	string	query	Não
type	number	query	Não
displayedOnComments	boolean	query	Não
limit	number	query	Não
skip	number	query	Não

Resposta

Retorna: GetUserBadges200Response

Exemplo

Exemplo de GetUserBadges

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (opcional)
	badgeId := "badgeId_example" // string |  (opcional)
	type_ := float64(1.2) // float64 |  (opcional)
	displayedOnComments := true // bool |  (opcional)
	limit := float64(1.2) // float64 |  (opcional)
	skip := float64(1.2) // float64 |  (opcional)
	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)
	}
	// resposta de `GetUserBadges`: GetUserBadges200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadges`: %v\n", resp)
}

Atualizar Insígnia de Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Yes
id	string	path	Yes

Resposta

Retorna: UpdateUserBadge200Response

Exemplo

Exemplo de UpdateUserBadge

Copy

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

Obter Contagem de Notificações do Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório	Descrição
tenantId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: GetUserNotificationCount200Response

Exemplo

Exemplo de GetUserNotificationCount

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `GetUserNotificationCount`: GetUserNotificationCount200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotificationCount`: %v\n", resp)
}

Obter Notificações do Usuário

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
pageSize	integer	query	Não
afterId	string	query	Não
includeContext	boolean	query	Não
afterCreatedAt	integer	query	Não
unreadOnly	boolean	query	Não
dmOnly	boolean	query	Não
noDm	boolean	query	Não
includeTranslations	boolean	query	Não
sso	string	query	Não

Resposta

Retorna: GetUserNotifications200Response

Exemplo

Exemplo de GetUserNotifications

Copy

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

Redefinir Contagem de Notificações do Usuário

Parâmetros

Name	Type	Location	Required	Description
tenantId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: ResetUserNotifications200Response

Exemplo

Exemplo de ResetUserNotificationCount

Copy

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

Redefinir Notificações do Usuário

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
afterId	string	query	Não
afterCreatedAt	integer	query	Não
unreadOnly	boolean	query	Não
dmOnly	boolean	query	Não
noDm	boolean	query	Não
sso	string	query	Não

Resposta

Retorna: ResetUserNotifications200Response

Exemplo

Exemplo de ResetUserNotifications

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	afterId := "afterId_example" // string |  (opcional)
	afterCreatedAt := int64(789) // int64 |  (opcional)
	unreadOnly := true // bool |  (opcional)
	dmOnly := true // bool |  (opcional)
	noDm := true // bool |  (opcional)
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `ResetUserNotifications`: ResetUserNotifications200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ResetUserNotifications`: %v\n", resp)
}

Atualizar Status de Assinatura de Comentário nas Notificações do Usuário

Habilitar ou desabilitar notificações para um comentário específico.

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
notificationId	string	path	Sim
optedInOrOut	string	path	Sim
commentId	string	query	Sim
sso	string	query	Não

Resposta

Retorna: UpdateUserNotificationStatus200Response

Exemplo

Exemplo de UpdateUserNotificationCommentSubscriptionStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	notificationId := "notificationId_example" // string | 
	optedInOrOut := "optedInOrOut_example" // string | 
	commentId := "commentId_example" // string | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `UpdateUserNotificationCommentSubscriptionStatus`: UpdateUserNotificationStatus200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationCommentSubscriptionStatus`: %v\n", resp)
}

Atualizar Status de Assinatura de Página nas Notificações do Usuário

Ativar ou desativar notificações para uma página. Quando os usuários estão inscritos em uma página, notificações são criadas para novos comentários raiz, e também

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
urlId	string	query	Sim
url	string	query	Sim
pageTitle	string	query	Sim
subscribedOrUnsubscribed	string	path	Sim
sso	string	query	Não

Resposta

Retorna: UpdateUserNotificationStatus200Response

Exemplo

Exemplo de UpdateUserNotificationPageSubscriptionStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	url := "url_example" // string | 
	pageTitle := "pageTitle_example" // string | 
	subscribedOrUnsubscribed := "subscribedOrUnsubscribed_example" // string | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `UpdateUserNotificationPageSubscriptionStatus`: UpdateUserNotificationStatus200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationPageSubscriptionStatus`: %v\n", resp)
}

Atualizar Status de Notificação do Usuário

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
notificationId	string	path	Sim
newStatus	string	path	Sim
sso	string	query	Não

Resposta

Retorna: UpdateUserNotificationStatus200Response

Exemplo

Exemplo de UpdateUserNotificationStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	notificationId := "notificationId_example" // string | 
	newStatus := "newStatus_example" // string | 
	sso := "sso_example" // string |  (opcional)
	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)
	}
	// resposta de `UpdateUserNotificationStatus`: UpdateUserNotificationStatus200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationStatus`: %v\n", resp)
}

Obter Status de Presença dos Usuários

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Sim
urlIdWS	string	query	Sim
userIds	string	query	Sim

Resposta

Retorna: GetUserPresenceStatuses200Response

Exemplo

Exemplo de GetUserPresenceStatuses

Copy

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

Pesquisar Usuários

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	path	Sim
urlId	string	query	Sim
usernameStartsWith	string	query	Não
mentionGroupIds	array	query	Não
sso	string	query	Não
searchSection	string	query	Não

Resposta

Retorna: SearchUsers200Response

Exemplo

Exemplo de 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 |  (opcional)
	mentionGroupIds := []string{"Inner_example"} // []string |  (opcional)
	sso := "sso_example" // string |  (opcional)
	searchSection := "searchSection_example" // string |  (opcional)
	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)
	}
	// resposta de `SearchUsers`: SearchUsers200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SearchUsers`: %v\n", resp)
}

Obter Usuário

Parâmetros

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

Resposta

Retorna: GetUser200Response

Exemplo

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

Criar Voto

Parâmetros

Nome	Tipo	Localização	Obrigatório
tenantId	string	query	Sim
commentId	string	query	Sim
direction	string	query	Sim
userId	string	query	Não
anonUserId	string	query	Não

Resposta

Retorna: VoteComment200Response

Exemplo

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

Excluir Voto

Parâmetros

Name	Type	Location	Obrigatório
tenantId	string	query	Sim
id	string	path	Sim
editKey	string	query	Não

Resposta

Retorna: DeleteCommentVote200Response

Exemplo

Exemplo de DeleteVote

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	editKey := "editKey_example" // string |  (opcional)
	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)
	}
	// resposta de `DeleteVote`: DeleteCommentVote200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteVote`: %v\n", resp)
}

Obter Votos

Parâmetros

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

Resposta

Retorna: GetVotes200Response

Exemplo

Exemplo de GetVotes

Copy

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

Obter Votos de um Usuário

Parâmetros

Name	Type	Location	Required
tenantId	string	query	Yes
urlId	string	query	Yes
userId	string	query	No
anonUserId	string	query	No

Resposta

Retorna: GetVotesForUser200Response

Exemplo

Exemplo de 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 |  (opcional)
	anonUserId := "anonUserId_example" // string |  (opcional)
	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)
	}
	// resposta de `GetVotesForUser`: GetVotesForUser200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetVotesForUser`: %v\n", resp)
}

Precisa de ajuda?

Se você encontrar algum problema ou tiver dúvidas sobre o SDK para Go, por favor:

Contribuindo

Contribuições são bem-vindas! Por favor, visite o repositório no GitHub para as diretrizes de contribuição.

Idioma 🇧🇷 Português (Brasil)

Primeiros Passos

Uso

Agregação

Logs de Auditoria

Bloquear por Comentário

Verificar Comentários Bloqueados

Comentários

Configurações de Domínio

Modelos de E-mail

Registro de Eventos

Publicações do Feed

Denunciar Comentário

Hashtags

Moderadores

Contagem de Notificações

Notificações

Páginas

Eventos de Webhook Pendentes

Configurações de Perguntas

Resultados de Perguntas

Agregação de Resultados de Perguntas

Usuários SSO

Assinaturas

Uso Diário do Tenant

Pacotes do Tenant

Usuários do Tenant

Tenants

Tickets

Enviar Imagem

Progresso de Insígnias do Usuário

Insígnias do Usuário

Notificações do Usuário

Status de Presença do Usuário

Busca de Usuários

Usuários

Votos

SDK FastComments para Go

Repositório

Instalação

Usando o Cliente da API

PublicAPI (Sem Autenticação)

DefaultAPI (Requer chave de API)

Uso

SSO Simples

SSO Seguro

Agregação

Parameters

Response

Example

Obter Logs de Auditoria

Parâmetros

Resposta

Exemplo

Bloquear a partir do Comentário (Público)

Parameters

Response

Exemplo

Desbloquear Comentário (Público)

Parâmetros

Resposta

Exemplo

Verificar Comentários Bloqueados

Parâmetros

Resposta

Exemplo

Bloquear Usuário a partir do Comentário

Parâmetros

Resposta

Exemplo

Criar Comentário (Público)

Parâmetros

Resposta

Exemplo

Excluir Comentário

Parâmetros

Resposta

Exemplo

Excluir Comentário (Público)

Parâmetros