FastComments Go SDK

This is the official Go SDK for FastComments.

Official Go SDK for the FastComments API

Repository

Installation

go get github.com/fastcomments/fastcomments-go

Using the API Client

Public API (No Authentication)

The PublicAPI allows unauthenticated access to public endpoints:

package main

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

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

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

    if err != nil {
        panic(err)
    }

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

Default API (Requires API Key)

The DefaultAPI requires authentication using your API key:

package main

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

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

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

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

    if err != nil {
        panic(err)
    }

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

Usage

Simple SSO

package main

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

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

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

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

    // Use the SSO token to make an authenticated API call
    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)
}

Secure SSO

package main

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

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

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

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

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

    // Use the SSO token to make an authenticated API call
    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)
}

Testing

Set the required environment variables:

export FASTCOMMENTS_API_KEY="your-api-key"
export FASTCOMMENTS_TENANT_ID="your-tenant-id"

Run the tests:

go test ./tests

Development

To update the generated client from the OpenAPI spec:

./update.sh

This will download the latest OpenAPI spec from a running FastComments server (or use a local copy) and regenerate the client code.

Support

For support, please visit https://fastcomments.com/auth/my-account/help or email support@fastcomments.com

Aggregate

Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
parentTenantId	string	query	No
includeStats	boolean	query	No

Response

Returns: AggregationResponse

Example

Aggregate Example

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 |  (optional)
    includeStats := true // bool |  (optional)
    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)
}

GetAuditLogs

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
limit	number	query	No
skip	number	query	No
order	string	query	No
after	number	query	No
before	number	query	No

Response

Returns: GetAuditLogs200Response

Example

GetAuditLogs Example

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 |  (optional)
    skip := float64(1.2) // float64 |  (optional)
    order := openapiclient.SORT_DIR("ASC") // SORTDIR |  (optional)
    after := float64(1.2) // float64 |  (optional)
    before := float64(1.2) // float64 |  (optional)
    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)
    }
    // response from `GetAuditLogs`: GetAuditLogs200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetAuditLogs`: %v\n", resp)
}

BlockFromCommentPublic

Parameters

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

Response

Returns: BlockFromCommentPublic200Response

Example

BlockFromCommentPublic Example

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

UnBlockCommentPublic

Parameters

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

Response

Returns: UnBlockCommentPublic200Response

Example

UnBlockCommentPublic Example

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

CheckedCommentsForBlocked

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes
commentIds	string	query	Yes	A comma separated list of comment ids.
sso	string	query	No

Response

Returns: CheckedCommentsForBlocked200Response

Example

CheckedCommentsForBlocked Example

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 | A comma separated list of comment ids.
    sso := "sso_example" // string |  (optional)
    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)
    }
    // response from `CheckedCommentsForBlocked`: CheckedCommentsForBlocked200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CheckedCommentsForBlocked`: %v\n", resp)
}

BlockUserFromComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Response

Returns: BlockFromCommentPublic200Response

Example

BlockUserFromComment Example

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

CreateCommentPublic

Parameters

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

Response

Returns: CreateCommentPublic200Response

Example

CreateCommentPublic Example

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 |  (optional)
    sso := "sso_example" // string |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.CreateCommentPublic(context.Background(), tenantId).UrlId(urlId).BroadcastId(broadcastId).CommentData(commentData).SessionId(sessionId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.CreateCommentPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateCommentPublic`: CreateCommentPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CreateCommentPublic`: %v\n", resp)
}

DeleteComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
contextUserId	string	query	No
isLive	boolean	query	No

Response

Returns: DeleteComment200Response

Example

DeleteComment Example

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

DeleteCommentPublic

Parameters

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

Response

Returns: DeleteCommentPublic200Response

Example

DeleteCommentPublic Example

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

DeleteCommentVote

Parameters

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

Response

Returns: DeleteCommentVote200Response

Example

DeleteCommentVote Example

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

FlagComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Response

Returns: FlagComment200Response

Example

FlagComment Example

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

GetComment

Parameters

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

Response

Returns: GetComment200Response

Example

GetComment Example

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

GetComments

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
page	integer	query	No
limit	integer	query	No
skip	integer	query	No
asTree	boolean	query	No
skipChildren	integer	query	No
limitChildren	integer	query	No
maxTreeDepth	integer	query	No
urlId	string	query	No
userId	string	query	No
anonUserId	string	query	No
contextUserId	string	query	No
hashTag	string	query	No
parentId	string	query	No
direction	string	query	No

Response

Returns: GetComments200Response

Example

GetComments Example

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 |  (optional)
    limit := int32(56) // int32 |  (optional)
    skip := int32(56) // int32 |  (optional)
    asTree := true // bool |  (optional)
    skipChildren := int32(56) // int32 |  (optional)
    limitChildren := int32(56) // int32 |  (optional)
    maxTreeDepth := int32(56) // int32 |  (optional)
    urlId := "urlId_example" // string |  (optional)
    userId := "userId_example" // string |  (optional)
    anonUserId := "anonUserId_example" // string |  (optional)
    contextUserId := "contextUserId_example" // string |  (optional)
    hashTag := "hashTag_example" // string |  (optional)
    parentId := "parentId_example" // string |  (optional)
    direction := openapiclient.SortDirections("OF") // SortDirections |  (optional)
    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)
    }
    // response from `GetComments`: GetComments200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetComments`: %v\n", resp)
}

GetCommentsPublic

req tenantId urlId

Parameters

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

Response

Returns: GetCommentsPublic200Response

Example

GetCommentsPublic Example

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 |  (optional)
    direction := openapiclient.SortDirections("OF") // SortDirections |  (optional)
    sso := "sso_example" // string |  (optional)
    skip := int32(56) // int32 |  (optional)
    skipChildren := int32(56) // int32 |  (optional)
    limit := int32(56) // int32 |  (optional)
    limitChildren := int32(56) // int32 |  (optional)
    countChildren := true // bool |  (optional)
    fetchPageForCommentId := "fetchPageForCommentId_example" // string |  (optional)
    includeConfig := true // bool |  (optional)
    countAll := true // bool |  (optional)
    includei10n := true // bool |  (optional)
    locale := "locale_example" // string |  (optional)
    modules := "modules_example" // string |  (optional)
    isCrawler := true // bool |  (optional)
    includeNotificationCount := true // bool |  (optional)
    asTree := true // bool |  (optional)
    maxTreeDepth := int32(56) // int32 |  (optional)
    useFullTranslationIds := true // bool |  (optional)
    parentId := "parentId_example" // string |  (optional)
    searchText := "searchText_example" // string |  (optional)
    hashTags := []string{"Inner_example"} // []string |  (optional)
    userId := "userId_example" // string |  (optional)
    customConfigStr := "customConfigStr_example" // string |  (optional)
    afterCommentId := "afterCommentId_example" // string |  (optional)
    beforeCommentId := "beforeCommentId_example" // string |  (optional)
    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)
    }
    // response from `GetCommentsPublic`: GetCommentsPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetCommentsPublic`: %v\n", resp)
}

GetCommentText

Parameters

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

Response

Returns: GetCommentText200Response

Example

GetCommentText Example

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

GetCommentVoteUserNames

Parameters

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

Response

Returns: GetCommentVoteUserNames200Response

Example

GetCommentVoteUserNames Example

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

LockComment

Parameters

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

Response

Returns: LockComment200Response

Example

LockComment Example

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

PinComment

Parameters

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

Response

Returns: PinComment200Response

Example

PinComment Example

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

SaveComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
isLive	boolean	query	No
doSpamCheck	boolean	query	No
sendEmails	boolean	query	No
populateNotifications	boolean	query	No

Response

Returns: SaveComment200Response

Example

SaveComment Example

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 |  (optional)
    doSpamCheck := true // bool |  (optional)
    sendEmails := true // bool |  (optional)
    populateNotifications := true // bool |  (optional)
    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)
    }
    // response from `SaveComment`: SaveComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveComment`: %v\n", resp)
}

SaveCommentsBulk

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
isLive	boolean	query	No
doSpamCheck	boolean	query	No
sendEmails	boolean	query	No
populateNotifications	boolean	query	No

Response

Returns: []SaveComment200Response

Example

SaveCommentsBulk Example

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 |  (optional)
    doSpamCheck := true // bool |  (optional)
    sendEmails := true // bool |  (optional)
    populateNotifications := true // bool |  (optional)
    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)
    }
    // response from `SaveCommentsBulk`: []SaveComment200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.SaveCommentsBulk`: %v\n", resp)
}

SetCommentText

Parameters

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

Response

Returns: SetCommentText200Response

Example

SetCommentText Example

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

UnBlockUserFromComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Response

Returns: UnBlockCommentPublic200Response

Example

UnBlockUserFromComment Example

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

UnFlagComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Response

Returns: FlagComment200Response

Example

UnFlagComment Example

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

UnLockComment

Parameters

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

Response

Returns: LockComment200Response

Example

UnLockComment Example

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

UnPinComment

Parameters

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

Response

Returns: PinComment200Response

Example

UnPinComment Example

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

UpdateComment

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
contextUserId	string	query	No
doSpamCheck	boolean	query	No
isLive	boolean	query	No

Response

Returns: FlagCommentPublic200Response

Example

UpdateComment Example

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 |  (optional)
    doSpamCheck := true // bool |  (optional)
    isLive := true // bool |  (optional)
    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)
}

VoteComment

Parameters

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

Response

Returns: VoteComment200Response

Example

VoteComment Example

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

AddDomainConfig

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: AddDomainConfig200Response

Example

AddDomainConfig Example

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

DeleteDomainConfig

Parameters

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

Response

Returns: DeleteDomainConfig200Response

Example

DeleteDomainConfig Example

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

GetDomainConfig

Parameters

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

Response

Returns: GetDomainConfig200Response

Example

GetDomainConfig Example

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

GetDomainConfigs

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: GetDomainConfigs200Response

Example

GetDomainConfigs Example

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

PatchDomainConfig

Parameters

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

Response

Returns: GetDomainConfig200Response

Example

PatchDomainConfig Example

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

PutDomainConfig

Parameters

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

Response

Returns: GetDomainConfig200Response

Example

PutDomainConfig Example

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

GetEventLog

req tenantId urlId userIdWS

Parameters

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

Response

Returns: GetEventLog200Response

Example

GetEventLog Example

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

GetGlobalEventLog

req tenantId urlId userIdWS

Parameters

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

Response

Returns: GetEventLog200Response

Example

GetGlobalEventLog Example

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

CreateFeedPost

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
broadcastId	string	query	No
isLive	boolean	query	No
doSpamCheck	boolean	query	No
skipDupCheck	boolean	query	No

Response

Returns: CreateFeedPost200Response

Example

CreateFeedPost Example

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 |  (optional)
    isLive := true // bool |  (optional)
    doSpamCheck := true // bool |  (optional)
    skipDupCheck := true // bool |  (optional)
    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)
    }
    // response from `CreateFeedPost`: CreateFeedPost200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CreateFeedPost`: %v\n", resp)
}

CreateFeedPostPublic

Parameters

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

Response

Returns: CreateFeedPostPublic200Response

Example

CreateFeedPostPublic Example

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

DeleteFeedPostPublic

Parameters

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

Response

Returns: DeleteFeedPostPublic200Response

Example

DeleteFeedPostPublic Example

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

GetFeedPosts

req tenantId afterId

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
afterId	string	query	No
limit	integer	query	No
tags	array	query	No

Response

Returns: GetFeedPosts200Response

Example

GetFeedPosts Example

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 |  (optional)
    limit := int32(56) // int32 |  (optional)
    tags := []string{"Inner_example"} // []string |  (optional)
    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)
    }
    // response from `GetFeedPosts`: GetFeedPosts200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetFeedPosts`: %v\n", resp)
}

GetFeedPostsPublic

req tenantId afterId

Parameters

Name	Type	Location	Required
tenantId	string	path	Yes
afterId	string	query	No
limit	integer	query	No
tags	array	query	No
sso	string	query	No
isCrawler	boolean	query	No
includeUserInfo	boolean	query	No

Response

Returns: GetFeedPostsPublic200Response

Example

GetFeedPostsPublic Example

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 |  (optional)
    limit := int32(56) // int32 |  (optional)
    tags := []string{"Inner_example"} // []string |  (optional)
    sso := "sso_example" // string |  (optional)
    isCrawler := true // bool |  (optional)
    includeUserInfo := true // bool |  (optional)
    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)
    }
    // response from `GetFeedPostsPublic`: GetFeedPostsPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetFeedPostsPublic`: %v\n", resp)
}

GetFeedPostsStats

Parameters

Name	Type	Location	Required
tenantId	string	path	Yes
postIds	array	query	Yes
sso	string	query	No

Response

Returns: GetFeedPostsStats200Response

Example

GetFeedPostsStats Example

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

GetUserReactsPublic

Parameters

Name	Type	Location	Required
tenantId	string	path	Yes
postIds	array	query	No
sso	string	query	No

Response

Returns: GetUserReactsPublic200Response

Example

GetUserReactsPublic Example

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 |  (optional)
    sso := "sso_example" // string |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.GetUserReactsPublic(context.Background(), tenantId).PostIds(postIds).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.GetUserReactsPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetUserReactsPublic`: GetUserReactsPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserReactsPublic`: %v\n", resp)
}

ReactFeedPostPublic

Parameters

Name	Type	Location	Required
tenantId	string	path	Yes
postId	string	path	Yes
isUndo	boolean	query	No
broadcastId	string	query	No
sso	string	query	No

Response

Returns: ReactFeedPostPublic200Response

Example

ReactFeedPostPublic Example

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 |  (optional)
    broadcastId := "broadcastId_example" // string |  (optional)
    sso := "sso_example" // string |  (optional)
    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)
    }
    // response from `ReactFeedPostPublic`: ReactFeedPostPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ReactFeedPostPublic`: %v\n", resp)
}

UpdateFeedPost

Parameters

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

Response

Returns: FlagCommentPublic200Response

Example

UpdateFeedPost Example

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

UpdateFeedPostPublic

Parameters

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

Response

Returns: CreateFeedPostPublic200Response

Example

UpdateFeedPostPublic Example

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 |  (optional)
    sso := "sso_example" // string |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UpdateFeedPostPublic(context.Background(), tenantId, postId).UpdateFeedPostParams(updateFeedPostParams).BroadcastId(broadcastId).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UpdateFeedPostPublic``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateFeedPostPublic`: CreateFeedPostPublic200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateFeedPostPublic`: %v\n", resp)
}

FlagCommentPublic

Parameters

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

Response

Returns: FlagCommentPublic200Response

Example

FlagCommentPublic Example

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

AddPage

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: AddPageAPIResponse

Example

AddPage Example

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

DeletePage

Parameters

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

Response

Returns: DeletePageAPIResponse

Example

DeletePage Example

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

GetPageByURLId

Parameters

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

Response

Returns: GetPageByURLIdAPIResponse

Example

GetPageByURLId Example

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

GetPages

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: GetPagesAPIResponse

Example

GetPages Example

Copy

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

PatchPage

Parameters

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

Response

Returns: PatchPageAPIResponse

Example

PatchPage Example

Copy

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

AggregateQuestionResults

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
questionId	string	query	No
questionIds	array	query	No
urlId	string	query	No
timeBucket	string	query	No
startDate	string	query	No
forceRecalculate	boolean	query	No

Response

Returns: AggregateQuestionResults200Response

Example

AggregateQuestionResults Example

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 |  (optional)
    questionIds := []string{"Inner_example"} // []string |  (optional)
    urlId := "urlId_example" // string |  (optional)
    timeBucket := openapiclient.AggregateTimeBucket("day") // AggregateTimeBucket |  (optional)
    startDate := time.Now() // time.Time |  (optional)
    forceRecalculate := true // bool |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.AggregateQuestionResults(context.Background()).TenantId(tenantId).QuestionId(questionId).QuestionIds(questionIds).UrlId(urlId).TimeBucket(timeBucket).StartDate(startDate).ForceRecalculate(forceRecalculate).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.AggregateQuestionResults``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `AggregateQuestionResults`: AggregateQuestionResults200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.AggregateQuestionResults`: %v\n", resp)
}

BulkAggregateQuestionResults

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes
forceRecalculate	boolean	query	No

Response

Returns: BulkAggregateQuestionResults200Response

Example

BulkAggregateQuestionResults Example

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

CombineCommentsWithQuestionResults

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
questionId	string	query	No
questionIds	array	query	No
urlId	string	query	No
startDate	string	query	No
forceRecalculate	boolean	query	No
minValue	number	query	No
maxValue	number	query	No
limit	number	query	No

Response

Returns: CombineCommentsWithQuestionResults200Response

Example

CombineCommentsWithQuestionResults Example

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 |  (optional)
    questionIds := []string{"Inner_example"} // []string |  (optional)
    urlId := "urlId_example" // string |  (optional)
    startDate := time.Now() // time.Time |  (optional)
    forceRecalculate := true // bool |  (optional)
    minValue := float64(1.2) // float64 |  (optional)
    maxValue := float64(1.2) // float64 |  (optional)
    limit := float64(1.2) // float64 |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.CombineCommentsWithQuestionResults(context.Background()).TenantId(tenantId).QuestionId(questionId).QuestionIds(questionIds).UrlId(urlId).StartDate(startDate).ForceRecalculate(forceRecalculate).MinValue(minValue).MaxValue(maxValue).Limit(limit).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.CombineCommentsWithQuestionResults``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CombineCommentsWithQuestionResults`: CombineCommentsWithQuestionResults200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.CombineCommentsWithQuestionResults`: %v\n", resp)
}

AddSSOUser

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: AddSSOUserAPIResponse

Example

AddSSOUser Example

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

DeleteSSOUser

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
deleteComments	boolean	query	No
commentDeleteMode	string	query	No

Response

Returns: DeleteSSOUserAPIResponse

Example

DeleteSSOUser Example

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 |  (optional)
    commentDeleteMode := "commentDeleteMode_example" // string |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.DefaultAPI.DeleteSSOUser(context.Background(), id).TenantId(tenantId).DeleteComments(deleteComments).CommentDeleteMode(commentDeleteMode).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.DeleteSSOUser``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteSSOUser`: DeleteSSOUserAPIResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.DeleteSSOUser`: %v\n", resp)
}

GetSSOUserByEmail

Parameters

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

Response

Returns: GetSSOUserByEmailAPIResponse

Example

GetSSOUserByEmail Example

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

GetSSOUserById

Parameters

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

Response

Returns: GetSSOUserByIdAPIResponse

Example

GetSSOUserById Example

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

GetSSOUsers

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes
skip	integer	query	No

Response

Returns: GetSSOUsers200Response

Example

GetSSOUsers Example

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

PatchSSOUser

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
updateComments	boolean	query	No

Response

Returns: PatchSSOUserAPIResponse

Example

PatchSSOUser Example

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

PutSSOUser

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
updateComments	boolean	query	No

Response

Returns: PutSSOUserAPIResponse

Example

PutSSOUser Example

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

CreateSubscription

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: CreateSubscriptionAPIResponse

Example

CreateSubscription Example

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

DeleteSubscription

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No

Response

Returns: DeleteSubscriptionAPIResponse

Example

DeleteSubscription Example

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

GetSubscriptions

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes
userId	string	query	No

Response

Returns: GetSubscriptionsAPIResponse

Example

GetSubscriptions Example

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

UploadImage

Upload and resize an image

Parameters

Name	Type	Location	Required	Description
tenantId	string	path	Yes
sizePreset	string	query	No	Size preset: "Default" (1000x1000px) or "CrossPlatform" (creates sizes for popular devices)
urlId	string	query	No	Page id that upload is happening from, to configure

Response

Returns: UploadImageResponse

Example

UploadImage Example

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 | Size preset: \"Default\" (1000x1000px) or \"CrossPlatform\" (creates sizes for popular devices) (optional)
    urlId := "urlId_example" // string | Page id that upload is happening from, to configure (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UploadImage(context.Background(), tenantId).File(file).SizePreset(sizePreset).UrlId(urlId).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UploadImage``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UploadImage`: UploadImageResponse
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UploadImage`: %v\n", resp)
}

GetUserBadgeProgressById

Parameters

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

Response

Returns: GetUserBadgeProgressById200Response

Example

GetUserBadgeProgressById Example

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

GetUserBadgeProgressByUserId

Parameters

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

Response

Returns: GetUserBadgeProgressById200Response

Example

GetUserBadgeProgressByUserId Example

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

GetUserBadgeProgressList

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
userId	string	query	No
limit	number	query	No
skip	number	query	No

Response

Returns: GetUserBadgeProgressList200Response

Example

GetUserBadgeProgressList Example

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

CreateUserBadge

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes

Response

Returns: CreateUserBadge200Response

Example

CreateUserBadge Example

Copy

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

DeleteUserBadge

Parameters

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

Response

Returns: UpdateUserBadge200Response

Example

DeleteUserBadge Example

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

GetUserBadge

Parameters

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

Response

Returns: GetUserBadge200Response

Example

GetUserBadge Example

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

GetUserBadges

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
userId	string	query	No
badgeId	string	query	No
type	number	query	No
displayedOnComments	boolean	query	No
limit	number	query	No
skip	number	query	No

Response

Returns: GetUserBadges200Response

Example

GetUserBadges Example

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 |  (optional)
    badgeId := "badgeId_example" // string |  (optional)
    type_ := float64(1.2) // float64 |  (optional)
    displayedOnComments := true // bool |  (optional)
    limit := float64(1.2) // float64 |  (optional)
    skip := float64(1.2) // float64 |  (optional)
    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)
    }
    // response from `GetUserBadges`: GetUserBadges200Response
    fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetUserBadges`: %v\n", resp)
}

UpdateUserBadge

Parameters

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

Response

Returns: UpdateUserBadge200Response

Example

UpdateUserBadge Example

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

GetUserNotificationCount

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes
sso	string	query	No

Response

Returns: GetUserNotificationCount200Response

Example

GetUserNotificationCount Example

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

GetUserNotifications

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
pageSize	integer	query	No
afterId	string	query	No
includeContext	boolean	query	No
afterCreatedAt	integer	query	No
unreadOnly	boolean	query	No
dmOnly	boolean	query	No
noDm	boolean	query	No
includeTranslations	boolean	query	No
sso	string	query	No

Response

Returns: GetUserNotifications200Response

Example

GetUserNotifications Example

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 |  (optional)
    afterId := "afterId_example" // string |  (optional)
    includeContext := true // bool |  (optional)
    afterCreatedAt := int64(789) // int64 |  (optional)
    unreadOnly := true // bool |  (optional)
    dmOnly := true // bool |  (optional)
    noDm := true // bool |  (optional)
    includeTranslations := true // bool |  (optional)
    sso := "sso_example" // string |  (optional)
    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)
}

ResetUserNotificationCount

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Yes
sso	string	query	No

Response

Returns: ResetUserNotifications200Response

Example

ResetUserNotificationCount Example

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

ResetUserNotifications

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
afterId	string	query	No
afterCreatedAt	integer	query	No
unreadOnly	boolean	query	No
dmOnly	boolean	query	No
noDm	boolean	query	No
sso	string	query	No

Response

Returns: ResetUserNotifications200Response

Example

ResetUserNotifications Example

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 |  (optional)
    afterCreatedAt := int64(789) // int64 |  (optional)
    unreadOnly := true // bool |  (optional)
    dmOnly := true // bool |  (optional)
    noDm := true // bool |  (optional)
    sso := "sso_example" // string |  (optional)
    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)
    }
    // response from `ResetUserNotifications`: ResetUserNotifications200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.ResetUserNotifications`: %v\n", resp)
}

UpdateUserNotificationCommentSubscriptionStatus

Enable or disable notifications for a specific comment.

Parameters

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

Response

Returns: UpdateUserNotificationStatus200Response

Example

UpdateUserNotificationCommentSubscriptionStatus Example

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

UpdateUserNotificationPageSubscriptionStatus

Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
urlId	string	query	Yes
url	string	query	Yes
pageTitle	string	query	Yes
subscribedOrUnsubscribed	string	path	Yes
sso	string	query	No

Response

Returns: UpdateUserNotificationStatus200Response

Example

UpdateUserNotificationPageSubscriptionStatus Example

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 |  (optional)
    configuration := openapiclient.NewConfiguration()
    apiClient := openapiclient.NewAPIClient(configuration)
    resp, r, err := apiClient.PublicAPI.UpdateUserNotificationPageSubscriptionStatus(context.Background(), subscribedOrUnsubscribed).TenantId(tenantId).UrlId(urlId).Url(url).PageTitle(pageTitle).Sso(sso).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.UpdateUserNotificationPageSubscriptionStatus``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateUserNotificationPageSubscriptionStatus`: UpdateUserNotificationStatus200Response
    fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UpdateUserNotificationPageSubscriptionStatus`: %v\n", resp)
}

UpdateUserNotificationStatus

Parameters

Name	Type	Location	Required
tenantId	string	query	Yes
notificationId	string	path	Yes
newStatus	string	path	Yes
sso	string	query	No

Response

Returns: UpdateUserNotificationStatus200Response

Example

UpdateUserNotificationStatus Example

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

GetUserPresenceStatuses

Parameters

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

Response

Returns: GetUserPresenceStatuses200Response

Example

GetUserPresenceStatuses Example

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

SearchUsers

Parameters

Name	Type	Location	Required
tenantId	string	path	Yes
urlId	string	query	Yes
usernameStartsWith	string	query	Yes
mentionGroupIds	array	query	No
sso	string	query	No

Response

Returns: SearchUsers200Response

Example

SearchUsers Example

Copy

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

Need Help?

If you encounter any issues or have questions about the Go SDK, please:

Contributing

Contributions are welcome! Please visit the GitHub repository for contribution guidelines.

Getting Started

Usage

Documentation

Aggregate

Audit Logs

Block From Comment

Check Blocked Comments

Comments

Domain Configs

Event Log

Feed Posts

Flag Comment

Pages

Question Results Aggregation

SSO Users

Subscriptions

Upload Image

User Badge Progress

User Badges

User Notifications

User Presence Status

User Search

FastComments Go SDK

Repository

Installation

Using the API Client

Public API (No Authentication)

Default API (Requires API Key)

Usage

Simple SSO

Secure SSO

Testing

Development

Support

Aggregate

Parameters

Response

Example

GetAuditLogs

Parameters

Response

Example

BlockFromCommentPublic

Parameters

Response

Example

UnBlockCommentPublic

Parameters

Response

Example

CheckedCommentsForBlocked

Parameters

Response

Example

BlockUserFromComment

Parameters

Response

Example

CreateCommentPublic

Parameters

Response

Example

DeleteComment

Parameters

Response

Example

DeleteCommentPublic

Parameters

Response

Example

DeleteCommentVote

Parameters

Response

Example

FlagComment

Parameters

Response

Example

GetComment

Parameters