FastComments C++ SDK

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

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

Repository

KI-Coding-Agenten

Geben Sie Ihrem Coding‑Agent den FastComments‑Kontext, den er benötigt – Widgets, Konfiguration, Secure SSO, die REST‑API und die SDKs:

npx skills add fastcomments/skills

Funktioniert mit Claude Code, Codex, Cursor, Copilot, Gemini und jedem anderen Agenten, den das skills CLI unterstützt.

Anforderungen

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

Abhängigkeiten installieren

sudo apt install libcpprest-dev libboost-all-dev

Aus dem Quellcode bauen

mkdir build
cd build
cmake ..
make

Installation

sudo make install

Bibliotheksinhalt

Diese Bibliothek enthält den generierten API-Client und die SSO-Dienstprogramme, um die Arbeit mit der API zu erleichtern.

API-Client-Bibliotheksdokumentation

Öffentliche vs gesicherte APIs

Für den API-Client gibt es drei Klassen, DefaultApi, PublicApi und ModerationApi. Die DefaultApi enthält Methoden, die Ihren API-Schlüssel erfordern, und die PublicApi enthält Methoden, die direkt von einem Browser/Mobilgerät usw. ohne Authentifizierung aufgerufen werden können. Die ModerationApi bietet eine umfangreiche Palette von Live- und schnellen Moderations-APIs. Jede ModerationApi-Methode akzeptiert einen sso-Parameter und kann sich über SSO oder ein FastComments.com‑Sitzungs‑Cookie authentifizieren.

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 tätigen: 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-Verwendung

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

Documentation for API Endpoints

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

Class	Method	HTTP request	Description
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	Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.
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	Past commenters on the page who are NOT currently online. Sorted by displayName. Use this after exhausting /users/online to render a "Members" section. Cursor pagination on commenterName: server walks the partial {tenantId, urlId, commenterName} index from afterName forward via $gt, no $skip cost.
PublicApi	getOnlineUsers	GET /pages/{tenantId}/users/online	Currently-online viewers of a page: people whose websocket session is subscribed to the page right now. Returns anonCount + totalCount (room-wide subscribers, including anon viewers we don't enumerate).
PublicApi	getPagesPublic	GET /pages/{tenantId}	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.
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 for a tenant. Given userIds, return display info from User / SSOUser. Used by the comment widget to enrich users that just appeared via a presence event. No page context: privacy is enforced uniformly (private profiles are masked).
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}	Enable or disable notifications for a specific comment.
PublicApi	updateUserNotificationPageSubscriptionStatus	POST /user-notifications/set-subscription-state/{subscribedOrUnsubscribed}	Enable or disable notifications for a page. When users are subscribed to a page, notifications are created for new root comments, and also
PublicApi	updateUserNotificationStatus	POST /user-notifications/{notificationId}/mark/{newStatus}
PublicApi	uploadImage	POST /upload-image/{tenantId}	Upload and resize an image
PublicApi	voteComment	POST /comments/{tenantId}/{commentId}/vote

Documentation for Models

Documentation for Authorization

api_key

Type: API key
API key parameter name: x-api-key
Location: HTTP header

Aggregieren

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

Audit-Logs abrufen

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

Öffentliches Logout

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

Öffentliches Blockieren aus Kommentar

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

Öffentliches Entblocken von Kommentar

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

Überprüfte Kommentare auf Blockierung

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

Benutzer aus Kommentar blockieren

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&) { } });

Öffentlichen Kommentar erstellen

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

Kommentar löschen

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&){
    }
});

Öffentlichen Kommentar löschen

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

Kommentarabstimmung löschen

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

Kommentar melden

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

Kommentar abrufen

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&){
    }
});

Kommentare abrufen

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

Öffentliche Kommentare abrufen

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

Kommentartext abrufen

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

Namen der Abstimmenden für Kommentar abrufen

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&){ }
});

Kommentar sperren

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&){
    }
});

Kommentar anheften

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&) {
        }
    });

Kommentar speichern

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

Kommentartext setzen

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

Benutzer aus Kommentar entblocken

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

Meldung des Kommentars aufheben

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

Kommentar entsperren

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&) {
    }
});

Kommentar loslösen

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

Kommentar aktualisieren

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&) {} });

Kommentar bewerten

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&) {
       }
   });

Kommentare für Benutzer abrufen

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&){}
});

Domain-Konfiguration hinzufügen

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&){
    }
});

Domain-Konfiguration löschen

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&) {
        }
    });

Domain-Konfiguration abrufen

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();

Domain-Konfigurationen abrufen

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

Domain-Konfiguration patchen

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 */ }
    });

Domain-Konfiguration setzen

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

E-Mail-Vorlage erstellen

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

E-Mail-Vorlage löschen

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&) {}
    });

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

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

E-Mail-Vorlage abrufen

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&) {
        }
    });

E-Mail-Vorlagen-Definitionen abrufen

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

Render-Fehler der E-Mail-Vorlage abrufen

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

E-Mail-Vorlagen abrufen

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

E-Mail-Vorlage rendern

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

E-Mail-Vorlage aktualisieren

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 */ }
    });

Ereignisprotokoll abrufen

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

Globales Ereignisprotokoll abrufen

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

Feed-Beitrag erstellen

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

Öffentlichen Feed-Beitrag erstellen

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

Öffentlichen Feed-Beitrag löschen

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

Feed-Beiträge abrufen

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

Öffentliche Feed-Beiträge abrufen

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

Statistiken der Feed-Beiträge abrufen

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

Öffentliche Reaktionen des Benutzers abrufen

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

Öffentlich auf Feed-Beitrag reagieren

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

Feed-Beitrag aktualisieren

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

Öffentlichen Feed-Beitrag aktualisieren

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

Öffentlichen Kommentar melden

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&){
        }
    });

Großes GIF abrufen

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

GIFs suchen

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&){
    }
});

Trendige GIFs abrufen

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

Hashtag hinzufügen

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

Hashtags in Bulk hinzufügen

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&){
    }
});

Hashtag löschen

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

Hashtags abrufen

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

Hashtag patchen

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

Moderationsabstimmung löschen

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

API-Kommentare abrufen

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&){
    }
});

API-Exportstatus abrufen

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&){
        }
    });

API-IDs abrufen

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&){
    }
});

Gesperrte Benutzer aus Kommentar abrufen

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&) {
    }
});

Kommentar-Bannstatus abrufen

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&){ }
});

Unterkommentare abrufen

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&) {
        }
    });

Anzahl abrufen

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

Anzahlen abrufen

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&){
    }
});

Protokolle abrufen

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

Manuelle Abzeichen abrufen

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

Manuelle Abzeichen für Benutzer abrufen

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&){
    }
});

Moderationskommentar abrufen

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

Moderationskommentar-Text abrufen

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&) {
        }
    });

Pre-Ban-Zusammenfassung abrufen

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

Zusammenfassung der Suchkommentare abrufen

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&){
    }
});

Suchseiten abrufen

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

Suchseiten (Sites) abrufen

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

Suchvorschläge abrufen

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();

Suchbenutzer abrufen

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

Vertrauensfaktor abrufen

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

Benutzer-Bannpräferenz abrufen

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&) {
        }
    });

Internes Benutzerprofil abrufen

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

Kommentarabstimmungen anpassen

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

API-Export durchführen

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();

Benutzer aus Kommentar bannen

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 */ }
    });

Bann von Benutzer rückgängig machen

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

Bulk-Pre-Ban-Zusammenfassung erstellen

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

Kommentare nach IDs posten

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&){ }
});

Kommentar melden

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&){
        }
    });

Kommentar entfernen

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

Gelöschten Kommentar wiederherstellen

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

Genehmigungsstatus des Kommentars setzen

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

Review-Status des Kommentars setzen

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

Spam-Status des Kommentars setzen

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&) {}
    });

Kommentartext setzen

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&) {}
    });

Meldung des Kommentars aufheben

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&) {}
    });

Abstimmung abgeben

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

Abzeichen verleihen

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

Thread schließen

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&){
    }
});

Abzeichen entfernen

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

Thread wieder öffnen

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

Vertrauensfaktor setzen

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&) {
        }
    });

Moderator erstellen

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

Moderator löschen

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

Moderator abrufen

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&) {
        }
    });

Moderatoren abrufen

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

Einladung senden

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

Moderator aktualisieren

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&) {} });

Benachrichtigungszähler löschen

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&) {} });

Zwischengespeicherten Benachrichtigungszähler abrufen

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

Benachrichtigungszähler abrufen

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

Benachrichtigungen abrufen

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

Benachrichtigung aktualisieren

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

V1-Seitenreaktion erstellen

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&) {
    }
});

V2-Seitenreaktion erstellen

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&){ }
});

V1-Seitenreaktion löschen

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

V2-Seitenreaktion löschen

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

V1-Seiten-Likes abrufen

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

V2-Seitenreaktionen abrufen

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

Benutzer von V2-Seitenreaktionen abrufen

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

Seite hinzufügen

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

Seite löschen

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

Offline-Benutzer abrufen

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&) {
        }
    });

Online-Benutzer abrufen

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&){
    }
});

Seite nach URL-ID abrufen

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&) {
        }
    });

Seiten abrufen

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&) {
        }
    });

Öffentliche Seiten abrufen

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

Benutzerinformationen abrufen

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

Seite patchen

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&) {}
    });

Ausstehendes Webhook-Ereignis löschen

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

Anzahl ausstehender Webhook-Ereignisse abrufen

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

Ausstehende Webhook-Ereignisse abrufen

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&) {}
    });

Fragenkonfiguration erstellen

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&){}
});

Fragenkonfiguration löschen

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

Fragenkonfiguration abrufen

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

Fragenkonfigurationen abrufen

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

Fragenkonfiguration aktualisieren

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&) {}
    });

Fragergebnis erstellen

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&) {
        }
    });

Fragergebnis löschen

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

Fragergebnis abrufen

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&) {
        }
    });

Fragergebnisse abrufen

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

Fragergebnis aktualisieren

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&) {
        }
    });

Fragergebnisse aggregieren

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

Massenaggregation von Fragergebnissen

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

Kommentare mit Fragergebnissen kombinieren

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&){
        }
    });

SSO-Benutzer hinzufügen

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

SSO-Benutzer löschen

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

SSO-Benutzer per E-Mail abrufen

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&) {
    }
});

SSO-Benutzer per ID abrufen

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

SSO-Benutzer abrufen

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&) {
    }
});

SSO-Benutzer patchen

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&){
        }
    });

SSO-Benutzer setzen

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

Abonnement erstellen

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&) {
        }
    });

Abonnement löschen

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

---

Abonnements abrufen

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

Abonnement aktualisieren

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

Tägliche Nutzung des Mandanten abrufen

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();

Mandantenpaket erstellen

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&){
    }
});

Mandantenpaket löschen

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&){ } });

Mandantenpaket abrufen

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

Mandantenpakete abrufen

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

Mandantenpaket ersetzen

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&) { }
    });

Mandantenpaket aktualisieren

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

Mandantenbenutzer erstellen

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&) {
        }
    });

Mandantenbenutzer löschen

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

Mandantenbenutzer abrufen

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

Mandantenbenutzer abrufen

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&) {
    }
});

Mandantenbenutzer ersetzen

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

Login-Link senden

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

Mandantenbenutzer aktualisieren

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

Mandant erstellen

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

Mandant löschen

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

Mandant abrufen

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

Mandanten abrufen

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

Mandant aktualisieren

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

Ticket-Status ändern

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

Ticket erstellen

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

Ticket abrufen

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&){
    }
});

Tickets abrufen

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&) {
    }
});

Übersetzungen abrufen

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

Bild hochladen

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

Benutzerabzeichen-Fortschritt nach ID abrufen

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&){}
    });

Benutzerabzeichen-Fortschritt nach Benutzer-ID abrufen

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

Liste des Benutzerabzeichen-Fortschritts abrufen

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

Benutzerabzeichen erstellen

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

Benutzerabzeichen löschen

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&){ }
    });

Benutzerabzeichen abrufen

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&){
    }
});

Benutzerabzeichen abrufen

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&) {
       }
   });

Benutzerabzeichen aktualisieren

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

Benachrichtigungszähler des Benutzers abrufen

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

Benutzerbenachrichtigungen abrufen

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

Benachrichtigungszähler des Benutzers zurücksetzen

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

Benutzerbenachrichtigungen zurücksetzen

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

Kommentar-Abonnement-Status der Benutzerbenachrichtigung aktualisieren

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

Seiten-Abonnement-Status der Benutzerbenachrichtigung aktualisieren

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

Benutzerbenachrichtigungsstatus aktualisieren

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();

Präsenzstatus des Benutzers abrufen

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

Benutzer suchen

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&){}
});

Benutzer abrufen

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

Abstimmung erstellen

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

Abstimmung löschen

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

Abstimmungen abrufen

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

Abstimmungen für Benutzer abrufen

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

Aggregieren

Audit-Logs

Authentifizierung

Blockieren aus Kommentar

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

Seitenreaktionen

Seiten

Ausstehende Webhook-Ereignisse

Fragenkonfigurationen

Fragergebnisse

Aggregierung von Fragergebnissen

SSO-Benutzer

Abonnements

Tägliche Mandantennutzung

Mandantenpakete

Mandantenbenutzer

Mandanten

Tickets

Übersetzungen

Bild hochladen

Benutzerabzeichen-Fortschritt

Benutzerabzeichen

Benutzerbenachrichtigungen

Benutzer-Präsenzstatus

Benutzersuche

Benutzer

Abstimmungen

FastComments C++ SDK

Repository

KI-Coding-Agenten

Anforderungen

Installation

Abhängigkeiten installieren

Aus dem Quellcode bauen

Installation

Bibliotheksinhalt

Öffentliche vs gesicherte APIs

Schnellstart

Using Authenticated APIs (DefaultAPI)

Using Public APIs (PublicAPI)

Using Moderation APIs (ModerationApi)

Common Issues

API-Aufrufe tätigen: Synchron vs Asynchron

Synchrone Aufrufe mit .get()

Asynchrone Aufrufe mit .then()

Auswahl zwischen synchron und asynchron

Hinweise

Broadcast-IDs

SSO (Einmalanmeldung)

SSO-Verwendung

Einfaches SSO

Sicheres SSO

Dokumentation für FastComments

Documentation for API Endpoints

Documentation for Models

Documentation for Authorization

api_key

Aggregieren

Parameter

Antwort

Beispiel

Audit-Logs abrufen

Synchrone Aufrufe mit `.get()`

Asynchrone Aufrufe mit `.then()`