FastComments C++ SDK

Dies ist das offizielle C++-SDK für FastComments.

Offizielles C++-SDK für die FastComments-API

Repository

Voraussetzungen

C++17 oder später
CMake 3.14 oder später
OpenSSL
C++ REST SDK (cpprestsdk)
Boost
Google Test (wird automatisch für Tests heruntergeladen)

Installation

Install Dependencies

sudo apt install libcpprest-dev libboost-all-dev

Building from Source

mkdir build
cd build
cmake ..
make

Installing

sudo make install

Library Contents

This library contains the generated API client and the SSO utilities to make working with the API easier.

API Client Library Docs

Public vs Secured APIs

For the API client, there are three classes, DefaultApi, PublicApi, and ModerationApi. The DefaultApi contains methods that require your API key, and PublicApi contains methods that can be made directly from a browser/mobile device/etc without authentication. The ModerationApi provides an extensive suite of live and fast moderation APIs. Every ModerationApi method accepts an sso parameter and can authenticate via SSO or a FastComments.com session cookie.

Schnellstart

Using Authenticated APIs (DefaultAPI)

Wichtig:

Sie müssen die Basis-URL festlegen (der cpp-restsdk-Generator liest sie nicht aus der OpenAPI-Spezifikation)
Sie müssen Ihren API‑Schlüssel im ApiClient setzen, bevor Sie authentifizierte Anfragen senden. Wenn Sie das nicht tun, schlagen die Anfragen mit einem 401‑Fehler fehl.

#include <iostream>
#include "FastCommentsClient/api/DefaultApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

int main() {
    auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();

    // ERFORDERLICH: Basis-URL festlegen (Region auswählen)
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));  // US
    // ODER: config->setBaseUrl(utility::conversions::to_string_t("https://eu.fastcomments.com"));  // EU

    // ERFORDERLICH: API-Schlüssel setzen
    config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_API_KEY_HERE"));

    auto apiClient = std::make_shared<org::openapitools::client::api::ApiClient>(config);
    org::openapitools::client::api::DefaultApi api(apiClient);

    // Jetzt authentifizierte API-Aufrufe tätigen
    return 0;
}

Using Public APIs (PublicAPI)

Öffentliche Endpunkte benötigen keine Authentifizierung:

#include <iostream>
#include "FastCommentsClient/api/PublicApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

int main() {
    auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();

    // ERFORDERLICH: Basis-URL festlegen
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

    auto apiClient = std::make_shared<org::openapitools::client::api::ApiClient>(config);
    org::openapitools::client::api::PublicApi publicApi(apiClient);

    // Öffentliche API-Aufrufe tätigen
    return 0;
}

Using Moderation APIs (ModerationApi)

Die ModerationApi treibt das Moderator‑Dashboard an. Jede Methode akzeptiert einen sso‑Parameter, sodass der Aufruf im Namen eines SSO‑authentifizierten Moderators ausgeführt wird (siehe den SSO‑Abschnitt unten, um zu erfahren, wie man ein Token erstellt):

#include <iostream>
#include "FastCommentsClient/api/ModerationApi.h"
#include "FastCommentsClient/ApiClient.h"
#include "FastCommentsClient/ApiConfiguration.h"

int main() {
    auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();

    // ERFORDERLICH: Basis-URL festlegen
    config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));

    auto apiClient = std::make_shared<org::openapitools::client::api::ApiClient>(config);
    org::openapitools::client::api::ModerationApi moderationApi(apiClient);

    // Übergeben Sie das SSO-Token des Moderators, um den Aufruf zu authentifizieren
    auto ssoToken = utility::conversions::to_string_t("YOUR_MODERATOR_SSO_TOKEN");

    org::openapitools::client::api::GetCountOptions options;
    options.sso = ssoToken;

    auto response = moderationApi.getCount(options).get();

    return 0;
}

Common Issues

"URI must contain a hostname"-Fehler: Stellen Sie sicher, dass Sie config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com")) aufrufen, bevor Sie den ApiClient erstellen. Der cpp-restsdk-Generator liest die Server‑URL nicht automatisch aus der OpenAPI‑Spezifikation.
401 "missing-api-key"-Fehler: Stellen Sie sicher, dass Sie config->setApiKey(utility::conversions::to_string_t("api_key"), utility::conversions::to_string_t("YOUR_KEY")) aufrufen, bevor Sie die DefaultAPI‑Instanz erstellen.
Falsche API-Klasse: Verwenden Sie DefaultApi für serverseitige authentifizierte Anfragen, PublicApi für clientseitige/öffentliche Anfragen und ModerationApi für Anfragen des Moderator‑Dashboards (authentifiziert mit einem Moderator‑SSO‑Token).

API-Aufrufe: Synchron vs. Asynchron

Alle API-Methoden in diesem SDK geben pplx::task<std::shared_ptr<ResponseType>> aus dem C++ REST SDK zurück. Das gibt Ihnen Flexibilität im Umgang mit API‑Antworten.

Synchrone Aufrufe mit `.get()`

Verwenden Sie .get(), um den aufrufenden Thread zu blockieren, bis die Anfrage abgeschlossen ist, und das Ergebnis synchron abzurufen:

auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();
config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));
config->setApiKey(utility::conversions::to_string_t("api_key"),
                  utility::conversions::to_string_t("YOUR_API_KEY"));

auto apiClient = std::make_shared<org::openapitools::client::api::ApiClient>(config);
org::openapitools::client::api::DefaultApi api(apiClient);

// Required parameters are positional; optional ones go in the options struct
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// Call .get() to block and get the result synchronously
auto response = api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).get();  // Blocks until the HTTP request completes

if (response && response->comments) {
    std::cout << "Found " << response->comments->size() << " comments" << std::endl;
}

Asynchrone Aufrufe mit `.then()`

Verwenden Sie .then() für nicht‑blockierende asynchrone Ausführung mit Callbacks:

auto config = std::make_shared<org::openapitools::client::api::ApiConfiguration>();
config->setBaseUrl(utility::conversions::to_string_t("https://fastcomments.com"));
config->setApiKey(utility::conversions::to_string_t("api_key"),
                  utility::conversions::to_string_t("YOUR_API_KEY"));

auto apiClient = std::make_shared<org::openapitools::client::api::ApiClient>(config);
org::openapitools::client::api::DefaultApi api(apiClient);

// Required parameters are positional; optional ones go in the options struct
org::openapitools::client::api::GetCommentsOptions options;
options.urlId = utility::conversions::to_string_t("your-url-id");

// Use .then() for asynchronous callback-based execution
api.getComments(
    utility::conversions::to_string_t("your-tenant-id"),
    options
).then([](std::shared_ptr<GetComments_200_response> response) {
    // This runs asynchronously when the request completes
    if (response && response->comments) {
        std::cout << "Found " << response->comments->size() << " comments" << std::endl;
    }
});

// Execution continues immediately without blocking
std::cout << "Request sent, continuing..." << std::endl;

Auswahl zwischen synchron und asynchron

Die Wahl hängt von Ihrer Laufzeitumgebung und Anwendungsarchitektur ab:

.get() (Synchronous blocking)

Blockiert den aufrufenden Thread, bis die HTTP‑Anfrage abgeschlossen ist
Einfacherer Codefluss, leichter nachvollziehbar
Geeignet für dedizierte Worker‑Threads, Batch‑Verarbeitung oder Kommandozeilen‑Tools
Nicht geeignet für Ereignisschleifen, GUI‑Threads oder ein‑threadige Server

.then() (Asynchronous non-blocking)

Gibt sofort zurück, der Callback wird ausgeführt, wenn die Anfrage abgeschlossen ist
Blockiert den aufrufenden Thread nicht
Erforderlich für ereignisgesteuerte Architekturen, GUI‑Anwendungen oder ein‑threadige Ereignisschleifen
Ermöglicht das Verketten mehrerer Operationen
Komplexerer Kontrollfluss

Die Testsuite des SDK verwendet ausschließlich .get(), was jedoch für die Testumgebung, in der Blockieren akzeptabel ist, passend ist.

Hinweise

Broadcast-IDs

Sie werden feststellen, dass Sie in einigen API-Aufrufen ein broadcastId übergeben sollen. Wenn Sie Ereignisse empfangen, erhalten Sie diese ID zurück, sodass Sie das Ereignis ignorieren können, wenn Sie vorhaben, Änderungen auf dem Client optimistisch anzuwenden (was Sie wahrscheinlich tun möchten, da es die beste Benutzererfahrung bietet). Übergeben Sie hier eine UUID. Die ID sollte ausreichend eindeutig sein, damit sie nicht zweimal in einer Browsersitzung auftritt.

SSO (Einmalanmeldung)

Beispiele für SSO finden Sie unten.

SSO-Nutzung

Einfaches SSO

#include <fastcomments/sso/fastcomments_sso.hpp>
#include <iostream>

using namespace fastcomments::sso;

int main() {
    SimpleSSOUserData user("user-123", "user@example.com", "https://example.com/avatar.jpg");
    FastCommentsSSO sso = FastCommentsSSO::newSimple(user);
    std::string token = sso.createToken();

    std::cout << "SSO Token: " << token << std::endl;
    return 0;
}

Sicheres SSO

#include <fastcomments/sso/fastcomments_sso.hpp>
#include <iostream>

using namespace fastcomments::sso;

int main() {
    SecureSSOUserData user("user-123", "user@example.com", "johndoe", "https://example.com/avatar.jpg");

    std::string apiKey = "your-api-key";
    FastCommentsSSO sso = FastCommentsSSO::newSecure(apiKey, user);
    std::string token = sso.createToken();

    std::cout << "Secure SSO Token: " << token << std::endl;
    return 0;
}

Dokumentation für fastcomments

Dokumentation der API-Endpunkte

All URIs are relative to https://fastcomments.com

Klasse	Methode	HTTP-Anfrage	Beschreibung
DefaultApi	addDomainConfig	POST /api/v1/domain-configs
DefaultApi	addHashTag	POST /api/v1/hash-tags
DefaultApi	addHashTagsBulk	POST /api/v1/hash-tags/bulk
DefaultApi	addPage	POST /api/v1/pages
DefaultApi	addSSOUser	POST /api/v1/sso-users
DefaultApi	aggregate	POST /api/v1/aggregate	Aggregiert Dokumente, indem sie (falls groupBy angegeben) gruppiert werden und mehrere Operationen angewendet werden. Verschiedene Operationen (z. B. sum, countDistinct, avg usw.) werden unterstützt.
DefaultApi	aggregateQuestionResults	GET /api/v1/question-results-aggregation
DefaultApi	blockUserFromComment	POST /api/v1/comments/{id}/block
DefaultApi	bulkAggregateQuestionResults	POST /api/v1/question-results-aggregation/bulk
DefaultApi	changeTicketState	PATCH /api/v1/tickets/{id}/state
DefaultApi	combineCommentsWithQuestionResults	GET /api/v1/question-results-aggregation/combine/comments
DefaultApi	createEmailTemplate	POST /api/v1/email-templates
DefaultApi	createFeedPost	POST /api/v1/feed-posts
DefaultApi	createModerator	POST /api/v1/moderators
DefaultApi	createQuestionConfig	POST /api/v1/question-configs
DefaultApi	createQuestionResult	POST /api/v1/question-results
DefaultApi	createSubscription	POST /api/v1/subscriptions
DefaultApi	createTenant	POST /api/v1/tenants
DefaultApi	createTenantPackage	POST /api/v1/tenant-packages
DefaultApi	createTenantUser	POST /api/v1/tenant-users
DefaultApi	createTicket	POST /api/v1/tickets
DefaultApi	createUserBadge	POST /api/v1/user-badges
DefaultApi	createVote	POST /api/v1/votes
DefaultApi	deleteComment	DELETE /api/v1/comments/{id}
DefaultApi	deleteDomainConfig	DELETE /api/v1/domain-configs/{domain}
DefaultApi	deleteEmailTemplate	DELETE /api/v1/email-templates/{id}
DefaultApi	deleteEmailTemplateRenderError	DELETE /api/v1/email-templates/{id}/render-errors/{errorId}
DefaultApi	deleteHashTag	DELETE /api/v1/hash-tags/{tag}
DefaultApi	deleteModerator	DELETE /api/v1/moderators/{id}
DefaultApi	deleteNotificationCount	DELETE /api/v1/notification-count/{id}
DefaultApi	deletePage	DELETE /api/v1/pages/{id}
DefaultApi	deletePendingWebhookEvent	DELETE /api/v1/pending-webhook-events/{id}
DefaultApi	deleteQuestionConfig	DELETE /api/v1/question-configs/{id}
DefaultApi	deleteQuestionResult	DELETE /api/v1/question-results/{id}
DefaultApi	deleteSSOUser	DELETE /api/v1/sso-users/{id}
DefaultApi	deleteSubscription	DELETE /api/v1/subscriptions/{id}
DefaultApi	deleteTenant	DELETE /api/v1/tenants/{id}
DefaultApi	deleteTenantPackage	DELETE /api/v1/tenant-packages/{id}
DefaultApi	deleteTenantUser	DELETE /api/v1/tenant-users/{id}
DefaultApi	deleteUserBadge	DELETE /api/v1/user-badges/{id}
DefaultApi	deleteVote	DELETE /api/v1/votes/{id}
DefaultApi	flagComment	POST /api/v1/comments/{id}/flag
DefaultApi	getAuditLogs	GET /api/v1/audit-logs
DefaultApi	getCachedNotificationCount	GET /api/v1/notification-count/{id}
DefaultApi	getComment	GET /api/v1/comments/{id}
DefaultApi	getComments	GET /api/v1/comments
DefaultApi	getDomainConfig	GET /api/v1/domain-configs/{domain}
DefaultApi	getDomainConfigs	GET /api/v1/domain-configs
DefaultApi	getEmailTemplate	GET /api/v1/email-templates/{id}
DefaultApi	getEmailTemplateDefinitions	GET /api/v1/email-templates/definitions
DefaultApi	getEmailTemplateRenderErrors	GET /api/v1/email-templates/{id}/render-errors
DefaultApi	getEmailTemplates	GET /api/v1/email-templates
DefaultApi	getFeedPosts	GET /api/v1/feed-posts	req tenantId afterId
DefaultApi	getHashTags	GET /api/v1/hash-tags
DefaultApi	getModerator	GET /api/v1/moderators/{id}
DefaultApi	getModerators	GET /api/v1/moderators
DefaultApi	getNotificationCount	GET /api/v1/notifications/count
DefaultApi	getNotifications	GET /api/v1/notifications
DefaultApi	getPageByURLId	GET /api/v1/pages/by-url-id
DefaultApi	getPages	GET /api/v1/pages
DefaultApi	getPendingWebhookEventCount	GET /api/v1/pending-webhook-events/count
DefaultApi	getPendingWebhookEvents	GET /api/v1/pending-webhook-events
DefaultApi	getQuestionConfig	GET /api/v1/question-configs/{id}
DefaultApi	getQuestionConfigs	GET /api/v1/question-configs
DefaultApi	getQuestionResult	GET /api/v1/question-results/{id}
DefaultApi	getQuestionResults	GET /api/v1/question-results
DefaultApi	getSSOUserByEmail	GET /api/v1/sso-users/by-email/{email}
DefaultApi	getSSOUserById	GET /api/v1/sso-users/by-id/{id}
DefaultApi	getSSOUsers	GET /api/v1/sso-users
DefaultApi	getSubscriptions	GET /api/v1/subscriptions
DefaultApi	getTenant	GET /api/v1/tenants/{id}
DefaultApi	getTenantDailyUsages	GET /api/v1/tenant-daily-usage
DefaultApi	getTenantPackage	GET /api/v1/tenant-packages/{id}
DefaultApi	getTenantPackages	GET /api/v1/tenant-packages
DefaultApi	getTenantUser	GET /api/v1/tenant-users/{id}
DefaultApi	getTenantUsers	GET /api/v1/tenant-users
DefaultApi	getTenants	GET /api/v1/tenants
DefaultApi	getTicket	GET /api/v1/tickets/{id}
DefaultApi	getTickets	GET /api/v1/tickets
DefaultApi	getUser	GET /api/v1/users/{id}
DefaultApi	getUserBadge	GET /api/v1/user-badges/{id}
DefaultApi	getUserBadgeProgressById	GET /api/v1/user-badge-progress/{id}
DefaultApi	getUserBadgeProgressByUserId	GET /api/v1/user-badge-progress/user/{userId}
DefaultApi	getUserBadgeProgressList	GET /api/v1/user-badge-progress
DefaultApi	getUserBadges	GET /api/v1/user-badges
DefaultApi	getVotes	GET /api/v1/votes
DefaultApi	getVotesForUser	GET /api/v1/votes/for-user
DefaultApi	patchDomainConfig	PATCH /api/v1/domain-configs/{domainToUpdate}
DefaultApi	patchHashTag	PATCH /api/v1/hash-tags/{tag}
DefaultApi	patchPage	PATCH /api/v1/pages/{id}
DefaultApi	patchSSOUser	PATCH /api/v1/sso-users/{id}
DefaultApi	putDomainConfig	PUT /api/v1/domain-configs/{domainToUpdate}
DefaultApi	putSSOUser	PUT /api/v1/sso-users/{id}
DefaultApi	renderEmailTemplate	POST /api/v1/email-templates/render
DefaultApi	replaceTenantPackage	PUT /api/v1/tenant-packages/{id}
DefaultApi	replaceTenantUser	PUT /api/v1/tenant-users/{id}
DefaultApi	saveComment	POST /api/v1/comments
DefaultApi	saveCommentsBulk	POST /api/v1/comments/bulk
DefaultApi	sendInvite	POST /api/v1/moderators/{id}/send-invite
DefaultApi	sendLoginLink	POST /api/v1/tenant-users/{id}/send-login-link
DefaultApi	unBlockUserFromComment	POST /api/v1/comments/{id}/un-block
DefaultApi	unFlagComment	POST /api/v1/comments/{id}/un-flag
DefaultApi	updateComment	PATCH /api/v1/comments/{id}
DefaultApi	updateEmailTemplate	PATCH /api/v1/email-templates/{id}
DefaultApi	updateFeedPost	PATCH /api/v1/feed-posts/{id}
DefaultApi	updateModerator	PATCH /api/v1/moderators/{id}
DefaultApi	updateNotification	PATCH /api/v1/notifications/{id}
DefaultApi	updateQuestionConfig	PATCH /api/v1/question-configs/{id}
DefaultApi	updateQuestionResult	PATCH /api/v1/question-results/{id}
DefaultApi	updateSubscription	PATCH /api/v1/subscriptions/{id}
DefaultApi	updateTenant	PATCH /api/v1/tenants/{id}
DefaultApi	updateTenantPackage	PATCH /api/v1/tenant-packages/{id}
DefaultApi	updateTenantUser	PATCH /api/v1/tenant-users/{id}
DefaultApi	updateUserBadge	PUT /api/v1/user-badges/{id}
ModerationApi	deleteModerationVote	DELETE /auth/my-account/moderate-comments/mod_api/vote/{commentId}/{voteId}
ModerationApi	getApiComments	GET /auth/my-account/moderate-comments/mod_api/api/comments
ModerationApi	getApiExportStatus	GET /auth/my-account/moderate-comments/mod_api/api/export/status
ModerationApi	getApiIds	GET /auth/my-account/moderate-comments/mod_api/api/ids
ModerationApi	getBanUsersFromComment	GET /auth/my-account/moderate-comments/mod_api/ban-users/from-comment/{commentId}
ModerationApi	getCommentBanStatus	GET /auth/my-account/moderate-comments/mod_api/get-comment-ban-status/{commentId}
ModerationApi	getCommentChildren	GET /auth/my-account/moderate-comments/mod_api/comment-children/{commentId}
ModerationApi	getCount	GET /auth/my-account/moderate-comments/mod_api/count
ModerationApi	getCounts	GET /auth/my-account/moderate-comments/banned-users/mod_api/counts
ModerationApi	getLogs	GET /auth/my-account/moderate-comments/mod_api/logs/{commentId}
ModerationApi	getManualBadges	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges
ModerationApi	getManualBadgesForUser	GET /auth/my-account/moderate-comments/mod_api/get-manual-badges-for-user
ModerationApi	getModerationComment	GET /auth/my-account/moderate-comments/mod_api/comment/{commentId}
ModerationApi	getModerationCommentText	GET /auth/my-account/moderate-comments/mod_api/get-comment-text/{commentId}
ModerationApi	getPreBanSummary	GET /auth/my-account/moderate-comments/mod_api/pre-ban-summary/{commentId}
ModerationApi	getSearchCommentsSummary	GET /auth/my-account/moderate-comments/mod_api/search/comments/summary
ModerationApi	getSearchPages	GET /auth/my-account/moderate-comments/mod_api/search/pages
ModerationApi	getSearchSites	GET /auth/my-account/moderate-comments/mod_api/search/sites
ModerationApi	getSearchSuggest	GET /auth/my-account/moderate-comments/mod_api/search/suggest
ModerationApi	getSearchUsers	GET /auth/my-account/moderate-comments/mod_api/search/users
ModerationApi	getTrustFactor	GET /auth/my-account/moderate-comments/mod_api/get-trust-factor
ModerationApi	getUserBanPreference	GET /auth/my-account/moderate-comments/mod_api/user-ban-preference
ModerationApi	getUserInternalProfile	GET /auth/my-account/moderate-comments/mod_api/get-user-internal-profile
ModerationApi	postAdjustCommentVotes	POST /auth/my-account/moderate-comments/mod_api/adjust-comment-votes/{commentId}
ModerationApi	postApiExport	POST /auth/my-account/moderate-comments/mod_api/api/export
ModerationApi	postBanUserFromComment	POST /auth/my-account/moderate-comments/mod_api/ban-user/from-comment/{commentId}
ModerationApi	postBanUserUndo	POST /auth/my-account/moderate-comments/mod_api/ban-user/undo
ModerationApi	postBulkPreBanSummary	POST /auth/my-account/moderate-comments/mod_api/bulk-pre-ban-summary
ModerationApi	postCommentsByIds	POST /auth/my-account/moderate-comments/mod_api/comments-by-ids
ModerationApi	postFlagComment	POST /auth/my-account/moderate-comments/mod_api/flag-comment/{commentId}
ModerationApi	postRemoveComment	POST /auth/my-account/moderate-comments/mod_api/remove-comment/{commentId}
ModerationApi	postRestoreDeletedComment	POST /auth/my-account/moderate-comments/mod_api/restore-deleted-comment/{commentId}
ModerationApi	postSetCommentApprovalStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-approval-status/{commentId}
ModerationApi	postSetCommentReviewStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-review-status/{commentId}
ModerationApi	postSetCommentSpamStatus	POST /auth/my-account/moderate-comments/mod_api/set-comment-spam-status/{commentId}
ModerationApi	postSetCommentText	POST /auth/my-account/moderate-comments/mod_api/set-comment-text/{commentId}
ModerationApi	postUnFlagComment	POST /auth/my-account/moderate-comments/mod_api/un-flag-comment/{commentId}
ModerationApi	postVote	POST /auth/my-account/moderate-comments/mod_api/vote/{commentId}
ModerationApi	putAwardBadge	PUT /auth/my-account/moderate-comments/mod_api/award-badge
ModerationApi	putCloseThread	PUT /auth/my-account/moderate-comments/mod_api/close-thread
ModerationApi	putRemoveBadge	PUT /auth/my-account/moderate-comments/mod_api/remove-badge
ModerationApi	putReopenThread	PUT /auth/my-account/moderate-comments/mod_api/reopen-thread
ModerationApi	setTrustFactor	PUT /auth/my-account/moderate-comments/mod_api/set-trust-factor
PublicApi	blockFromCommentPublic	POST /block-from-comment/{commentId}
PublicApi	checkedCommentsForBlocked	GET /check-blocked-comments
PublicApi	createCommentPublic	POST /comments/{tenantId}
PublicApi	createFeedPostPublic	POST /feed-posts/{tenantId}
PublicApi	createV1PageReact	POST /page-reacts/v1/likes/{tenantId}
PublicApi	createV2PageReact	POST /page-reacts/v2/{tenantId}
PublicApi	deleteCommentPublic	DELETE /comments/{tenantId}/{commentId}
PublicApi	deleteCommentVote	DELETE /comments/{tenantId}/{commentId}/vote/{voteId}
PublicApi	deleteFeedPostPublic	DELETE /feed-posts/{tenantId}/{postId}
PublicApi	deleteV1PageReact	DELETE /page-reacts/v1/likes/{tenantId}
PublicApi	deleteV2PageReact	DELETE /page-reacts/v2/{tenantId}
PublicApi	flagCommentPublic	POST /flag-comment/{commentId}
PublicApi	getCommentText	GET /comments/{tenantId}/{commentId}/text
PublicApi	getCommentVoteUserNames	GET /comments/{tenantId}/{commentId}/votes
PublicApi	getCommentsForUser	GET /comments-for-user
PublicApi	getCommentsPublic	GET /comments/{tenantId}	req tenantId urlId
PublicApi	getEventLog	GET /event-log/{tenantId}	req tenantId urlId userIdWS
PublicApi	getFeedPostsPublic	GET /feed-posts/{tenantId}	req tenantId afterId
PublicApi	getFeedPostsStats	GET /feed-posts/{tenantId}/stats
PublicApi	getGifLarge	GET /gifs/get-large/{tenantId}
PublicApi	getGifsSearch	GET /gifs/search/{tenantId}
PublicApi	getGifsTrending	GET /gifs/trending/{tenantId}
PublicApi	getGlobalEventLog	GET /event-log/global/{tenantId}	req tenantId urlId userIdWS
PublicApi	getOfflineUsers	GET /pages/{tenantId}/users/offline	Früher kommentierende Nutzer der Seite, die derzeit NICHT online sind. Sortiert nach displayName. Verwenden Sie dies, nachdem /users/online erschöpft ist, um einen "Members"-Abschnitt zu rendern. Cursor‑Paginierung nach commenterName: Der Server durchläuft den partiellen {tenantId, urlId, commenterName}-Index ab afterName weiter mittels $gt, ohne $skip‑Kosten.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Derzeit online befindliche Betrachter einer Seite: Personen, deren Websocket‑Sitzung gerade für die Seite abonniert ist. Gibt anonCount + totalCount zurück (räumweite Abonnenten, einschließlich anonymer Betrachter, die wir nicht auflisten).
PublicApi	getPagesPublic	GET /pages/{tenantId}	Liste der Seiten für einen Tenant. Wird vom FChat‑Desktop‑Client verwendet, um dessen Raumliste zu füllen. Erfordert, dass `enableFChat` in der aufgelösten benutzerdefinierten Konfiguration jeder Seite auf true gesetzt ist. Seiten, die SSO benötigen, werden anhand des Gruppenzugriffs des anfordernden Benutzers gefiltert.
PublicApi	getTranslations	GET /translations/{namespace}/{component}
PublicApi	getUserNotificationCount	GET /user-notifications/get-count
PublicApi	getUserNotifications	GET /user-notifications
PublicApi	getUserPresenceStatuses	GET /user-presence-status
PublicApi	getUserReactsPublic	GET /feed-posts/{tenantId}/user-reacts
PublicApi	getUsersInfo	GET /pages/{tenantId}/users/info	Bulk‑User‑Info für einen Tenant. Gegeben userIds, Rückgabe von Anzeigedaten aus User / SSOUser. Wird vom Kommentar‑Widget verwendet, um Nutzer zu erweitern, die gerade über ein Presence‑Event erschienen sind. Kein Seiten‑Kontext: Datenschutz wird einheitlich durchgesetzt (private Profile werden maskiert).
PublicApi	getV1PageLikes	GET /page-reacts/v1/likes/{tenantId}
PublicApi	getV2PageReactUsers	GET /page-reacts/v2/{tenantId}/list
PublicApi	getV2PageReacts	GET /page-reacts/v2/{tenantId}
PublicApi	lockComment	POST /comments/{tenantId}/{commentId}/lock
PublicApi	logoutPublic	PUT /auth/logout
PublicApi	pinComment	POST /comments/{tenantId}/{commentId}/pin
PublicApi	reactFeedPostPublic	POST /feed-posts/{tenantId}/react/{postId}
PublicApi	resetUserNotificationCount	POST /user-notifications/reset-count
PublicApi	resetUserNotifications	POST /user-notifications/reset
PublicApi	searchUsers	GET /user-search/{tenantId}
PublicApi	setCommentText	POST /comments/{tenantId}/{commentId}/update-text
PublicApi	unBlockCommentPublic	DELETE /block-from-comment/{commentId}
PublicApi	unLockComment	POST /comments/{tenantId}/{commentId}/unlock
PublicApi	unPinComment	POST /comments/{tenantId}/{commentId}/unpin
PublicApi	updateFeedPostPublic	PUT /feed-posts/{tenantId}/{postId}
PublicApi	updateUserNotificationCommentSubscriptionStatus	POST /user-notifications/{notificationId}/mark-opted/{optedInOrOut}	Benachrichtigungen für einen konkreten Kommentar aktivieren oder deaktivieren.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Benachrichtigungen für eine Seite aktivieren oder deaktivieren. Wenn Benutzer eine Seite abonnieren, werden Benachrichtigungen für neue Hauptkommentare erstellt, und außerdem
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Bild hochladen und skalieren
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Dokumentation der Modelle

aggregate

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

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
aggregationRequest	AggregationRequest	Ja
options	const AggregateOptions&	Ja

Antwort

Rückgabe: AggregateResponse

Beispiel

Aggregationsbeispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
AggregationRequest aggregationRequest;
aggregationRequest.setMetric(U("commentCount"));
aggregationRequest.setStartDate(U("2023-01-01T00:00:00Z"));
aggregationRequest.setEndDate(U("2023-12-31T23:59:59Z"));
aggregationRequest.setFilters({ U("status:approved") });
AggregateOptions options;
options.limit = boost::optional<int>(100);
options.includeMetadata = boost::optional<bool>(true);
api->aggregate(tenantId, aggregationRequest, options)
    .then([](pplx::task<std::shared_ptr<AggregateResponse>> task) {
        try {
            auto response = task.get();
            // Antwort verarbeiten
        } catch (const std::exception& e) {
            // Fehler behandeln
        }
    });

getAuditLogs

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetAuditLogsOptions&	Yes

Antwort

Rückgabe: GetAuditLogsResponse

Beispiel

getAuditLogs Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetAuditLogsOptions options;
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::RFC_1123));
options.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::RFC_1123));
options.limit     = boost::optional<int>(100);
api->getAuditLogs(tenantId, options).then([](pplx::task<std::shared_ptr<GetAuditLogsResponse>> t) {
    try {
        auto response = t.get();
        // Antwort verwenden
    } catch (const std::exception& e) {
        // Fehler behandeln
    }
});

logoutPublic

Antwort

Rückgabe: APIEmptyResponse

Beispiel

logoutPublic Beispiel

Copy

api->logoutPublic()
    .then([](std::shared_ptr<APIEmptyResponse> /*resp*/) {
        std::cout << "Logout successful\n";
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception& e) {
            std::cerr << "Logout failed: " << e.what() << std::endl;
        }
    });

blockFromCommentPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
publicBlockFromCommentParams	PublicBlockFromCommentParams	Yes
sso	string	No

Antwort

Rückgabe: BlockSuccess

Beispiel

blockFromCommentPublic Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-987654");
PublicBlockFromCommentParams blockParams;
blockParams.reason = utility::conversions::to_string_t("spam");
blockParams.durationHours = 24;
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("sso-token-abc123");
api->blockFromCommentPublic(tenantId, commentId, blockParams, sso)
    .then([](std::shared_ptr<BlockSuccess> result){
        auto successCopy = std::make_shared<BlockSuccess>(*result);
    });

unBlockCommentPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
publicBlockFromCommentParams	PublicBlockFromCommentParams	Ja
sso	string	Nein

Antwort

Rückgabe: UnblockSuccess

Beispiel

unBlockCommentPublic Beispiel

Copy

auto blockParams = PublicBlockFromCommentParams();  
blockParams.reason = U("spam");  
api->unBlockCommentPublic(  
    U("my-tenant-123"),  
    U("comment-789"),  
    blockParams,  
    boost::optional<utility::string_t>(U("sso-token-abc"))  
).then([](std::shared_ptr<UnblockSuccess> result){ });

checkedCommentsForBlocked

Parameters

Name	Typ	Erforderlich
tenantId	string	Yes
commentIds	string	Yes
sso	string	No

Response

Rückgabe: CheckBlockedCommentsResponse

Example

checkedCommentsForBlocked Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto commentIds = U("cmt-001,cmt-002");
boost::optional<utility::string_t> sso = U("user@example.com");
api->checkedCommentsForBlocked(tenantId, commentIds, sso).then([](std::shared_ptr<CheckBlockedCommentsResponse> resp){
    (void)resp;
});

blockUserFromComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
blockFromCommentParams	BlockFromCommentParams	Ja
options	const BlockUserFromCommentOptions&	Ja

Antwort

Rückgabe: BlockSuccess

Beispiel

blockUserFromComment Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-789");
BlockFromCommentParams params;
params.reason = utility::conversions::to_string_t("Inappropriate content");
params.durationDays = boost::optional<int>(30);
BlockUserFromCommentOptions options;
options.notifyUser = boost::optional<bool>(true);
api->blockUserFromComment(tenantId, commentId, params, options)
    .then([](std::shared_ptr<BlockSuccess> result){ })
    .then([](pplx::task<void> t){ try { t.get(); } catch (const std::exception&) { } });

createCommentPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
commentData	CommentData	Ja
options	const CreateCommentPublicOptions&	Ja

Antwort

Rückgabe: SaveCommentsResponseWithPresence

Beispiel

createCommentPublic Beispiel

Copy

auto comment = CommentData();
comment.body = U("This is a test comment");
comment.authorName = U("John Doe");
comment.authorEmail = U("john.doe@example.com");
CreateCommentPublicOptions opts;
opts.replyToCommentId = boost::optional<utility::string_t>(U("parent-123"));
api->createCommentPublic(
    U("my-tenant-123"),
    U("article-456"),
    U("broadcast-789"),
    comment,
    opts).then([](std::shared_ptr<SaveCommentsResponseWithPresence> res){
        auto commentId = res->commentId;
    });

deleteComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
options	const DeleteCommentOptions&	Ja

Antwort

Rückgabe: DeleteCommentResult

Beispiel

deleteComment Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-789");
DeleteCommentOptions options;
options.reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Inappropriate content"));
options.force = boost::optional<bool>(true);
api->deleteComment(tenantId, commentId, options).then([](pplx::task<std::shared_ptr<DeleteCommentResult>> task){
    try{
        auto result = task.get();
    }catch(const std::exception&){
    }
});

deleteCommentPublic

Parameter

Name	Type	Erforderlich
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentPublicOptions&	Yes

Antwort

Rückgabe: PublicAPIDeleteCommentResponse

Beispiel

deleteCommentPublic Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("comment-456"));
auto broadcastId = utility::string_t(U("broadcast-789"));
DeleteCommentPublicOptions options;
options.force = boost::optional<bool>(true);
options.reason = boost::optional<utility::string_t>(U("Inappropriate content"));
api->deleteCommentPublic(tenantId, commentId, broadcastId, options)
    .then([](pplx::task<std::shared_ptr<PublicAPIDeleteCommentResponse>> t){
        try{
            auto resp = t.get();
        }catch(const std::exception& e){
        }
    });

deleteCommentVote

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
voteId	string	Yes
urlId	string	Yes
broadcastId	string	Yes
options	const DeleteCommentVoteOptions&	Yes

Antwort

Rückgabe: VoteDeleteResponse

Beispiel

deleteCommentVote Beispiel

Copy

auto options = DeleteCommentVoteOptions{};
options.reason = boost::optional<utility::string_t>(U("spam"));
options.adminOverride = boost::optional<bool>(true);
api->deleteCommentVote(
    U("my-tenant-123"),
    U("cmt-456789"),
    U("vote-987"),
    U("url-abc123"),
    U("broadcast-001"),
    options
).then([](std::shared_ptr<VoteDeleteResponse> resp){
    if (resp) {
        std::cout << "Deleted vote, code: " << resp->code << std::endl;
    }
});

flagComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
options	const FlagCommentOptions&	Yes

Antwort

Rückgabe: FlagCommentResponse

Beispiel

flagComment Beispiel

Copy

auto opts = std::make_shared<FlagCommentOptions>();
opts->reason = utility::conversions::to_string_t("spam");
opts->note = boost::optional<utility::string_t>(utility::conversions::to_string_t("User posted duplicate links"));
api->flagComment(utility::conversions::to_string_t("my-tenant-123"),
                 utility::conversions::to_string_t("comment-456"),
                 *opts)
    .then([](pplx::task<std::shared_ptr<FlagCommentResponse>> t) {
        auto resp = t.get();
    });

getComment

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIGetCommentResponse

Beispiel

getComment Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
boost::optional<int> maxDepth = boost::none;
api->getComment(tenantId, commentId).then([](pplx::task<std::shared_ptr<APIGetCommentResponse>> t){
    try{
        auto resp = t.get();
    }catch(const std::exception&){
    }
});

getComments

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetCommentsOptions&	Yes

Antwort

Rückgabe: APIGetCommentsResponse

Beispiel

getComments Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCommentsOptions options;
options.page = 1;
options.limit = 50;
options.sort = U("newest");
options.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
api->getComments(tenantId, options).then([](pplx::task<std::shared_ptr<APIGetCommentsResponse>> task) {
    try {
        auto response = task.get();
        // Antwort nach Bedarf verwenden
    } catch (const std::exception& e) {
        // Fehler behandeln
    }
});

getCommentsPublic

req tenantId urlId

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
options	const GetCommentsPublicOptions&	Ja

Antwort

Rückgabe: GetCommentsResponseWithPresence_PublicComment_

Beispiel

getCommentsPublic Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto urlId = U("article-456");
GetCommentsPublicOptions opts;
opts.pageSize = 20;
opts.includeDeleted = false;
api->getCommentsPublic(tenantId, urlId, opts).then([](std::shared_ptr<GetCommentsResponseWithPresence_PublicComment_> resp) {
    (void)resp;
});

getCommentText

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const GetCommentTextOptions&	Ja

Antwort

Rückgabe: PublicAPIGetCommentTextResponse

Beispiel

getCommentText Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
auto options = std::make_shared<GetCommentTextOptions>();
options->language = boost::optional<utility::string_t>(U("en"));
options->includeDeleted = boost::optional<bool>(false);
api->getCommentText(tenantId, commentId, *options).then([](pplx::task<std::shared_ptr<PublicAPIGetCommentTextResponse>> task){
    try{
        auto response = task.get();
        (void)response;
    }catch(...){}
});

getCommentVoteUserNames

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
dir	int32_t	Ja
sso	string	Nein

Antwort

Rückgabe: GetCommentVoteUserNamesSuccessResponse

Beispiel

getCommentVoteUserNames Beispiel

Copy

auto task = api->getCommentVoteUserNames(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("comment-456"),
    static_cast<int32_t>(1),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("sso-token"))
).then([](pplx::task<std::shared_ptr<GetCommentVoteUserNamesSuccessResponse>> t){
    try{
        auto response = t.get();
    }catch(const std::exception&){ }
});

lockComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Antwort

Rückgabe: APIEmptyResponse

Beispiel

lockComment Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-987");
auto broadcastId = utility::conversions::to_string_t("broadcast-654");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("sso-token-xyz");
api->lockComment(tenantId, commentId, broadcastId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

pinComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
broadcastId	string	Yes
sso	string	No

Antwort

Rückgabe: ChangeCommentPinStatusResponse

Beispiel

pinComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
utility::string_t broadcastId = U("broadcast-789");
boost::optional<utility::string_t> sso = U("sso-token-abc");
api->pinComment(tenantId, commentId, broadcastId, sso)
    .then([](pplx::task<std::shared_ptr<ChangeCommentPinStatusResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

saveComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
createCommentParams	CreateCommentParams	Yes
options	const SaveCommentOptions&	Yes

Antwort

Rückgabewert: APISaveCommentResponse

Beispiel

saveComment Beispiel

Copy

CreateCommentParams commentParams;
commentParams.body = utility::string_t(U("Great article!"));
commentParams.author = utility::string_t(U("jane.doe@example.com"));
commentParams.parentId = boost::optional<utility::string_t>(utility::string_t(U("parent-789")));
SaveCommentOptions options;
options.preview = boost::optional<bool>(false);
api->saveComment(utility::string_t(U("my-tenant-123")), commentParams, options)
    .then([](std::shared_ptr<APISaveCommentResponse> response) {
        auto commentId = response->commentId;
    });

setCommentText

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
commentTextUpdateRequest	CommentTextUpdateRequest	Ja
options	const SetCommentTextOptions&	Ja

Antwort

Returns: PublicAPISetCommentTextResponse

Beispiel

setCommentText Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto commentId = U("cmt-456");
auto broadcastId = U("brd-789");
CommentTextUpdateRequest updateReq;
updateReq.text = U("Updated comment content");
updateReq.isEdited = boost::make_optional(true);
SetCommentTextOptions opts;
opts.notifySubscribers = boost::make_optional(true);
api->setCommentText(tenantId, commentId, broadcastId, updateReq, opts)
    .then([](std::shared_ptr<PublicAPISetCommentTextResponse> resp) {
    });

unBlockUserFromComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
unBlockFromCommentParams	UnBlockFromCommentParams	Ja
options	const UnBlockUserFromCommentOptions&	Ja

Antwort

Rückgabe: UnblockSuccess

Beispiel

unBlockUserFromComment Beispiel

Copy

auto params = std::make_shared<UnBlockFromCommentParams>();
params->commentId = U("cmt-12345");
params->reason = U("resolved");
UnBlockUserFromCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->unBlockUserFromComment(U("my-tenant-123"), U("user-456"), *params, opts)
    .then([](pplx::task<std::shared_ptr<UnblockSuccess>> t){
        try{
            auto result = t.get();
        }catch(...){}
    });

unFlagComment

Parameter

Name	Type	Required
tenantId	string	Ja
id	string	Ja
options	const UnFlagCommentOptions&	Ja

Antwort

Rückgabe: FlagCommentResponse

Beispiel

unFlagComment Beispiel

Copy

auto options = UnFlagCommentOptions{};
options.reason = boost::optional<utility::string_t>(U("Resolved by moderator"));
api->unFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<FlagCommentResponse> response) {
        if (response) {
            auto status = response->status;
            // Status bei Bedarf verarbeiten
        }
    })
    .then([](pplx::task<void> previous) {
        try {
            previous.get();
        } catch (const std::exception& e) {
            // Fehler behandeln
        }
    });

unLockComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

unLockComment Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
auto broadcastId = utility::conversions::to_string_t("broadcast-001");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("john.doe@example.com");
api->unLockComment(tenantId, commentId, broadcastId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
    try {
        auto response = task.get();
    } catch (const std::exception&) {
    }
});

unPinComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
broadcastId	string	Ja
sso	string	Nein

Antwort

Rückgabe: ChangeCommentPinStatusResponse

Beispiel

unPinComment Beispiel

Copy

auto task = api->unPinComment(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("cmt-456789"),
    utility::conversions::to_string_t("broadcast-001"),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("user@example.com"))
);
task.then([](std::shared_ptr<ChangeCommentPinStatusResponse> resp){
    auto result = std::make_shared<ChangeCommentPinStatusResponse>(*resp);
});

updateComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
updatableCommentParams	UpdatableCommentParams	Yes
options	const UpdateCommentOptions&	Yes

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateComment Beispiel

Copy

auto tenantId = utility::string_t("my-tenant-123");
auto commentId = utility::string_t("cmt-789");
UpdatableCommentParams updatable;
updatable.body = utility::string_t("Edited comment content");
updatable.isSpam = boost::optional<bool>(false);
UpdateCommentOptions options;
options.notify = boost::optional<bool>(true);
api->updateComment(tenantId, commentId, updatable, options)
    .then([](std::shared_ptr<APIEmptyResponse>) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch(const std::exception&) {} });

voteComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
urlId	string	Ja
broadcastId	string	Ja
voteBodyParams	VoteBodyParams	Ja
options	const VoteCommentOptions&	Ja

Antwort

Rückgabe: VoteResponse

Beispiel

voteComment Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-7890");
auto urlId = utility::conversions::to_string_t("article-456");
auto broadcastId = utility::conversions::to_string_t("broadcast-321");
VoteBodyParams voteParams;
voteParams.upvote = true;
voteParams.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Great insight"));
VoteCommentOptions options;
options.dryRun = boost::optional<bool>(false);
api->voteComment(tenantId, commentId, urlId, broadcastId, voteParams, options)
   .then([](pplx::task<std::shared_ptr<VoteResponse>> t) {
       try {
           auto response = t.get();
           // Antwort behandeln
       } catch (const std::exception&) {
       }
   });

getCommentsForUser

Parameter

Name	Typ	Erforderlich	Beschreibung
options	const GetCommentsForUserOptions&	Ja

Antwort

Rückgabe: GetCommentsForUserResponse

Beispiel

getCommentsForUser Beispiel

Copy

auto options = GetCommentsForUserOptions{
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("user@example.com"),
    boost::optional<int>(50),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("next-page-token"))
};
api->getCommentsForUser(options).then([](pplx::task<std::shared_ptr<GetCommentsForUserResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){}
});

addDomainConfig

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
addDomainConfigParams	AddDomainConfigParams	Ja

Antwort

Rückgabe: AddDomainConfigResponse

Beispiel

addDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
AddDomainConfigParams params;
params.domain = U("example.com");
params.adminEmail = U("admin@example.com");
params.notes = boost::optional<utility::string_t>(U("Primary domain"));
api->addDomainConfig(tenantId, params).then([](pplx::task<std::shared_ptr<AddDomainConfigResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

deleteDomainConfig

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
domain	string	Ja

Antwort

Rückgabe: DeleteDomainConfigResponse

Beispiel

deleteDomainConfig Beispiel

Copy

boost::optional<utility::string_t> optTenant = U("my-tenant-123");
boost::optional<utility::string_t> optDomain = U("example.com");
api->deleteDomainConfig(optTenant.value(), optDomain.value())
    .then([](pplx::task<std::shared_ptr<DeleteDomainConfigResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getDomainConfig

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
domain	string	Ja

Antwort

Rückgabe: GetDomainConfigResponse

Beispiel

getDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domain = U("myblog.example.com");
api->getDomainConfig(tenantId, domain)
    .then([](std::shared_ptr<GetDomainConfigResponse> response) {
        if (!response) return;
        boost::optional<bool> moderationEnabled = response->moderationEnabled;
        boost::optional<std::string> theme = response->theme;
        if (moderationEnabled && *moderationEnabled) {
            // aktivierte Moderation verarbeiten
        }
        if (theme) {
            // Themenwert verwenden
        }
    })
    .wait();

getDomainConfigs

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja

Antwort

Rückgabe: GetDomainConfigsResponse

Beispiel

getDomainConfigs Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> optionalTenant = tenantId;
api->getDomainConfigs(optionalTenant.value())
    .then([](std::shared_ptr<GetDomainConfigsResponse> response) {
        auto domains = response->getDomainList();
        for (const auto& d : domains) {
            std::cout << d << std::endl;
        }
    });

patchDomainConfig

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
domainToUpdate	string	Ja
patchDomainConfigParams	PatchDomainConfigParams	Ja

Antwort

Rückgabe: PatchDomainConfigResponse

Beispiel

patchDomainConfig Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto domainToUpdate = utility::conversions::to_string_t("example.com");
PatchDomainConfigParams patchDomainConfigParams;
patchDomainConfigParams.enableComments = boost::optional<bool>(true);
patchDomainConfigParams.moderationLevel = boost::optional<int>(2);
patchDomainConfigParams.customHeader = boost::optional<utility::string_t>(utility::conversions::to_string_t("X-Custom-Header"));
api->patchDomainConfig(tenantId, domainToUpdate, patchDomainConfigParams)
    .then([](std::shared_ptr<PatchDomainConfigResponse> resp) {
        // Erfolgsbehandlung
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* Fehlerbehandlung */ }
    });

putDomainConfig

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
domainToUpdate	string	Ja
updateDomainConfigParams	UpdateDomainConfigParams	Ja

Antwort

Rückgabe: PutDomainConfigResponse

Beispiel

putDomainConfig Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t domainToUpdate = U("example.com");
UpdateDomainConfigParams updateParams;
updateParams.enableComments = true;
updateParams.moderationLevel = boost::optional<int>(2);
updateParams.customCss = boost::optional<utility::string_t>(U(".fc-comment{color:red;}"));
api->putDomainConfig(tenantId, domainToUpdate, updateParams)
    .then([](std::shared_ptr<PutDomainConfigResponse> resp) {
    });

createEmailTemplate

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createEmailTemplateBody	CreateEmailTemplateBody	Ja

Antwort

Rückgabe: CreateEmailTemplateResponse

Beispiel

createEmailTemplate Beispiel

Copy

auto body = std::make_shared<CreateEmailTemplateBody>();
body->subject = utility::string_t("Welcome Email");
body->htmlContent = utility::string_t("<h1>Welcome!</h1><p>Thanks for joining.</p>");
body->fromEmail = utility::string_t("no-reply@myapp.com");
body->replyTo = boost::optional<utility::string_t>(utility::string_t("support@myapp.com"));
body->cc = boost::none;
api->createEmailTemplate(utility::string_t("my-tenant-123"), *body)
    .then([](std::shared_ptr<CreateEmailTemplateResponse> resp) {
        std::cout << "Created template ID: " << resp->id << std::endl;
    });

deleteEmailTemplate

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteEmailTemplate Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto templateId = utility::conversions::to_string_t("welcome-email-template");
boost::optional<utility::string_t> optTenantId = tenantId;
boost::optional<utility::string_t> optTemplateId = templateId;
api->deleteEmailTemplate(optTenantId.value(), optTemplateId.value())
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t) {
        try { t.get(); }
        catch (const std::exception&) {}
    });

deleteEmailTemplateRenderError

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
errorId	string	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteEmailTemplateRenderError Beispiel

Copy

boost::optional<utility::string_t> optTemplateId = utility::conversions::to_string_t("template-456");
api->deleteEmailTemplateRenderError(
    utility::conversions::to_string_t("my-tenant-123"),
    *optTemplateId,
    utility::conversions::to_string_t("error-789"))
    .then([](std::shared_ptr<APIEmptyResponse>) {})
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (...) {}
    });

getEmailTemplate

Parameter

Name	Type	Required	Description
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetEmailTemplateResponse

Beispiel

getEmailTemplate Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto templateId = utility::conversions::to_string_t("welcome-email");
boost::optional<utility::string_t> language = utility::conversions::to_string_t("en-US");
api->getEmailTemplate(tenantId, templateId)
    .then([=](pplx::task<std::shared_ptr<GetEmailTemplateResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getEmailTemplateDefinitions

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja

Antwort

Rückgabe: GetEmailTemplateDefinitionsResponse

Beispiel

getEmailTemplateDefinitions Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
api->getEmailTemplateDefinitions(tenantId).then([](pplx::task<std::shared_ptr<GetEmailTemplateDefinitionsResponse>> t) {
    try {
        auto resp = t.get();
        boost::optional<utility::string_t> tmplName = resp ? resp->templateName : boost::none;
        if (tmplName) {
            std::cout << *tmplName << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
});

getEmailTemplateRenderErrors

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
skip	double	Nein

Antwort

Rückgabe: GetEmailTemplateRenderErrorsResponse

Beispiel

getEmailTemplateRenderErrors Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t id = U("email-template-789");
boost::optional<double> skip = 20.0;
api->getEmailTemplateRenderErrors(tenantId, id, skip)
    .then([](pplx::task<std::shared_ptr<GetEmailTemplateRenderErrorsResponse>> task) {
        try {
            auto response = task.get();
            // Verwenden Sie die Antwort nach Bedarf
        } catch (const std::exception& ex) {
            // Fehler behandeln
        }
    });

getEmailTemplates

Parameter

Name	Type	Required	Description
tenantId	string	Ja
skip	double	Nein

Antwort

Rückgabe: GetEmailTemplatesResponse

Beispiel

getEmailTemplates Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> skip = 10.0;
api->getEmailTemplates(tenantId, skip)
    .then([](std::shared_ptr<GetEmailTemplatesResponse> resp) {
        (void)resp;
    });

renderEmailTemplate

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
renderEmailTemplateBody	RenderEmailTemplateBody	Ja
locale	string	Nein

Antwort

Rückgabe: RenderEmailTemplateResponse

Beispiel

renderEmailTemplate Beispiel

Copy

auto body = RenderEmailTemplateBody();
body.templateId = U("welcome-email");
body.recipientEmail = U("user@example.com");
boost::optional<utility::string_t> locale = U("en-US");
api->renderEmailTemplate(U("my-tenant-123"), body, locale)
    .then([](std::shared_ptr<RenderEmailTemplateResponse> resp) {
        std::cout << "Email template rendered successfully\n";
    });

updateEmailTemplate

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateEmailTemplateBody	UpdateEmailTemplateBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateEmailTemplate Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t templateId = U("welcome-email");
UpdateEmailTemplateBody body;
body.subject = U("Welcome to Our Platform");
body.content = U("<p>Hello \{{userName}}, welcome aboard!</p>");
body.isActive = boost::optional<bool>(true);
api->updateEmailTemplate(tenantId, templateId, body)
    .then([](std::shared_ptr<APIEmptyResponse> response) {
        // Erfolgsbehandlung
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception &) { /* Fehlerbehandlung */ }
    });

getEventLog

req tenantId urlId userIdWS

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
userIdWS	string	Ja
startTime	int64_t	Ja
endTime	int64_t	Nein

Antwort

Returns: GetEventLogResponse

Beispiel

getEventLog Beispiel

Copy

auto startTime = int64_t(1622505600);
boost::optional<int64_t> endTime = int64_t(1622592000);
api->getEventLog(U("my-tenant-123"), U("article-456"), U("user@example.com"), startTime, endTime)
    .then([](std::shared_ptr<GetEventLogResponse> response){
        auto copy = std::make_shared<GetEventLogResponse>(*response);
        (void)copy;
    });

getGlobalEventLog

req tenantId urlId userIdWS

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
userIdWS	string	Ja
startTime	int64_t	Ja
endTime	int64_t	Nein

Antwort

Rückgabe: GetEventLogResponse

Beispiel

getGlobalEventLog Beispiel

Copy

api->getGlobalEventLog(
    U("my-tenant-123"),
    U("article-456"),
    U("user@example.com"),
    1622505600,
    boost::optional<int64_t>(1625097600)
).then([](std::shared_ptr<GetEventLogResponse> resp) {
    (void)resp;
});

createFeedPost

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
createFeedPostParams	CreateFeedPostParams	Yes
options	const CreateFeedPostOptions&	Yes

Antwort

Rückgabe: CreateFeedPostsResponse

Beispiel

createFeedPost Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateFeedPostParams postParams;
postParams.content = utility::conversions::to_string_t("Excited to join FastComments!");
postParams.authorEmail = utility::conversions::to_string_t("user@example.com");
postParams.title = utility::conversions::to_string_t("My First Post");
postParams.tags = boost::optional<std::vector<utility::string_t>>({ utility::conversions::to_string_t("intro") });
CreateFeedPostOptions options;
options.notifyFollowers = boost::optional<bool>(true);
options.scheduledAt = boost::optional<utility::datetime>(utility::datetime::utc_now());
api->createFeedPost(tenantId, postParams, options).then([](std::shared_ptr<CreateFeedPostsResponse> resp) {
    auto postId = resp->postId;
});

createFeedPostPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
createFeedPostParams	CreateFeedPostParams	Ja
options	const CreateFeedPostPublicOptions&	Ja

Antwort

Rückgabe: CreateFeedPostResponse

Beispiel

createFeedPostPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateFeedPostParams params;
params.title = U("Introducing Our New Feature");
params.content = U("We are excited to announce the release of our latest update.");
params.authorEmail = boost::optional<utility::string_t>(U("user@example.com"));
params.tags = boost::optional<std::vector<utility::string_t>>({U("announcement"), U("release")});
CreateFeedPostPublicOptions options;
api->createFeedPostPublic(tenantId, params, options)
    .then([](std::shared_ptr<CreateFeedPostResponse> resp) {
        if (resp) {
            std::wcout << U("Post created with ID: ") << resp->postId << std::endl;
        }
    });

deleteFeedPostPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
postId	string	Yes
options	const DeleteFeedPostPublicOptions&	Yes

Antwort

Rückgabe: DeleteFeedPostPublicResponse

Beispiel

deleteFeedPostPublic Beispiel

Copy

auto opts = std::make_shared<DeleteFeedPostPublicOptions>();
opts->reason = boost::optional<utility::string_t>(U("Inappropriate content"));
api->deleteFeedPostPublic(U("my-tenant-123"), U("post-789"), *opts)
    .then([](std::shared_ptr<DeleteFeedPostPublicResponse> resp) {
        if (resp && resp->isSuccess()) {
            // Erfolgslogik
        }
    });

getFeedPosts

req tenantId afterId

Parameter

Name	Type	Required	Description
tenantId	string	Ja
options	const GetFeedPostsOptions&	Ja

Antwort

Rückgabe: GetFeedPostsResponse

Beispiel

Beispiel für getFeedPosts

Copy

auto opts = std::make_shared<GetFeedPostsOptions>();
opts->maxResults = boost::optional<int>(50);
opts->cursor = boost::optional<utility::string_t>(U("next-cursor"));
api->getFeedPosts(U("my-tenant-123"), *opts).then([](std::shared_ptr<GetFeedPostsResponse> resp) {
    auto count = resp->posts.size();
});

getFeedPostsPublic

req tenantId afterId

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetFeedPostsPublicOptions&	Ja

Antwort

Gibt zurück: PublicFeedPostsResponse

Beispiel

getFeedPostsPublic Beispiel

Copy

auto options = GetFeedPostsPublicOptions{};
options.limit = boost::optional<int>{20};
options.before = boost::optional<utility::string_t>{U("2023-01-01T00:00:00Z")};
api->getFeedPostsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<PublicFeedPostsResponse>> task){
    try{
        auto response = task.get();
        auto processed = std::make_shared<PublicFeedPostsResponse>(*response);
        // Verwenden Sie das Verarbeitete nach Bedarf
    }catch(const std::exception&){
        // Fehler behandeln
    }
});

getFeedPostsStats

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
postIds	vector<string	Yes
sso	string	No

Antwort

Rückgabe: FeedPostsStatsResponse

Beispiel

getFeedPostsStats Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
std::vector<utility::string_t> postIds = {
    utility::conversions::to_string_t("post-001"),
    utility::conversions::to_string_t("post-002")
};
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getFeedPostsStats(tenantId, postIds, sso)
    .then([](std::shared_ptr<FeedPostsStatsResponse> response) {
        (void)response;
    });

getUserReactsPublic

Parameter

Name	Type	Required	Description
tenantId	string	Yes
options	const GetUserReactsPublicOptions&	Yes

Antwort

Returns: UserReactsResponse

Beispiel

getUserReactsPublic Beispiel

Copy

auto options = GetUserReactsPublicOptions{};
options.userId = boost::optional<utility::string_t>(U("user@example.com"));
options.limit = boost::optional<int>(50);
api->getUserReactsPublic(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<UserReactsResponse>> t){
    auto response = t.get();
});

reactFeedPostPublic

Parameters

Name	Typ	Erforderlich
tenantId	string	Yes
postId	string	Yes
reactBodyParams	ReactBodyParams	Yes
options	const ReactFeedPostPublicOptions&	Yes

Response

Rückgabe: ReactFeedPostResponse

Example

reactFeedPostPublic Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto postId = utility::conversions::to_string_t("post-987");
ReactBodyParams reactBody;
reactBody.reaction = utility::conversions::to_string_t("love");
reactBody.userId = utility::conversions::to_string_t("user@example.com");
ReactFeedPostPublicOptions options;
options.metadata = boost::optional<utility::string_t>(utility::conversions::to_string_t("mobile"));
api->reactFeedPostPublic(tenantId, postId, reactBody, options)
    .then([](std::shared_ptr<ReactFeedPostResponse> resp) {
    });

updateFeedPost

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
feedPost	FeedPost	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateFeedPost Beispiel

Copy

utility::string_t tenantId = U"my-tenant-123";
utility::string_t postId = U"post-456";
FeedPost feedPost;
feedPost.title = U"Breaking News";
feedPost.content = U"Details of the update go here.";
feedPost.imageUrl = boost::optional<utility::string_t>(U"https://example.com/image.jpg");
api->updateFeedPost(tenantId, postId, feedPost)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception& ex) {
        }
    });

updateFeedPostPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
postId	string	Yes
updateFeedPostParams	UpdateFeedPostParams	Yes
options	const UpdateFeedPostPublicOptions&	Yes

Antwort

Rückgabe: CreateFeedPostResponse

Beispiel

updateFeedPostPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t postId = U("post-456");
UpdateFeedPostParams params;
params.title = boost::optional<utility::string_t>(U("Updated Title"));
params.body = boost::optional<utility::string_t>(U("Updated content of the post."));
UpdateFeedPostPublicOptions options;
options.notifyFollowers = boost::optional<bool>(true);
api->updateFeedPostPublic(tenantId, postId, params, options)
    .then([](std::shared_ptr<CreateFeedPostResponse> resp) {
        auto result = resp;
    });

flagCommentPublic

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
isFlagged	bool	Ja
sso	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

flagCommentPublic Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
bool isFlagged = true;
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("sso-token-abc");
api->flagCommentPublic(tenantId, commentId, isFlagged, sso)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t){
        try{
            auto resp = t.get();
        }catch(const std::exception&){
        }
    });

getGifLarge

Parameters

Name	Type	Required	Description
tenantId	string	Yes
largeInternalURLSanitized	string	Yes

Antwort

Rückgabe: GifGetLargeResponse

Beispiel

getGifLarge Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto largeUrl = utility::conversions::to_string_t("https://cdn.example.com/gifs/large/abc123.gif");
api->getGifLarge(tenantId, largeUrl)
   .then([&](std::shared_ptr<GifGetLargeResponse> resp) {
        boost::optional<utility::string_t> maybeUrl;
        if (resp && resp->url) {
            maybeUrl = resp->url;
        }
        if (maybeUrl) {
            std::wcout << *maybeUrl << std::endl;
        }
   });

getGifsSearch

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
search	string	Ja
options	const GetGifsSearchOptions&	Ja

Antwort

Rückgabe: GetGifsSearchResponse

Beispiel

getGifsSearch Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto search = U("funny cats");
GetGifsSearchOptions options;
options.limit = boost::optional<int>(10);
options.rating = boost::optional<utility::string_t>(U("pg"));
api->getGifsSearch(tenantId, search, options).then([](pplx::task<std::shared_ptr<GetGifsSearchResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

getGifsTrending

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetGifsTrendingOptions&	Ja

Antwort

Rückgabe: GetGifsTrendingResponse

Beispiel

getGifsTrending Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetGifsTrendingOptions options;
options.limit = 10;
options.rating = boost::optional<utility::string_t>(U("G"));
api->getGifsTrending(tenantId, options).then([](std::shared_ptr<GetGifsTrendingResponse> response) {
    for (const auto& gif : response->gifs) {
        auto url = gif.url;
    }
});

addHashTag

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
createHashTagBody	CreateHashTagBody	Yes

Antwort

Rückgabe: CreateHashTagResponse

Beispiel

addHashTag Beispiel

Copy

CreateHashTagBody request;
request.tag = utility::conversions::to_string_t("feature-request");
request.description = utility::conversions::to_string_t("Requests for new features");
request.relatedUrl = boost::optional<utility::string_t>(utility::conversions::to_string_t("https://example.com/feature-request"));
api->addHashTag(utility::conversions::to_string_t("my-tenant-123"), request)
    .then([](std::shared_ptr<CreateHashTagResponse> resp) {
        (void)resp;
    });

addHashTagsBulk

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
bulkCreateHashTagsBody	BulkCreateHashTagsBody	Yes

Antwort

Rückgabe: BulkCreateHashTagsResponse

Beispiel

addHashTagsBulk Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BulkCreateHashTagsBody bulkBody;
bulkBody.tags = { utility::string_t(U("announcement")), utility::string_t(U("feature-request")) };
bulkBody.description = boost::optional<utility::string_t>(U("Bulk tag creation"));
api->addHashTagsBulk(tenantId, bulkBody).then([](pplx::task<std::shared_ptr<BulkCreateHashTagsResponse>> task){
    try{
        auto resp = task.get();
    }catch(const std::exception&){
    }
});

deleteHashTag

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
tag	string	Ja
deleteHashTagRequestBody	DeleteHashTagRequestBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteHashTag Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-001");
auto tag = utility::conversions::to_string_t("news");
DeleteHashTagRequestBody requestBody;
requestBody.userId = utility::conversions::to_string_t("user-42");
requestBody.reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("User request"));
api->deleteHashTag(tenantId, tag, requestBody)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
    });

getHashTags

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
page	double	Nein

Antwort

Rückgabe: GetHashTagsResponse

Beispiel

getHashTags Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> page = 2.0;
api->getHashTags(tenantId, page).then([](pplx::task<std::shared_ptr<GetHashTagsResponse>> task) {
    try {
        auto resultPtr = task.get();
        auto response = std::make_shared<GetHashTagsResponse>(*resultPtr);
        // Antwort verwenden
    } catch (const std::exception&) {
        // Fehler behandeln
    }
});

patchHashTag

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
tag	string	Ja
updateHashTagBody	UpdateHashTagBody	Ja

Antwort

Rückgabe: UpdateHashTagResponse

Beispiel

patchHashTag Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t tag = U("important");
auto body = std::make_shared<UpdateHashTagBody>();
body->name = U("important-updated");
body->description = boost::optional<utility::string_t>(U("Updated description"));
api->patchHashTag(tenantId, tag, *body)
   .then([](pplx::task<std::shared_ptr<UpdateHashTagResponse>> t){
       try{
           auto response = t.get();
           std::cout << "Updated tag ID: " << response->id << std::endl;
       }catch(const std::exception& e){
           std::cerr << "Patch failed: " << e.what() << std::endl;
       }
   });

deleteModerationVote

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
voteId	string	Ja
options	const DeleteModerationVoteOptions&	Ja

Antwort

Returns: VoteDeleteResponse

Beispiel

deleteModerationVote Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-abc123");
auto voteId = utility::conversions::to_string_t("vote-xyz789");
DeleteModerationVoteOptions opts;
opts.reason = utility::conversions::to_string_t("Offensive language");
opts.hardDelete = boost::optional<bool>(true);
api->deleteModerationVote(tenantId, commentId, voteId, opts)
    .then([](std::shared_ptr<VoteDeleteResponse> resp){});

getApiComments

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetApiCommentsOptions&	Ja

Antwort

Rückgabe: ModerationAPIGetCommentsResponse

Beispiel

getApiComments Beispiel

Copy

auto options = GetApiCommentsOptions{};
options.page = boost::make_optional(2);
options.authorEmail = boost::make_optional<utility::string_t>(U("user@example.com"));
options.includeDeleted = boost::make_optional(false);
api->getApiComments(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<ModerationAPIGetCommentsResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

getApiExportStatus

Parameters

Name	Type	Required	Description
tenantId	string	Yes
options	const GetApiExportStatusOptions&	Yes

Response

Rückgabe: ModerationExportStatusResponse

Example

getApiExportStatus Beispiel

Copy

auto opts = GetApiExportStatusOptions{};
opts.exportId = boost::make_optional<utility::string_t>(U("export-456"));
api->getApiExportStatus(U("my-tenant-123"), opts)
    .then([](pplx::task<std::shared_ptr<ModerationExportStatusResponse>> t){
        try{
            auto status = t.get();
        }catch(const std::exception&){
        }
    });

getApiIds

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetApiIdsOptions&	Yes

Antwort

Rückgabe: ModerationAPIGetCommentIdsResponse

Beispiel

getApiIds Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetApiIdsOptions options;
options.limit = boost::optional<int>(100);
options.cursor = boost::optional<utility::string_t>(U("next-page-token"));
api->getApiIds(tenantId, options).then([](pplx::task<std::shared_ptr<ModerationAPIGetCommentIdsResponse>> t){
    try{
        auto response = t.get();
        auto ids = response->commentIds;
    }catch(const std::exception&){
    }
});

getBanUsersFromComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Antwort

Rückgabe: GetBannedUsersFromCommentResponse

Beispiel

Beispiel für getBanUsersFromComment

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("comment-456"));
boost::optional<utility::string_t> sso = boost::make_optional(utility::string_t(U("sso-token-abc")));
api->getBanUsersFromComment(tenantId, commentId, sso).then([](pplx::task<std::shared_ptr<GetBannedUsersFromCommentResponse>> task) {
    try {
        auto response = task.get();
    } catch (const std::exception&) {
    }
});

getCommentBanStatus

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
sso	string	Nein

Antwort

Rückgabe: GetCommentBanStatusResponse

Beispiel

getCommentBanStatus Beispiel

Copy

auto tenantId = utility::string_t(U"my-tenant-123");
auto commentId = utility::string_t(U"comment-456");
boost::optional<utility::string_t> sso = utility::string_t(U"user@example.com");
api->getCommentBanStatus(tenantId, commentId, sso).then([](pplx::task<std::shared_ptr<GetCommentBanStatusResponse>> t){
    try{
        auto response = t.get();
    }catch(const std::exception&){ }
});

getCommentChildren

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
sso	string	Nein

Antwort

Rückgabe: ModerationAPIChildCommentsResponse

Beispiel

Beispiel für getCommentChildren

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
boost::optional<utility::string_t> sso = U("sso-token-abc");
api->getCommentChildren(tenantId, commentId, sso)
    .then([](pplx::task<std::shared_ptr<ModerationAPIChildCommentsResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getCount

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetCountOptions&	Yes

Antwort

Rückgabe: ModerationAPICountCommentsResponse

Beispiel

getCount Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetCountOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.maxResults = boost::optional<int>(100);
api->getCount(tenantId, options).then([](pplx::task<std::shared_ptr<ModerationAPICountCommentsResponse>> task){
    try{
        auto resp = task.get();
        auto copy = std::make_shared<ModerationAPICountCommentsResponse>(*resp);
        std::cout << "Count: " << copy->count << std::endl;
    }catch(const std::exception& e){
        std::cerr << "Error: " << e.what() << std::endl;
    }
});

getCounts

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
sso	string	Nein

Antwort

Rückgabe: GetBannedUsersCountResponse

Beispiel

getCounts Beispiel

Copy

api->getCounts(
    utility::conversions::to_string_t("my-tenant-123"),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("john.doe@example.com"))
).then([](pplx::task<std::shared_ptr<GetBannedUsersCountResponse>> t){
    try{
        auto response = t.get();
    }catch(const std::exception&){
    }
});

getLogs

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Antwort

Rückgabe: ModerationAPIGetLogsResponse

Beispiel

getLogs Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456");
boost::optional<utility::string_t> sso = U("sso-token-abc");
api->getLogs(tenantId, commentId, sso).then([](pplx::task<std::shared_ptr<ModerationAPIGetLogsResponse>> t){
    try{
        auto response = t.get();
    }catch(...){
    }
});

getManualBadges

Parameter

Name	Type	Required	Description
tenantId	string	Yes
sso	string	No

Antwort

Rückgabe: GetTenantManualBadgesResponse

Beispiel

getManualBadges Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<utility::string_t> sso = boost::make_optional(U("user@example.com"));
api->getManualBadges(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<GetTenantManualBadgesResponse>> t) {
        try {
            auto response = t.get();
            // Antwort verarbeiten, z.B. response->badgeList
        } catch (const std::exception& ex) {
            // Fehler behandeln
        }
    });

getManualBadgesForUser

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetManualBadgesForUserOptions&	Yes

Antwort

Rückgabe: GetUserManualBadgesResponse

Beispiel

getManualBadgesForUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetManualBadgesForUserOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.includeInactive = boost::optional<bool>(true);
api->getManualBadgesForUser(tenantId, options).then([](pplx::task<std::shared_ptr<GetUserManualBadgesResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

getModerationComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const GetModerationCommentOptions&	Ja

Antwort

Rückgabe: ModerationAPICommentResponse

Beispiel

Beispiel für getModerationComment

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-456");
GetModerationCommentOptions options;
options.includeDeleted = boost::optional<bool>(true);
options.locale = boost::optional<utility::string_t>(utility::conversions::to_string_t("en-US"));
api->getModerationComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<ModerationAPICommentResponse>> task) {
        try {
            auto response = task.get();
            // Verarbeite die Antwort nach Bedarf
        } catch (const std::exception& ex) {
            // Fehler behandeln
        }
    });

getModerationCommentText

Parameter

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
sso	string	No

Antwort

Rückgabe: GetCommentTextResponse

Beispiel

Beispiel für getModerationCommentText

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
boost::optional<utility::string_t> sso = U("sso-token-abc");
api->getModerationCommentText(tenantId, commentId, sso)
    .then([](pplx::task<std::shared_ptr<GetCommentTextResponse>> t) {
        try {
            auto resp = t.get();
            auto text = std::make_shared<std::string>(resp->commentText);
        } catch (const std::exception&) {
        }
    });

getPreBanSummary

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
options	const GetPreBanSummaryOptions&	Yes

Antwort

Rückgabe: PreBanSummary

Beispiel

getPreBanSummary Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
GetPreBanSummaryOptions options;
options.locale = boost::optional<utility::string_t>{utility::conversions::to_string_t("en-US")};
api->getPreBanSummary(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PreBanSummary>> t) {
        try {
            auto summary = t.get();
            // Zusammenfassung verarbeiten
        } catch (const std::exception&) {
            // Fehler behandeln
        }
    });

getSearchCommentsSummary

Parameter

Name	Type	Required	Description
tenantId	string	Yes
options	const GetSearchCommentsSummaryOptions&	Yes

Antwort

Rückgabe: ModerationCommentSearchResponse

Beispiel

Beispiel für getSearchCommentsSummary

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto options = std::make_shared<GetSearchCommentsSummaryOptions>();
options->query = utility::conversions::to_string_t("spam");
options->pageSize = boost::optional<int>(50);
options->pageNumber = boost::optional<int>(1);
options->fromDate = boost::none;
api->getSearchCommentsSummary(tenantId, *options).then([](pplx::task<std::shared_ptr<ModerationCommentSearchResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

getSearchPages

Parameter

Name	Type	Required	Description
tenantId	string	Ja
options	const GetSearchPagesOptions&	Ja

Antwort

Rückgabe: ModerationPageSearchResponse

Beispiel

getSearchPages Beispiel

Copy

GetSearchPagesOptions options;
options.pageNumber = boost::optional<int>(1);
options.pageSize = boost::optional<int>(50);
options.searchTerm = boost::optional<utility::string_t>(U("spam"));
api->getSearchPages(U("my-tenant-123"), options)
    .then([](pplx::task<std::shared_ptr<ModerationPageSearchResponse>> task) {
        try {
            auto response = task.get();
            // Antwort verwenden
        } catch (const std::exception& e) {
            // Fehler behandeln
        }
    });

getSearchSites

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetSearchSitesOptions&	Ja

Antwort

Rückgabe: ModerationSiteSearchResponse

Beispiel

getSearchSites Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchSitesOptions options;
options.query = boost::make_optional(utility::string_t(U("example query")));
options.limit = boost::make_optional(25);
api->getSearchSites(tenantId, options)
   .then([](pplx::task<std::shared_ptr<ModerationSiteSearchResponse>> t) {
       try {
           auto response = t.get();
           auto respPtr = std::make_shared<ModerationSiteSearchResponse>(*response);
           for (const auto& site : respPtr->sites) {
               // Verarbeitungslogik
           }
       } catch (const std::exception&) {
           // Fehlerbehandlung
       }
   });

getSearchSuggest

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetSearchSuggestOptions&	Ja

Antwort

Rückgabe: ModerationSuggestResponse

Beispiel

getSearchSuggest Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetSearchSuggestOptions opts;
opts.query = U("search term");
opts.limit = boost::optional<int>(5);
opts.includeInactive = boost::optional<bool>(false);
api->getSearchSuggest(tenantId, opts).then([](pplx::task<std::shared_ptr<ModerationSuggestResponse>> t){
    try{
        auto resp = t.get();
    }catch(const std::exception&){ }
}).wait();

getSearchUsers

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetSearchUsersOptions&	Yes

Antwort

Rückgabe: ModerationUserSearchResponse

Beispiel

getSearchUsers Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetSearchUsersOptions opts;
opts.query = utility::string_t(U("john.doe@example.com"));
opts.page = boost::optional<int>(1);
opts.pageSize = boost::optional<int>(20);
api->getSearchUsers(tenantId, opts)
    .then([](std::shared_ptr<ModerationUserSearchResponse> resp) {
        for (const auto& user : resp->users) {
            std::wcout << user.id << L" - " << user.email << std::endl;
        }
    });

getTrustFactor

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetTrustFactorOptions&	Ja

Antwort

Rückgabe: GetUserTrustFactorResponse

Beispiel

getTrustFactor Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetTrustFactorOptions options;
options.userEmail = boost::optional<utility::string_t>(U("user@example.com"));
options.ipAddress = boost::optional<utility::string_t>(U("203.0.113.42"));
api->getTrustFactor(tenantId, options).then([](std::shared_ptr<GetUserTrustFactorResponse> resp) {
    if (resp) {
        std::cout << "Trust factor: " << resp->trustFactor << std::endl;
    }
});

getUserBanPreference

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
sso	string	Nein

Antwort

Rückgabe: APIModerateGetUserBanPreferencesResponse

Beispiel

Beispiel für getUserBanPreference

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<utility::string_t> sso = boost::optional<utility::string_t>(U("user@example.com"));
api->getUserBanPreference(tenantId, sso)
    .then([](pplx::task<std::shared_ptr<APIModerateGetUserBanPreferencesResponse>> t) {
        try {
            auto resp = t.get();
        } catch (const std::exception&) {
        }
    });

getUserInternalProfile

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetUserInternalProfileOptions&	Ja

Antwort

Rückgabe: GetUserInternalProfileResponse

Beispiel

getUserInternalProfile Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserInternalProfileOptions options;
options.email = boost::optional<utility::string_t>(U("user@example.com"));
options.includeDetails = boost::optional<bool>(true);
api->getUserInternalProfile(tenantId, options)
    .then([](std::shared_ptr<GetUserInternalProfileResponse> response) {
        if (response) {
            auto name = response->displayName;
            auto id = response->userId;
        }
    });

postAdjustCommentVotes

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
adjustCommentVotesParams	AdjustCommentVotesParams	Yes
options	const PostAdjustCommentVotesOptions&	Yes

Antwort

Rückgabe: AdjustVotesResponse

Beispiel

postAdjustCommentVotes Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
AdjustCommentVotesParams params;
params.voteDelta = 1;
params.userIdentifier = utility::conversions::to_string_t("user@example.com");
params.reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Helpful"));
PostAdjustCommentVotesOptions opts;
opts.timeout = boost::optional<int>(30);
api->postAdjustCommentVotes(tenantId, commentId, params, opts).then([](pplx::task<std::shared_ptr<AdjustVotesResponse>> t){
    try{
        auto resp = t.get();
    }catch(const std::exception& e){
    }
});

postApiExport

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const PostApiExportOptions&	Yes

Antwort

Rückgabe: ModerationExportResponse

Beispiel

postApiExport Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
PostApiExportOptions options;
options.format = utility::string_t(U("json"));
options.email = utility::string_t(U("reports@example.com"));
options.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z")));
options.endDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z")));
api->postApiExport(tenantId, options)
    .then([](std::shared_ptr<ModerationExportResponse> response) {
        if (response) {
            // erfolgreiche Exportantwort verarbeiten
        }
    })
    .wait();

postBanUserFromComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
options	const PostBanUserFromCommentOptions&	Yes

Antwort

Rückgabe: BanUserFromCommentResult

Beispiel

postBanUserFromComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("comment-456789");
PostBanUserFromCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.durationDays = boost::optional<int>(30);
api->postBanUserFromComment(tenantId, commentId, options)
    .then([](std::shared_ptr<BanUserFromCommentResult> result) {
        // Ergebnisverarbeitung
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { /* Fehlerbehandlung */ }
    });

postBanUserUndo

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
banUserUndoParams	BanUserUndoParams	Ja
sso	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

postBanUserUndo Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
BanUserUndoParams banParams;
banParams.userId = utility::string_t(U("user-567"));
banParams.reason = utility::string_t(U("reinstated"));
boost::optional<utility::string_t> sso = utility::string_t(U("sso-token-abc"));
api->postBanUserUndo(tenantId, banParams, sso).then([](std::shared_ptr<APIEmptyResponse> resp){
    // Erfolg behandeln
});

postBulkPreBanSummary

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
bulkPreBanParams	BulkPreBanParams	Ja
options	const PostBulkPreBanSummaryOptions&	Ja

Antwort

Rückgabe: BulkPreBanSummary

Beispiel

postBulkPreBanSummary Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
BulkPreBanParams bulkPreBanParams;
bulkPreBanParams.emails = {
    utility::conversions::to_string_t("spam1@example.com"),
    utility::conversions::to_string_t("spam2@example.com")
};
bulkPreBanParams.reason = utility::conversions::to_string_t("spam");
PostBulkPreBanSummaryOptions options;
options.requestId = boost::optional<utility::string_t>(utility::conversions::to_string_t("req-456"));
api->postBulkPreBanSummary(tenantId, bulkPreBanParams, options)
    .then([](std::shared_ptr<BulkPreBanSummary> result) {
        (void)result;
    });

postCommentsByIds

Parameters

Name	Typ	Erforderlich
tenantId	string	Yes
commentsByIdsParams	CommentsByIdsParams	Yes
sso	string	No

Response

Rückgabe: ModerationAPIChildCommentsResponse

Beispiel

postCommentsByIds Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
CommentsByIdsParams params;
params.commentIds = {U("cmt-001"), U("cmt-002")};
boost::optional<utility::string_t> sso = U("sso-token-abc");
api->postCommentsByIds(tenantId, params, sso).then([](pplx::task<std::shared_ptr<ModerationAPIChildCommentsResponse>> t){
    try{
        auto resp = t.get();
        auto copy = std::make_shared<ModerationAPIChildCommentsResponse>(*resp);
    }catch(const std::exception&){ }
});

postFlagComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const PostFlagCommentOptions&	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

postFlagComment Beispiel

Copy

PostFlagCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("spam"));
options.reportedBy = boost::optional<utility::string_t>(U("moderator@example.com"));
api->postFlagComment(U("my-tenant-123"), U("comment-456"), options)
    .then([](std::shared_ptr<APIEmptyResponse> resp){
        (void)resp;
    })
    .then([](pplx::task<void> t){
        try{
            t.get();
        }catch(const std::exception&){
        }
    });

postRemoveComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const PostRemoveCommentOptions&	Ja

Antwort

Rückgabe: PostRemoveCommentApiResponse

Beispiel

postRemoveComment Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto commentId = utility::string_t(U("cmt-456789"));
PostRemoveCommentOptions options;
options.permanent = boost::optional<bool>(true);
api->postRemoveComment(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<PostRemoveCommentApiResponse>> task) {
        try {
            auto response = task.get();
            // Antwort verarbeiten
        } catch (const std::exception& ex) {
            // Fehler behandeln
        }
    });

postRestoreDeletedComment

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
commentId	string	Yes
options	const PostRestoreDeletedCommentOptions&	Yes

Antwort

Returns: APIEmptyResponse

Beispiel

postRestoreDeletedComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-987654");
PostRestoreDeletedCommentOptions options;
options.reason = boost::optional<utility::string_t>(U("Restoring after accidental delete"));
options.notifyUser = boost::optional<bool>(true);
api->postRestoreDeletedComment(tenantId, commentId, options)
    .then([](std::shared_ptr<APIEmptyResponse> resp){
    });

postSetCommentApprovalStatus

Parameter

Name	Type	Required
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentApprovalStatusOptions&	Ja

Antwort

Rückgabe: SetCommentApprovedResponse

Beispiel

postSetCommentApprovalStatus Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("comment-abc123");
auto options = std::make_shared<PostSetCommentApprovalStatusOptions>();
options->approved = boost::optional<bool>(true);
options->reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Inappropriate content"));
api->postSetCommentApprovalStatus(tenantId, commentId, *options)
    .then([](pplx::task<std::shared_ptr<SetCommentApprovedResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception& ex) {
        }
    });

postSetCommentReviewStatus

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentReviewStatusOptions&	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

postSetCommentReviewStatus Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456789");
PostSetCommentReviewStatusOptions opts;
opts.status = utility::conversions::to_string_t("approved");
opts.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Looks good"));
api->postSetCommentReviewStatus(tenantId, commentId, opts)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t){
        try{
            auto resp = t.get();
        }catch(const std::exception& e){
        }
    });

postSetCommentSpamStatus

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const PostSetCommentSpamStatusOptions&	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

postSetCommentSpamStatus Beispiel

Copy

auto options = PostSetCommentSpamStatusOptions{};
options.isSpam = true;
options.reason = boost::optional<utility::string_t>{U"User reported spam"};
api->postSetCommentSpamStatus(U("my-tenant-123"), U("comment-789"), options)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        auto copy = std::make_shared<APIEmptyResponse>(*resp);
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch(const std::exception&) {}
    });

postSetCommentText

Parameter

Name	Type	Required
tenantId	string	Ja
commentId	string	Ja
setCommentTextParams	SetCommentTextParams	Ja
options	const PostSetCommentTextOptions&	Ja

Antwort

Rückgabe: SetCommentTextResponse

Beispiel

postSetCommentText Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto commentId = U("comment-456");
SetCommentTextParams params;
params.text = U("Revised comment content");
PostSetCommentTextOptions options;
options.requestId = boost::optional<utility::string_t>(U("req-987"));
api->postSetCommentText(tenantId, commentId, params, options)
    .then([](std::shared_ptr<SetCommentTextResponse> resp) {
        auto updatedId = resp->commentId;
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postUnFlagComment

Parameter

Name	Type	Required
tenantId	string	Yes
commentId	string	Yes
options	const PostUnFlagCommentOptions&	Yes

Antwort

Rückgabe: APIEmptyResponse

Beispiel

postUnFlagComment Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostUnFlagCommentOptions opts;
opts.notifyUser = boost::optional<bool>(true);
api->postUnFlagComment(tenantId, commentId, opts)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // Verarbeitung kann hier durchgeführt werden
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

postVote

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
options	const PostVoteOptions&	Ja

Antwort

Rückgabe: VoteResponse

Beispiel

postVote Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t commentId = U("cmt-456789");
PostVoteOptions options;
options.upvote = boost::make_optional(true);
options.reason = boost::make_optional<std::string>("Inappropriate content");
api->postVote(tenantId, commentId, options)
    .then([](pplx::task<std::shared_ptr<VoteResponse>> t) {
        try {
            auto resp = t.get();
            auto count = resp->voteCount;
        } catch (const std::exception& e) {
        }
    });

putAwardBadge

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
badgeId	string	Yes
options	const PutAwardBadgeOptions&	Yes

Antwort

Rückgabe: AwardUserBadgeResponse

Beispiel

putAwardBadge Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto badgeId = utility::conversions::to_string_t("badge-456");
PutAwardBadgeOptions opts;
opts.userId = utility::conversions::to_string_t("user-42");
opts.note = boost::optional<utility::string_t>(utility::conversions::to_string_t("Excellent comment"));
api->putAwardBadge(tenantId, badgeId, opts).then([](pplx::task<std::shared_ptr<AwardUserBadgeResponse>> t){
    try{
        auto resp = t.get();
        auto respCopy = std::make_shared<AwardUserBadgeResponse>(*resp);
    }catch(const std::exception& e){
    }
});

putCloseThread

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
sso	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

putCloseThread Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-4321"));
auto urlId = utility::string_t(U("article-9876"));
boost::optional<utility::string_t> sso = boost::make_optional<utility::string_t>(U("user@example.com"));
api->putCloseThread(tenantId, urlId, sso).then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

putRemoveBadge

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
badgeId	string	Ja
options	const PutRemoveBadgeOptions&	Ja

Antwort

Rückgabe: RemoveUserBadgeResponse

Beispiel

putRemoveBadge Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t badgeId = U("badge-abc-456");
PutRemoveBadgeOptions options;
options.reason = boost::optional<utility::string_t>(U("Spamming"));
api->putRemoveBadge(tenantId, badgeId, options).then([](std::shared_ptr<RemoveUserBadgeResponse> resp) {
    (void)resp;
});

putReopenThread

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
sso	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

putReopenThread Beispiel

Copy

api->putReopenThread(utility::string_t(U("my-tenant-123")), utility::string_t(U("thread-456")), boost::make_optional<utility::string_t>(U("user@example.com")))
    .then([](std::shared_ptr<APIEmptyResponse> result){
        std::cout << "Thread reopened" << std::endl;
    });

setTrustFactor

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const SetTrustFactorOptions&	Ja

Antwort

Rückgabe: SetUserTrustFactorResponse

Beispiel

setTrustFactor Beispiel

Copy

SetTrustFactorOptions opts;
opts.userId = utility::conversions::to_string_t("user@example.com");
opts.trustFactor = 8;
opts.reason = boost::optional<utility::string_t>(utility::conversions::to_string_t("Spam check passed"));
api->setTrustFactor(utility::conversions::to_string_t("my-tenant-123"), opts)
    .then([](pplx::task<std::shared_ptr<SetUserTrustFactorResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

createModerator

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createModeratorBody	CreateModeratorBody	Ja

Antwort

Rückgabe: CreateModeratorResponse

Beispiel

createModerator Beispiel

Copy

CreateModeratorBody moderatorBody;
moderatorBody.email = utility::conversions::to_string_t("moderator@example.com");
moderatorBody.name = utility::conversions::to_string_t("John Moderator");
moderatorBody.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Community moderator"));
api->createModerator(utility::conversions::to_string_t("my-tenant-123"), moderatorBody)
    .then([](std::shared_ptr<CreateModeratorResponse> resp) {});

deleteModerator

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
sendEmail	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteModerator Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-456");
boost::optional<utility::string_t> sendEmail = utility::conversions::to_string_t("admin@example.com");
api->deleteModerator(tenantId, moderatorId, sendEmail)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // Erfolg behandeln
    });

getModerator

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetModeratorResponse

Beispiel

getModerator Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto moderatorId = utility::string_t(U("moderator-789"));
api->getModerator(tenantId, moderatorId)
    .then([](pplx::task<std::shared_ptr<GetModeratorResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception&) {
        }
    });

getModerators

Parameter

Name	Type	Required	Description
tenantId	string	Yes
skip	double	No

Antwort

Rückgabe: GetModeratorsResponse

Beispiel

getModerators Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getModerators(tenantId, skip).then([](pplx::task<std::shared_ptr<GetModeratorsResponse>> t){
    auto response = t.get();
});

sendInvite

Parameter

Name	Type	Required
tenantId	string	Yes
id	string	Yes
fromName	string	Yes

Antwort

Rückgabe: APIEmptyResponse

Beispiel

sendInvite Beispiel

Copy

boost::optional<utility::string_t> cc = utility::conversions::to_string_t("cc@example.com");
api->sendInvite(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("invitee@example.com"),
    utility::conversions::to_string_t("John Doe")
).then([](std::shared_ptr<APIEmptyResponse> resp) {
    // erfolgreiche Einladung verarbeiten
});

updateModerator

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateModeratorBody	UpdateModeratorBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateModerator Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto moderatorId = utility::conversions::to_string_t("mod-789");
UpdateModeratorBody body;
body.email = utility::conversions::to_string_t("moderator@example.com");
body.isActive = true;
body.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Senior moderator"));
api->updateModerator(tenantId, moderatorId, body)
    .then([](std::shared_ptr<APIEmptyResponse>) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch (const std::exception&) {} });

deleteNotificationCount

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteNotificationCount Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto notificationId = utility::conversions::to_string_t("notif-789");
api->deleteNotificationCount(tenantId, notificationId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {})
    .then([](pplx::task<void> t) { try { t.get(); } catch (const std::exception&) {} });

getCachedNotificationCount

Parameter

Name	Type	Required	Description
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetCachedNotificationCountResponse

Beispiel

getCachedNotificationCount Beispiel

Copy

auto tenantId = boost::optional<utility::string_t>(utility::conversions::to_string_t("my-tenant-123"));
auto userId = boost::optional<utility::string_t>(utility::conversions::to_string_t("user-456"));
api->getCachedNotificationCount(tenantId.value(), userId.value())
    .then([](pplx::task<std::shared_ptr<GetCachedNotificationCountResponse>> task) {
        try {
            auto response = task.get();
            // Antwort verarbeiten
        } catch (const std::exception&) {
            // Fehler behandeln
        }
    });

getNotificationCount

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetNotificationCountOptions&	Ja

Antwort

Rückgabe: GetNotificationCountResponse

Beispiel

getNotificationCount Beispiel

Copy

auto tenantId = U("my-tenant-123");
GetNotificationCountOptions options;
options.filter = boost::optional<utility::string_t>(U("unread"));
options.maxCount = boost::optional<int>(10);
api->getNotificationCount(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetNotificationCountResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception& ex) {
        }
    });

getNotifications

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetNotificationsOptions&	Ja

Antwort

Rückgabe: GetNotificationsResponse

Beispiel

getNotifications Beispiel

Copy

GetNotificationsOptions options;
options.limit = 20;
options.after = U("cursor-123");
api->getNotifications(U("my-tenant-123"), options)
    .then([](std::shared_ptr<GetNotificationsResponse> resp) {
        (void)resp;
    });

updateNotification

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateNotificationBody	UpdateNotificationBody	Ja
userId	string	Nein

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateNotification Beispiel

Copy

auto updateBody = std::make_shared<UpdateNotificationBody>();
updateBody->title = utility::conversions::to_string_t("System Maintenance");
updateBody->message = utility::conversions::to_string_t("Scheduled downtime at 02:00 UTC.");
api->updateNotification(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("notif-456"),
    updateBody,
    boost::optional<utility::string_t>(utility::conversions::to_string_t("admin-user"))
).then([](std::shared_ptr<APIEmptyResponse>){});

createV1PageReact

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
title	string	Nein

Antwort

Rückgabe: CreateV1PageReact

Beispiel

createV1PageReact Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("https://example.com/articles/789"));
boost::optional<utility::string_t> title = utility::string_t(U("Understanding Async C++"));
api->createV1PageReact(tenantId, urlId, title).then([](pplx::task<std::shared_ptr<CreateV1PageReact>> task) {
    try {
        auto response = task.get();
    } catch (const std::exception&) {
    }
});

createV2PageReact

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
urlId	string	Yes
id	string	Yes
title	string	No

Antwort

Rückgabe: CreateV1PageReact

Beispiel

createV2PageReact Beispiel

Copy

api->createV2PageReact(
    utility::string_t(U("my-tenant-789")),
    utility::string_t(U("https://example.com/articles/12345")),
    utility::string_t(U("user-42")),
    boost::optional<utility::string_t>(U("Helpful"))
).then([](pplx::task<std::shared_ptr<CreateV1PageReact>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){ }
});

deleteV1PageReact

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
urlId	string	Ja

Antwort

Rückgabe: CreateV1PageReact

Beispiel

deleteV1PageReact Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-abc-456");
api->deleteV1PageReact(tenantId, urlId).then([](pplx::task<std::shared_ptr<CreateV1PageReact>> task){
    try{
        auto response = task.get();
        boost::optional<std::shared_ptr<CreateV1PageReact>> optResponse = response;
    }catch(...){
    }
});

deleteV2PageReact

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
id	string	Ja

Antwort

Rückgabe: CreateV1PageReact

Beispiel

deleteV2PageReact Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto reactId = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> correlationId = utility::conversions::to_string_t("corr-001");
api->deleteV2PageReact(tenantId, urlId, reactId)
   .then([](pplx::task<std::shared_ptr<CreateV1PageReact>> t) {
        auto result = t.get();
    });

getV1PageLikes

Parameters

Name	Type	Required	Description
tenantId	string	Yes
urlId	string	Yes

Response

Rückgabe: GetV1PageLikes

Beispiel

getV1PageLikes Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("article-789");
boost::optional<utility::string_t> filter;
api->getV1PageLikes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetV1PageLikes>> task){
    try{
        auto raw = task.get();
        auto likes = std::make_shared<GetV1PageLikes>(*raw);
        auto total = likes->totalLikes;
    }catch(...){
    }
});

getV2PageReacts

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
urlId	string	Ja

Antwort

Rückgabe: GetV2PageReacts

Beispiel

getV2PageReacts Beispiel

Copy

auto tenantId = utility::string_t("my-tenant-123");
auto urlId = utility::string_t("https://example.com/article/42");
boost::optional<utility::string_t> locale = utility::string_t("en-US");
api->getV2PageReacts(tenantId, urlId)
    .then([locale](std::shared_ptr<GetV2PageReacts> reacts){
        if (locale) {}
    })
    .then([](pplx::task<void> t){
        try { t.get(); } catch (...) {}
    });

getV2PageReactUsers

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
urlId	string	Yes
id	string	Yes

Antwort

Rückgabe: GetV2PageReactUsersResponse

Beispiel

getV2PageReactUsers Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
auto id = utility::conversions::to_string_t("react-789");
boost::optional<utility::string_t> maybeFilter;
api->getV2PageReactUsers(tenantId, urlId, id).then([](pplx::task<std::shared_ptr<GetV2PageReactUsersResponse>> task){
    try{
        auto response = task.get();
        // Antwort nach Bedarf verwenden
    }catch(const std::exception&){
        // Fehler behandeln
    }
});

addPage

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createAPIPageData	CreateAPIPageData	Ja

Antwort

Rückgabe: AddPageAPIResponse

Beispiel

addPage Beispiel

Copy

auto createData = CreateAPIPageData{};
createData.title = utility::string_t(U("Welcome Page"));
createData.url = utility::string_t(U("https://example.com/welcome"));
createData.description = boost::optional<utility::string_t>(utility::string_t(U("Landing page for new users")));
api->addPage(utility::string_t(U("my-tenant-123")), createData)
    .then([](std::shared_ptr<AddPageAPIResponse> response) {
        if (response && response->success) {
            // erfolgreiche Hinzufügung verarbeiten
        } else {
            // Fehler behandeln
        }
    });

deletePage

Parameter

Name	Type	Required	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: DeletePageAPIResponse

Beispiel

deletePage Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pageId   = utility::conversions::to_string_t("page-456");
api->deletePage(tenantId, pageId)
   .then([](pplx::task<std::shared_ptr<DeletePageAPIResponse>> t) {
       try {
           auto response = t.get();
           // Verarbeite die Antwort nach Bedarf
       } catch (const std::exception& ex) {
           // Fehler behandeln
       }
   });

getOfflineUsers

Past commenters on the page who are NOT currently online. Sorted by displayName.
Verwenden Sie dies, nachdem /users/online erschöpft wurde, um einen „Members“-Abschnitt darzustellen.
Cursor-Paginierung auf commenterName: Der Server durchläuft den partiellen {tenantId, urlId, commenterName} Index ab afterName vorwärts mittels $gt, ohne $skip‑Kosten.

Parameters

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
options	const GetOfflineUsersOptions&	Yes

Response

Returns: PageUsersOfflineResponse

Beispiel

getOfflineUsers Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
GetOfflineUsersOptions options;
options.limit = boost::optional<int>(50);
options.includeDetails = boost::optional<bool>(true);
api->getOfflineUsers(tenantId, urlId, options)
    .then([](pplx::task<std::shared_ptr<PageUsersOfflineResponse>> t) {
        try {
            auto response = t.get();
        } catch (const std::exception&) {
        }
    });

getOnlineUsers

Derzeit online betrachtende Besucher einer Seite: Personen, deren Websocket‑Sitzung gerade die Seite abonniert.
Gibt anonCount + totalCount zurück (räumweite Abonnenten, einschließlich anonymer Viewer, die wir nicht auflisten).

Parameters

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
options	const GetOnlineUsersOptions&	Ja

Response

Rückgabe: PageUsersOnlineResponse

Beispiel

Beispiel für getOnlineUsers

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-456");
auto options = std::make_shared<GetOnlineUsersOptions>();
options->maxResults = boost::optional<int>(100);
options->includeInactive = boost::optional<bool>(false);
api->getOnlineUsers(tenantId, urlId, *options).then([](pplx::task<std::shared_ptr<PageUsersOnlineResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){
    }
});

getPageByURLId

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
urlId	string	Yes

Antwort

Rückgabe: GetPageByURLIdAPIResponse

Beispiel

getPageByURLId Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto urlId = utility::conversions::to_string_t("page-456");
boost::optional<utility::string_t> correlationId = boost::make_optional(utility::conversions::to_string_t("corr-789"));
api->getPageByURLId(tenantId, urlId)
    .then([correlationId](pplx::task<std::shared_ptr<GetPageByURLIdAPIResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getPages

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja

Antwort

Rückgabe: GetPagesAPIResponse

Beispiel

getPages Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
api->getPages(tenantId)
    .then([](pplx::task<std::shared_ptr<GetPagesAPIResponse>> task) {
        try {
            auto response = task.get();
            boost::optional<utility::string_t> nextCursor = response->nextCursor;
        } catch (const std::exception&) {
        }
    });

getPagesPublic

List pages for a tenant. Used by the FChat desktop client to populate its room list.
Requires enableFChat to be true on the resolved custom config for each page.
Pages that require SSO are filtered against the requesting user's group access.

Parameters

Name	Type	Required	Description
tenantId	string	Yes
options	const GetPagesPublicOptions&	Yes

Response

Returns: GetPublicPagesResponse

Example

getPagesPublic Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetPagesPublicOptions options;
options.limit = boost::optional<int>(50);
options.cursor = boost::optional<utility::string_t>(U("cursor-token"));
api->getPagesPublic(tenantId, options).then([](pplx::task<std::shared_ptr<GetPublicPagesResponse>> task){
    try{
        auto response = task.get();
        // Antwort verarbeiten bei Bedarf
    }catch(const std::exception&){
        // Fehler behandeln bei Bedarf
    }
});

getUsersInfo

Bulk‑Benutzerinformationen für einen Mandanten. Angesichts von userIds wird Anzeigedaten von User / SSOUser zurückgegeben.
Wird vom Kommentar‑Widget verwendet, um Benutzer zu erweitern, die gerade über ein Präsenzereignis erschienen sind.
Kein Seitenkontext: Datenschutz wird einheitlich durchgesetzt (private Profile werden maskiert).

Parameters

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
ids	string	Ja

Response

Returns: PageUsersInfoResponse

Example

Beispiel getUsersInfo

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ids = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> locale = boost::make_optional(U("en-US"));
api->getUsersInfo(tenantId, ids).then([](pplx::task<std::shared_ptr<PageUsersInfoResponse>> t){
    try{
        auto response = t.get();
        // Antwort verarbeiten
    }catch(const std::exception&){
        // Fehler behandeln
    }
});

patchPage

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateAPIPageData	UpdateAPIPageData	Ja

Antwort

Rückgabe: PatchPageAPIResponse

Beispiel

patchPage Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t pageId = U("page-789");
UpdateAPIPageData update;
update.title = boost::optional<utility::string_t>(U("Updated Page Title"));
update.metadata = boost::optional<utility::string_t>(U("{\"author\":\"jane.doe@example.com\"}"));
api->patchPage(tenantId, pageId, update)
    .then([](std::shared_ptr<PatchPageAPIResponse> response) {
        if (response && response->isSuccess) {
            // Erfolg behandeln
        }
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

deletePendingWebhookEvent

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
id	string	Yes

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deletePendingWebhookEvent Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto eventId = utility::conversions::to_string_t("event-987654");
boost::optional<utility::string_t> optTenant = tenantId;
api->deletePendingWebhookEvent(optTenant.value(), eventId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        (void)resp;
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception& e) { }
    });

getPendingWebhookEventCount

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetPendingWebhookEventCountOptions&	Ja

Antwort

Rückgabe: GetPendingWebhookEventCountResponse

Beispiel

getPendingWebhookEventCount Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
GetPendingWebhookEventCountOptions opts;
opts.filter = boost::optional<utility::string_t>(utility::conversions::to_string_t("active"));
api->getPendingWebhookEventCount(tenantId, opts)
    .then([](std::shared_ptr<GetPendingWebhookEventCountResponse> resp){
        auto count = resp->getCount();
    });

getPendingWebhookEvents

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetPendingWebhookEventsOptions&	Yes

Antwort

Returns: GetPendingWebhookEventsResponse

Beispiel

getPendingWebhookEvents Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
GetPendingWebhookEventsOptions opts;
opts.pageSize = boost::optional<int>(100);
opts.startAfter = boost::optional<utility::string_t>(U("event-abc-456"));
api->getPendingWebhookEvents(tenantId, opts)
    .then([](pplx::task<std::shared_ptr<GetPendingWebhookEventsResponse>> task) {
        try {
            auto resp = task.get();
            auto copy = std::make_shared<GetPendingWebhookEventsResponse>(*resp);
        } catch (const std::exception&) {}
    });

createQuestionConfig

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createQuestionConfigBody	CreateQuestionConfigBody	Ja

Antwort

Rückgabe: CreateQuestionConfigResponse

Beispiel

createQuestionConfig Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
CreateQuestionConfigBody configBody;
configBody.question = utility::string_t(U("How satisfied are you with our service?"));
configBody.required = true;
configBody.defaultAnswer = boost::optional<utility::string_t>(utility::string_t(U("Very satisfied")));
api->createQuestionConfig(tenantId, configBody).then([](pplx::task<std::shared_ptr<CreateQuestionConfigResponse>> task){
    try{
        auto response = task.get();
    }catch(const std::exception&){}
});

deleteQuestionConfig

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Gibt zurück: APIEmptyResponse

Beispiel

deleteQuestionConfig Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto configId = utility::conversions::to_string_t("question-config-456");
api->deleteQuestionConfig(tenantId, configId)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
        // erfolgreiche Löschung verarbeiten
    })
    .then([](pplx::task<void> t) {
        try {
            t.get();
        } catch (const std::exception&) {
            // Fehler behandeln
        }
    });

getQuestionConfig

Parameters

Name	Type	Required	Description
tenantId	string	Ja
id	string	Ja

Response

Rückgabe: GetQuestionConfigResponse

Beispiel

getQuestionConfig Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto questionId = utility::conversions::to_string_t("question-456");
api->getQuestionConfig(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionConfigResponse>> task) {
        try {
            auto response = task.get();
            // Antwort nach Bedarf verwenden
        } catch (const std::exception&) {
            // Fehler behandeln
        }
    });

getQuestionConfigs

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Antwort

Rückgabe: GetQuestionConfigsResponse

Beispiel

getQuestionConfigs Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<double> skip = 10.0;
api->getQuestionConfigs(tenantId, skip).then([](std::shared_ptr<GetQuestionConfigsResponse> resp){
    auto config = std::make_shared<GetQuestionConfigsResponse>(*resp);
});

updateQuestionConfig

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateQuestionConfigBody	UpdateQuestionConfigBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateQuestionConfig Beispiel

Copy

UpdateQuestionConfigBody updateBody;
updateBody.enabled = true;
updateBody.maxResponses = boost::optional<int>{10};
updateBody.notes = boost::optional<utility::string_t>{U("Config updated via SDK")};
api->updateQuestionConfig(U("my-tenant-123"), U("config-789"), updateBody)
    .then([](std::shared_ptr<APIEmptyResponse> resp) {
    })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) {}
    });

createQuestionResult

Parameter

Name	Type	Required	Description
tenantId	string	Ja
createQuestionResultBody	CreateQuestionResultBody	Ja

Antwort

Returns: CreateQuestionResultResponse

Beispiel

createQuestionResult Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
CreateQuestionResultBody body;
body.questionId = U("question-456");
body.result = U("approved");
body.comment = boost::optional<utility::string_t>(U("Looks good"));
api->createQuestionResult(tenantId, body)
    .then([=](pplx::task<std::shared_ptr<CreateQuestionResultResponse>> t) {
        try {
            auto resp = t.get();
        } catch (const std::exception&) {
        }
    });

deleteQuestionResult

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteQuestionResult Beispiel

Copy

boost::optional<utility::string_t> optTenant = utility::conversions::to_string_t( "my-tenant-123" );
utility::string_t questionId = utility::conversions::to_string_t( "question-456" );
if ( optTenant )
{
    api->deleteQuestionResult( *optTenant, questionId )
        .then( []( pplx::task<std::shared_ptr<APIEmptyResponse>> t )
        {
            try
            {
                auto resp = t.get();
                // Erfolgsbehandlung
            }
            catch ( const std::exception& e )
            {
                // Fehlerbehandlung
            }
        } );
}

getQuestionResult

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetQuestionResultResponse

Beispiel

getQuestionResult Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto questionId = utility::string_t(U("question-789"));
boost::optional<utility::string_t> optionalParam = boost::none;
api->getQuestionResult(tenantId, questionId)
    .then([](pplx::task<std::shared_ptr<GetQuestionResultResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

getQuestionResults

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetQuestionResultsOptions&	Ja

Antwort

Rückgabe: GetQuestionResultsResponse

Beispiel

getQuestionResults Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetQuestionResultsOptions options;
options.questionId = boost::optional<utility::string_t>(U("question-456"));
options.includeDeleted = boost::optional<bool>(false);
api->getQuestionResults(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetQuestionResultsResponse>> t) {
        auto response = t.get();
        // Antwort verarbeiten
    });

updateQuestionResult

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateQuestionResultBody	UpdateQuestionResultBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateQuestionResult Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto questionId = utility::string_t(U("question-456"));
UpdateQuestionResultBody body;
body.result = U("approved");
body.note = boost::optional<utility::string_t>(U("Reviewed by admin"));
api->updateQuestionResult(tenantId, questionId, body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t) {
        try {
            auto respPtr = std::make_shared<APIEmptyResponse>(*t.get());
        } catch (const std::exception&) {
        }
    });

aggregateQuestionResults

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const AggregateQuestionResultsOptions&	Ja

Antwort

Rückgabe: AggregateQuestionResultsResponse

Beispiel

aggregateQuestionResults Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
AggregateQuestionResultsOptions opts;
opts.questionId = utility::conversions::to_string_t("question-789");
opts.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z"), utility::datetime::ISO_8601));
opts.endDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z"), utility::datetime::ISO_8601));
api->aggregateQuestionResults(tenantId, opts)
    .then([](std::shared_ptr<AggregateQuestionResultsResponse> resp) {
        static_cast<void>(resp);
    });

bulkAggregateQuestionResults

Parameter

Name	Type	Required
tenantId	string	Yes
bulkAggregateQuestionResultsRequest	BulkAggregateQuestionResultsRequest	Yes
forceRecalculate	bool	No

Antwort

Rückgabe: BulkAggregateQuestionResultsResponse

Beispiel

bulkAggregateQuestionResults Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
BulkAggregateQuestionResultsRequest request;
request.questionIds = {
    utility::conversions::to_string_t("q123"),
    utility::conversions::to_string_t("q456")
};
request.startDate = utility::datetime::from_string(U("2023-01-01T00:00:00Z"));
request.endDate = utility::datetime::from_string(U("2023-01-31T23:59:59Z"));
boost::optional<bool> forceRecalc = true;
api->bulkAggregateQuestionResults(tenantId, request, forceRecalc)
   .then([](pplx::task<std::shared_ptr<BulkAggregateQuestionResultsResponse>> t) {
       auto resp = t.get();
   });

combineCommentsWithQuestionResults

Parameter

Name	Type	Required	Beschreibung
tenantId	string	Ja
options	const CombineCommentsWithQuestionResultsOptions&	Ja

Antwort

Rückgabe: CombineQuestionResultsWithCommentsResponse

Beispiel

combineCommentsWithQuestionResults Beispiel

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
CombineCommentsWithQuestionResultsOptions options;
options.questionId = utility::string_t("question-789");
options.maxComments = boost::optional<int>(50);
api->combineCommentsWithQuestionResults(tenantId, options).then(
    [](pplx::task<std::shared_ptr<CombineQuestionResultsWithCommentsResponse>> task){
        try{
            auto respPtr = task.get();
            auto combined = std::make_shared<CombineQuestionResultsWithCommentsResponse>(*respPtr);
            // Verwenden Sie combined nach Bedarf
        }catch(const std::exception&){
        }
    });

addSSOUser

Parameters

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
createAPISSOUserData	CreateAPISSOUserData	Yes

Response

Rückgabe: AddSSOUserAPIResponse

Example

addSSOUser Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateAPISSOUserData createAPISSOUserData;
createAPISSOUserData.email = utility::conversions::to_string_t("john.doe@example.com");
createAPISSOUserData.externalId = utility::conversions::to_string_t("ext-9876");
createAPISSOUserData.firstName = boost::optional<utility::string_t>(utility::conversions::to_string_t("John"));
createAPISSOUserData.lastName = boost::optional<utility::string_t>(utility::conversions::to_string_t("Doe"));
api->addSSOUser(tenantId, createAPISSOUserData)
    .then([](std::shared_ptr<AddSSOUserAPIResponse> resp) {
    });

deleteSSOUser

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
options	const DeleteSSOUserOptions&	Ja

Antwort

Rückgabe: DeleteSSOUserAPIResponse

Beispiel

deleteSSOUser Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto userId = U("user-456");
DeleteSSOUserOptions options;
options.dryRun = boost::optional<bool>(true);
api->deleteSSOUser(tenantId, userId, options).then([](std::shared_ptr<DeleteSSOUserAPIResponse> resp) {
    if (resp) {
        (void)resp;
    }
});

getSSOUserByEmail

Parameter

Name	Type	Required	Description
tenantId	string	Yes
email	string	Yes

Antwort

Rückgabe: GetSSOUserByEmailAPIResponse

Beispiel

getSSOUserByEmail Beispiel

Copy

auto correlationId = boost::optional<utility::string_t>(utility::conversions::to_string_t("corr-001"));
api->getSSOUserByEmail(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("user@example.com")
).then([](pplx::task<std::shared_ptr<GetSSOUserByEmailAPIResponse>> t) {
    try {
        auto response = t.get();
    } catch (const std::exception&) {
    }
});

getSSOUserById

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
id	string	Yes

Antwort

Rückgabe: GetSSOUserByIdAPIResponse

Beispiel

getSSOUserById Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto ssoUserId = U("user-789");
api->getSSOUserById(tenantId, ssoUserId)
    .then([](std::shared_ptr<GetSSOUserByIdAPIResponse> resp) {
        boost::optional<utility::string_t> email;
        if (resp && resp->email) email = resp->email;
        if (email) {
            auto e = *email;
        }
    });

getSSOUsers

Parameters

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	int32_t	Nein

Response

Rückgabe: GetSSOUsersResponse

Beispiel

getSSOUsers Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
boost::optional<int32_t> skip = 25;
api->getSSOUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetSSOUsersResponse>> t) {
    try {
        auto response = t.get();
    } catch (const std::exception&) {
    }
});

patchSSOUser

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateAPISSOUserData	UpdateAPISSOUserData	Ja
updateComments	bool	Nein

Antwort

Rückgabe: PatchSSOUserAPIResponse

Beispiel

patchSSOUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user-456");
UpdateAPISSOUserData updateData;
updateData.email = U("jane.doe@example.com");
updateData.displayName = U("Jane Doe");
boost::optional<bool> updateComments = true;
api->patchSSOUser(tenantId, userId, updateData, updateComments)
    .then([](pplx::task<std::shared_ptr<PatchSSOUserAPIResponse>> t){
        try{
            auto resp = t.get();
            (void)resp;
        }catch(const std::exception&){
        }
    });

putSSOUser

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateAPISSOUserData	UpdateAPISSOUserData	Ja
updateComments	bool	Nein

Antwort

Rückgabe: PutSSOUserAPIResponse

Beispiel

putSSOUser Beispiel

Copy

UpdateAPISSOUserData userData;
userData.email = utility::conversions::to_string_t("alice@example.com");
userData.first_name = utility::conversions::to_string_t("Alice");
userData.last_name = utility::conversions::to_string_t("Smith");
userData.role = utility::conversions::to_string_t("moderator");
api->putSSOUser(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("alice.smith"),
    userData,
    boost::optional<bool>(true)
).then([](pplx::task<std::shared_ptr<PutSSOUserAPIResponse>> t) {
    auto response = t.get();
});

createSubscription

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createAPIUserSubscriptionData	CreateAPIUserSubscriptionData	Ja

Antwort

Rückgabe: CreateSubscriptionAPIResponse

Beispiel

createSubscription Beispiel

Copy

auto tenantId = U("my-tenant-123");
CreateAPIUserSubscriptionData subscriptionData;
subscriptionData.email = U("user@example.com");
subscriptionData.planId = U("premium-plan");
subscriptionData.couponCode = boost::optional<utility::string_t>(U("WELCOME10"));
api->createSubscription(tenantId, subscriptionData)
    .then([](pplx::task<std::shared_ptr<CreateSubscriptionAPIResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

deleteSubscription

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
userId	string	No

Antwort

Rückgabe: DeleteSubscriptionAPIResponse

Beispiel

deleteSubscription Beispiel

Copy

api->deleteSubscription(utility::string_t(U("my-tenant-123")), utility::string_t(U("sub-456")), boost::optional<utility::string_t>(utility::string_t(U("user@example.com"))))
    .then([](std::shared_ptr<DeleteSubscriptionAPIResponse> resp){
        if (resp) {
        }
    });

---

getSubscriptions

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
userId	string	Nein

Antwort

Rückgabe: GetSubscriptionsAPIResponse

Beispiel

Beispiel getSubscriptions

Copy

auto tenant = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> user = utility::conversions::to_string_t("user@example.com");
api->getSubscriptions(tenant, user).then(
    [](pplx::task<std::shared_ptr<GetSubscriptionsAPIResponse>> t) {
        try {
            auto response = t.get();
            // Antwort verarbeiten
        } catch (const std::exception& e) {
            // Fehler behandeln
        }
    }
);

updateSubscription

Parameter

Name	Type	Required
tenantId	string	Yes
id	string	Yes
updateAPIUserSubscriptionData	UpdateAPIUserSubscriptionData	Yes
userId	string	No

Antwort

Rückgabe: UpdateSubscriptionAPIResponse

Beispiel

updateSubscription Beispiel

Copy

UpdateAPIUserSubscriptionData subscriptionData;
subscriptionData.plan = utility::conversions::to_string_t("premium");
subscriptionData.active = true;
api->updateSubscription(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("sub-987654"),
    subscriptionData,
    boost::optional<utility::string_t>(utility::conversions::to_string_t("admin-user-456"))
).then([](std::shared_ptr<UpdateSubscriptionAPIResponse> response){
    bool ok = response && response->isSuccess;
    (void)ok;
});

getTenantDailyUsages

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetTenantDailyUsagesOptions&	Ja

Antwort

Rückgabe: GetTenantDailyUsagesResponse

Beispiel

getTenantDailyUsages Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetTenantDailyUsagesOptions opts;
opts.startDate = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-01T00:00:00Z")));
opts.endDate   = boost::optional<utility::datetime>(utility::datetime::from_string(U("2023-01-31T23:59:59Z")));
api->getTenantDailyUsages(tenantId, opts).then([](std::shared_ptr<GetTenantDailyUsagesResponse> resp){
    auto result = std::make_shared<GetTenantDailyUsagesResponse>(*resp);
}).wait();

createTenantPackage

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createTenantPackageBody	CreateTenantPackageBody	Ja

Antwort

Rückgabe: CreateTenantPackageResponse

Beispiel

createTenantPackage Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateTenantPackageBody body;
body.name = utility::conversions::to_string_t("Pro Plan");
body.maxUsers = 100;
body.expiryDate = boost::optional<utility::datetime>(utility::datetime::utc_now() + std::chrono::hours(24 * 30));
body.notes = boost::none;
api->createTenantPackage(tenantId, body).then([](pplx::task<std::shared_ptr<CreateTenantPackageResponse>> t){
    try{
        auto resp = t.get();
    }catch(const std::exception&){
    }
});

deleteTenantPackage

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Rückgabe

Rückgabe: APIEmptyResponse

Beispiel

deleteTenantPackage Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto packageId = utility::conversions::to_string_t("pkg-456");
boost::optional<utility::string_t> optTenant = tenantId;
boost::optional<utility::string_t> optPackage = packageId;
api->deleteTenantPackage(optTenant.value(), optPackage.value())
    .then([](std::shared_ptr<APIEmptyResponse>){ })
    .then([](pplx::task<void> t){ try{ t.get(); }catch(const std::exception&){ } });

getTenantPackage

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetTenantPackageResponse

Beispiel

getTenantPackage Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto packageId = U("pkg-456");
api->getTenantPackage(tenantId, packageId).then([](pplx::task<std::shared_ptr<GetTenantPackageResponse>> task){
    try{
        auto resp = task.get();
        auto result = std::make_shared<GetTenantPackageResponse>(*resp);
    }catch(...){}
});

getTenantPackages

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
skip	double	No

Antwort

Rückgabe: GetTenantPackagesResponse

Beispiel

getTenantPackages Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
boost::optional<double> skip = 20.0;
api->getTenantPackages(tenantId, skip)
    .then([](std::shared_ptr<GetTenantPackagesResponse> resp) {
        (void)resp;
    });

replaceTenantPackage

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
replaceTenantPackageBody	ReplaceTenantPackageBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

replaceTenantPackage Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto pkgId = utility::conversions::to_string_t("pkg-456");
ReplaceTenantPackageBody body;
body.planId = utility::conversions::to_string_t("enterprise");
body.notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgrade request"));
api->replaceTenantPackage(tenantId, pkgId, body)
    .then([](std::shared_ptr<APIEmptyResponse>) { })
    .then([](pplx::task<void> t) {
        try { t.get(); } catch (const std::exception&) { }
    });

updateTenantPackage

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
updateTenantPackageBody	UpdateTenantPackageBody	Yes

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateTenantPackage Beispiel

Copy

auto body = std::make_shared<UpdateTenantPackageBody>();
body->packageId = utility::conversions::to_string_t("premium-plan");
body->expirationDate = utility::conversions::to_string_t("2025-12-31");
body->notes = boost::optional<utility::string_t>(utility::conversions::to_string_t("Upgraded package"));
api->updateTenantPackage(utility::conversions::to_string_t("my-tenant-123"),
                         utility::conversions::to_string_t("pkg-456"),
                         body)
    .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> task) {
        try {
            auto response = task.get();
            // success handling
        } catch (const std::exception& ex) {
            // error handling
        }
    });

createTenantUser

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createTenantUserBody	CreateTenantUserBody	Ja

Antwort

Rückgabe: CreateTenantUserResponse

Beispiel

createTenantUser Beispiel

Copy

auto body = CreateTenantUserBody{};
body.email = utility::conversions::to_string_t("newuser@example.com");
body.firstName = utility::conversions::to_string_t("Alice");
body.lastName = utility::conversions::to_string_t("Smith");
body.role = boost::optional<utility::string_t>(utility::conversions::to_string_t("moderator"));
api->createTenantUser(utility::conversions::to_string_t("my-tenant-123"), body)
    .then([](pplx::task<std::shared_ptr<CreateTenantUserResponse>> task) {
        try {
            auto response = task.get();
        } catch (const std::exception&) {
        }
    });

deleteTenantUser

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
options	const DeleteTenantUserOptions&	Yes

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteTenantUser Beispiel

Copy

DeleteTenantUserOptions options;
options.reason = boost::optional<utility::string_t>(U("User requested deletion"));
api->deleteTenantUser(U("my-tenant-123"), U("user@example.com"), options)
    .then([](std::shared_ptr<APIEmptyResponse> resp){
        (void)resp;
    });

getTenantUser

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetTenantUserResponse

Beispiel

getTenantUser Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
api->getTenantUser(tenantId, userId)
    .then([](pplx::task<std::shared_ptr<GetTenantUserResponse>> task) {
        try {
            auto response = task.get();
            // Verwenden Sie die Antwort nach Bedarf
        } catch (const std::exception&) {
            // Fehlerbehandlung
        }
    });

getTenantUsers

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
skip	double	Nein

Antwort

Gibt zurück: GetTenantUsersResponse

Beispiel

getTenantUsers Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<double> skip = 10;
api->getTenantUsers(tenantId, skip).then([](pplx::task<std::shared_ptr<GetTenantUsersResponse>> t){
    try {
        auto resp = t.get();
    } catch (const std::exception&) {
    }
});

replaceTenantUser

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
replaceTenantUserBody	ReplaceTenantUserBody	Yes
updateComments	string	No

Antwort

Rückgabe: APIEmptyResponse

Beispiel

replaceTenantUser Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto userId = utility::string_t(U("john.doe@example.com"));
ReplaceTenantUserBody replaceBody;
replaceBody.email = utility::string_t(U("john.doe@example.com"));
replaceBody.role = utility::string_t(U("admin"));
boost::optional<utility::string_t> updateComments = utility::string_t(U("Promoted to admin"));
api->replaceTenantUser(tenantId, userId, replaceBody, updateComments)
    .then([](std::shared_ptr<APIEmptyResponse> resp){ });

sendLoginLink

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
redirectURL	string	No

Antwort

Rückgabe: APIEmptyResponse

Beispiel

sendLoginLink Beispiel

Copy

api->sendLoginLink(
    U("my-tenant-123"),
    U("user@example.com"),
    boost::make_optional(U("https://myapp.com/auth/callback"))
).then([](std::shared_ptr<APIEmptyResponse> resp) {
});

updateTenantUser

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
updateTenantUserBody	UpdateTenantUserBody	Yes
updateComments	string	No

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateTenantUser Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user-456");
UpdateTenantUserBody body;
body.email = U("john.doe@example.com");
body.role = U("admin");
boost::optional<utility::string_t> updateComments = U("Promoted to admin");
api->updateTenantUser(tenantId, userId, body, updateComments)
    .then([](std::shared_ptr<APIEmptyResponse>){ });

createTenant

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
createTenantBody	CreateTenantBody	Ja

Antwort

Rückgabe: CreateTenantResponse

Beispiel

createTenant Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
CreateTenantBody body;
body.setName(utility::conversions::to_string_t("Acme Corp"));
body.setAdminEmail(utility::conversions::to_string_t("admin@acme.com"));
body.setPlan(utility::conversions::to_string_t("enterprise"));
body.setDescription(boost::optional<utility::string_t>(utility::conversions::to_string_t("Primary tenant for Acme")));
api->createTenant(tenantId, body).then([](pplx::task<std::shared_ptr<CreateTenantResponse>> t){
    auto resp = t.get();
});

deleteTenant

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
sure	string	No

Antwort

Rückgabe: APIEmptyResponse

Beispiel

deleteTenant Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
boost::optional<utility::string_t> sure = utility::conversions::to_string_t("true");
api->deleteTenant(tenantId, userId, sure)
   .then([](pplx::task<std::shared_ptr<APIEmptyResponse>> t){
       try{
           auto resp = t.get();
           auto result = std::make_shared<APIEmptyResponse>(*resp);
       }catch(const std::exception&){})

getTenant

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
id	string	Yes

Antwort

Rückgabe: GetTenantResponse

Beispiel

getTenant Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto id = utility::conversions::to_string_t("tenant-admin-456");
boost::optional<utility::string_t> includeDetails = utility::conversions::to_string_t("full");
api->getTenant(tenantId, id)
    .then([](std::shared_ptr<GetTenantResponse> resp) {
        if (resp) {
            std::wcout << resp->toString() << std::endl;
        }
    });

getTenants

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetTenantsOptions&	Ja

Antwort

Rückgabe: GetTenantsResponse

Beispiel

getTenants Beispiel

Copy

GetTenantsOptions options;
options.includeDeleted = boost::make_optional(false);
options.searchTerm = boost::make_optional(utility::string_t(U("enterprise")));
api->getTenants(utility::string_t(U("my-tenant-123")), options)
    .then([](std::shared_ptr<GetTenantsResponse> response) {
    })
    .then([](pplx::task<void> t){ try{ t.get(); }catch(...){} });

updateTenant

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
updateTenantBody	UpdateTenantBody	Ja

Antwort

Rückgabe: APIEmptyResponse

Beispiel

updateTenant Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto recordId = utility::string_t(U("tenant-456"));
UpdateTenantBody body;
body.name = boost::optional<utility::string_t>(U("Acme Corp"));
body.contactEmail = boost::optional<utility::string_t>(U("admin@acme.com"));
api->updateTenant(tenantId, recordId, body).then([](std::shared_ptr<APIEmptyResponse> resp) {
    auto log = std::make_shared<utility::string_t>(U("Tenant update succeeded"));
    (void)resp;
    (void)log;
});

changeTicketState

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
userId	string	Ja
id	string	Ja
changeTicketStateBody	ChangeTicketStateBody	Ja

Antwort

Rückgabe: ChangeTicketStateResponse

Beispiel

changeTicketState Beispiel

Copy

auto body = std::make_shared<ChangeTicketStateBody>();
body->state = U("closed");
body->comment = boost::optional<utility::string_t>(U("Ticket resolved"));
api->changeTicketState(U("my-tenant-123"), U("user@example.com"), U("ticket-456"), *body)
    .then([](std::shared_ptr<ChangeTicketStateResponse>) {});

createTicket

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
userId	string	Yes
createTicketBody	CreateTicketBody	Yes

Antwort

Rückgabe: CreateTicketResponse

Beispiel

createTicket Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("john.doe@example.com");
CreateTicketBody ticketBody;
ticketBody.setSubject(utility::conversions::to_string_t("Login Issue"));
ticketBody.setDescription(utility::conversions::to_string_t("Cannot log in after password reset."));
boost::optional<int> priority = 2;
ticketBody.setPriority(priority);
api->createTicket(tenantId, userId, ticketBody).then([](pplx::task<std::shared_ptr<CreateTicketResponse>> task){
    try{
        auto response = task.get();
        // Antwort nach Bedarf verwenden
    }catch(const std::exception&){
        // Fehler behandeln
    }
});

getTicket

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
userId	string	Nein

Antwort

Rückgabe: GetTicketResponse

Beispiel

getTicket Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t ticketId = U("ticket-789");
boost::optional<utility::string_t> userId = U("alice@example.com");
api->getTicket(tenantId, ticketId, userId).then([](pplx::task<std::shared_ptr<GetTicketResponse>> task){
    try{
        auto resp = task.get();
    }catch(const std::exception&){
    }
});

getTickets

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetTicketsOptions&	Yes

Antwort

Rückgabe: GetTicketsResponse

Beispiel

getTickets Beispiel

Copy

auto options = GetTicketsOptions{};
options.page = boost::optional<int>(1);
options.status = boost::optional<utility::string_t>(U("open"));
api->getTickets(U("my-tenant-123"), options).then([](pplx::task<std::shared_ptr<GetTicketsResponse>> task) {
    try {
        auto response = task.get();
        auto responseCopy = std::make_shared<GetTicketsResponse>(*response);
    } catch (const std::exception&) {
    }
});

getTranslations

Parameter

Name	Typ	Erforderlich
r_namespace	string	Ja
component	string	Ja
options	const GetTranslationsOptions&	Ja

Antwort

Rückgabe: GetTranslationsResponse

Beispiel

getTranslations Beispiel

Copy

utility::string_t ns = U("my-tenant-123");
utility::string_t comp = U("comments");
auto optsPtr = std::make_shared<GetTranslationsOptions>();
optsPtr->language = boost::make_optional(U("en"));
optsPtr->fallback = boost::none;
api->getTranslations(ns, comp, *optsPtr)
    .then([](pplx::task<std::shared_ptr<GetTranslationsResponse>> t) {
        try {
            auto resp = t.get();
        } catch (const std::exception& e) {
        }
    });

uploadImage

Upload and resize an image

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
file	HttpContent	Ja
options	const UploadImageOptions&	Ja

Antwort

Returns: UploadImageResponse

Beispiel

uploadImage Beispiel

Copy

auto fileStream = concurrency::streams::fstream::open_istream(U("avatar.png"), std::ios::in).get();
HttpContent file(fileStream, U("image/png"));
UploadImageOptions options;
options.description = boost::optional<utility::string_t>(U("Profile picture"));
options.width = boost::optional<int>(256);
options.height = boost::optional<int>(256);
api->uploadImage(U("my-tenant-123"), file, options).then([](pplx::task<std::shared_ptr<UploadImageResponse>> t){
    auto resp = t.get();
});

getUserBadgeProgressById

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIGetUserBadgeProgressResponse

Beispiel

Beispiel für getUserBadgeProgressById

Copy

auto tenantId = U("my-tenant-123");
auto userId = U("user-456");
api->getUserBadgeProgressById(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<APIGetUserBadgeProgressResponse>> t){
        try{
            auto resp = t.get();
            boost::optional<std::shared_ptr<APIGetUserBadgeProgressResponse>> optResp = resp;
            if(optResp){}
        }catch(const std::exception&){}
    });

getUserBadgeProgressByUserId

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
userId	string	Yes

Antwort

Rückgabe: APIGetUserBadgeProgressResponse

Beispiel

getUserBadgeProgressByUserId Beispiel

Copy

boost::optional<std::shared_ptr<APIGetUserBadgeProgressResponse>> responseOpt;
api->getUserBadgeProgressByUserId(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("user@example.com"))
    .then([&responseOpt](pplx::task<std::shared_ptr<APIGetUserBadgeProgressResponse>> t) {
        try {
            responseOpt = t.get();
        } catch (...) {
            responseOpt = boost::none;
        }
    });

getUserBadgeProgressList

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
options	const GetUserBadgeProgressListOptions&	Yes

Antwort

Gibt zurück: APIGetUserBadgeProgressListResponse

Beispiel

getUserBadgeProgressList Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
GetUserBadgeProgressListOptions options;
options.userId = U("user@example.com");
options.page = boost::optional<int>(1);
options.pageSize = boost::optional<int>(20);
api->getUserBadgeProgressList(tenantId, options)
    .then([](std::shared_ptr<APIGetUserBadgeProgressListResponse> resp) {
        if (!resp) return;
        for (const auto& badge : resp->badges) {
            // process badge
        }
    });

createUserBadge

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
createUserBadgeParams	CreateUserBadgeParams	Yes

Antwort

Rückgabe: APICreateUserBadgeResponse

Beispiel

createUserBadge Beispiel

Copy

auto tenantId = U("my-tenant-123");
CreateUserBadgeParams badgeParams;
badgeParams.userEmail = U("user@example.com");
badgeParams.badgeCode = U("gold");
badgeParams.expirationDate = boost::optional<utility::datetime>(utility::datetime::utc_now() + utility::datetime::from_seconds(2592000));
api->createUserBadge(tenantId, badgeParams).then([](std::shared_ptr<APICreateUserBadgeResponse> resp){
    if (resp && resp->success) {
        auto result = std::make_shared<APICreateUserBadgeResponse>(*resp);
    }
});

deleteUserBadge

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIEmptySuccessResponse

Beispiel

deleteUserBadge Beispiel

Copy

auto tenantId = boost::optional<utility::string_t>(U("my-tenant-123"));
auto badgeId = utility::string_t(U("badge-789"));
api->deleteUserBadge(tenantId.value(), badgeId)
    .then([](std::shared_ptr<APIEmptySuccessResponse> resp){
        auto copy = std::make_shared<APIEmptySuccessResponse>(*resp);
    })
    .then([](pplx::task<void> t){
        try{ t.get(); } catch(const std::exception&){ }
    });

getUserBadge

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: APIGetUserBadgeResponse

Beispiel

getUserBadge Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t userId = U("user-456");
api->getUserBadge(tenantId, userId).then([](pplx::task<std::shared_ptr<APIGetUserBadgeResponse>> t){
    try{
        auto resp = t.get();
        boost::optional<std::string> badgeUrl = resp->badge_url ? boost::optional<std::string>(*resp->badge_url) : boost::none;
    }catch(const std::exception&){
    }
});

getUserBadges

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetUserBadgesOptions&	Ja

Antwort

Rückgabe: APIGetUserBadgesResponse

Beispiel

Beispiel für getUserBadges

Copy

GetUserBadgesOptions opts;
opts.userId = boost::make_optional(U("user@example.com"));
opts.includeExpired = boost::make_optional(false);
api->getUserBadges(U("my-tenant-123"), opts)
   .then([](pplx::task<std::shared_ptr<APIGetUserBadgesResponse>> t) {
       try {
           auto response = t.get();
       } catch (const std::exception&) {
       }
   });

updateUserBadge

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
id	string	Yes
updateUserBadgeParams	UpdateUserBadgeParams	Yes

Antwort

Rückgabe: APIEmptySuccessResponse

Beispiel

updateUserBadge Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user@example.com");
UpdateUserBadgeParams params;
params.badgeId = utility::conversions::to_string_t("vip-badge");
params.expiration = boost::optional<utility::datetime>(utility::datetime::from_string(U("2024-12-31T23:59:59Z")));
api->updateUserBadge(tenantId, userId, params)
    .then([](std::shared_ptr<APIEmptySuccessResponse> resp){
        std::cout << "Badge updated successfully\n";
    })
    .catch([](std::exception const& e){
        std::cerr << "Error updating badge: " << e.what() << "\n";
    });

getUserNotificationCount

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Yes
sso	string	No

Antwort

Rückgabe: GetUserNotificationCountResponse

Beispiel

getUserNotificationCount Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
boost::optional<utility::string_t> sso = utility::conversions::to_string_t("user@example.com");
api->getUserNotificationCount(tenantId, sso).then([](pplx::task<std::shared_ptr<GetUserNotificationCountResponse>> t){
    try{
        auto resp = t.get();
        // use resp as needed
    }catch(const std::exception&){
        // handle error
    }
});

getUserNotifications

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const GetUserNotificationsOptions&	Ja

Antwort

Rückgabe: GetMyNotificationsResponse

Beispiel

getUserNotifications Beispiel

Copy

utility::string_t tenantId = utility::string_t("my-tenant-123");
GetUserNotificationsOptions options;
options.limit = boost::optional<int>(20);
options.unreadOnly = boost::optional<bool>(true);
api->getUserNotifications(tenantId, options)
    .then([](pplx::task<std::shared_ptr<GetMyNotificationsResponse>> task){
        auto resp = task.get();
        auto notifications = std::make_shared<GetMyNotificationsResponse>(*resp);
    });

resetUserNotificationCount

Parameter

Name	Type	Erforderlich	Beschreibung
tenantId	string	Ja
sso	string	Nein

Antwort

Rückgabe: ResetUserNotificationsResponse

Beispiel

Beispiel für resetUserNotificationCount

Copy

auto resetTask = api->resetUserNotificationCount(
    U("my-tenant-123"),
    boost::optional<utility::string_t>(U("user@example.com"))
).then([](std::shared_ptr<ResetUserNotificationsResponse> resp){
});

resetUserNotifications

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
options	const ResetUserNotificationsOptions&	Ja

Antwort

Rückgabe: ResetUserNotificationsResponse

Beispiel

resetUserNotifications Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
ResetUserNotificationsOptions options;
options.email = boost::optional<utility::string_t>(U("user@example.com"));
api->resetUserNotifications(tenantId, options)
    .then([](std::shared_ptr<ResetUserNotificationsResponse> resp) {
        // Antwort verarbeiten
    });

updateUserNotificationCommentSubscriptionStatus

Aktivieren oder deaktivieren Sie Benachrichtigungen für einen bestimmten Kommentar.

Parameters

Name	Type	Required
tenantId	string	Yes
notificationId	string	Yes
optedInOrOut	string	Yes
commentId	string	Yes
sso	string	No

Response

Rückgabe: UpdateUserNotificationCommentSubscriptionStatusResponse

Beispiel

updateUserNotificationCommentSubscriptionStatus Beispiel

Copy

auto updateTask = api->updateUserNotificationCommentSubscriptionStatus(
    utility::conversions::to_string_t("my-tenant-123"),
    utility::conversions::to_string_t("notif-456"),
    utility::conversions::to_string_t("optedIn"),
    utility::conversions::to_string_t("comment-789"),
    boost::optional<utility::string_t>(utility::conversions::to_string_t("sso-token-abc"))
).then([](std::shared_ptr<UpdateUserNotificationCommentSubscriptionStatusResponse> resp){
    (void)resp;
});

updateUserNotificationPageSubscriptionStatus

Enable oder deaktivieren Sie Benachrichtigungen für eine Seite. Wenn Benutzer eine Seite abonniert haben, werden Benachrichtigungen für neue Stammkommentare erstellt und auch

Parameter

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

Antwort

Rückgabe: UpdateUserNotificationPageSubscriptionStatusResponse

Beispiel

updateUserNotificationPageSubscriptionStatus Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("page-456");
utility::string_t url = U("https://example.com/articles/awesome-article");
utility::string_t pageTitle = U("Awesome Article");
utility::string_t subscription = U("subscribed");
boost::optional<utility::string_t> sso = boost::make_optional<utility::string_t>(U("sso-token-789"));
api->updateUserNotificationPageSubscriptionStatus(tenantId, urlId, url, pageTitle, subscription, sso)
    .then([](std::shared_ptr<UpdateUserNotificationPageSubscriptionStatusResponse> resp) {
        // process resp if needed
    });

updateUserNotificationStatus

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
notificationId	string	Yes
newStatus	string	Yes
sso	string	No

Antwort

Rückgabe: UpdateUserNotificationStatusResponse

Beispiel

updateUserNotificationStatus Beispiel

Copy

api->updateUserNotificationStatus(
    U("my-tenant-123"),
    U("notif-456"),
    U("read"),
    boost::optional<utility::string_t>(U("sso-token-abc"))
).then([](std::shared_ptr<UpdateUserNotificationStatusResponse> resp) {
}).wait();

getUserPresenceStatuses

Parameter

Name	Typ	Erforderlich
tenantId	string	Yes
urlIdWS	string	Yes
userIds	string	Yes

Antwort

Rückgabe: GetUserPresenceStatusesResponse

Beispiel

getUserPresenceStatuses Beispiel

Copy

auto tenantId = U("my-tenant-123");
auto urlIdWS = U("article-789");
auto userIds = U("alice@example.com,bob@example.com");
boost::optional<utility::string_t> optionalFilter = boost::none;
api->getUserPresenceStatuses(tenantId, urlIdWS, userIds)
    .then([](pplx::task<std::shared_ptr<GetUserPresenceStatusesResponse>> t){
        try{
            auto response = t.get();
        }catch(...){
        }
    });

searchUsers

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
urlId	string	Ja
options	const SearchUsersOptions&	Ja

Antwort

Rückgabe: SearchUsersResult

Beispiel

searchUsers Beispiel

Copy

utility::string_t tenantId = U("my-tenant-123");
utility::string_t urlId = U("article-456");
SearchUsersOptions options;
options.query = U("john.doe@example.com");
options.page = boost::optional<int>(1);
options.pageSize = boost::optional<int>(20);
api->searchUsers(tenantId, urlId, options).then([](pplx::task<std::shared_ptr<SearchUsersResult>> task){
    try{
        auto result = task.get();
    }catch(const std::exception&){}
});

getUser

Parameter

Name	Typ	Erforderlich	Beschreibung
tenantId	string	Ja
id	string	Ja

Antwort

Rückgabe: GetUserResponse

Beispiel

getUser Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto userId = utility::conversions::to_string_t("user-789");
boost::optional<utility::string_t> optTag = boost::none;
api->getUser(tenantId, userId)
    .then([=](pplx::task<std::shared_ptr<GetUserResponse>> task) {
        try {
            auto response = task.get();
            if (!response) {
                response = std::make_shared<GetUserResponse>();
            }
            // Antwort nach Bedarf verarbeiten
        } catch (const std::exception&) {
            // Fehler behandeln
        }
    });

createVote

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
commentId	string	Ja
direction	string	Ja
options	const CreateVoteOptions&	Ja

Antwort

Rückgabe: VoteResponse

Beispiel

createVote Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto commentId = utility::conversions::to_string_t("cmt-456");
auto direction = utility::conversions::to_string_t("up");
auto optionsPtr = std::make_shared<CreateVoteOptions>();
optionsPtr->userId = utility::conversions::to_string_t("user-789");
optionsPtr->ipAddress = boost::optional<utility::string_t>(utility::conversions::to_string_t("192.168.1.100"));
api->createVote(tenantId, commentId, direction, *optionsPtr)
    .then([](std::shared_ptr<VoteResponse> resp){});

deleteVote

Parameter

Name	Typ	Erforderlich
tenantId	string	Ja
id	string	Ja
editKey	string	Nein

Antwort

Rückgabe: VoteDeleteResponse

Beispiel

deleteVote Beispiel

Copy

auto tenantId = utility::conversions::to_string_t("my-tenant-123");
auto voteId = utility::conversions::to_string_t("vote-9876");
boost::optional<utility::string_t> editKey = utility::conversions::to_string_t("edit-abc123");
api->deleteVote(tenantId, voteId, editKey).then([](pplx::task<std::shared_ptr<VoteDeleteResponse>> task) {
    try {
        auto response = task.get();
        // Antwort verarbeiten nach Bedarf
    } catch (const std::exception&) {
        // Fehler behandeln
    }
});

getVotes

Parameters

Name	Type	Required	Description
tenantId	string	Ja
urlId	string	Ja

Response

Returns: GetVotesResponse

Example

getVotes Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("article-456"));
boost::optional<utility::string_t> extraHeader = boost::none;
api->getVotes(tenantId, urlId).then([=](pplx::task<std::shared_ptr<GetVotesResponse>> task) {
    try {
        auto original = task.get();
        auto response = std::make_shared<GetVotesResponse>(*original);
    } catch (...) {
        // Fehlerbehandlung
    }
});

getVotesForUser

Parameter

Name	Type	Required
tenantId	string	Yes
urlId	string	Yes
options	const GetVotesForUserOptions&	Yes

Antwort

Rückgabe: GetVotesForUserResponse

Beispiel

getVotesForUser Beispiel

Copy

auto tenantId = utility::string_t(U("my-tenant-123"));
auto urlId = utility::string_t(U("post-456"));
GetVotesForUserOptions options;
options.page = boost::optional<int>(2);
options.pageSize = boost::optional<int>(50);
api->getVotesForUser(tenantId, urlId, options).then([](std::shared_ptr<GetVotesForUserResponse> response) {
    if (response) {
        // handle response, e.g., iterate votes
    }
});

Benötigen Sie Hilfe?

Wenn Sie auf Probleme stoßen oder Fragen zum C++ SDK haben, bitte:

Mitwirken

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

Sprache 🇩🇪 Deutsch

Dokumentation

Erste Schritte

API-Referenz

Verwendung

Aggregation

Audit-Protokolle

Authentifizierung

Vom Kommentar blockieren

Blockierte Kommentare prüfen

Kommentare

Kommentare für Benutzer

Domain-Konfigurationen

E-Mail-Vorlagen

Ereignisprotokoll

Feed-Beiträge

Kommentar melden

GIFs

Hashtags

Moderation

Moderatoren

Benachrichtigungszähler

Benachrichtigungen

Seiten-Reaktionen

Seiten

Ausstehende Webhook-Ereignisse

Fragekonfigurationen

Frageergebnisse

Aggregation der Frageergebnisse

SSO-Benutzer

Abonnements

Tägliche Nutzung des Mandanten

Mandantenpakete

Mandanten-Benutzer

Mandanten

Tickets

Übersetzungen

Bild hochladen

Fortschritt der Benutzerabzeichen

Benutzerabzeichen

Benutzerbenachrichtigungen

Präsenzstatus der Benutzer

Benutzersuche

Benutzer

Stimmen

FastComments C++ SDK

Repository

Voraussetzungen

Installation

Install Dependencies

Building from Source

Installing

Library Contents

Public vs Secured APIs

Schnellstart

Using Authenticated APIs (DefaultAPI)

Using Public APIs (PublicAPI)

Using Moderation APIs (ModerationApi)

Common Issues

API-Aufrufe: Synchron vs. Asynchron

Synchrone Aufrufe mit .get()

Asynchrone Aufrufe mit .then()

Auswahl zwischen synchron und asynchron

Hinweise

Broadcast-IDs

SSO (Einmalanmeldung)

SSO-Nutzung

Einfaches SSO

Sicheres SSO

Dokumentation für fastcomments

Dokumentation der API-Endpunkte

Dokumentation der Modelle

aggregate

Parameter

Antwort

Beispiel

getAuditLogs

Parameter

Antwort

Beispiel

Synchrone Aufrufe mit `.get()`

Asynchrone Aufrufe mit `.then()`