FastComments Go SDK

Dies ist das offizielle Go-SDK für FastComments.

Offizielles Go-SDK für die FastComments-API

Repository

Installation

go get github.com/fastcomments/fastcomments-go

Verwendung des API-Clients

Öffentliche API (keine Authentifizierung)

Die PublicAPI ermöglicht nicht authentifizierten Zugriff auf öffentliche Endpunkte:

package main

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

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

    // Kommentare mit PublicAPI abrufen
    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 (erfordert API-Schlüssel)

Die Default-API erfordert Authentifizierung mit Ihrem API-Schlüssel:

package main

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

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

    // Authentifizierten Kontext mit API-Schlüssel erstellen
    auth := context.WithValue(
        context.Background(),
        client.ContextAPIKeys,
        map[string]client.APIKey{
            "api_key": {Key: "your-api-key-here"},
        },
    )

    // Kommentare mit authentifizierter Default-API abrufen
    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)
}

Verwendung

Einfaches SSO

package main

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

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

    // Verwende das SSO-Token, um einen authentifizierten API-Aufruf zu tätigen
    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)
}

Sicheres SSO

package main

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

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

    // Verwende das SSO-Token, um einen authentifizierten API-Aufruf zu tätigen
    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)
}

Aggregation

Fasst Dokumente zusammen, indem sie gruppiert werden (falls groupBy angegeben ist) und mehrere Operationen angewendet werden. Verschiedene Operationen (z. B. sum, countDistinct, avg usw.) werden unterstützt.

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Yes
parentTenantId	string	query	No
includeStats	boolean	query	No

Antwort

Gibt zurück: AggregationResponse

Beispiel

Beispiel für Aggregation

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

Audit-Protokolle abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
limit	number	query	Nein
skip	number	query	Nein
order	string	query	Nein
after	number	query	Nein
before	number	query	Nein

Antwort

Gibt zurück: GetAuditLogs200Response

Beispiel

Beispiel für GetAuditLogs

Copy

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

Vom Kommentar blockieren (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Yes
commentId	string	path	Yes
sso	string	query	No

Antwort

Gibt zurück: BlockFromCommentPublic200Response

Beispiel

BlockFromCommentPublic Beispiel

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

Kommentar entsperren (öffentlich)

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
commentId	string	path	Ja
sso	string	query	Nein

Antwort

Gibt zurück: UnBlockCommentPublic200Response

Beispiel

UnBlockCommentPublic Beispiel

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

Auf blockierte Kommentare prüfen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
commentIds	string	query	Ja	Eine durch Kommas getrennte Liste von Kommentar-IDs.
sso	string	query	Nein

Antwort

Gibt zurück: CheckedCommentsForBlocked200Response

Beispiel

CheckedCommentsForBlocked Beispiel

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 | Eine durch Kommas getrennte Liste von Kommentar-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)
	}
	// Antwort von `CheckedCommentsForBlocked`: CheckedCommentsForBlocked200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.CheckedCommentsForBlocked`: %v\n", resp)
}

Benutzer vom Kommentar sperren

Parameter

Name	Type	Location	Required
tenantId	string	query	Ja
id	string	path	Ja
userId	string	query	Nein
anonUserId	string	query	Nein

Antwort

Gibt zurück: BlockFromCommentPublic200Response

Beispiel

BlockUserFromComment Beispiel

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

Kommentar erstellen (öffentlich)

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	path	Ja
urlId	string	query	Ja
broadcastId	string	query	Ja
sessionId	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: CreateCommentPublic200Response

Beispiel

CreateCommentPublic Beispiel

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

Kommentar löschen

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
contextUserId	string	query	Nein
isLive	boolean	query	Nein

Antwort

Gibt zurück: DeleteComment200Response

Beispiel

DeleteComment Beispiel

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

Kommentar löschen (öffentlich)

Parameter

Name	Type	Location	Required
tenantId	string	path	Ja
commentId	string	path	Ja
broadcastId	string	query	Ja
editKey	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: DeleteCommentPublic200Response

Beispiel

DeleteCommentPublic Beispiel

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

Kommentar-Stimme löschen

Parameter

Name	Typ	Ort	Erforderlich
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

Antwort

Gibt zurück: DeleteCommentVote200Response

Beispiel

Beispiel DeleteCommentVote

Copy

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

Kommentar melden

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Antwort

Gibt zurück: FlagComment200Response

Beispiel

FlagComment Beispiel

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

Kommentar abrufen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetComment200Response

Beispiel

GetComment Beispiel

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

Kommentare abrufen

Parameter

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

Antwort

Gibt zurück: GetComments200Response

Beispiel

GetComments Beispiel

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

Kommentare abrufen (öffentlich)

erforderlich tenantId urlId

Parameter

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

Antwort

Gibt zurück: GetCommentsPublic200Response

Beispiel

GetCommentsPublic Beispiel

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

Kommentartext abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
editKey	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: GetCommentText200Response

Beispiel

GetCommentText Beispiel

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

Nutzernamen von Kommentarstimmen abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
dir	integer	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: GetCommentVoteUserNames200Response

Beispiel

GetCommentVoteUserNames Beispiel

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

Kommentar sperren

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
broadcastId	string	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: LockComment200Response

Beispiel

LockComment Beispiel

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

Kommentar anheften

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Yes
commentId	string	path	Yes
broadcastId	string	query	Yes
sso	string	query	No

Antwort

Gibt zurück: PinComment200Response

Beispiel

PinComment Beispiel

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

Kommentar speichern

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
isLive	boolean	query	Nein
doSpamCheck	boolean	query	Nein
sendEmails	boolean	query	Nein
populateNotifications	boolean	query	Nein

Antwort

Gibt zurück: SaveComment200Response

Beispiel

SaveComment Beispiel

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

Kommentare stapelweise speichern

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
isLive	boolean	query	Nein
doSpamCheck	boolean	query	Nein
sendEmails	boolean	query	Nein
populateNotifications	boolean	query	Nein

Antwort

Gibt zurück: []SaveComment200Response

Beispiel

Beispiel für SaveCommentsBulk

Copy

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

Kommentartext festlegen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
broadcastId	string	query	Ja
editKey	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: SetCommentText200Response

Beispiel

SetCommentText Beispiel

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

Benutzer vom Kommentar entsperren

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
userId	string	query	Nein
anonUserId	string	query	Nein

Antwort

Gibt zurück: UnBlockCommentPublic200Response

Beispiel

UnBlockUserFromComment Beispiel

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

Kommentar-Meldung aufheben

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No
anonUserId	string	query	No

Antwort

Gibt zurück: FlagComment200Response

Beispiel

UnFlagComment Beispiel

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

Kommentar entsperren

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
broadcastId	string	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: LockComment200Response

Beispiel

UnLockComment Beispiel

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

Anheftung des Kommentars entfernen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
broadcastId	string	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: PinComment200Response

Beispiel

UnPinComment Beispiel

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

Kommentar aktualisieren

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
contextUserId	string	query	Nein
doSpamCheck	boolean	query	Nein
isLive	boolean	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für UpdateComment

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	id := "id_example" // string | 
	body := PickAPICommentUpdatableCommentFields(987) // PickAPICommentUpdatableCommentFields | 
	contextUserId := "contextUserId_example" // string |  (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)
	}
	// Antwort von `UpdateComment`: FlagCommentPublic200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.UpdateComment`: %v\n", resp)
}

Kommentar bewerten

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
commentId	string	path	Ja
urlId	string	query	Ja
broadcastId	string	query	Ja
sessionId	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: VoteComment200Response

Beispiel

VoteComment Beispiel

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

Domain-Konfiguration hinzufügen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: AddDomainConfig200Response

Beispiel

Beispiel für AddDomainConfig

Copy

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

Domain-Konfiguration löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
domain	string	path	Ja

Antwort

Gibt zurück: DeleteDomainConfig200Response

Beispiel

DeleteDomainConfig Beispiel

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

Domain-Konfiguration abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
domain	string	path	Ja

Antwort

Rückgabe: GetDomainConfig200Response

Beispiel

Beispiel für GetDomainConfig

Copy

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

Domain-Konfigurationen abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: GetDomainConfigs200Response

Beispiel

GetDomainConfigs Beispiel

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

Domain-Konfiguration teilweise aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
domainToUpdate	string	path	Ja

Antwort

Gibt zurück: GetDomainConfig200Response

Beispiel

PatchDomainConfig Beispiel

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

Domain-Konfiguration ersetzen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
domainToUpdate	string	path	Ja

Antwort

Gibt zurück: GetDomainConfig200Response

Beispiel

PutDomainConfig Beispiel

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

E-Mail-Vorlage erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateEmailTemplate200Response

Beispiel

Beispiel für CreateEmailTemplate

Copy

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

E-Mail-Vorlage löschen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für DeleteEmailTemplate

Copy

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

Render-Fehler der E-Mail-Vorlage löschen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
errorId	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für DeleteEmailTemplateRenderError

Copy

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

E-Mail-Vorlage abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetEmailTemplate200Response

Beispiel

GetEmailTemplate Beispiel

Copy

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

E-Mail-Vorlagen-Definitionen abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: GetEmailTemplateDefinitions200Response

Beispiel

GetEmailTemplateDefinitions Beispiel

Copy

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

Render-Fehler der E-Mail-Vorlagen abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
skip	number	query	Nein

Antwort

Gibt zurück: GetEmailTemplateRenderErrors200Response

Beispiel

Beispiel für GetEmailTemplateRenderErrors

Copy

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

E-Mail-Vorlagen abrufen

Parameter

Name	Type	Location	Required	Description
tenantId	string	query	Ja
skip	number	query	Nein

Antwort

Gibt zurück: GetEmailTemplates200Response

Beispiel

Beispiel für GetEmailTemplates

Copy

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

E-Mail-Vorlage rendern

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
locale	string	query	Nein

Antwort

Gibt zurück: RenderEmailTemplate200Response

Beispiel

RenderEmailTemplate Beispiel

Copy

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

E-Mail-Vorlage aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateEmailTemplate Beispiel

Copy

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

Ereignisprotokoll abrufen

req tenantId urlId userIdWS

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	path	Ja
urlId	string	query	Ja
userIdWS	string	query	Ja
startTime	integer	query	Ja
endTime	integer	query	Ja

Antwort

Gibt zurück: GetEventLog200Response

Beispiel

GetEventLog Beispiel

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

Globales Ereignisprotokoll abrufen

req tenantId urlId userIdWS

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	path	Ja
urlId	string	query	Ja
userIdWS	string	query	Ja
startTime	integer	query	Ja
endTime	integer	query	Ja

Antwort

Gibt zurück: GetEventLog200Response

Beispiel

Beispiel für GetGlobalEventLog

Copy

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

Feedbeitrag erstellen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
broadcastId	string	query	Nein
isLive	boolean	query	Nein
doSpamCheck	boolean	query	Nein
skipDupCheck	boolean	query	Nein

Antwort

Gibt zurück: CreateFeedPost200Response

Beispiel

CreateFeedPost Beispiel

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

Feedbeitrag erstellen (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
broadcastId	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: CreateFeedPostPublic200Response

Beispiel

CreateFeedPostPublic Beispiel

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

Feedbeitrag löschen (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Yes
postId	string	path	Yes
broadcastId	string	query	No
sso	string	query	No

Antwort

Gibt zurück: DeleteFeedPostPublic200Response

Beispiel

Beispiel für DeleteFeedPostPublic

Copy

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

Feedbeiträge abrufen

req tenantId afterId

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
afterId	string	query	Nein
limit	integer	query	Nein
tags	array	query	Nein

Antwort

Gibt zurück: GetFeedPosts200Response

Beispiel

GetFeedPosts Beispiel

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

Feedbeiträge abrufen (öffentlich)

erforderlich tenantId afterId

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
afterId	string	query	Nein
limit	integer	query	Nein
tags	array	query	Nein
sso	string	query	Nein
isCrawler	boolean	query	Nein
includeUserInfo	boolean	query	Nein

Antwort

Gibt zurück: GetFeedPostsPublic200Response

Beispiel

GetFeedPostsPublic Beispiel

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

Statistiken zu Feedbeiträgen abrufen

Parameter

Name	Type	Location	Required
tenantId	string	path	Ja
postIds	array	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: GetFeedPostsStats200Response

Beispiel

Beispiel für GetFeedPostsStats

Copy

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

Benutzerreaktionen abrufen (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
postIds	array	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: GetUserReactsPublic200Response

Beispiel

GetUserReactsPublic Beispiel

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

Auf Feedbeitrag reagieren (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
postId	string	path	Ja
isUndo	boolean	query	Nein
broadcastId	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: ReactFeedPostPublic200Response

Beispiel

ReactFeedPostPublic Beispiel

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

Feedbeitrag aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Yes
id	string	path	Yes

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateFeedPost Beispiel

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

Feedbeitrag aktualisieren (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
postId	string	path	Ja
broadcastId	string	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: CreateFeedPostPublic200Response

Beispiel

UpdateFeedPostPublic Beispiel

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

Kommentar melden (öffentlich)

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
commentId	string	path	Ja
isFlagged	boolean	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für FlagCommentPublic

Copy

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

Hashtag hinzufügen

Parameters

Name	Type	Location	Required	Description
tenantId	string	query	Nein

Response

Gibt zurück: AddHashTag200Response

Beispiel

AddHashTag Beispiel

Copy

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

Hashtags stapelweise hinzufügen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	No

Antwort

Gibt zurück: AddHashTagsBulk200Response

Beispiel

Beispiel für AddHashTagsBulk

Copy

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

Hashtag löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tag	string	Pfad	Ja
tenantId	string	Abfrage	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

DeleteHashTag Beispiel

Copy

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

Hashtags abrufen

Parameter

Name	Type	Location	Required	Description
tenantId	string	query	Ja
page	number	query	Nein

Antwort

Gibt zurück: GetHashTags200Response

Beispiel

GetHashTags Beispiel

Copy

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

Hashtag teilweise aktualisieren

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tag	string	path	Ja
tenantId	string	query	Nein

Antwort

Gibt zurück: PatchHashTag200Response

Beispiel

PatchHashTag Beispiel

Copy

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

Moderator erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateModerator200Response

Beispiel

CreateModerator Beispiel

Copy

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

Moderator löschen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
sendEmail	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

DeleteModerator Beispiel

Copy

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

Moderator abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetModerator200Response

Beispiel

GetModerator-Beispiel

Copy

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

Moderatoren abrufen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
skip	number	query	Nein

Antwort

Gibt zurück: GetModerators200Response

Beispiel

GetModerators Beispiel

Copy

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

Einladung senden

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
fromName	string	query	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

SendInvite Beispiel

Copy

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

Moderator aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateModerator Beispiel

Copy

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

Benachrichtigungszähler löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

DeleteNotificationCount Beispiel

Copy

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

Zwischengespeicherten Benachrichtigungszähler abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	Abfrage	Ja
id	string	Pfad	Ja

Antwort

Gibt zurück: GetCachedNotificationCount200Response

Beispiel

Beispiel für GetCachedNotificationCount

Copy

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

Anzahl der Benachrichtigungen abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
userId	string	query	Nein
urlId	string	query	Nein
fromCommentId	string	query	Nein
viewed	boolean	query	Nein
type	string	query	Nein

Antwort

Gibt zurück: GetNotificationCount200Response

Beispiel

GetNotificationCount Beispiel

Copy

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

Benachrichtigungen abrufen

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
userId	string	query	Nein
urlId	string	query	Nein
fromCommentId	string	query	Nein
viewed	boolean	query	Nein
type	string	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetNotifications200Response

Beispiel

GetNotifications Beispiel

Copy

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

Benachrichtigung aktualisieren

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
userId	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateNotification Beispiel

Copy

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

Seite hinzufügen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: AddPageAPIResponse

Beispiel

AddPage Beispiel

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

Seite löschen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: DeletePageAPIResponse

Beispiel

DeletePage Beispiel

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

Seite nach URL-ID abrufen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
urlId	string	query	Ja

Antwort

Gibt zurück: GetPageByURLIdAPIResponse

Beispiel

GetPageByURLId Beispiel

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

Seiten abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: GetPagesAPIResponse

Beispiel

GetPages-Beispiel

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

Seite teilweise aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: PatchPageAPIResponse

Beispiel

PatchPage Beispiel

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

Ausstehendes Webhook-Ereignis löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für DeletePendingWebhookEvent

Copy

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

Anzahl ausstehender Webhook-Ereignisse abrufen

Parameter

Name	Type	Location	Erforderlich
tenantId	string	query	Ja
commentId	string	query	Nein
externalId	string	query	Nein
eventType	string	query	Nein
type	string	query	Nein
domain	string	query	Nein
attemptCountGT	number	query	Nein

Antwort

Gibt zurück: GetPendingWebhookEventCount200Response

Beispiel

Beispiel für GetPendingWebhookEventCount

Copy

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

Ausstehende Webhook-Ereignisse abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
commentId	string	query	Nein
externalId	string	query	Nein
eventType	string	query	Nein
type	string	query	Nein
domain	string	query	Nein
attemptCountGT	number	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetPendingWebhookEvents200Response

Beispiel

GetPendingWebhookEvents Beispiel

Copy

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

Fragekonfiguration erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateQuestionConfig200Response

Beispiel

Beispiel für CreateQuestionConfig

Copy

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

Fragekonfiguration löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für DeleteQuestionConfig

Copy

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

Fragekonfiguration abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Yes
id	string	path	Yes

Antwort

Gibt zurück: GetQuestionConfig200Response

Beispiel

GetQuestionConfig Beispiel

Copy

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

Fragekonfigurationen abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
skip	number	query	Nein

Antwort

Gibt zurück: GetQuestionConfigs200Response

Beispiel

Beispiel für GetQuestionConfigs

Copy

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

Fragekonfiguration aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Yes
id	string	path	Yes

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateQuestionConfig Beispiel

Copy

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

Frageergebnis erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Yes

Antwort

Gibt zurück: CreateQuestionResult200Response

Beispiel

Beispiel für CreateQuestionResult

Copy

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

Frageergebnis löschen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

DeleteQuestionResult Beispiel

Copy

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

Frageergebnis abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetQuestionResult200Response

Beispiel

GetQuestionResult Beispiel

Copy

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

Frageergebnisse abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
urlId	string	query	Nein
userId	string	query	Nein
startDate	string	query	Nein
questionId	string	query	Nein
questionIds	string	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetQuestionResults200Response

Beispiel

GetQuestionResults Beispiel

Copy

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

Frageergebnis aktualisieren

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateQuestionResult Beispiel

Copy

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

Frageergebnisse aggregieren

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
questionId	string	query	Nein
questionIds	array	query	Nein
urlId	string	query	Nein
timeBucket	string	query	Nein
startDate	string	query	Nein
forceRecalculate	boolean	query	Nein

Antwort

Gibt zurück: AggregateQuestionResults200Response

Beispiel

AggregateQuestionResults Beispiel

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

Frageergebnisse stapelweise aggregieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
forceRecalculate	boolean	query	Nein

Antwort

Gibt zurück: BulkAggregateQuestionResults200Response

Beispiel

Beispiel für BulkAggregateQuestionResults

Copy

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

Kommentare mit Frageergebnissen kombinieren

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
questionId	string	query	Nein
questionIds	array	query	Nein
urlId	string	query	Nein
startDate	string	query	Nein
forceRecalculate	boolean	query	Nein
minValue	number	query	Nein
maxValue	number	query	Nein
limit	number	query	Nein

Antwort

Gibt zurück: CombineCommentsWithQuestionResults200Response

Beispiel

CombineCommentsWithQuestionResults Beispiel

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

SSO-Benutzer hinzufügen

Parameter

Name	Type	Location	Required	Description
tenantId	string	query	Ja

Antwort

Gibt zurück: AddSSOUserAPIResponse

Beispiel

AddSSOUser Beispiel

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

SSO-Benutzer löschen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
deleteComments	boolean	query	Nein
commentDeleteMode	string	query	Nein

Antwort

Gibt zurück: DeleteSSOUserAPIResponse

Beispiel

DeleteSSOUser Beispiel

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

SSO-Benutzer nach E-Mail abrufen

Parameter

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

Antwort

Gibt zurück: GetSSOUserByEmailAPIResponse

Beispiel

GetSSOUserByEmail Beispiel

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

SSO-Benutzer nach ID abrufen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetSSOUserByIdAPIResponse

Beispiel

GetSSOUserById Beispiel

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

SSO-Benutzer abrufen

Parameter

Name	Type	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
skip	integer	query	Nein

Antwort

Gibt zurück: GetSSOUsers200Response

Beispiel

GetSSOUsers Beispiel

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

SSO-Benutzer teilweise aktualisieren

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
updateComments	boolean	query	Nein

Antwort

Gibt zurück: PatchSSOUserAPIResponse

Beispiel

PatchSSOUser Beispiel

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

SSO-Benutzer ersetzen

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
updateComments	boolean	query	Nein

Antwort

Gibt zurück: PutSSOUserAPIResponse

Beispiel

PutSSOUser Beispiel

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

Abonnement erstellen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateSubscriptionAPIResponse

Beispiel

Beispiel für CreateSubscription

Copy

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

Abonnement löschen

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Yes
id	string	path	Yes
userId	string	query	No

Antwort

Gibt zurück: DeleteSubscriptionAPIResponse

Beispiel

DeleteSubscription Beispiel

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

Abonnements abrufen

Parameter

Name	Type	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
userId	string	query	Nein

Antwort

Gibt zurück: GetSubscriptionsAPIResponse

Beispiel

Beispiel für GetSubscriptions

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (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)
	}
	// Antwort von `GetSubscriptions`: GetSubscriptionsAPIResponse
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetSubscriptions`: %v\n", resp)
}

Abonnement aktualisieren

Parameter

Name	Type	Location	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
userId	string	query	Nein

Antwort

Gibt zurück: UpdateSubscriptionAPIResponse

Beispiel

Beispiel für UpdateSubscription

Copy

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

Tägliche Nutzung des Mandanten abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
yearNumber	number	query	Nein
monthNumber	number	query	Nein
dayNumber	number	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetTenantDailyUsages200Response

Beispiel

GetTenantDailyUsages Beispiel

Copy

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

Mandantenpaket erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateTenantPackage200Response

Beispiel

CreateTenantPackage Beispiel

Copy

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

Mandantenpaket löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für DeleteTenantPackage

Copy

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

Mandantenpaket abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetTenantPackage200Response

Beispiel

GetTenantPackage Beispiel

Copy

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

Mandantenpakete abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
skip	number	query	Nein

Antwort

Gibt zurück: GetTenantPackages200Response

Beispiel

GetTenantPackages Beispiel

Copy

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

Mandantenpaket ersetzen

Parameter

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

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

ReplaceTenantPackage Beispiel

Copy

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

Mandantenpaket aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

Beispiel für UpdateTenantPackage

Copy

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

Mandanten-Benutzer erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateTenantUser200Response

Beispiel

CreateTenantUser Beispiel

Copy

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

Mandanten-Benutzer löschen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
deleteComments	string	query	Nein
commentDeleteMode	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

DeleteTenantUser Beispiel

Copy

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

Mandanten-Benutzer abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetTenantUser200Response

Beispiel

GetTenantUser Beispiel

Copy

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

Mandanten-Benutzer abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
skip	number	query	Nein

Antwort

Gibt zurück: GetTenantUsers200Response

Beispiel

GetTenantUsers Beispiel

Copy

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

Mandanten-Benutzer ersetzen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
updateComments	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

ReplaceTenantUser Beispiel

Copy

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

Login-Link senden

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
redirectURL	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

SendLoginLink Beispiel

Copy

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

Mandanten-Benutzer aktualisieren

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
updateComments	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateTenantUser Beispiel

Copy

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

Mandant erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateTenant200Response

Beispiel

CreateTenant Beispiel

Copy

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

Mandant löschen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
sure	string	query	Nein

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

DeleteTenant Beispiel

Copy

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

Mandant abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetTenant200Response

Beispiel

GetTenant Beispiel

Copy

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

Mandanten abrufen

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
meta	string	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetTenants200Response

Beispiel

GetTenants Beispiel

Copy

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

Mandant aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: FlagCommentPublic200Response

Beispiel

UpdateTenant Beispiel

Copy

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

Ticket-Status ändern

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
userId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: ChangeTicketState200Response

Beispiel

Beispiel für ChangeTicketState

Copy

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

Ticket erstellen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
userId	string	query	Ja

Antwort

Gibt zurück: CreateTicket200Response

Beispiel

CreateTicket Beispiel

Copy

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

Ticket abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	Abfrage	Ja
id	string	Pfad	Ja
userId	string	Abfrage	Nein

Antwort

Gibt zurück: GetTicket200Response

Beispiel

GetTicket Beispiel

Copy

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

Tickets abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
userId	string	query	Nein
state	number	query	Nein
skip	number	query	Nein
limit	number	query	Nein

Antwort

Gibt zurück: GetTickets200Response

Beispiel

GetTickets Beispiel

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	userId := "userId_example" // string |  (optional)
	state := float64(1.2) // float64 |  (optional)
	skip := float64(1.2) // float64 |  (optional)
	limit := float64(1.2) // float64 |  (optional)
	configuration := openapiclient.NewConfiguration()
	apiClient := openapiclient.NewAPIClient(configuration)
	resp, r, err := apiClient.DefaultAPI.GetTickets(context.Background()).TenantId(tenantId).UserId(userId).State(state).Skip(skip).Limit(limit).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `DefaultAPI.GetTickets``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// Antwort von `GetTickets`: GetTickets200Response
	fmt.Fprintf(os.Stdout, "Response from `DefaultAPI.GetTickets`: %v\n", resp)
}

Bild hochladen

Bild hochladen und skalieren

Parameter

Name	Type	Location	Required	Description
tenantId	string	path	Ja
sizePreset	string	query	Nein	Größenvoreinstellung: "Default" (1000x1000px) oder "CrossPlatform" (erstellt Größen für gängige Geräte)
urlId	string	query	Nein	Seiten-ID, von der der Upload erfolgt, zur Konfiguration

Antwort

Gibt zurück: UploadImageResponse

Beispiel

UploadImage Beispiel

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 | Größenvoreinstellung: \"Default\" (1000x1000px) oder \"CrossPlatform\" (erstellt Größen für gängige Geräte) (optional)
	urlId := "urlId_example" // string | Seiten-ID, von der der Upload erfolgt, zur Konfiguration (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)
	}
	// Antwort von `UploadImage`: UploadImageResponse
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.UploadImage`: %v\n", resp)
}

Fortschritt des Benutzerabzeichens nach ID abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetUserBadgeProgressById200Response

Beispiel

GetUserBadgeProgressById Beispiel

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

Fortschritt des Benutzerabzeichens nach Benutzer-ID abrufen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja
userId	string	path	Ja

Antwort

Gibt zurück: GetUserBadgeProgressById200Response

Beispiel

Beispiel für GetUserBadgeProgressByUserId

Copy

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

Liste des Fortschritts der Benutzerabzeichen abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
userId	string	query	Nein
limit	number	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetUserBadgeProgressList200Response

Beispiel

GetUserBadgeProgressList Beispiel

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

Benutzerabzeichen erstellen

Parameter

Name	Typ	Location	Erforderlich	Beschreibung
tenantId	string	query	Ja

Antwort

Gibt zurück: CreateUserBadge200Response

Beispiel

Beispiel für CreateUserBadge

Copy

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

Benutzerabzeichen löschen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: UpdateUserBadge200Response

Beispiel

DeleteUserBadge Beispiel

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

Benutzerabzeichen abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Yes
id	string	path	Yes

Antwort

Gibt zurück: GetUserBadge200Response

Beispiel

GetUserBadge Beispiel

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

Benutzerabzeichen abrufen

Parameter

Name	Type	Location	Required
tenantId	string	query	Ja
userId	string	query	Nein
badgeId	string	query	Nein
type	number	query	Nein
displayedOnComments	boolean	query	Nein
limit	number	query	Nein
skip	number	query	Nein

Antwort

Gibt zurück: GetUserBadges200Response

Beispiel

GetUserBadges Beispiel

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

Benutzerabzeichen aktualisieren

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: UpdateUserBadge200Response

Beispiel

UpdateUserBadge Beispiel

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

Anzahl der Benutzerbenachrichtigungen abrufen

Parameter

Name	Type	Location	Required	Description
tenantId	string	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: GetUserNotificationCount200Response

Beispiel

Beispiel für GetUserNotificationCount

Copy

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

Benutzerbenachrichtigungen abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
pageSize	integer	query	Nein
afterId	string	query	Nein
includeContext	boolean	query	Nein
afterCreatedAt	integer	query	Nein
unreadOnly	boolean	query	Nein
dmOnly	boolean	query	Nein
noDm	boolean	query	Nein
includeTranslations	boolean	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: GetUserNotifications200Response

Beispiel

Beispiel für GetUserNotifications

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	pageSize := int32(56) // int32 |  (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)
	}
	// Antwort von `GetUserNotifications`: GetUserNotifications200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.GetUserNotifications`: %v\n", resp)
}

Benutzer-Benachrichtigungszähler zurücksetzen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: ResetUserNotifications200Response

Beispiel

Beispiel für ResetUserNotificationCount

Copy

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

Benachrichtigungen des Benutzers zurücksetzen

Parameter

Name	Typ	Location	Erforderlich
tenantId	string	query	Ja
afterId	string	query	Nein
afterCreatedAt	integer	query	Nein
unreadOnly	boolean	query	Nein
dmOnly	boolean	query	Nein
noDm	boolean	query	Nein
sso	string	query	Nein

Antwort

Gibt zurück: ResetUserNotifications200Response

Beispiel

ResetUserNotifications Beispiel

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

Kommentar-Abonnementstatus des Benutzers aktualisieren

Benachrichtigungen für einen bestimmten Kommentar aktivieren oder deaktivieren.

Parameter

Name	Type	Location	Required
tenantId	string	query	Ja
notificationId	string	path	Ja
optedInOrOut	string	path	Ja
commentId	string	query	Ja
sso	string	query	Nein

Antwort

Gibt zurück: UpdateUserNotificationStatus200Response

Beispiel

Beispiel für UpdateUserNotificationCommentSubscriptionStatus

Copy

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

Seiten-Abonnementstatus des Benutzers aktualisieren

Aktivieren oder deaktivieren Sie Benachrichtigungen für eine Seite. Wenn Benutzer für eine Seite abonniert sind, werden Benachrichtigungen für neue Root-Kommentare erstellt, und auch

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
urlId	string	query	Ja
url	string	query	Ja
pageTitle	string	query	Ja
subscribedOrUnsubscribed	string	path	Ja
sso	string	query	Nein

Antwort

Gibt zurück: UpdateUserNotificationStatus200Response

Beispiel

Beispiel für UpdateUserNotificationPageSubscriptionStatus

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/GIT_USER_ID/GIT_REPO_ID/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	url := "url_example" // string | 
	pageTitle := "pageTitle_example" // string | 
	subscribedOrUnsubscribed := "subscribedOrUnsubscribed_example" // string | 
	sso := "sso_example" // string |  (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)
}

Status der Benutzerbenachrichtigung aktualisieren

Parameter

Name	Type	Location	Required
tenantId	string	query	Ja
notificationId	string	path	Ja
newStatus	string	path	Ja
sso	string	query	Nein

Antwort

Gibt zurück: UpdateUserNotificationStatus200Response

Beispiel

UpdateUserNotificationStatus Beispiel

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

Anwesenheitsstatus der Benutzer abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
urlIdWS	string	query	Ja
userIds	string	query	Ja

Antwort

Gibt zurück: GetUserPresenceStatuses200Response

Beispiel

Beispiel für GetUserPresenceStatuses

Copy

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

Benutzer suchen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	path	Ja
urlId	string	query	Ja
usernameStartsWith	string	query	Nein
mentionGroupIds	array	query	Nein
sso	string	query	Nein
searchSection	string	query	Nein

Antwort

Gibt zurück: SearchUsers200Response

Beispiel

Beispiel für SearchUsers

Copy

package main
import (
	"context"
	"fmt"
	"os"
	openapiclient "github.com/fastcomments/fastcomments-go/client"
)
func main() {
	tenantId := "tenantId_example" // string | 
	urlId := "urlId_example" // string | 
	usernameStartsWith := "usernameStartsWith_example" // string |  (optional)
	mentionGroupIds := []string{"Inner_example"} // []string |  (optional)
	sso := "sso_example" // string |  (optional)
	searchSection := "searchSection_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).SearchSection(searchSection).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `PublicAPI.SearchUsers``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}
	// Antwort von `SearchUsers`: SearchUsers200Response
	fmt.Fprintf(os.Stdout, "Response from `PublicAPI.SearchUsers`: %v\n", resp)
}

Benutzer abrufen

Parameter

Name	Typ	Ort	Erforderlich	Beschreibung
tenantId	string	query	Ja
id	string	path	Ja

Antwort

Gibt zurück: GetUser200Response

Beispiel

GetUser Beispiel

Copy

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

Stimme erstellen

Parameter

Name	Type	Location	Erforderlich
tenantId	string	query	Ja
commentId	string	query	Ja
direction	string	query	Ja
userId	string	query	Nein
anonUserId	string	query	Nein

Antwort

Gibt zurück: VoteComment200Response

Beispiel

CreateVote Beispiel

Copy

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

Stimme löschen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Ja
id	string	path	Ja
editKey	string	query	Nein

Antwort

Gibt zurück: DeleteCommentVote200Response

Beispiel

DeleteVote Beispiel

Copy

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

Stimmen abrufen

Parameter

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

Antwort

Gibt zurück: GetVotes200Response

Beispiel

GetVotes Beispiel

Copy

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

Stimmen für Benutzer abrufen

Parameter

Name	Typ	Ort	Erforderlich
tenantId	string	query	Yes
urlId	string	query	Yes
userId	string	query	No
anonUserId	string	query	No

Antwort

Gibt zurück: GetVotesForUser200Response

Beispiel

Beispiel für GetVotesForUser

Copy

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

Benötigen Sie Hilfe?

Wenn Sie auf Probleme stoßen oder Fragen zum Go SDK haben, dann:

Contributing

Beiträge sind willkommen! Bitte besuchen Sie das GitHub-Repository für Richtlinien zur Mitwirkung.

Sprache 🇩🇪 Deutsch

Erste Schritte

Verwendung

Aggregation

Audit-Protokolle

Vom Kommentar sperren

Blockierte Kommentare prüfen

Kommentare

Domain-Konfigurationen

E-Mail-Vorlagen

Ereignisprotokoll

Feed-Beiträge

Kommentar melden

Hashtags

Moderatoren

Benachrichtigungszähler

Benachrichtigungen

Seiten

Ausstehende Webhook-Ereignisse

Fragekonfigurationen

Frageergebnisse

Aggregation von Frageergebnissen

SSO-Benutzer

Abonnements

Tägliche Nutzung des Mandanten

Mandantenpakete

Mandanten-Benutzer

Mandanten

Tickets

Bild hochladen

Fortschritt der Benutzerabzeichen

Benutzerabzeichen

Benutzerbenachrichtigungen

Anwesenheitsstatus der Benutzer

Benutzersuche

Benutzer

Stimmen

FastComments Go SDK

Repository

Installation

Verwendung des API-Clients

Öffentliche API (keine Authentifizierung)

Default-API (erfordert API-Schlüssel)

Verwendung

Einfaches SSO

Sicheres SSO

Aggregation

Parameter

Antwort

Beispiel

Audit-Protokolle abrufen

Parameter

Antwort

Beispiel

Vom Kommentar blockieren (öffentlich)

Parameter

Antwort

Beispiel

Kommentar entsperren (öffentlich)

Parameter

Antwort

Beispiel

Auf blockierte Kommentare prüfen

Parameter

Antwort

Beispiel

Benutzer vom Kommentar sperren

Parameter

Antwort

Beispiel

Kommentar erstellen (öffentlich)

Parameter

Antwort

Beispiel

Kommentar löschen

Parameter

Antwort

Beispiel

Kommentar löschen (öffentlich)

Parameter